Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Tipi e opzioni di connessione per ETL in AWS Glue per Spark In AWS Glue Spark, vari metodi e trasformazioni PySpark e Scala specificano il tipo di connessione utilizzando un `connectionType` parametro. Specificano le opzioni di connessione utilizzando un parametro `connectionOptions` o `options`. Il parametro `connectionType` può assumere i valori indicati nella tabella seguente. I valori dei parametri associati `connectionOptions` (o `options`) per ciascun tipo sono documentati nelle sezioni seguenti. Salvo indicazione contraria, i parametri si applicano quando la connessione viene utilizzata come sorgente o sink. Per il codice di esempio che illustra l'impostazione e l'utilizzo delle opzioni di connessione, consulta la home page per ogni tipo di connessione. | `connectionType` | Si connette a | | --- | --- | | [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) database | | [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Flusso di dati Amazon Kinesis](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) | | [s3](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) | [Amazon DocumentDB (compatibile con MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) database | | [opensearch](aws-glue-programming-etl-connect-opensearch-home.md) | [ OpenSearch Servizio Amazon](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). | | [redshift](aws-glue-programming-etl-connect-redshift-home.md) | Database [Amazon Redshift](https://aws.amazon.com/redshift/) | | [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) o [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 per 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) | Database [MongoDB](https://www.mongodb.com/what-is-mongodb), incluso MongoDB Atlas. | | [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Microsoft SQL Server database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [mysql](aws-glue-programming-etl-connect-jdbc-home.md) | [MySQL](https://www.mysql.com/) database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | [Oracle](https://www.oracle.com/database/) database (vedere [Connessioni JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | [PostgreSQL](https://www.postgresql.org/) database (vedere [Connessioni 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 [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. | | [personalizzato.\*](#aws-glue-programming-etl-connect-market) | Archivi dati Spark, Athena o JDBC (consulta [Valori Custom e Marketplace AWS ConnectionType](#aws-glue-programming-etl-connect-market) | | [marketplace.\*](#aws-glue-programming-etl-connect-market) | Archivi dati Spark, Athena o JDBC (consulta [Valori Custom e Marketplace AWS ConnectionType](#aws-glue-programming-etl-connect-market)) | ## DataFrame opzioni per ETL in AWS Glue 5.0 for Spark A DataFrame è un set di dati organizzato in colonne denominate simili a una tabella e supporta operazioni in stile funzionale (map/reduce/filter/etc.) e operazioni SQL (select, project, aggregate). Per creare un file DataFrame per un'origine dati supportata da Glue, sono necessari i seguenti requisiti: + Connettore dell'origine dati `ClassName` + Connessione dell'origine dati `Options` Allo stesso modo, per scrivere DataFrame a su un data sink supportato da Glue, sono necessari gli stessi: + Connettore del data sink `ClassName` + Connessione del data sink `Options` Tieni presente che le funzionalità di AWS Glue come i segnalibri di lavoro e DynamicFrame le opzioni come non `connectionName` sono supportate in DataFrame. Per maggiori dettagli sulle operazioni supportate DataFrame e sulle operazioni supportate, consulta la documentazione di Spark per. [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html) ### Specificare il connettore ClassName Per specificare il `ClassName` tipo di dati source/sink, utilizzate l'`.format`opzione per fornire il connettore corrispondente `ClassName` che definisce i dati source/sink. **Connettori JDBC** Per i connettori JDBC, specificare `jdbc` come valore dell'opzione `.format` e indicare il driver JDBC `ClassName` nell'opzione `driver`. ``` df = spark.read.format("jdbc").option("driver", "")... df.write.format("jdbc").option("driver", "")... ``` La tabella seguente elenca il driver JDBC `ClassName` dell'origine dati supportata in AWS Glue for. DataFrames | Origine dati | Autista ClassName | | --- |--- | | PostgreSQL | org.PostgreSQL.Driver | | Oracle | oracle.jdbc.driver. OracleDriver | | SQLServer | com.microsoft.sqlserver.jdbc. SQLServerDriver | | MySQL | com.mysql.jdbc. Driver | | SAP Hana | com.sap.db.jdbc. Driver | | Teradata | com.teradata.jdbc. TeraDriver | **Connettori Spark** Per i connettori Spark, specificare il `ClassName` del connettore come valore dell'opzione `.format`. ``` df = spark.read.format("")... df.write.format("")... ``` La tabella seguente elenca il connettore Spark `ClassName` dell'origine dati supportata in AWS Glue for DataFrames. | Origine dati | 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 | ### Specificare le opzioni di connessione Per specificare `Options` la connessione a un dato source/sink, usa `.option(, )` per fornire opzioni individuali o `.options()` per fornire più opzioni come mappa chiave-valore. Ogni dato source/sink supporta il proprio set di connessioni. `Options` Per i dettagli sui dati disponibili`Options`, consulta la documentazione pubblica relativa allo specifico connettore source/sink Spark di dati elencata nella tabella seguente. + [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) ### Esempi I seguenti esempi leggono da PostgreSQL e scrivono in: SnowFlake **Python** Esempio: ``` 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** Esempio: ``` 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() ``` ## Valori Custom e Marketplace AWS ConnectionType Questi sono i seguenti: + `"connectionType": "marketplace.athena"`: designa una connessione a un archivio dati Amazon Athena. La connessione utilizza un connettore di Marketplace AWS. + `"connectionType": "marketplace.spark"`: designa una connessione a un archivio dati Apache Spark. La connessione utilizza un connettore di Marketplace AWS. + `"connectionType": "marketplace.jdbc"`: designa una connessione a un archivio dati JDBC. La connessione utilizza un connettore di Marketplace AWS. + `"connectionType": "custom.athena"`: designa una connessione a un archivio dati Amazon Athena. La connessione utilizza un connettore personalizzato che va caricato in AWS Glue Studio. + `"connectionType": "custom.spark"`: designa una connessione a un archivio dati Apache Spark. La connessione utilizza un connettore personalizzato che va caricato in AWS Glue Studio. + `"connectionType": "custom.jdbc"`: designa una connessione a un archivio dati JDBC. La connessione utilizza un connettore personalizzato che va caricato in AWS Glue Studio. ### Opzioni di connessione per il tipo custom.jdbc o marketplace.jdbc + `className`— String, obbligatorio, il nome completo della classe Java del driver JDBC (ad esempio,). `com.mysql.cj.jdbc.Driver` È necessario specificare questa opzione quando si utilizza un connettore JDBC o personalizzato. Marketplace AWS Se si omette questa opzione, il processo potrebbe fallire con un `No suitable driver` errore, in particolare quando si utilizzano URL JDBC con parametri. + `connectionName`: stringa, obbligatorio, nome della connessione associata al connettore. + `url`: stringa, obbligatorio, URL JDBC con segnaposto (`${}`) che vengono utilizzati per creare la connessione all'origine dati. Il segnaposto `${secretKey}` viene sostituito con il segreto con lo stesso nome in Gestione dei segreti AWS. Per ulteriori informazioni sulla creazione dell'URL, fare riferimento alla documentazione dell'archivio dati. + `secretId` o `user/password`: stringa, obbligatorio, utilizzato per recuperare le credenziali per l'URL. + `dbTable` o `query`: stringa, obbligatorio, la tabella o la query SQL da cui ottenere i dati. Puoi specificare `dbTable` o `query`, ma non entrambi. + `partitionColumn`: stringa, facoltativo, il nome di una colonna intera utilizzata per il partizionamento. Questa opzione funziona solo quando è inclusa con `lowerBound`, `upperBound` e `numPartitions`. Questa opzione funziona allo stesso modo del lettore Spark SQL JDBC. *Per ulteriori informazioni, consulta [JDBC To Other Databases nella Apache Spark SQL and Datasets](https://spark.apache.org/docs/latest/sql-data-sources-jdbc.html) Guide. DataFrames* I valori `lowerBound` e `upperBound` vengono utilizzati per decidere lo stride della partizione, non per filtrare le righe nella tabella. Tutte le righe della tabella vengono partizionate e restituite. **Nota** Quando si utilizza una query anziché un nome di tabella, è necessario verificare che la query funzioni con la condizione di partizionamento specificata. Ad esempio: Se il formato della query è `"SELECT col1 FROM table1"`, testa la query aggiungendo una clausola `WHERE` alla fine della query che utilizza la colonna della partizione. Se il formato della query è "`SELECT col1 FROM table1 WHERE col2=val"`, testa la query estendendo la clausola `WHERE` con `AND` e un'espressione che utilizza la colonna della partizione. + `lowerBound`: intero, facoltativo, il valore minimo di `partitionColumn` che viene utilizzato per decidere lo stride della partizione. + `upperBound`: intero, facoltativo, il valore massimo di `partitionColumn` che viene utilizzato per decidere lo stride della partizione. + `numPartitions`: intero, facoltativo, il numero di partizioni. Questo valore, insieme a `lowerBound` (incluso) e `upperBound` (escluso), forma stride di partizione per espressioni con le clausole `WHERE` generate che vengono utilizzate per dividere la `partitionColumn`. **Importante** Presta attenzione al numero di partizioni perché troppe partizioni potrebbero causare problemi nei sistemi di database esterni. + `filterPredicate`: stringa, opzionale, clausola condizione extra per filtrare i dati dall'origine. Ad esempio: ``` BillingCity='Mountain View' ``` Quando si utilizza una *query* anziché un nome di *table*, è necessario verificare che la query funzioni con il `filterPredicate` specificato. Ad esempio: + Se il formato della query è `"SELECT col1 FROM table1"`, testa la query aggiungendo una clausola `WHERE` alla fine della query che utilizza il predicato filtro. + Se il formato della query è `"SELECT col1 FROM table1 WHERE col2=val"`, testa la query estendendo la clausola `WHERE` con `AND` e un'espressione che utilizza il predicato filtro. + `dataTypeMapping`: dizionario, opzionale, mappatura del tipo di dati personalizzata che crea una mappatura da un tipo di dati **JDBC** a un tipo di dati **Glue**. Ad esempio, l'opzione `"dataTypeMapping":{"FLOAT":"STRING"}` mappa i campi di dati di tipo JDBC `FLOAT` nel tipo Java `String` chiamando il metodo `ResultSet.getString()` del driver e lo usa per costruire registri di AWS Glue. L'oggetto `ResultSet` viene implementato da ciascun driver, quindi il comportamento è specifico del driver utilizzato. Consulta la documentazione relativa al driver JDBC per capire come il driver esegue le conversioni. + I tipi di dati AWS Glue correntemente supportati sono: + DATE + STRING + TIMESTAMP + INT + FLOAT + LONG + BIGDECIMAL + BYTE + SHORT + DOUBLE I tipi di dati JDBC supportati sono [Java8 java.sql.types](https://docs.oracle.com/javase/8/docs/api/java/sql/Types.html). Le mappature di default dei tipi di dati (da JDBC a AWS Glue) sono: + 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 si utilizza un mapping del tipo di dati personalizzato con l'opzione `dataTypeMapping`, è possibile sovrascrivere una mappatura di default del tipo di dati. Sono interessati solo i tipi di dati JDBC elencati nell'opzione `dataTypeMapping`; per tutti gli altri tipi di dati JDBC viene utilizzata la mappatura di default. Se necessario, è possibile aggiungere mappature per tipi di dati JDBC aggiuntivi. Se un tipo di dati JDBC non è incluso nella mappatura di default o in una mappatura personalizzata, per impostazione predefinita viene convertito nel tipo di dati `STRING` AWS Glue. Il seguente esempio di codice Python mostra come leggere dai database JDBC con driver JDBC. Marketplace AWS Mostra la lettura da un database e la scrittura in una posizione 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() ``` ### Opzioni di connessione per il tipo custom.athena o marketplace.athena + `className` – Stringa, obbligatorio, nome della classe driver. Quando si utilizza il Athena-CloudWatch connettore, il valore di questo parametro è il prefisso del nome della classe (ad esempio,). `"com.amazonaws.athena.connectors"` Il Athena-CloudWatch connettore è composto da due classi: un gestore di metadati e un gestore di record. Se si fornisce qui il prefisso comune, l'API carica le classi corrette in base a tale prefisso. + `tableName`— Stringa, obbligatoria, il nome del flusso di CloudWatch log da leggere. In questo frammento di codice viene utilizzato il nome della vista speciale `all_log_streams`, il che significa che il frame di dati dinamico restituito conterrà i dati di tutti i flussi di log nel gruppo di log. + `schemaName`— String, obbligatorio, il nome del gruppo di CloudWatch log da cui leggere. Ad esempio, `/aws-glue/jobs/output`. + `connectionName` – Stringa, obbligatorio, nome della connessione associata al connettore. Per ulteriori opzioni per questo connettore, consulta il file [README di Amazon Athena CloudWatch Connector](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch) su. GitHub Il seguente esempio di codice Python mostra come leggere da un archivio dati Athena utilizzando un connettore Marketplace AWS . Mostra la lettura da Athena e la scrittura in una posizione 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() ``` ### Opzioni di connessione per il tipo custom.spark o marketplace.spark + `className`: stringa, obbligatorio, nome della classe del connettore. + `secretId`: stringa, facoltativo, utilizzato per recuperare le credenziali per la connessione del connettore. + `connectionName` – Stringa, obbligatorio, nome della connessione associata al connettore. + Altre opzioni dipendono dall'archivio dati. Ad esempio, le opzioni di OpenSearch configurazione iniziano con il prefisso`es`, come descritto nella documentazione di [Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/hadoop/current/configuration.html) for Apache Hadoop. Le connessioni Spark a Snowflake utilizzano opzioni come `sfUser` e `sfPassword`, come descritto in [Using the Spark Connector](https://docs.snowflake.com/en/user-guide/spark-connector-use.html) nella guida *Connecting to Snowflake*. Il seguente esempio di codice Python mostra come leggere da un archivio OpenSearch dati utilizzando una `marketplace.spark` connessione. ``` 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() ``` ## Opzioni generali Le opzioni in questa sezione sono fornite come connettore `connection_options`, ma non si applicano specificamente a tale connettore. I seguenti parametri vengono generalmente utilizzati per la configurazione dei segnalibri. Possono applicarsi ai flussi di lavoro Amazon S3 o JDBC. Per ulteriori informazioni, consulta [Utilizzo di segnalibri di processo](programming-etl-connect-bookmarks.md). + `jobBookmarkKeys`: un array di nomi di colonna. + `jobBookmarkKeysSortOrder`: una stringa che definisce come confrontare i valori in base all'ordinamento. Valori validi: `"asc"`, `"desc"`. + `useS3ListImplementation`: utilizzato per gestire le prestazioni della memoria quando si elencano i contenuti dei bucket Amazon S3. Per ulteriori informazioni, consulta [Ottimizzare la gestione della memoria in AWS Glue](https://aws.amazon.com/blogs/big-data/optimize-memory-management-in-aws-glue/).