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.

# Connexions DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-home"></a>

Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables de DynamoDB dans Glue. AWS Vous vous connectez à DynamoDB à l'aide des autorisations IAM associées à votre tâche Glue. AWS AWS Glueprend en charge l'écriture de données dans la table DynamoDB d'un autre AWS compte. Pour de plus amples informations, veuillez consulter [Accès entre régions et entre comptes aux tables DynamoDB](aws-glue-programming-etl-dynamo-db-cross-account.md).

Le connecteur DynamoDB d'origine utilise des objets DynamicFrame Glue pour travailler avec les données extraites de DynamoDB. AWS Glue 5.0\$1 introduit une nouveauté [Connecteur DynamoDB avec prise en charge de Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) qui fournit le support natif de Spark DataFrame .

[Outre le connecteur AWS Glue DynamoDB ETL, vous pouvez lire depuis DynamoDB à l'aide du connecteur d'exportation DynamoDB, qui appelle une demande DynamoDB et la stocke dans un emplacement Amazon `ExportTableToPointInTime` S3 que vous fournissez, au format DynamoDB JSON.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) AWS Gluecrée ensuite un DynamicFrame objet en lisant les données depuis le site 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. Le nouveau connecteur DataFrame DynamoDB est disponible dans la version 5.0 ou les versions ultérieures de AWS Glue.

Pour plus d’informations sur DynamoDB, consultez la [documentation Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).

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

## Configuration de connexions DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-configure"></a>

Pour vous connecter à DynamoDB AWS depuis Glue, accordez au rôle IAM associé à AWS votre tâche 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](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) 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 devrez 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](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html).
+ 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 de recourir à un type de connexion AWS Glue DynamoDB.

## Lecture et écriture dans DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-read-write"></a>

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

}
```

------

## Utilisation du connecteur d’exportation DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-export-connector"></a>

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](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) 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](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Par exemple, Point-in-Time-Restore (PITR) doit être activé sur la table pour utiliser ce connecteur. Le connecteur DynamoDB prend également en charge le AWS KMS chiffrement pour les exportations DynamoDB vers Amazon S3. La saisie de votre configuration de sécurité dans la configuration de la tâche AWS Glue active AWS KMS le chiffrement 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. L'une des conditions requises pour utiliser ce connecteur est que point-in-time la restauration (PITR) soit 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()
  }

}
```

------

Ces exemples montrent comment effectuer la lecture (via le connecteur d'exportation) et imprimer le nombre de partitions à partir d'une table AWS Glue Data Catalog comportant une `dynamodb` classification :

------
#### [ 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())
)
```

------

## Simplification de l’utilisation de l’exportation DynamoDB au format JSON
<a name="etl-connect-dynamodb-traversing-structure"></a>

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 la section [Objets de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Gluefournit une DynamicFrame transformation qui peut transformer ces structures en une easier-to-use forme destinée à des 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 indépendamment 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 AWS Glue 3.0 et versions 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
<a name="aws-glue-programming-etl-connect-dynamodb-parallelism"></a>

Pour améliorer les performances, vous pouvez régler certains paramètres disponibles pour le connecteur DynamoDB. Lorsque vous ajustez les paramètres de parallélisme, votre objectif est de maximiser l'utilisation des AWS Glue workers provisionnés. Ensuite, si vous avez besoin de plus de performances, nous vous recommandons d'étendre votre travail en augmentant le nombre de DPUs. 

 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](add-job.md). 
+ `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`

------
+ `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, = Norme. WorkerType L'entrée DynamicFrame comporte 100 partitions RDD.
  + `numPartitions = 100`
  + `numExecutors = (10 - 1) * 2 - 1 = 17`
  + `numSlots = 4 * 17 = 68`
  + `numParallelTasks = min(100, 68) = 68`
+ Exemple 2. DPU = 10, = Norme. WorkerType L'entrée DynamicFrame comporte 20 partitions RDD.
  + `numPartitions = 20`
  + `numExecutors = (10 - 1) * 2 - 1 = 17`
  + `numSlots = 4 * 17 = 68`
  + `numParallelTasks = min(20, 68) = 20`

