Sélectionner vos préférences de cookies

Nous utilisons des cookies essentiels et des outils similaires qui sont nécessaires au fonctionnement de notre site et à la fourniture de nos services. Nous utilisons des cookies de performance pour collecter des statistiques anonymes afin de comprendre comment les clients utilisent notre site et d’apporter des améliorations. Les cookies essentiels ne peuvent pas être désactivés, mais vous pouvez cliquer sur « Personnaliser » ou « Refuser » pour refuser les cookies de performance.

Si vous êtes d’accord, AWS et les tiers approuvés utiliseront également des cookies pour fournir des fonctionnalités utiles au site, mémoriser vos préférences et afficher du contenu pertinent, y compris des publicités pertinentes. Pour accepter ou refuser tous les cookies non essentiels, cliquez sur « Accepter » ou « Refuser ». Pour effectuer des choix plus détaillés, cliquez sur « Personnaliser ».

Connexions DynamoDB

Mode de mise au point
Connexions DynamoDB - AWS Glue

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Vous pouvez utiliser AWS Glue pour Spark pour lire et écrire dans des tables DynamoDB dans AWS Glue. Vous vous connectez à DynamoDB à l’aide des autorisations IAM associées à votre tâche AWS Glue. AWS Glue prend en charge l’écriture de données dans la table DynamoDB du compte AWS. Pour de plus amples informations, veuillez consulter Accès entre régions et entre comptes aux tables DynamoDB.

En plus du connecteur ETL DynamoDB AWS Glue, vous pouvez lire à partir de DynamoDB à l’aide du connecteur d’exportation DynamoDB, qui invoque une demande ExportTableToPointInTime DynamoDB et la stocke dans un emplacement Amazon S3 que vous fournissez, au format JSON DynamoDB. AWS Glue crée ensuite un objet DynamicFrame en lisant les données à partir de l’emplacement d’exportation Amazon S3.

Le dispositif d’écriture DynamoDB est disponible dans la version 1.0 ou les versions ultérieures de AWS Glue. Le dispositif de connecteur d’exportation DynamoDB AWS Glue est disponible dans la version 2.0 ou les versions ultérieures d’AWS Glue.

Pour plus d’informations sur DynamoDB, consultez la documentation Amazon DynamoDB.

Note

Le lecteur ETL DynamoDB ne prend pas en charge les filtres ou les prédicats pushdown.

Configuration de connexions DynamoDB

Pour vous connecter à DynamoDB à partir d’AWS Glue, accordez au rôle IAM associé à votre tâche AWS Glue l’autorisation d’interagir avec DynamoDB. Pour plus d’informations sur les autorisations requises pour lire ou écrire à partir de DynamoDB, consultez Actions, ressources et clés de condition pour DynamoDB dans la documentation IAM.

Dans les situations suivantes, vous autre peut-être besoin d’une configuration supplémentaire :

  • Lorsque vous utilisez le connecteur d’exportation DynamoDB, vous devez configurer IAM pour que votre tâche puisse demander des exportations de tables DynamoDB. En outre, vous devez identifier un compartiment Amazon S3 pour l’exportation et fournir les autorisations appropriées dans IAM pour que DynamoDB puisse y écrire, et pour que votre tâche AWS Glue puisse y lire. Pour plus d’informations, consultez Demande d’exportation de table dans DynamoDB.

  • Si votre tâche AWS Glue comporte des exigences de connectivité Amazon VPC spécifiques, utilisez le type de connexion NETWORK AWS Glue pour fournir des options réseau. L’accès à DynamoDB étant autorisé par IAM, il n’est pas nécessaire d’utiliser un type de connexion AWS Glue DynamoDB.

Lecture et écriture dans DynamoDB

Les exemples de code suivants montrent comment lire et écrire des tables DynamoDB. Ils montrent la lecture d'une table et l'écriture dans une autre table.

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() } }
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()

Utilisation du connecteur d’exportation DynamoDB

