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à. # Connessioni a DynamoDB Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in DynamoDB in Glue. AWS Ti connetti a DynamoDB utilizzando le autorizzazioni IAM allegate al tuo job Glue. AWS AWS Gluesupporta la scrittura di dati nella tabella DynamoDB di un altro AWS account. Per ulteriori informazioni, consulta [Accesso multi-account in più regioni alle tabelle DynamoDB](aws-glue-programming-etl-dynamo-db-cross-account.md). Il connettore DynamoDB originale utilizza oggetti DynamicFrame Glue per lavorare con i dati estratti da DynamoDB. AWS Glue 5.0\+ introduce una novità [Connettore DynamoDB con supporto Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) che fornisce il supporto nativo per Spark. DataFrame [Oltre al connettore AWS Glue DynamoDB ETL, puoi leggere da DynamoDB utilizzando il connettore di esportazione DynamoDB, che richiama una richiesta DynamoDB e la archivia in una posizione Amazon S3 da te `ExportTableToPointInTime` fornita, nel formato DynamoDB JSON.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) AWS Gluequindi crea un DynamicFrame oggetto leggendo i dati dalla posizione di esportazione di Amazon S3. Il writer DynamoDB è disponibile nella versione 1.0 di AWS Glue Glue o nelle versioni successive. Il connettore di esportazione DynamoDB per AWS Glue è disponibile nella versione 2.0 di AWS Glue o nelle versioni successive. Il nuovo connettore DynamoDB DataFrame basato su DynamoDB è disponibile nella versione AWS Glue 5.0 o successive. Per ulteriori informazioni su DynamoDB, consulta la documentazione di [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/). **Nota** Il lettore DynamoDB ETL non supporta filtri o predicati pushdown. ## Configurazione delle connessioni a MongoDB Per connetterti a DynamoDB AWS da Glue, concedi al ruolo IAM associato al AWS tuo job Glue l'autorizzazione a interagire con DynamoDB. Per ulteriori informazioni sulle autorizzazioni necessarie per leggere o scrivere da DynamoDB, consulta [Operazioni, risorse e chiavi di condizione per Amazon DynamoDB](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) nella documentazione di IAM. Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva: + Quando utilizzi il connettore di esportazione DynamoDB, devi configurare IAM in modo che il processo possa richiedere l'esportazione di tabelle DynamoDB. Inoltre, dovrai identificare un bucket Amazon S3 per l'esportazione e fornire le autorizzazioni appropriate in IAM affinché DynamoDB possa scrivervi e che il tuo job Glue possa leggerlo. AWS Per ulteriori informazioni, consulta [Richiesta di esportazione di una tabella in DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html). + Se il tuo job AWS Glue ha requisiti di connettività Amazon VPC specifici, usa il tipo di connessione `NETWORK` AWS Glue per fornire opzioni di rete. Poiché l'accesso a DynamoDB è autorizzato da IAM, non è necessario un tipo di connessione AWS Glue DynamoDB. ## Lettura e scrittura su DynamoDB Gli esempi di codice seguenti mostrano come leggere (tramite il connettore ETL) e scrivere tabelle DynamoDB. Mostrano la lettura da una tabella e la scrittura su un'altra tabella. ------ #### [ Python ] ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dyf = glue_context.create_dynamic_frame.from_options( connection_type="dynamodb", connection_options={"dynamodb.input.tableName": {{test_source}}, "dynamodb.throughput.read.percent": "1.0", "dynamodb.splits": "100" } ) print(dyf.getNumPartitions()) glue_context.write_dynamic_frame_from_options( frame=dyf, connection_type="dynamodb", connection_options={"dynamodb.output.tableName": {{test_sink}}, "dynamodb.throughput.write.percent": "1.0" } ) job.commit() ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.util.GlueArgParser import com.amazonaws.services.glue.util.Job import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.DynamoDbDataSink import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]): Unit = { val glueContext = new GlueContext(SparkContext.getOrCreate()) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) val dynamicFrame = glueContext.getSourceWithFormat( connectionType = "dynamodb", options = JsonOptions(Map( "dynamodb.input.tableName" -> {{test_source}}, "dynamodb.throughput.read.percent" -> "1.0", "dynamodb.splits" -> "100" )) ).getDynamicFrame() print(dynamicFrame.getNumPartitions()) val dynamoDbSink: DynamoDbDataSink = glueContext.getSinkWithFormat( connectionType = "dynamodb", options = JsonOptions(Map( "dynamodb.output.tableName" -> {{test_sink}}, "dynamodb.throughput.write.percent" -> "1.0" )) ).asInstanceOf[DynamoDbDataSink] dynamoDbSink.writeDynamicFrame(dynamicFrame) Job.commit() } } ``` ------ ## Utilizzo del connettore di esportazione DynamoDB Il connettore di esportazione ha prestazioni migliori rispetto al connettore ETL quando le dimensioni della tabella DynamoDB sono superiori a 80 GB. Inoltre, dato che la richiesta di esportazione è condotta al di fuori dei processi Spark in un processo AWS Glue, puoi abilitare [Scalabilità automatica di processi Glue AWS](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) per salvare l'utilizzo della DPU durante la richiesta di esportazione. Con il connettore di esportazione, non è inoltre necessario configurare il numero di divisioni per il parallelismo dell'esecutore Spark o la percentuale di lettura del throughput DynamoDB. **Nota** DynamoDB ha requisiti specifici per richiamare le richieste `ExportTableToPointInTime`. Per ulteriori informazioni, consulta [Richiesta di esportazione di una tabella in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Ad esempio, è necessario abilitare Point-in-Time-Restore (PITR) sulla tabella per utilizzare questo connettore. Il connettore DynamoDB supporta anche la AWS KMS crittografia per le esportazioni DynamoDB verso Amazon S3. L'indicazione della configurazione di sicurezza nella configurazione del job AWS Glue abilita la AWS KMS crittografia per un'esportazione DynamoDB. La chiave KMS deve essere nella stessa regione del bucket Amazon S3. Tieni presente che si applicano costi aggiuntivi per l'esportazione DynamoDB e i costi di storage Amazon S3. I dati esportati in Amazon S3 persistono al termine dell'esecuzione di un processo in modo da poterli riutilizzare senza ulteriori esportazioni DynamoDB. Un requisito per l'utilizzo di questo connettore è che il point-in-time ripristino (PITR) sia abilitato per la tabella. Il connettore ETL DynamoDB o il connettore di esportazione non supportano filtri o predicati pushdown da applicare all'origine DynamoDB. Gli esempi di codice seguenti mostrano come leggere (tramite il connettore di esportazione) e stampare il numero di partizioni. ------ #### [ Python ] ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dyf = glue_context.create_dynamic_frame.from_options( connection_type="dynamodb", connection_options={ "dynamodb.export": "ddb", "dynamodb.tableArn": {{test_source}}, "dynamodb.s3.bucket": {{bucket_name}}, "dynamodb.s3.prefix": {{bucket_prefix}}, "dynamodb.s3.bucketOwner": {{account_id_of_bucket}}, } ) print(dyf.getNumPartitions()) job.commit() ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.util.GlueArgParser import com.amazonaws.services.glue.util.Job import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.DynamoDbDataSink import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]): Unit = { val glueContext = new GlueContext(SparkContext.getOrCreate()) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) val dynamicFrame = glueContext.getSourceWithFormat( connectionType = "dynamodb", options = JsonOptions(Map( "dynamodb.export" -> "ddb", "dynamodb.tableArn" -> {{test_source}}, "dynamodb.s3.bucket" -> {{bucket_name}}, "dynamodb.s3.prefix" -> {{bucket_prefix}}, "dynamodb.s3.bucketOwner" -> {{account_id_of_bucket}}, )) ).getDynamicFrame() print(dynamicFrame.getNumPartitions()) Job.commit() } } ``` ------ Questi esempi mostrano come eseguire la lettura da (tramite il connettore di esportazione) e stampare il numero di partizioni da una tabella AWS Glue Data Catalog con una `dynamodb` classificazione: ------ #### [ Python ] ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dynamicFrame = glue_context.create_dynamic_frame.from_catalog( database={{catalog_database}}, table_name={{catalog_table_name}}, additional_options={ "dynamodb.export": "ddb", "dynamodb.s3.bucket": {{s3_bucket}}, "dynamodb.s3.prefix": {{s3_bucket_prefix}} } ) print(dynamicFrame.getNumPartitions()) job.commit() ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.util.GlueArgParser import com.amazonaws.services.glue.util.Job import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.DynamoDbDataSink import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]): Unit = { val glueContext = new GlueContext(SparkContext.getOrCreate()) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) val dynamicFrame = glueContext.getCatalogSource( database = {{catalog_database}}, tableName = {{catalog_table_name}}, additionalOptions = JsonOptions(Map( "dynamodb.export" -> "ddb", "dynamodb.s3.bucket" -> {{s3_bucket}}, "dynamodb.s3.prefix" -> {{s3_bucket_prefix}} )) ).getDynamicFrame() print(dynamicFrame.getNumPartitions()) ) ``` ------ ## Semplificazione dell'utilizzo del JSON di esportazione DynamoDB Le esportazioni di DynamoDB con il connettore di esportazione DynamoDB AWS Glue possono risultare in file JSON con specifiche strutture annidate. Per ulteriori informazioni, consulta [Oggetti dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Gluefornisce una DynamicFrame trasformazione che può trasformare tali strutture in una easier-to-use forma per le applicazioni a valle. La trasformazione può essere invocata in uno dei due modi possibili. Puoi impostare l'opzione di connessione `"dynamodb.simplifyDDBJson"` sul valore `"true"` quando effettui una chiamata a un metodo per leggere da DynamoDB. Puoi anche chiamare la trasformazione come metodo disponibile indipendentemente nella libreria AWS Glue. Prendi in considerazione lo schema seguente generato da un'esportazione DynamoDB: ``` root |-- Item: struct | |-- parentMap: struct | | |-- M: struct | | | |-- childMap: struct | | | | |-- M: struct | | | | | |-- appName: struct | | | | | | |-- S: string | | | | | |-- packageName: struct | | | | | | |-- S: string | | | | | |-- updatedAt: struct | | | | | | |-- N: string | |-- strings: struct | | |-- SS: array | | | |-- element: string | |-- numbers: struct | | |-- NS: array | | | |-- element: string | |-- binaries: struct | | |-- BS: array | | | |-- element: string | |-- isDDBJson: struct | | |-- BOOL: boolean | |-- nullValue: struct | | |-- NULL: boolean ``` La trasformazione `simplifyDDBJson` semplificherà questo processo in: ``` root |-- parentMap: struct | |-- childMap: struct | | |-- appName: string | | |-- packageName: string | | |-- updatedAt: string |-- strings: array | |-- element: string |-- numbers: array | |-- element: string |-- binaries: array | |-- element: string |-- isDDBJson: boolean |-- nullValue: null ``` **Nota** `simplifyDDBJson`è disponibile in AWS Glue 3.0 e versioni successive. Per semplificare il JSON di esportazione DynamoDB è disponibile anche la trasformazione `unnestDDBJson`. Incoraggiamo gli utenti a passare da `unnestDDBJson` a `simplifyDDBJson`. ## Configurazione del parallelismo nelle operazioni DynamoDB Per migliorare le prestazioni, è possibile regolare alcuni parametri disponibili per il connettore DynamoDB. Il vostro obiettivo quando regolate i parametri di paralleismo è massimizzare l'uso dei Glue worker forniti. AWS Quindi, se hai bisogno di maggiori prestazioni, ti consigliamo di ampliare il tuo lavoro aumentando il numero di. DPUs Puoi modificare il parallelismo in un'operazione di lettura di DynamoDB con il parametro `dynamodb.splits` quando utilizzi il connettore ETL. La lettura con il connettore di esportazione non richiede la configurazione del numero di divisioni per il parallelismo dell'esecutore Spark. Puoi modificare il parallelismo in un'operazione di scrittura DynamoDB con `dynamodb.output.numParallelTasks`. **Lettura con il connettore ETL per DynamoDB** Ti consigliamo di calcolare `dynamodb.splits` in base al numero massimo di worker impostato nella configurazione del lavoro e al seguente calcolo `numSlots`. In caso di dimensionamento automatico, il numero effettivo di worker disponibili potrebbe variare al di sotto di tale limite. Per ulteriori informazioni sull'impostazione del numero massimo di worker, consulta **Numero di worker** (`NumberOfWorkers`) in [Configurazione delle proprietà dei job per i job Spark in AWS Glue](add-job.md). + `numExecutors = NumberOfWorkers - 1` Per il contesto, un esecutore è riservato per il driver Spark; altri esecutori sono utilizzati per elaborare i dati. + `numSlotsPerExecutor =` ------ #### [ AWS Glue 3.0 and later versions ] + `4`: se `WorkerType` è `G.1X`. + `8`: se `WorkerType` è `G.2X`. + `16`: se `WorkerType` è `G.4X`. + `32`: se `WorkerType` è `G.8X`. ------ #### [ AWS Glue 2.0 and legacy versions ] + `8`: se `WorkerType` è `G.1X`. + `16`: se `WorkerType` è `G.2X`. ------ + `numSlots = numSlotsPerExecutor * numExecutors` Ti consigliamo di impostare `dynamodb.splits` sul numero di slot disponibili, `numSlots`. **Scrittura su DynamoDB** Il parametro `dynamodb.output.numParallelTasks` viene utilizzato per determinare il valore WCU per ogni attività Spark, utilizzando il seguente calcolo: `permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks` Il writer DynamoDB funzionerà al meglio se la configurazione rappresenta accuratamente il numero di attività Spark che scrivono su DynamoDB. In alcuni casi, potrebbe essere necessario sovrascrivere il calcolo predefinito per migliorare le prestazioni di scrittura. Se questo parametro non viene specificato, il valore WCU consentito per i processi Spark verrà calcolato automaticamente mediante la seguente formula: + + `numPartitions = dynamicframe.getNumPartitions()` + `numSlots` (come definito in precedenza in questa sezione) + `numParallelTasks = min(numPartitions, numSlots)` + Esempio 1: DPU=10, =Standard. WorkerType L'input DynamicFrame ha 100 partizioni RDD. + `numPartitions = 100` + `numExecutors = (10 - 1) * 2 - 1 = 17` + `numSlots = 4 * 17 = 68` + `numParallelTasks = min(100, 68) = 68` + Esempio 2: DPU=10, =Standard. WorkerType L'ingresso DynamicFrame ha 20 partizioni RDD. + `numPartitions = 20` + `numExecutors = (10 - 1) * 2 - 1 = 17` + `numSlots = 4 * 17 = 68` + `numParallelTasks = min(20, 68) = 20` **Nota** I lavori sulle versioni precedenti di AWS Glue e quelli che utilizzano Standard worker richiedono metodi diversi per calcolare il numero di slot. Se hai bisogno di ottimizzare le prestazioni di questi lavori, ti consigliamo di passare alle versioni supportate di AWS Glue. ## Indicazioni di riferimento per le opzioni di connessione a DynamoDB Indica una connessione ad Amazon DynamoDB. Le opzioni di connessione differiscono per una connessione sorgente e una connessione sink. ### "connectionType": "dynamodb" con il connettore ETL come origine Usa le seguenti opzioni di connessione `"connectionType": "dynamodb"` come sorgente, quando usi il connettore AWS Glue DynamoDB ETL: + `"dynamodb.input.tableName"`: (Obbligatorio) la tabella DynamoDB da cui leggere. + `"dynamodb.throughput.read.percent"`: (Facoltativo) percentuale di unità di capacità di lettura (RCU) da usare. Il valore predefinito è "0,5". I valori accettabili vanno da "0,1" a "1,5", inclusi. + `0.5` rappresenta la velocità di lettura di default, il che significa che AWS Glue cercherà di consumare metà della capacità di lettura della tabella. Se si aumenta il valore sopra `0.5`, AWS Glue aumenterà il tasso di richiesta; diminuendo il valore al di sotto di `0.5`, riduce la frequenza di richiesta di lettura. La velocità di lettura effettiva varia in base a fattori come la presenza di una distribuzione uniforme delle chiavi nella tabella DynamoDB. + Quando la tabella DynamoDB è in modalità on demand, AWS Glue gestisce la capacità di lettura della tabella a 40000. Per esportare una tabella di grandi dimensioni, si consiglia di passare alla modalità su richiesta della tabella DynamoDB. + `"dynamodb.splits"`: (Facoltativo) Definisce il numero di partizioni applicate a questa tabella DynamoDB durante la lettura. Il valore predefinito è "1". I valori accettabili vanno da "1" a "1,000,000", inclusi. `1` indica che non c'è parallelismo. Si consiglia vivamente di specificare un valore maggiore per migliorare le prestazioni utilizzando la formula riportata di seguito. Per ulteriori informazioni sull'impostazione corretta di un valore, consulta [Configurazione del parallelismo nelle operazioni DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism). + `"dynamodb.sts.roleArn"`: (Facoltativo) il ruolo IAM ARN da assumere per l'accesso multi-account. Questo parametro è disponibile in AWS Glue 1.0 o versione successiva. + `"dynamodb.sts.roleSessionName"`: (Facoltativo) nome della sessione STS. L'impostazione predefinita è "glue-dynamodb-read-sts-session». Questo parametro è disponibile in AWS Glue 1.0 o versione successiva. ### "connectionType": "dynamodb" con il connettore di esportazione DynamoDB AWS Glue come sorgente Utilizzare le seguenti opzioni di connessione con «connectionType»: «dynamodb» come origine, quando utilizzi il Connettore di esportazione DynamoDB AWS Glue, disponibile solo per la versione AWS Glue 2.0 in poi: + `"dynamodb.export"`: (Richiesto) Un valore stringa: + Se impostato su `ddb` abilita il Connettore di esportazione DynamoDB AWS Glue dove un nuovo `ExportTableToPointInTimeRequest` verrà invocato durante il processo AWS Glue. Verrà generata una nuova esportazione con la posizione passata da `dynamodb.s3.bucket` e `dynamodb.s3.prefix`. + Se impostato su `s3` abilita il Connettore di esportazione DynamoDB AWS Glue ma salta la creazione di una nuova esportazione DynamoDB e utilizza invece il `dynamodb.s3.bucket` e il `dynamodb.s3.prefix` come posizione di Amazon S3 di un'esportazione precedente di quella tabella. + `"dynamodb.tableArn"`: (Obbligatorio) la tabella DynamoDB da cui leggere. + `"dynamodb.unnestDDBJson"`: false per impostazione predefinita (facoltativo). Valori validi: booleani. Se impostato su true, esegue una trasformazione non nidificata della struttura JSON DynamoDB presente nelle esportazioni. È un errore impostare contemporaneamente `"dynamodb.unnestDDBJson"` e `"dynamodb.simplifyDDBJson"` su true. In AWS Glue 3.0 e versioni successive, si consiglia di utilizzare `"dynamodb.simplifyDDBJson"` per un comportamento migliore durante la semplificazione dei tipi di mappe DynamoDB. Per ulteriori informazioni, consulta [Semplificazione dell'utilizzo del JSON di esportazione DynamoDB](#etl-connect-dynamodb-traversing-structure). + `"dynamodb.simplifyDDBJson"`: false per impostazione predefinita (facoltativo). Valori validi: booleani. Se impostato su true, esegue una trasformazione per semplificare la struttura JSON DynamoDB presente nelle esportazioni. Questa opzione ha lo stesso scopo di `"dynamodb.unnestDDBJson"`, ma fornisce un supporto migliore per i tipi di mappe DynamoDB o per i tipi di mappe annidate nella tabella DynamoDB. Questa opzione è disponibile in AWS Glue 3.0 e versioni successive. È un errore impostare contemporaneamente `"dynamodb.unnestDDBJson"` e `"dynamodb.simplifyDDBJson"` su true. Per ulteriori informazioni, consulta [Semplificazione dell'utilizzo del JSON di esportazione DynamoDB](#etl-connect-dynamodb-traversing-structure). + `"dynamodb.s3.bucket"`: (facoltativo) indica la posizione del bucket Amazon S3 in cui deve essere condotto il processo DynamoDB `ExportTableToPointInTime`. Il formato del file per l'esportazione è DynamoDB JSON. + `"dynamodb.s3.prefix"`: (facoltativo) indica la posizione del prefisso di Amazon S3 all'interno del bucket Amazon S3 in cui devono essere archiviati i carichi `ExportTableToPointInTime` di DynamoDB. Se non si specificano i valori `dynamodb.s3.prefix` e `dynamodb.s3.bucket`, per impostazione predefinita sarà utilizzata la posizione della directory temporanea specificata nella configurazione del processo AWS Glue. Per ulteriori informazioni, vedere [Parametri speciali utilizzati da AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html). + `"dynamodb.s3.bucketOwner"`: indica il proprietario del bucket necessario per l'accesso di Amazon S3 tra account. + `"dynamodb.sts.roleArn"`: (Facoltativo) L'ARN del ruolo IAM da assumere per l'accesso tra account e più and/or regioni per la tabella DynamoDB. Nota: lo stesso ARN del ruolo IAM verrà utilizzato per accedere alla posizione Amazon S3 specificata per la richiesta `ExportTableToPointInTime`. + `"dynamodb.sts.roleSessionName"`: (Facoltativo) nome della sessione STS. L'impostazione predefinita è "-session». glue-dynamodb-read-sts + `"dynamodb.exportTime"` (facoltativo). Valori validi: stringhe che rappresentano istanti ISO-8601. point-in-timeA in cui deve essere effettuata l'esportazione. + `"dynamodb.sts.region"`: la regione che ospita la tabella DynamoDB da leggere (obbligatorio se si effettua una chiamata tra regioni utilizzando un endpoint regionale). ### "connectionType": "dynamodb" con il connettore ETL come sink Utilizzare le seguenti opzioni di connessione con `"connectionType": "dynamodb"` come sink: + `"dynamodb.output.tableName"`: (Obbligatorio) la tabella DynamoDB su cui scrivere. + `"dynamodb.throughput.write.percent"`: (Facoltativo) percentuale di unità di capacità di scrittura (WCU) da usare. Il valore predefinito è "0,5". I valori accettabili vanno da "0,1" a "1,5", inclusi. + `0.5` rappresenta la velocità di scrittura di default, il che significa che AWS Glue cercherà di consumare metà della capacità di scrittura della tabella. Se si aumenta il valore sopra 0,5, AWS Glue aumenterà il tasso di richiesta; diminuendo il valore al di sotto di 0,5, riduce la frequenza di richiesta di scrittura. (La velocità di scrittura effettiva varia in base a fattori come la presenza di una distribuzione uniforme delle chiavi nella tabella DynamoDB). + Quando la tabella DynamoDB è in modalità on demand, AWS Glue gestisce la capacità di lettura della tabella come `40000`. Per importare una tabella di grandi dimensioni, si consiglia di passare alla modalità su richiesta della tabella DynamoDB. + `"dynamodb.output.numParallelTasks"`: (Facoltativo) definisce il numero di attività parallele scritte contemporaneamente in DynamoDB. Utilizzato per calcolare WCU permissivo per i processi Spark. Nella maggior parte dei casi, AWS Glue calcolerà un valore predefinito ragionevole per questo valore. Per ulteriori informazioni, consulta [Configurazione del parallelismo nelle operazioni DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism). + `"dynamodb.output.retry"`: (Facoltativo) definisce il numero di tentativi eseguiti quando esiste una `ProvisionedThroughputExceededException` da DynamoDB. Il valore predefinito è "10". + `"dynamodb.sts.roleArn"`: (facoltativo) il ruolo IAM ARN da assumere per l'accesso multi-account. + `"dynamodb.sts.roleSessionName"`: (Facoltativo) nome della sessione STS. L'impostazione predefinita è "glue-dynamodb-write-sts-session».