# Tipos e opções de conexão para ETL no AWS Glue para Spark No AWS Glue Glue, vários métodos e transformações do PySpark e do Scala especificam o tipo de conexão usando um parâmetro `connectionType`. Eles especificam opções de conexão usando um parâmetro `connectionOptions` ou `options`. O parâmetro `connectionType` pode usar os valores mostrados na tabela a seguir. Os valores do parâmetro `connectionOptions` (ou `options`) associados para cada tipo estão documentados nas seções a seguir. Salvo indicação em contrário, os parâmetros se aplicam quando a conexão é usada como fonte ou coletor. Para obter um código de exemplo que demonstra a configuração e o uso de opções de conexão, consulte a página inicial de cada tipo de conexão. | `connectionType` | Conecta-se a | | --- | --- | | [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | Banco de dados do [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) | | [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) | | [S3 da3](aws-glue-programming-etl-connect-s3-home.md) | [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/) | | [documentdb](aws-glue-programming-etl-connect-documentdb-home.md#aws-glue-programming-etl-connect-documentdb) | banco de dados do [Amazon DocumentDB (compatível com MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) | | [opensearch](aws-glue-programming-etl-connect-opensearch-home.md) | [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). | | [redshift](aws-glue-programming-etl-connect-redshift-home.md) | Banco de dados do [Amazon Redshift](https://aws.amazon.com/redshift/) | | [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) ou [Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) | | [azurecosmos](aws-glue-programming-etl-connect-azurecosmos-home.md) | Azure Cosmos para NoSQL. | | [azuresql](aws-glue-programming-etl-connect-azuresql-home.md) | Azure SQL. | | [bigquery](aws-glue-programming-etl-connect-bigquery-home.md) | Google BigQuery. | | [mongodb](aws-glue-programming-etl-connect-mongodb-home.md) | Banco de dados [MongoDB](https://www.mongodb.com/what-is-mongodb), incluindo MongoDB Atlas. | | [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados do Microsoft SQL Server (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [mysql](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados [MySQL](https://www.mysql.com/) (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados [Oracle](https://www.oracle.com/database/) (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | Banco de dados [PostgreSQL](https://www.postgresql.org/) (consulte [Conexões JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [saphana](aws-glue-programming-etl-connect-saphana-home.md) | SAP HANA. | | [snowflake](aws-glue-programming-etl-connect-snowflake-home.md) | Data lake do [Snowflake](https://www.snowflake.com/) | | [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. | | [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. | | [custom.\*](#aws-glue-programming-etl-connect-market) | Armazenamentos de dados do Spark, Athena ou JDBC (consulte [Valores de connectionType personalizados e AWS Marketplace](#aws-glue-programming-etl-connect-market) | | [marketplace.\*](#aws-glue-programming-etl-connect-market) | Armazenamentos de dados do Spark, Athena ou JDBC (consulte [Valores de connectionType personalizados e AWS Marketplace](#aws-glue-programming-etl-connect-market)) | ## Opções de DataFrame para ETL no AWS Glue 5.0 para Spark Um DataFrame é um conjunto de dados organizados em colunas nomeadas semelhante a uma tabela e é compatível com operações de estilo funcional (mapear/reduzir/filtrar etc.) e operações SQL (select, project, aggregate). Para criar um DataFrame para uma fonte de dados compatível com o Glue os seguintes requisitos devem ser atendidos: + conector da fonte de dados `ClassName` + conexão da fonte de dados `Options` Da mesma forma, para gravar um DataFrame em um coletor de dados suportado pelo Glue, o mesmo é necessário: + conector do coletor de dados `ClassName` + conexão do coletor de dados `Options` Observe que recursos do AWS Glue, como marcadores de tarefas, e opções de DynamicFrame, como `connectionName`, não são compatíveis com o DataFrame. Para obter mais detalhes sobre o DataFrame e as operações válidas, consulte a documentação do Spark para o [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html). ### Especificar o ClassName do conector Para especificar o `ClassName` de um coletor/fonte de dados, use a opção `.format` para fornecer o conector `ClassName` correspondente que define o coletor/fonte de dados. **Conectores JDBC** Para conectores JDBC, especifique `jdbc` como o valor da opção `.format` e forneça o driver JDBC `ClassName` na opção `driver`. ``` df = spark.read.format("jdbc").option("driver", "")... df.write.format("jdbc").option("driver", "")... ``` A tabela a seguir lista o driver JDBC `ClassName` da fonte de dados compatível no AWS Glue para DataFrames. | Fonte de dados | Driver ClassName | | --- |--- | | PostgreSQL | org.postgresql.Driver | | Oracle | oracle.jdbc.driver.OracleDriver | | SQLServer | com.microsoft.sqlserver.jdbc.SQLServerDriver | | MySQL | com.mysql.jdbc.Driver | | SAPHana | com.sap.db.jdbc.Driver | | Teradata | com.teradata.jdbc.TeraDriver | **Conectores do Spark** Para conectores do Spark, especifique o `ClassName` do conector como o valor da opção `.format`. ``` df = spark.read.format("")... df.write.format("")... ``` A tabela a seguir lista o conector Spark `ClassName` da fonte de dados compatível no AWS Glue para DataFrames. | Fonte de dados | ClassName | | --- |--- | | MongoDB/DocumentDB | glue.spark.mongodb | | Redshift | io.github.spark\_redshift\_community.spark.redshift | | AzureCosmos | cosmos.oltp | | AzureSQL | com.microsoft.sqlserver.jdbc.spark | | BigQuery | com.google.cloud.spark.bigquery | | OpenSearch | org.opensearch.spark.sql | | Snowflake | net.snowflake.spark.snowflake | | Vertica | com.vertica.spark.datasource.VerticaSource | ### Especificar as opções de conexão Para especificar as `Options` da conexão com um coletor/fonte de dados, use o `.option(, )` para fornecer opções individuais ou `.options()` para fornecer várias opções como um mapa de chave-valor. Cada coletor/fonte de dados oferece suporte ao seu próprio conjunto de conexão `Options`. Para obter detalhes sobre as `Options` disponíveis, consulte a documentação pública do conector Spark do coletor/fonte de dados específico listado na tabela a seguir. + [JDBC](https://spark.apache.org/docs/3.5.2/sql-data-sources-jdbc.html) + [MongoDB/DocumentDB](https://www.mongodb.com/docs/spark-connector/v10.4/) + [Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) + [AzureCosmos](https://github.com/Azure/azure-cosmosdb-spark) + [AzureSQL](https://learn.microsoft.com/en-us/sql/connect/spark/connector?view=sql-server-ver16) + [BigQuery](https://cloud.google.com/dataproc/docs/tutorials/bigquery-connector-spark-example) + [OpenSearch](https://github.com/opensearch-project/opensearch-hadoop/blob/main/USER_GUIDE.md#apache-spark) + [Snowflake](https://docs.snowflake.com/en/user-guide/spark-connector-use#setting-configuration-options-for-the-connector) + [Vertica](https://github.com/vertica/spark-connector) ### Exemplos Os seguintes exemplos leem do PostgreSQL e gravam no SnowFlake: **Python** Exemplo: ``` from awsglue.context import GlueContext from pyspark.sql import SparkSession spark = SparkSession.builder.getOrCreate() dataSourceClassName = "jdbc" dataSourceOptions = { "driver": "org.postgresql.Driver", "url": "", "user": "", "password": "", "dbtable": "", } dataframe = spark.read.format(className).options(**options).load() dataSinkClassName = "net.snowflake.spark.snowflake" dataSinkOptions = { "sfUrl": "", "sfUsername": "", "sfPassword": "", "sfDatabase" -> "", "sfSchema" -> "", "sfWarehouse" -> "" } dataframe.write.format(dataSinkClassName).options(**dataSinkOptions).save() ``` **Scala** Exemplo: ``` import org.apache.spark.sql.SparkSession val spark = SparkSession.builder().getOrCreate() val dataSourceClassName = "jdbc" val dataSourceOptions = Map( "driver" -> "org.postgresql.Driver", "url" -> "", "user" -> "", "password" -> "", "dbtable" -> "" ) val dataframe = spark.read.format(dataSourceClassName).options(dataSourceOptions).load() val dataSinkClassName = "net.snowflake.spark.snowflake" val dataSinkOptions = Map( "sfUrl" -> "", "sfUsername" -> "", "sfPassword" -> "", "sfDatabase" -> "", "sfSchema" -> "", "sfWarehouse" -> "" ) dataframe.write.format(dataSinkClassName).options(dataSinkOptions).save() ``` ## Valores de connectionType personalizados e AWS Marketplace Incluindo o seguinte: + `"connectionType": "marketplace.athena"`: designa uma conexão com um armazenamento de dados do Amazon Athena. A conexão usa um conector de AWS Marketplace. + `"connectionType": "marketplace.spark"`: designa uma conexão com um armazenamento de dados do Apache Spark. A conexão usa um conector de AWS Marketplace. + `"connectionType": "marketplace.jdbc"`: designa uma conexão com um armazenamento de dados do JDBC. A conexão usa um conector de AWS Marketplace. + `"connectionType": "custom.athena"`: designa uma conexão com um armazenamento de dados do Amazon Athena. A conexão usa um conector personalizado que você carrega no AWS Glue Studio. + `"connectionType": "custom.spark"`: designa uma conexão com um armazenamento de dados do Apache Spark. A conexão usa um conector personalizado que você carrega no AWS Glue Studio. + `"connectionType": "custom.jdbc"`: designa uma conexão com um armazenamento de dados do JDBC. A conexão usa um conector personalizado que você carrega no AWS Glue Studio. ### Opções de conexão para o tipo custom.jdbc ou marketplace.jdbc + `className`: string obrigatória, o nome da classe Java totalmente qualificado do driver JDBC (por exemplo, `com.mysql.cj.jdbc.Driver`). Você deve especificar essa opção ao usar um conector personalizado ou AWS Marketplace JDBC. Se você omitir essa opção, o trabalho poderá falhar com um erro `No suitable driver`, principalmente ao usar URLs JDBC parametrizados. + `connectionName`: string, obrigatório, nome da conexão associada ao conector. + `url`: string, obrigatório, URL do JDBC com espaços reservados (`${}`) que são usados para construir a conexão com a origem dos dados. O espaço reservado `${secretKey}` é substituído pelo segredo do mesmo nome em AWS Secrets Manager. Consulte a documentação do armazenamento de dados para obter mais informações sobre como construir o URL. + `secretId` ou `user/password`: string, obrigatório, usado para recuperar credenciais para o URL. + `dbTable` ou `query`: string, obrigatório, a tabela ou consulta SQL da qual obter os dados. Você pode especificar `dbTable` ou `query`, mas não os dois. + `partitionColumn`: string, opcional, o nome de uma coluna de inteiros usada para o particionamento. Essa opção só funciona quando está incluída em `lowerBound`, `upperBound` e `numPartitions`. Essa opção funciona da mesma maneira que no leitor JDBC Spark SQL. Para obter mais informações, consulte [JDBC para outros bancos de dados](https://spark.apache.org/docs/latest/sql-data-sources-jdbc.html) no *Guia do Apache Spark SQL, DataFrames e conjuntos de dados*. Os valores de `lowerBound` e `upperBound` são usados para decidir o passo de partição, não para filtrar as linhas na tabela. Todas as linhas na tabela são particionadas e retornadas. **nota** Ao usar uma consulta em vez de um nome de tabela, você deve validar se a consulta funciona com a condição de particionamento especificada. Por exemplo: Se o seu formato de consulta for `"SELECT col1 FROM table1"`, teste a consulta anexando uma cláusula `WHERE` no final da consulta que usa a coluna de partição. Se o seu formato de consulta for "`SELECT col1 FROM table1 WHERE col2=val"`, teste a consulta estendendo a cláusula `WHERE` com `AND` e uma expressão que usa a coluna de partição. + `lowerBound`: inteiro, opcional, o valor mínimo de `partitionColumn` que é usado para decidir o passo de partição. + `upperBound`: inteiro, opcional, o valor máximo de `partitionColumn` que é usado para decidir o passo de partição. + `numPartitions`: inteiro, opcional, o número de partições. Esse valor, juntamente com `lowerBound` (inclusive) e `upperBound` (exclusive), forma os passos de partição para as expressões de cláusula `WHERE` geradas que são usadas para dividir a `partitionColumn`. **Importante** Tenha cuidado com a quantidade, pois muitas partições podem causar problemas em seus sistemas de banco de dados externo. + `filterPredicate`: string, opcional, cláusula de condição extra para filtrar dados da fonte. Por exemplo: ``` BillingCity='Mountain View' ``` Ao usar uma *consulta* em vez de um nome de *tabela*, você deve validar que a consulta funciona com o `filterPredicate` especificado. Por exemplo: + Se o seu formato de consulta for `"SELECT col1 FROM table1"`, teste a consulta anexando uma cláusula `WHERE` no final da consulta que usa o predicado do filtro. + Se o seu formato de consulta for `"SELECT col1 FROM table1 WHERE col2=val"`, teste a consulta estendendo a cláusula `WHERE` com `AND` e uma expressão que usa o predicado do filtro. + `dataTypeMapping`: dicionário, opcional, mapeamento de tipo de dados personalizado que constrói um mapeamento a partir de um tipo de dados **JDBC** para um tipo de dados **Glue**. Por exemplo, a opção `"dataTypeMapping":{"FLOAT":"STRING"}` mapeia campos de dados JDBC do tipo `FLOAT` para o tipo `String` do Java chamando o método `ResultSet.getString()` do driver e o usa para complilar registros do AWS Glue. O objeto `ResultSet` é implantado por cada driver, portanto, o comportamento é específico para o driver que você usa. Consulte a documentação do driver do JDBC para entender como ele executa as conversões. + Os tipos de dados do AWS Glue compatíveis atualmente são: + DATE + STRING + TIMESTAMP + INT + FLOAT + LONG + BIGDECIMAL + BYTE + SHORT + DOUBLE Os tipos de dados JDBC compatíveis são [Java8 java.sql.types](https://docs.oracle.com/javase/8/docs/api/java/sql/Types.html). Os mapeamentos de tipos de dados padrão (de JDBC para o AWS Glue) são: + DATE -> DATE + VARCHAR -> STRING + CHAR -> STRING + LONGNVARCHAR -> STRING + TIMESTAMP -> TIMESTAMP + INTEGER -> INT + FLOAT -> FLOAT + REAL -> FLOAT + BIT -> BOOLEAN + BOOLEAN -> BOOLEAN + BIGINT -> LONG + DECIMAL -> BIGDECIMAL + NUMERIC -> BIGDECIMAL + TINYINT -> SHORT + SMALLINT -> SHORT + DOUBLE -> DOUBLE Se você usar um mapeamento de tipo de dados personalizado com a opção `dataTypeMapping`, poderá substituir um mapeamento de tipo de dados padrão. Somente os tipos de dados JDBC listados na opção `dataTypeMapping` são afetados. O mapeamento padrão é usado para todos os outros tipos de dados JDBC. Você pode adicionar mapeamentos para tipos de dados JDBC adicionais, se necessário. Se um tipo de dados JDBC não estiver incluído no mapeamento padrão ou em um mapeamento personalizado, o tipo de dados será convertido para o tipo de dados `STRING` do AWS Glue por padrão. Os exemplos de código Python a seguir mostram como fazer a leitura de bancos de dados JDBC com drivers JDBC AWS Marketplace. Ele demonstra a leitura de um banco de dados e a gravação em um local S3. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ## @type: DataSource ## @args: [connection_type = "marketplace.jdbc", connection_options = {"dataTypeMapping":{"INTEGER":"STRING"},"upperBound":"200","query":"select id, name, department from department where id < 200","numPartitions":"4", "partitionColumn":"id","lowerBound":"0","connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0"] ## @return: DataSource0 ## @inputs: [] DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = "marketplace.jdbc", connection_options = {"dataTypeMapping":{"INTEGER":"STRING"}, "upperBound":"200","query":"select id, name, department from department where id < 200","numPartitions":"4","partitionColumn":"id","lowerBound":"0", "connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0") ## @type: ApplyMapping ## @args: [mappings = [("department", "string", "department", "string"), ("name", "string", "name", "string"), ("id", "int", "id", "int")], transformation_ctx = "Transform0"] ## @return: Transform0 ## @inputs: [frame = DataSource0] Transform0 = ApplyMapping.apply(frame = DataSource0, mappings = [("department", "string", "department", "string"), ("name", "string", "name", "string"), ("id", "int", "id", "int")], transformation_ctx = "Transform0") ## @type: DataSink ## @args: [connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "partitionKeys": []}, transformation_ctx = "DataSink0"] ## @return: DataSink0 ## @inputs: [frame = Transform0] DataSink0 = glueContext.write_dynamic_frame.from_options(frame = Transform0, connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "partitionKeys": []}, transformation_ctx = "DataSink0") job.commit() ``` ### Opções de conexão para o tipo custom.athena ou marketplace.athena + `className`: string, obrigatório, nome da classe do driver. Quando você estiver usando o conector Athena-CloudWatch, esse valor de parâmetro será o prefixo da classe Name (Nome) (por exemplo, `"com.amazonaws.athena.connectors"`). O conector Athena-CloudWatch é composto por duas classes: um manipulador de metadados e um manipulador de registros. Se você fornecer o prefixo comum aqui, a API carregará as classes corretas com base nesse prefixo. + `tableName`: string, obrigatório, o nome do fluxo de log do CloudWatch a ser lido. Esse trecho de código usa o nome de exibição especial `all_log_streams`, o que significa que o quadro de dados dinâmicos retornada conterá dados de todos os fluxos de log no grupo de logs. + `schemaName`: string, obrigatório, o nome do grupo de logs do CloudWatch a ser lido. Por exemplo, `/aws-glue/jobs/output`. + `connectionName`: string, obrigatório, nome da conexão associada ao conector. Para obter opções adicionais para esse conector, consulte o arquivo [Amazon Athena CloudWatch Connector README](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch) (LEIAME do conector Amazon Athena CloudWatch) no GitHub. O exemplo de código Python a seguir mostra como fazer a leitura de um armazenamento de dados do Athena usando um conector AWS Marketplace. Ele demonstra a leitura do Athena e a gravação em um local S3. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ## @type: DataSource ## @args: [connection_type = "marketplace.athena", connection_options = {"tableName":"all_log_streams","schemaName":"/aws-glue/jobs/output", "connectionName":"test-connection-athena"}, transformation_ctx = "DataSource0"] ## @return: DataSource0 ## @inputs: [] DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = "marketplace.athena", connection_options = {"tableName":"all_log_streams",, "schemaName":"/aws-glue/jobs/output","connectionName": "test-connection-athena"}, transformation_ctx = "DataSource0") ## @type: ApplyMapping ## @args: [mappings = [("department", "string", "department", "string"), ("name", "string", "name", "string"), ("id", "int", "id", "int")], transformation_ctx = "Transform0"] ## @return: Transform0 ## @inputs: [frame = DataSource0] Transform0 = ApplyMapping.apply(frame = DataSource0, mappings = [("department", "string", "department", "string"), ("name", "string", "name", "string"), ("id", "int", "id", "int")], transformation_ctx = "Transform0") ## @type: DataSink ## @args: [connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "partitionKeys": []}, transformation_ctx = "DataSink0"] ## @return: DataSink0 ## @inputs: [frame = Transform0] DataSink0 = glueContext.write_dynamic_frame.from_options(frame = Transform0, connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "partitionKeys": []}, transformation_ctx = "DataSink0") job.commit() ``` ### Opções de conexão para o tipo custom.spark ou marketplace.spark + `className`: string, obrigatório, nome da classe do conector. + `secretId`: string, opcional, usado para recuperar credenciais para a conexão do conector. + `connectionName`: string, obrigatório, nome da conexão associada ao conector. + Outras opções dependem do armazenamento de dados. Por exemplo, as opções de configuração do OpenSearch começam com o prefixo `es`, conforme descrito na documentação [Elasticsearch for Apache Hadoop](https://www.elastic.co/guide/en/elasticsearch/hadoop/current/configuration.html) (Elasticsearch para Apache Hadoop). Conexões do Spark com o Snowflake usam opções como `sfUser` e `sfPassword`, conforme descrito em [Usar o conector do Spark](https://docs.snowflake.com/en/user-guide/spark-connector-use.html) no guia *Conexão com o Snowflake*. O exemplo de código Python a seguir mostra como fazer a leitura de um armazenamento de dados do OpenSearch usando um conector `marketplace.spark`. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ## @type: DataSource ## @args: [connection_type = "marketplace.spark", connection_options = {"path":"test", "es.nodes.wan.only":"true","es.nodes":"https://{{}}", "connectionName":"test-spark-es","es.port":"443"}, transformation_ctx = "DataSource0"] ## @return: DataSource0 ## @inputs: [] DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = "marketplace.spark", connection_options = {"path":"test","es.nodes.wan.only": "true","es.nodes":"https://{{}}","connectionName": "test-spark-es","es.port":"443"}, transformation_ctx = "DataSource0") ## @type: DataSink ## @args: [connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "partitionKeys": []}, transformation_ctx = "DataSink0"] ## @return: DataSink0 ## @inputs: [frame = DataSource0] DataSink0 = glueContext.write_dynamic_frame.from_options(frame = DataSource0, connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "partitionKeys": []}, transformation_ctx = "DataSink0") job.commit() ``` ## Opções gerais As opções nesta seção são fornecidas como `connection_options`, mas não se aplicam especificamente a um determinado conector. Os parâmetros a seguir geralmente são usados ao configurar marcadores. Eles podem se aplicar aos fluxos de trabalho do Amazon S3 ou JDBC. Para obter mais informações, consulte [Usar marcadores de trabalho](programming-etl-connect-bookmarks.md). + `jobBookmarkKeys`: uma matriz de nomes de coluna. + `jobBookmarkKeysSortOrder`: string que define como comparar valores com base na ordem de classificação. Valores válidos: `"asc"`, `"desc"`. + `useS3ListImplementation`: usado para gerenciar a performance da memória ao listar o conteúdo dos buckets do Amazon S3. Para obter mais informações, consulte [Optimize memory management in AWS Glue](https://aws.amazon.com/blogs/big-data/optimize-memory-management-in-aws-glue/).