Le connecteur d'exportation fonctionne mieux que le connecteur ETL lorsque la taille de la table DynamoDB est supérieure à 80 Go. En outre, étant donné que la demande d'exportation est effectuée en dehors des processus Spark dans une tâche AWS Glue, vous pouvez activer l'auto scaling des tâches AWS Glue pour enregistrer l'utilisation du DPU pendant la demande d'exportation. Avec le connecteur d'exportation, vous n'avez pas non plus besoin de configurer le nombre de fractionnements pour le parallélisme de l'exécuteur Spark ou le pourcentage de lecture du débit DynamoDB.

Note

DynamoDB a des exigences spécifiques pour recourir aux demandes ExportTableToPointInTime. Pour plus d'informations, consultez Demande d'exportation de table dans DynamoDB. Par exemple, la restauration à un point dans le temps (PITR) doit être activée sur la table pour utiliser ce connecteur. Le connecteur DynamoDB prend également en charge le chiffrement AWS KMS pour les exportations DynamoDB vers Amazon S3. La mise à disposition de votre configuration de sécurité dans la configuration de la tâche AWS Glue active le chiffrement AWS KMS pour une exportation DynamoDB. La clé KMS doit être située dans la même région que le compartiment Simple Storage Service (Amazon S3).

Notez que des frais supplémentaires pour l'exportation DynamoDB et les coûts de stockage Simple Storage Service (Amazon S3) s'appliquent. Les données exportées dans Simple Storage Service (Amazon S3) sont conservées une fois l'exécution d'une tâche terminée, ce qui vous permet de les réutiliser sans exportations DynamoDB supplémentaires. Pour utiliser ce connecteur, la récupération ponctuelle (PITR) doit être activée pour la table.

Le connecteur ETL DynamoDB ou le connecteur d'exportation ne prennent pas en charge les filtres ou les prédicats pushdown à appliquer à la source DynamoDB.

Les exemples de code suivants montrent comment lire (via le connecteur d'exportation) et comment imprimer le nombre de partitions.

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() } }
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()

Ces exemples montrent comment lire (via le connecteur d'exportation) et comment imprimer le nombre de partitions à partir d'une table de catalogue de données AWS Glue qui comporte une classification 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()) )
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()

Simplification de l’utilisation de l’exportation DynamoDB au format JSON

Les exportations DynamoDB avec le connecteur d’exportation AWS Glue DynamoDB donnent lieu à des fichiers JSON de structures imbriquées spécifiques. Pour plus d'informations, consultez Objets de données. AWS Gluefournit une transformation DynamicFrame, qui peut supprimer l'imbrication de telles structures dans un formulaire plus facile à utiliser pour les applications en aval.

La transformation peut être appelée de deux manières. Vous pouvez définir l’option de connexion "dynamodb.simplifyDDBJson" avec la valeur "true" lorsque vous appelez une méthode pour lire à partir de DynamoDB. Vous pouvez également appeler la transformation en tant que méthode disponible de façon indépendante dans la bibliothèque AWS Glue.

Tenez compte du schéma suivant généré par une exportation 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 transformation simplifyDDBJson simplifie cette exportation ainsi :

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
Note

simplifyDDBJson est disponible dans les versions AWS Glue 3.0 et ultérieures. La transformation unnestDDBJson est également disponible pour simplifier l’exportation DynamoDB au format JSON. Nous encourageons les utilisateurs à passer de simplifyDDBJson à unnestDDBJson.

Configuration du parallélisme des opérations de DynamoDB

Pour améliorer les performances, vous pouvez régler certains paramètres disponibles pour le connecteur DynamoDB. Lorsque vous réglez les paramètres de parallélisme, votre objectif est d’optimiser l’utilisation des employés alloués dans AWS Glue. Ensuite, si vous avez besoin de plus de performances, nous vous recommandons de monter en puissance votre tâche en augmentant le nombre de DPU.

Vous pouvez modifier le parallélisme dans une opération de lecture de DynamoDB à l’aide du paramètre dynamodb.splits lorsque vous utilisez le connecteur ETL. Lors d’une tâche de lecture avec le connecteur d’exportation, vous n’avez pas besoin de configurer le nombre de fractionnements pour le parallélisme de l’exécuteur Spark. Vous pouvez modifier le parallélisme dans une opération d’écriture de DynamoDB avec dynamodb.output.numParallelTasks.