**Note**  
Les jobs sur les anciennes versions de AWS Glue et ceux utilisant des outils Standard Workers nécessitent des méthodes différentes pour calculer le nombre d'emplacements. Si vous avez besoin d'optimiser les performances de ces tâches, nous vous recommandons de passer aux versions compatibles de AWS Glue.

## Référence des options de connexion DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb"></a>

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
<a name="etl-connect-dynamodb-as-source"></a>

Utilisez les options de connexion suivantes en `"connectionType": "dynamodb"` tant que source, lorsque vous utilisez le connecteur ETL AWS Glue DynamoDB :
+ `"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](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"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
<a name="etl-connect-dynamodb-as-source-export-connector"></a>

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 AWS versions 3.0 et ultérieures, nous vous recommandons de l'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](#etl-connect-dynamodb-traversing-structure). 
+ `"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 AWS Glue 3.0 et versions 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](#etl-connect-dynamodb-traversing-structure).
+ `"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 la section [Paramètres spéciaux utilisés par AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html).
  + `"dynamodb.s3.bucketOwner"` : indique le propriétaire du compartiment nécessaire à l'accès Amazon S3 entre comptes.
+ `"dynamodb.sts.roleArn"`: (Facultatif) L'ARN du rôle IAM à utiliser pour l'accès entre comptes L'accès and/or interrégional à 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. point-in-timeA 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
<a name="etl-connect-dynamodb-as-sink"></a>

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](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"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 ».

# Accès entre régions et entre comptes aux tables DynamoDB
<a name="aws-glue-programming-etl-dynamo-db-cross-account"></a>

AWS Glue Les tâches ETL prennent en charge l'accès entre régions et entre comptes aux tables DynamoDB. AWS Glue Les tâches ETL permettent à la fois de lire les données de la table DynamoDB d'un autre AWS compte et d'écrire des données dans la table DynamoDB d'un autre AWS compte. AWS Gluepermet également de lire à partir d'une table DynamoDB d'une autre région et d'écrire dans une table DynamoDB d'une autre région. Cette section donne des instructions sur la configuration de l'accès et fournit un exemple de script. 

Les procédures de cette section font référence à un didacticiel IAM pour créer un rôle IAM et accorder l'accès au rôle. Le didacticiel traite également de la prise en charge d'un rôle, mais ici, vous utiliserez plutôt un script de tâche pour endosser le rôle dans AWS Glue. Ce didacticiel contient également des informations sur les pratiques générales entre comptes. Pour plus d'informations, voir [Tutoriel : Déléguer l'accès entre AWS comptes à l'aide de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) dans le Guide de l'*utilisateur IAM*.

## Créer un rôle
<a name="aws-glue-programming-etl-dynamo-db-create-role"></a>

Suivez l'[étape 1 du didacticiel](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-1) pour créer un rôle IAM dans le compte A. Lorsque vous définissez les autorisations du rôle, vous pouvez choisir d'associer des politiques existantes telles que `AmazonDynamoDBReadOnlyAccess` ou d'autoriser le rôle `AmazonDynamoDBFullAccess` à read/write DynamoDB. L'exemple suivant illustre la création d'un rôle nommé `DynamoDBCrossAccessRole`, avec la politique d'autorisation `AmazonDynamoDBFullAccess`.

## Accorder l'accès au rôle
<a name="aws-glue-programming-etl-dynamo-db-grant-access"></a>

Suivez l'[étape 2 du didacticiel](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-2) du *Guide de l'utilisateur IAM* pour permettre au compte B de basculer vers le rôle qui vient d'être créé. L'exemple suivant crée une politique avec l'instruction suivante :

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "sts:AssumeRole",
    "Resource": "arn:aws:iam::111122223333:role/DynamoDBCrossAccessRole"
  }
}
```

------

Vous pouvez ensuite associer cette politique à celle group/role/user que vous souhaitez utiliser pour accéder à DynamoDB.

