Connessioni a DynamoDB - AWS Glue
Configurazione di DynamoDBUtilizzo di DynamoDBConnettore di esportazione DynamoDBSemplificazione dell'utilizzo del JSON di esportazione DynamoDBParallelismo di DynamoDBConnessione DynamoDB

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 utilizzare AWS Glue per Spark per la lettura e la scrittura su tabelle in DynamoDB per AWS Glue. Puoi connetterti a DynamoDB utilizzando le autorizzazioni IAM allegate al processo AWS Glue. AWS Glue supporta la scrittura di dati nella tabella DynamoDB di un altro account AWS. Per ulteriori informazioni, consulta Accesso multi-account in più regioni alle tabelle DynamoDB.

Oltre al connettore ETL per DynamoDB AWS Glue, è possibile leggere da DynamoDB utilizzando il connettore di esportazione DynamoDB, che richiama una richiesta DynamoDB ExportTableToPointInTime e la archivia in una posizione Amazon S3 da te fornita, nel formato JSON di DynamoDB. AWS Glue crea quindi un oggetto DynamicFrame 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.

Per ulteriori informazioni su DynamoDB, consulta la documentazione di Amazon DynamoDB.

Nota

Il lettore DynamoDB ETL non supporta filtri o predicati pushdown.

Configurazione delle connessioni a MongoDB

Per connetterti a DynamoDB da AWS Glue, concedi al ruolo IAM associato al processo AWS 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 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 per fare in modo che DynamoDB sia in grado di scrivere sul bucket e il processo AWS Glue sia in grado di leggere da esso. Per ulteriori informazioni, consulta Richiesta di esportazione di una tabella in DynamoDB.

  • Se il processo AWS Glue dispone di requisiti di connettività Amazon VPC specifici, usa il tipo di connessione NETWORK di AWS Glue per fornire opzioni di rete. Poiché l'accesso a DynamoDB è autorizzato da IAM, non è necessario un tipo di connessione DynamoDB per AWS Glue.

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 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. Ad esempio, è necessario abilitare Point-in-Time-Restore (PITR) sulla tabella per utilizzare questo connettore. Il connettore DynamoDB supporta la crittografia AWS KMS per le esportazioni DynamoDB in Amazon S3. Specificando la configurazione di sicurezza nella configurazione del processo AWS Glue, si abilita la crittografia AWS KMS 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. Per utilizzare questo connettore, è necessario che il ripristino point-in-time (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 leggere (tramite il connettore di esportazione) e stampare il numero di partizioni da una Tabella Glue Data Catalog AWS che ha una classificazione dynamodb:

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. AWS Glue fornisce una trasformazione DynamicFrame, che può snidificare tali strutture in una forma più facile da usare 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 effettuare una chiamata alla trasformazione come metodo disponibile in modo indipendente nella libreria di 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 solo 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. L'obiettivo dell'ottimizzazione dei parametri di parallelismo è massimizzare l'utilizzo dei worker AWS Glue di cui è stato effettuato il provisioning. Se hai bisogno di prestazioni più elevate, ti consigliamo quindi di impiegare la scalabilità orizzontale per il processo aumentando il numero di DPU.

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.

  • 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, WorkerType=Standard. 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, WorkerType=Standard. L'input DynamicFrame ha 20 partizioni RDD.

    • numPartitions = 20

    • numExecutors = (10 - 1) * 2 - 1 = 17

    • numSlots = 4 * 17 = 68

    • numParallelTasks = min(20, 68) = 20

Nota

I processi sulle versioni precedenti di AWS Glue e quelli che utilizzano worker standard richiedono metodi diversi per calcolare il numero di slot. Se hai bisogno di ottimizzare le prestazioni di tali processi, ti consigliamo di passare alle versioni di AWS Glue supportate.

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

Utilizzare le seguenti opzioni di connessione con "connectionType": "dynamodb" come origine, quando utilizzi Connettore ETL per Glue DynamoDB AWS:

  • "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.

  • "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. Il valore predefinito è impostato su "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, ti consigliamo di utilizzare "dynamodb.simplifyDDBJson" per ottenere un comportamento migliore durante la semplificazione dei tipi di mappe DynamoDB. Per ulteriori informazioni, consulta Semplificazione dell'utilizzo del JSON di esportazione DynamoDB.

  • "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.

  • "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, consulta Parametri speciali usati da AWS Glue.

    • "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 multi-account e/o l'accesso tra 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. Il valore predefinito è impostato su "glue-dynamodb-read-sts-session".

  • "dynamodb.exportTime" (facoltativo). Valori validi: stringhe che rappresentano istanti ISO-8601. Un point-in-time 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.

  • "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. Il valore predefinito è impostato su "glue-dynamodb-write-sts-session".