Lecture avec le connecteur ETL DynamoDB

Nous vous recommandons de calculer dynamodb.splits en fonction du nombre maximum d’employés défini dans la configuration de votre tâche et du calcul numSlots suivant. En cas de mise à l’échelle automatique, le nombre réel d’employés disponibles peut changer et passer en dessous de ce plafond. Pour plus d’informations sur la définition du nombre maximum d’employés, consultez Nombre d’employés (NumberOfWorkers) dans Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue.

  • numExecutors = NumberOfWorkers - 1

    À des fins de contexte, un exécuteur est réservé au pilote Spark ; d'autres exécuteurs sont utilisés pour traiter les données.

  • numSlotsPerExecutor =

    AWS Glue 3.0 and later versions
    • 4 si WorkerType a la valeur G.1X

    • 8 si WorkerType a la valeur G.2X

    • 16 si WorkerType a la valeur G.4X

    • 32 si WorkerType a la valeur G.8X

    AWS Glue 2.0 and legacy versions
    • 8 si WorkerType a la valeur G.1X

    • 16 si WorkerType a la valeur G.2X

    • 4 si WorkerType a la valeur G.1X

    • 8 si WorkerType a la valeur G.2X

    • 16 si WorkerType a la valeur G.4X

    • 32 si WorkerType a la valeur G.8X

  • numSlots = numSlotsPerExecutor * numExecutors

Nous vous recommandons de définir dynamodb.splits sur le nombre d’emplacements disponibles, numSlots.

Écriture dans DynamoDB

Le paramètre dynamodb.output.numParallelTasks est utilisé pour déterminer le WCU par tâche Spark, à l’aide du calcul suivant :

permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks

Le dispositif d’écriture DynamoDB fonctionne de manière optimale si la configuration représente avec précision le nombre de tâches Spark écrites dans DynamoDB. Dans certains cas, il se peut que vous ayez besoin de remplacer le calcul par défaut afin d’améliorer les performances d’écriture. Si vous ne spécifiez pas ce paramètre, le WCU autorisé pour chaque tâche Spark est automatiquement calculé par la formule suivante :

    • numPartitions = dynamicframe.getNumPartitions()

    • numSlots (tel que défini précédemment dans cette section)

    • numParallelTasks = min(numPartitions, numSlots)

  • Exemple 1 : DPU=10, WorkerType=Standard. L'entrée DynamicFrame possède 100 partitions RDD.

    • numPartitions = 100

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

    • numSlots = 4 * 17 = 68

    • numParallelTasks = min(100, 68) = 68

  • Exemple 2. DPU=10, WorkerType=Standard. L'entrée DynamicFrame possède 20 partitions RDD.

    • numPartitions = 20

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

    • numSlots = 4 * 17 = 68

    • numParallelTasks = min(20, 68) = 20

Note

Les tâches sur les anciennes versions d’AWS Glue et celles qui utilisent des employés en configuration Standard nécessitent des méthodes différentes pour calculer le nombre d’emplacements. Si vous avez besoin de régler les performances de ces tâches, nous vous recommandons de passer aux versions AWS Glue qui sont prises en charge.

Référence des options de connexion DynamoDB

Désigne une connexion à Amazon DynamoDB.

Les options de connexion sont différentes pour une connexion source et une connexion collecteur.

« connectionType » : « dynamodb » avec le connecteur ETL comme source