## Endosser le rôle dans le script de tâche AWS Glue
<a name="aws-glue-programming-etl-dynamo-db-assume-role"></a>

Maintenant, vous pouvez vous connecter au compte B et créer une tâche AWS Glue. Pour créer une tâche, reportez-vous aux instructions de la page [Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue](add-job.md). 

Dans le script de tâche, vous devez utiliser le paramètre `dynamodb.sts.roleArn` pour endosser le rôle `DynamoDBCrossAccessRole`. En supposant que ce rôle vous permet d'obtenir les informations d'identification temporaires, qui doivent être utilisées pour accéder à DynamoDB dans le compte B. Consultez ces exemples de scripts.

Pour une lecture entre comptes dans toutes les régions (connecteur ETL) :

```
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.region": "us-east-1",
    "dynamodb.input.tableName": "test_source",
    "dynamodb.sts.roleArn": "<DynamoDBCrossAccessRole's ARN>"
    }
)
dyf.show()
job.commit()
```

Pour une lecture entre comptes dans toutes les régions (connecteur ETL) :

```
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 ARN>",
        "dynamodb.sts.roleArn": "<DynamoDBCrossAccessRole's ARN>"
    }
)
dyf.show()
job.commit()
```

Pour une lecture et une écriture entre comptes dans toutes les régions :

```
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.region": "us-east-1",
        "dynamodb.input.tableName": "test_source"
    }
)
dyf.show()
 
glue_context.write_dynamic_frame_from_options(
    frame=dyf,
    connection_type="dynamodb",
    connection_options={
        "dynamodb.region": "us-west-2",
        "dynamodb.output.tableName": "test_sink",
        "dynamodb.sts.roleArn": "<DynamoDBCrossAccessRole's ARN>"
    }
)
 
job.commit()
```

# Connecteur DynamoDB avec prise en charge de Spark DataFrame
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-support"></a>