Utilisez les options de connexion suivantes avec "connectionType": "dynamodb" en tant que source, lorsque vous utilisez le connecteur ETL DynamoDB AWS Glue :

  • "dynamodb.input.tableName" : (obligatoire) table DynamoDB à lire.

  • "dynamodb.throughput.read.percent" : (Facultatif) Le pourcentage d'unités de capacité de lecture à utiliser. La valeur définie par défaut est « 0,5 ». Valeurs acceptées : de 0,1 à 1,5 inclus.

    • 0.5 représente la vitesse de lecture par défaut, ce qui signifie que AWS Glue tente de consommer la moitié de la capacité de lecture de la table. Si vous augmentez la valeur au-delà de 0.5, AWS Glue augmente le débit de demandes. Si vous réduisez la valeur en dessous de 0.5, le débit de demandes de lecture baisse. (La vitesse de lecture réelle dépend de facteurs tels que l'existence d'une distribution uniforme des clés dans la table DynamoDB.)

    • Lorsque la table DynamoDB est en mode à la demande, AWS Glue gère la capacité de lecture de la table à 40 000. Pour exporter une table volumineuse, nous vous recommandons de basculer votre table DynamoDB en mode à la demande.

  • "dynamodb.splits" : (facultatif) définit en combien de fractionnements nous partitionnons cette table DynamoDB lors de la lecture. La valeur définie par défaut est « 1 ». Valeurs acceptées : de 1 à 1 000 000 inclus.

    1 montre qu'il n'y a pas de parallélisme. Nous vous recommandons fortement de spécifier une valeur plus élevée pour de meilleures performances en utilisant la formule ci-dessous. Pour plus d’informations sur la définition appropriée d’une valeur, consultez Configuration du parallélisme des opérations de DynamoDB.

  • "dynamodb.sts.roleArn" : (facultatif) l'ARN du rôle IAM à endosser pour l'accès entre comptes. Ce paramètre est disponible dans AWS Glue 1.0 ou une version ultérieure.

  • "dynamodb.sts.roleSessionName" : (facultatif) nom de séance STS. La valeur par défaut est définie sur « glue-dynamodb-read-sts-session ». Ce paramètre est disponible dans AWS Glue 1.0 ou une version ultérieure.

« connectionType » : « dynamodb » avec le connecteur d'exportation DynamoDB AWS Glue comme source

Utilisez les options de connexion suivantes avec « connectionType » : « dynamodb » en tant que source, lorsque vous utilisez le connecteur d'exportation DynamoDB AWS Glue, disponible uniquement pour AWS Glue version 2.0 et au-delà :

  • "dynamodb.export" : (Obligatoire) Une valeur de chaîne :

    • Si la valeur est définie sur ddb, le connecteur d'exportation DynamoDB AWS Glue est activé où un nouveau paramètre ExportTableToPointInTimeRequest sera invoqué pendant la tâche AWS Glue. Une nouvelle exportation sera générée avec l'emplacement transmis depuis dynamodb.s3.bucket et dynamodb.s3.prefix.

    • Si la valeur est définie sur s3, le connecteur d'exportation DynamoDB AWS Glue est activé, mais ignore la création d'une nouvelle exportation DynamoDB et utilise plutôt les paramètres dynamodb.s3.bucket et dynamodb.s3.prefix en tant qu'emplacement Amazon S3 d'une exportation antérieure de cette table.

  • "dynamodb.tableArn" : (obligatoire) table DynamoDB à lire.

  • "dynamodb.unnestDDBJson" : (Facultatif) Par défaut : false. Valeurs valides : booléen. S'il est paramétré sur true, il effectue une transformation irréprochable de la structure JSON DynamoDB présente dans les exportations. Définir "dynamodb.unnestDDBJson" et "dynamodb.simplifyDDBJson" sur true en même temps constitue une erreur. Dans les versions AWS Glue 3.0 et ultérieures, nous vous recommandons d’utiliser "dynamodb.simplifyDDBJson" pour un meilleur comportement lors de la simplification des types de cartes DynamoDB. Pour de plus amples informations, veuillez consulter Simplification de l’utilisation de l’exportation DynamoDB au format JSON.

  • "dynamodb.simplifyDDBJson" : (Facultatif) Par défaut : false. Valeurs valides : booléen. S’il est paramétré sur true, il effectue une transformation pour simplifier le schéma de la structure JSON DynamoDB présente dans les exportations. Cela a le même objectif que l’option "dynamodb.unnestDDBJson", mais fournit une meilleure prise en charge des types de cartes DynamoDB ou même des types de cartes imbriqués dans votre table DynamoDB. Cette option est disponible dans les versions AWS Glue 3.0 et ultérieures. Définir "dynamodb.unnestDDBJson" et "dynamodb.simplifyDDBJson" sur true en même temps constitue une erreur. Pour de plus amples informations, veuillez consulter Simplification de l’utilisation de l’exportation DynamoDB au format JSON.

  • "dynamodb.s3.bucket" : (facultatif) Indique l'emplacement du compartiment Amazon S3 dans lequel le processus DynamoDB ExportTableToPointInTime doit être mené. Le format de fichier de l'exportation est DynamoDB JSON.

    • "dynamodb.s3.prefix" : (Facultatif) Indique l'emplacement du préfixe Amazon S3 dans le compartiment Amazon S3 dans lequel les charges ExportTableToPointInTime de DynamoDB doivent être stockées. Si dynamodb.s3.prefix ni dynamodb.s3.bucket ne sont indiqués, ces valeurs seront par défaut à l'emplacement du répertoire temporaire indiqué dans la configuration de la tâche AWS Glue. Pour plus d'informations, consultez Paramètres spéciaux utilisés par AWS Glue.

    • "dynamodb.s3.bucketOwner" : indique le propriétaire du compartiment nécessaire à l'accès Amazon S3 entre comptes.

  • "dynamodb.sts.roleArn" : (facultatif) ARN du rôle IAM à endosser pour l'accès intercompte et/ou l'accès entre régions pour la table DynamoDB. Remarque : Le même ARN de rôle IAM sera utilisé pour accéder à l'emplacement Amazon S3 spécifié pour la demande de ExportTableToPointInTime.

  • "dynamodb.sts.roleSessionName" : (facultatif) nom de séance STS. La valeur par défaut est définie sur « glue-dynamodb-read-sts-session ».

  • "dynamodb.exportTime" (Facultatif) Valeurs valides : chaînes représentant des instants ISO-8601. Moment où l’exportation doit être effectuée.

  • "dynamodb.sts.region" : (Obligatoire si vous passez un appel entre régions à l’aide d’un point de terminaison régional) Région hébergeant la table DynamoDB que vous souhaitez lire.

« connectionType » : « dynamodb » avec le connecteur ETL comme récepteur

Utilisez les options de connexion suivantes avec "connectionType": "dynamodb" comme collecteur :

  • "dynamodb.output.tableName" : (obligatoire) table DynamoDB où écrire.

  • "dynamodb.throughput.write.percent" : (facultatif) pourcentage d'unités de capacité de lecture (WCU) à utiliser. La valeur définie par défaut est « 0,5 ». Valeurs acceptées : de 0,1 à 1,5 inclus.

    • 0.5 représente la vitesse d'écriture par défaut, ce qui signifie que AWS Glue tente de consommer la moitié de la capacité d'écriture de la table. Si vous augmentez la valeur au-delà de 0,5, AWS Glue augmente le débit de demandes. Si vous réduisez la valeur en dessous de 0,5, le débit de demandes d'écriture baisse. (La vitesse d'écriture réelle dépend de facteurs tels que l'existence d'une distribution uniforme des clés dans la table DynamoDB.)

    • Lorsque la table DynamoDB est en mode à la demande, AWS Glue gère la capacité d'écriture de la table à 40000. Pour importer une table volumineuse, nous vous recommandons de basculer votre table DynamoDB en mode à la demande.

  • "dynamodb.output.numParallelTasks" : (facultatif) définit le nombre de tâches parallèles qui écrivent dans DynamoDB simultanément. Utilisé pour calculer le WCU permissif par tâche Spark. Dans la plupart des cas, AWS Glue calcule une valeur par défaut raisonnable pour cette valeur. Pour de plus amples informations, veuillez consulter Configuration du parallélisme des opérations de DynamoDB.

  • "dynamodb.output.retry" : (facultatif) définit le nombre de tentatives que nous effectuons lorsqu'il y a un ProvisionedThroughputExceededException de DynamoDB. La valeur définie par défaut est « 10 ».

  • "dynamodb.sts.roleArn" : (facultatif) l'ARN du rôle IAM à endosser pour l'accès entre comptes.

  • "dynamodb.sts.roleSessionName" : (facultatif) nom de séance STS. La valeur par défaut est définie sur « glue-dynamodb-write-sts-session ».

ConfidentialitéConditions d'utilisation du sitePréférences de cookies
© 2024, Amazon Web Services, Inc. ou ses affiliés. Tous droits réservés.