Le connecteur DynamoDB compatible avec DataFrame Spark vous permet de lire et d'écrire dans des tables de DynamoDB à l'aide de Spark. DataFrame APIs Les étapes de configuration du connecteur sont les mêmes que pour le connecteur DynamicFrame basé et peuvent être consultées [ici](aws-glue-programming-etl-connect-dynamodb-home.md#aws-glue-programming-etl-connect-dynamodb-configure).

Pour charger dans la bibliothèque de connecteurs DataFrame basée, veillez à associer une connexion DynamoDB à la tâche Glue.

**Note**  
L'interface utilisateur de la console Glue ne prend actuellement pas en charge la création d'une connexion DynamoDB. Vous pouvez utiliser Glue CLI ([CreateConnection](https://docs.aws.amazon.com/cli/latest/reference/glue/create-connection.html)) pour créer une connexion DynamoDB :  

```
        aws glue create-connection \
            --connection-input '{ \
                "Name": "my-dynamodb-connection", \
                "ConnectionType": "DYNAMODB", \
                "ConnectionProperties": {}, \
                "ValidateCredentials": false, \
                "ValidateForComputeEnvironments": ["SPARK"] \
            }'
```

Lors de la création de la connexion DynamoDB, vous pouvez l'associer à votre tâche Glue via CLI [CreateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/create-job.html)([UpdateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/update-job.html),) ou directement sur la page « Détails de la tâche » :

![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/dynamodb-dataframe-connector.png)


Après avoir vérifié qu'une connexion avec DYNAMODB Type est attachée à votre tâche Glue, vous pouvez utiliser les opérations de lecture, d'écriture et d'exportation suivantes à partir du connecteur DataFrame basé.

## Lecture et écriture dans DynamoDB à l'aide du connecteur basé DataFrame
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-read-write"></a>

Les exemples de code suivants montrent comment lire et écrire dans des tables DynamoDB via DataFrame le connecteur basé. 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())
spark = glueContext.spark_session
job = Job(glue_context)
job.init(args["JOB_NAME"], args)

# Read from DynamoDB
df = spark.read.format("dynamodb") \
    .option("dynamodb.input.tableName", "test-source") \
    .option("dynamodb.throughput.read.ratio", "0.5") \
    .option("dynamodb.consistentRead", "false") \
    .load()

print(df.rdd.getNumPartitions())

# Write to DynamoDB
df.write \
  .format("dynamodb") \
  .option("dynamodb.output.tableName", "test-sink") \
  .option("dynamodb.throughput.write.ratio", "0.5") \
  .option("dynamodb.item.size.check.enabled", "true") \
  .save()

job.commit()
```

------
#### [ Scala ]

```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._

object GlueApp {
  def main(sysArgs: Array[String]): Unit = {
    
    val glueContext = new GlueContext(SparkContext.getOrCreate())
    val spark = glueContext.getSparkSession
    val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
    Job.init(args("JOB_NAME"), glueContext, args.asJava)

    val df = spark.read
      .format("dynamodb")
      .option("dynamodb.input.tableName", "test-source")
      .option("dynamodb.throughput.read.ratio", "0.5")
      .option("dynamodb.consistentRead", "false")
      .load()

    print(df.rdd.getNumPartitions)

    df.write
      .format("dynamodb")
      .option("dynamodb.output.tableName", "test-sink")
      .option("dynamodb.throughput.write.ratio", "0.5")
      .option("dynamodb.item.size.check.enabled", "true")
      .save()

    job.commit()
  }
}
```

------

## Utilisation de l'exportation DynamoDB via le connecteur basé DataFrame
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-export"></a>

L'opération d'exportation est préférable à l'opération de lecture pour les tables DynamoDB de plus de 80 Go. Les exemples de code suivants montrent comment lire depuis une table, exporter vers S3 et imprimer le nombre de partitions via le connecteur DataFrame basé.

**Note**  
La fonctionnalité d'exportation DynamoDB est disponible via l'objet Scala. `DynamoDBExport` Les utilisateurs de Python peuvent y accéder via l'interopérabilité JVM de Spark ou utiliser le SDK AWS pour Python (boto3) avec l'API DynamoDB. `ExportTableToPointInTime`

------
#### [ Scala ]

```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.{GlueArgParser, Job}
import org.apache.spark.SparkContext
import glue.spark.dynamodb.DynamoDBExport
import scala.collection.JavaConverters._

object GlueApp {
  def main(sysArgs: Array[String]): Unit = {
    val glueContext = new GlueContext(SparkContext.getOrCreate())
    val spark = glueContext.getSparkSession
    val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
    Job.init(args("JOB_NAME"), glueContext, args.asJava)
    
    val options = Map(
      "dynamodb.export" -> "ddb",
      "dynamodb.tableArn" -> "arn:aws:dynamodb:us-east-1:123456789012:table/my-table",
      "dynamodb.s3.bucket" -> "my-s3-bucket",
      "dynamodb.s3.prefix" -> "my-s3-prefix",
      "dynamodb.simplifyDDBJson" -> "true"
    )
    val df = DynamoDBExport.fullExport(spark, options)
    
    print(df.rdd.getNumPartitions)
    df.count()
    
    Job.commit()
  }
}
```

------

## Options de configuration
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-options"></a>

### Options de lecture
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-read-options"></a>


| Option | Description | Par défaut | 
| --- | --- | --- | 
| dynamodb.input.tableName | Nom de la table DynamoDB (obligatoire) | - | 
| dynamodb.throughput.read | Les unités de capacité de lecture (RCU) à utiliser. S'il n'est pas spécifié, dynamodb.throughput.read.ratio il est utilisé pour le calcul. | - | 
| dynamodb.throughput.read.ratio | Le ratio d'unités de capacité de lecture (RCU) à utiliser | 0.5 | 
| dynamodb.table.read.capacity | Capacité de lecture de la table à la demande utilisée pour calculer le débit. Ce paramètre n'est efficace que dans les tables de capacité à la demande. Par défaut, ce sont les unités de lecture à débit chaud. | - | 
| dynamodb.splits | Définit le nombre de segments utilisés dans les opérations de scan en parallèle. S'il n'est pas fourni, le connecteur calculera une valeur par défaut raisonnable. | - | 
| dynamodb.consistentRead | S'il faut utiliser des lectures très cohérentes | FALSE | 
| dynamodb.input.retry | Définit le nombre de tentatives que nous effectuons en cas d'exception réessayable. | 10 | 

### Options d'écriture
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-write-options"></a>


| Option | Description | Par défaut | 
| --- | --- | --- | 
| dynamodb.output.tableName | Nom de la table DynamoDB (obligatoire) | - | 
| dynamodb.throughput.write | Les unités de capacité d'écriture (WCU) à utiliser. S'il n'est pas spécifié, dynamodb.throughput.write.ratio il est utilisé pour le calcul. | - | 
| dynamodb.throughput.write.ratio | Le ratio d'unités de capacité d'écriture (WCU) à utiliser | 0.5 | 
| dynamodb.table.write.capacity | Capacité d'écriture de la table à la demande utilisée pour calculer le débit. Ce paramètre n'est efficace que dans les tables de capacité à la demande. Par défaut, ce sont les unités d'écriture à débit chaud. | - | 
| dynamodb.item.size.check.enabled | Si c'est vrai, le connecteur calcule la taille de l'élément et abandonne si la taille dépasse la taille maximale, avant d'écrire dans la table DynamoDB. | TRUE | 
| dynamodb.output.retry | Définit le nombre de tentatives que nous effectuons en cas d'exception réessayable. | 10 | 

### Options d'exportation
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-export-options"></a>


| Option | Description | Par défaut | 
| --- | --- | --- | 
| dynamodb.export | S'il est défini sur, ddb active le connecteur d'exportation AWS Glue DynamoDB dans lequel un ExportTableToPointInTimeRequet nouveau connecteur sera invoqué pendant la AWS tâche Glue. Une nouvelle exportation sera générée avec l'emplacement transmis depuis dynamodb.s3.bucket et dynamodb.s3.prefix. S'il est défini sur, s3 active le connecteur d'exportation AWS Glue DynamoDB mais ignore la création d'une nouvelle exportation DynamoDB et utilise à la place le et dynamodb.s3.bucket comme emplacement Amazon S3 de dynamodb.s3.prefix l'ancienne exportation de cette table. | ddb | 
| dynamodb.tableArn | La table DynamoDB à partir de laquelle lire. Obligatoire si dynamodb.export est défini sur ddb. |  | 
| dynamodb.simplifyDDBJson | S'il est défini surtrue, exécute une transformation pour simplifier le schéma de la structure JSON DynamoDB présente dans les exportations. | FALSE | 
| dynamodb.s3.bucket | Le compartiment S3 pour stocker les données temporaires lors de l'exportation DynamoDB (obligatoire) |  | 
| dynamodb.s3.prefix | Le préfixe S3 pour stocker les données temporaires lors de l'exportation DynamoDB |  | 
| dynamodb.s3.bucketOwner | Indiquez le propriétaire du compartiment requis pour l'accès entre comptes Amazon S3 |  | 
| dynamodb.s3.sse.algorithm | Type de chiffrement utilisé sur le compartiment dans lequel les données temporaires seront stockées. Les valeurs valides sont AES256 et KMS. |  | 
| dynamodb.s3.sse.kmsKeyId | ID de la clé AWS KMS gérée utilisée pour chiffrer le compartiment S3 dans lequel les données temporaires seront stockées (le cas échéant). |  | 
| dynamodb.exportTime |  point-in-timeA où l'exportation doit être effectuée. Valeurs valides : chaînes représentant des instants ISO-8601. |  | 

### Options générales
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-general-options"></a>


| Option | Description | Par défaut | 
| --- | --- | --- | 
| dynamodb.sts.roleArn | L'ARN du rôle IAM à assumer pour l'accès entre comptes | - | 
| dynamodb.sts.roleSessionName | Nom de session STS | glue-dynamodb-sts-session | 
| dynamodb.sts.region | Région pour le client STS (pour l'hypothèse d'un rôle interrégional) | Identique à l'regionoption |