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

Puede utilizar AWS Glue para Spark para leer y escribir en tablas de DynamoDB en AWS Glue. Para conectarse a DynamoDB, utilice los permisos de IAM adjuntos a su trabajo de AWSGlue. AWS Glue admite la escritura de datos en otra cuenta de tablas de DynamoDB de AWS. Para obtener más información, consulte [Acceso entre cuentas y entre regiones a tablas de DynamoDB](aws-glue-programming-etl-dynamo-db-cross-account.md).

El conector original de DynamoDB utiliza objetos DynamicFrame de Glue para trabajar con los datos extraídos de AWS DynamoDB. La versión 5.0 o posterior de Glue presenta un nuevo [Conector de DynamoDB con compatibilidad con Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) que proporciona compatibilidad nativa con Spark DataFrame.

Además del conector de ETL de DynamoDB de AWS Glue, puede leer en DynamoDB por medio del conector de exportación de DynamoDB, que invoca una solicitud `ExportTableToPointInTime` de DynamoDB y la almacena en una ubicación de Amazon S3 que se proporcione, con el formato de [DynamoDB JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html). Después, AWS Glue crea un objeto DynamicFrame mediante la lectura de los datos desde la ubicación de exportación de Amazon S3.

El escritor de DynamoDB está disponible en la versión AWS Glue 1.0 o versiones posteriores. El conector de exportación de DynamoDB de AWS Glue está disponible en la versión 2.0 o versiones posteriores de AWS Glue. El nuevo conector de DynamoDB basado en DataFrame está disponible en la versión 5.0 de AWS Glue o posteriores.

Para obtener más información sobre DynamoDB, consulte la documentación de [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).

**nota**  
El lector de ETL de DynamoDB no es compatible con filtros ni predicados de inserción.

## Configuración de las conexiones DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-configure"></a>

Para conectarse a DynamoDB desde AWS Glue, conceda permiso al rol de IAM asociado a su trabajo de AWS Glue para interactuar con DynamoDB. Para obtener más información sobre los permisos necesarios para leer o escribir en DynamoDB, consulte [Acciones, recursos y claves de condición para DynamoDB](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) en la documentación de IAM.

En las siguientes situaciones, es posible que necesite una configuración adicional:
+ Cuando utilice el conector de exportación de DynamoDB, tendrá que configurar IAM para que su trabajo pueda solicitar exportaciones de tablas de DynamoDB. Además, tendrá que identificar un bucket de Amazon S3 para la exportación y proporcionar los permisos adecuados en IAM para que DynamoDB escriba en él y para que su trabajo de AWS Glue pueda leerlo. Para obtener más información, consulte [Solicitar una exportación de tabla en DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html).
+ Si su trabajo de AWS Glue tiene requisitos de conectividad de Amazon VPC específicos, utilice el tipo de conexión `NETWORK` de AWS Glue para proporcionar opciones de red. Como el acceso a DynamoDB está autorizado por IAM, no es necesario utilizar un tipo de conexión de DynamoDB de AWS Glue.

## Lectura y escritura en DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-read-write"></a>

En los siguientes ejemplos de código, se muestra cómo leer (con el conector de ETL) de tablas de DynamoDB y escribir en ellas. Demuestran la lectura de una tabla y la escritura en otra tabla.

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

}
```

------

## Uso del conector de exportación de DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-export-connector"></a>

El conector de exportación funciona mejor que el conector de ETL cuando el tamaño de la tabla de DynamoDB es superior a 80 GB. Además, dado que la solicitud de exportación se lleva a cabo fuera de los procesos de Spark en un trabajo de AWS Glue, se puede habilitar el [escalado automático de los trabajos de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) para guardar el uso de DPU durante la solicitud de exportación. Con el conector de exportación, tampoco es necesario configurar el número de divisiones del paralelismo del ejecutor de Spark o el porcentaje de lectura de rendimiento de DynamoDB.

**nota**  
DynamoDB tiene requisitos específicos para invocar las solicitudes `ExportTableToPointInTime`. Para obtener más información, consulte [Solicitud de una exportación de tabla en DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Por ejemplo, debe estar habilitada la restauración a un momento dado (PITR) en la tabla para utilizar este conector. El conector de DynamoDB también es compatible con el cifrado de AWS KMS para las exportaciones de DynamoDB a Amazon S3. Proporcionar la configuración de seguridad en la configuración del trabajo de AWS Glue habilita el cifrado de AWS KMS para una exportación de DynamoDB. La clave de KMS debe estar en la misma región que el bucket de Simple Storage Service (Amazon S3).  
Tenga en cuenta que se aplican cargos adicionales por la exportación de DynamoDB y los costos de almacenamiento de Simple Storage Service (Amazon S3). Los datos exportados en Simple Storage Service (Amazon S3) se mantienen cuando finaliza la ejecución de un trabajo para que pueda reutilizarlos sin exportaciones adicionales de DynamoDB. Un requisito para utilizar este conector es que la recuperación en un momento dado (PITR) esté habilitada para la tabla.  
El conector de ETL y el conector de exportación de DynamoDB no son compatibles con la aplicación de filtros o predicados de inserción en el origen de DynamoDB.

Los siguientes ejemplos de código muestran cómo leer desde particiones (a través del conector de exportación) e imprimir el número de estas.

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

}
```

------

Estos ejemplos muestran cómo realizar la lectura desde particiones (a través del conector de exportación) e imprimir el número de estas desde una tabla de Data Catalog de AWS Glue que tenga una clasificación `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())
)
```

------

## Simplificación del uso del JSON de exportación de DynamoDB
<a name="etl-connect-dynamodb-traversing-structure"></a>

Las exportaciones de DynamoDB con el conector de exportación de DynamoDB de AWS Glue generan archivos JSON con estructuras anidadas específicas. Para obtener más información, consulte [Objetos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Glue proporciona una transformación de DynamicFrame, que puede desanidar estas estructuras y dejarlas con una forma más fácil de usar para aplicaciones posteriores.

La transformación se puede invocar de dos formas. Puede configurar la opción de conexión de `"dynamodb.simplifyDDBJson"` con el valor `"true"` cuando se llame a un método para leer desde DynamoDB. También puede llamar a la transformación como un método disponible de forma independiente en la biblioteca de AWS Glue.

Considere el siguiente esquema generado por una exportación a 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 transformación de `simplifyDDBJson` simplificará esto de la siguiente forma:

```
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` solo está disponible en AWS Glue 3.0 o versiones posteriores. La transformación `unnestDDBJson` también está disponible para simplificar la exportación de JSON a DynamoDB. Alentamos a los usuarios a realizar la transición de `unnestDDBJson` a `simplifyDDBJson`.

## Configuración del paralelismo en las operaciones de DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb-parallelism"></a>

Para mejorar el rendimiento, puede ajustar determinados parámetros disponibles para el conector DynamoDB. Su objetivo al ajustar los parámetros de paralelismo es maximizar el uso de los trabajadores de AWS Glue aprovisionados. Por lo tanto, si necesita más rendimiento, le recomendamos que amplíe su trabajo al aumentar el número de DPU. 

 Puede modificar el paralelismo en una operación de lectura de DynamoDB mediante el parámetro `dynamodb.splits` cuando utilice el conector ETL. Cuando lea con el conector de exportación, no es necesario configurar el número de divisiones del paralelismo del ejecutor de Spark. Puede modificar el paralelismo en una operación de escritura de DynamoDB con `dynamodb.output.numParallelTasks`.

**Lectura con el conector ETL de DynamoDB**

Le recomendamos que calcule `dynamodb.splits` en función del número máximo de trabajadores establecido en la configuración de su trabajo y del siguiente cálculo `numSlots`. Si se autoescala, la cantidad real de trabajadores disponibles puede cambiar por debajo de ese límite. Para obtener más información sobre cómo establecer el número máximo de trabajadores, consulte **Número de trabajadores** (`NumberOfWorkers`) en [Configuración de las propiedades de trabajos para trabajos de Spark en AWS Glue](add-job.md). 
+ `numExecutors = NumberOfWorkers - 1`

   Para contextualizar, un ejecutor está reservado para el controlador de Spark mientras que otros ejecutores procesan datos.
+ `numSlotsPerExecutor =`

------
#### [ AWS Glue 3.0 and later versions ]
  + `4` si `WorkerType` es `G.1X`
  + `8` si `WorkerType` es `G.2X`
  + `16` si `WorkerType` es `G.4X`
  + `32` si `WorkerType` es `G.8X`

------
#### [ AWS Glue 2.0 and legacy versions ]
  + `8` si `WorkerType` es `G.1X`
  + `16` si `WorkerType` es `G.2X`

------
+ `numSlots = numSlotsPerExecutor * numExecutors`

Le recomendamos que establezca `dynamodb.splits` al número de ranuras disponibles, `numSlots`.

**Escritura en DynamoDB**

El parámetro `dynamodb.output.numParallelTasks` se utiliza para determinar la WCU por tarea de Spark mediante el siguiente cálculo:

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

El escritor de DynamoDB funcionará mejor si la configuración representa con precisión el número de tareas de Spark que se escriben en DynamoDB. En algunos casos, es posible que necesite anular el cálculo predeterminado para mejorar el rendimiento de la escritura. Si no especifica este parámetro, el WCU permitido por tarea de Spark se calculará automáticamente mediante la siguiente fórmula:
+ 
  + `numPartitions = dynamicframe.getNumPartitions()`
  + `numSlots` (tal y como se definió anteriormente en esta sección)
  + `numParallelTasks = min(numPartitions, numSlots)`
+ Ejemplo 1. DPU=10, tipo de empleado=estándar. La entrada DynamicFrame tiene 100 particiones RDD.
  + `numPartitions = 100`
  + `numExecutors = (10 - 1) * 2 - 1 = 17`
  + `numSlots = 4 * 17 = 68`
  + `numParallelTasks = min(100, 68) = 68`
+ Ejemplo 2. DPU=10, tipo de empleado=estándar. La entrada DynamicFrame tiene 20 particiones RDD.
  + `numPartitions = 20`
  + `numExecutors = (10 - 1) * 2 - 1 = 17`
  + `numSlots = 4 * 17 = 68`
  + `numParallelTasks = min(20, 68) = 20`

**nota**  
Los trabajos heredados de las versiones de AWS Glue, y los que utilizan trabajadores estándar, requieren diferentes métodos para calcular el número de ranuras. Si necesita ajustar el rendimiento de estos trabajos, le recomendamos que haga la transición a las versiones de AWS Glue compatibles.

## Referencia de opciones de conexión de DynamoDB
<a name="aws-glue-programming-etl-connect-dynamodb"></a>

Designa una conexión a Amazon DynamoDB.

Las opciones de conexión son distintas entre una conexión de origen y una conexión de receptor.

### "connectionType": "dynamodb" con el conector de ETL como origen
<a name="etl-connect-dynamodb-as-source"></a>

Utilice las siguientes opciones de conexión con `"connectionType": "dynamodb"` como origen cuando use el conector de ETL de DynamoDB de AWS Glue:
+ `"dynamodb.input.tableName"`: (obligatorio) la tabla de DynamoDB de la que se va a leer.
+ `"dynamodb.throughput.read.percent"`: (opcional) porcentaje de unidades de capacidad de lectura (RCU) que se usará. El valor predeterminado se establece en "0,5". Los valores aceptables abarcan de "0,1" a "1,5", inclusive.
  + `0.5` representa la tasa de lectura predeterminada, es decir que AWS Glue intentará consumir la mitad de la capacidad de lectura de la tabla. Si usted aumenta el valor por encima de `0.5`, AWS Glue incrementará la tasa de solicitudes; si reduce el valor por debajo de `0.5`, disminuirá la tasa de solicitudes de lectura. (La tasa de lectura real varía, según diversos factores tales como el hecho de que exista o no una distribución uniforme de claves en la tabla de DynamoDB).
  + Cuando la tabla de DynamoDB está en modo bajo demanda, AWS Glue maneja la capacidad de lectura de la tabla como 40 000. Para exportar una tabla de gran extensión, recomendamos cambiar la tabla de DynamoDB al modo bajo demanda.
+ `"dynamodb.splits"`: (opcional) define la cantidad de particiones en las que dividimos esta tabla de DynamoDB al leerla. El valor predeterminado se establece en "1". Los valores aceptables abarcan de "1" a "1,000,000", inclusive.

  `1` representa que no hay paralelismo. Se recomienda especialmente que especifique un valor mayor para un mejor rendimiento mediante la fórmula siguiente. Para obtener más información sobre cómo configurar un valor de forma adecuada, consulte [Configuración del paralelismo en las operaciones de DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.sts.roleArn"`: (opcional) el ARN de rol de IAM que se asumirá para el acceso entre cuentas. Este parámetro se encuentra disponible en AWS Glue 1.0 o posterior.
+ `"dynamodb.sts.roleSessionName"`: (opcional) nombre de sesión STS. El valor predeterminado se establece en “glue-dynamodb-read-sts-session”. Este parámetro se encuentra disponible en AWS Glue 1.0 o posterior.

### “connectionType”: “dynamodb” con el conector de exportación de DynamoDB de AWS Glue como origen
<a name="etl-connect-dynamodb-as-source-export-connector"></a>

Utilice las siguientes opciones de conexión con “connectionType”: “dynamodb” como origen cuando use el conector de exportación de DynamoDB de AWS Glue, que solo está disponible a partir de AWS Glue versión 2.0:
+ `"dynamodb.export"`: (obligatorio) valor de cadena:
  + Si se configura como `ddb`, habilita el conector de exportación de DynamoDB de AWS Glue cuando se invoque una nueva `ExportTableToPointInTimeRequest` durante el trabajo de AWS Glue. Se generará una nueva exportación con la ubicación pasada desde `dynamodb.s3.bucket` y `dynamodb.s3.prefix`.
  + Si se configura como `s3`, habilita el conector de exportación de DynamoDB de AWS Glue, pero omite la creación de una nueva exportación de DynamoDB y, en su lugar, utiliza `dynamodb.s3.bucket` y `dynamodb.s3.prefix` como ubicación de Simple Storage Service (Amazon S3) de una exportación anterior de esa tabla.
+ `"dynamodb.tableArn"`: (obligatorio) tabla de DynamoDB desde la que se debe leer.
+ `"dynamodb.unnestDDBJson"`: (Opcional) Predeterminado: falso. Valores válidos: booleano. Si se configura como true, realiza una transformación no anidada de la estructura JSON de DynamoDB que está presente en las exportaciones. Es un error si se establecen `"dynamodb.unnestDDBJson"` y `"dynamodb.simplifyDDBJson"` como verdaderos al mismo tiempo. En AWS Glue 3.0 y versiones posteriores, le recomendamos que lo utilice `"dynamodb.simplifyDDBJson"` para mejorar el comportamiento al simplificar los tipos de mapas de DynamoDB. Para obtener más información, consulte [Simplificación del uso del JSON de exportación de DynamoDB](#etl-connect-dynamodb-traversing-structure). 
+ `"dynamodb.simplifyDDBJson"`: (Opcional) Predeterminado: falso. Valores válidos: booleano. Si se configura como verdadero, realiza una transformación para simplificar el esquema de JSON de DynamoDB que está presente en las exportaciones. Tiene el mismo propósito que la opción `"dynamodb.unnestDDBJson"`, pero proporciona un mejor soporte para los tipos de mapas de DynamoDB o incluso con los tipos de mapas anidados en su tabla de DynamoDB. Esta característica solo está disponible en AWS Glue 3.0 o versiones posteriores. Es un error si se establecen `"dynamodb.unnestDDBJson"` y `"dynamodb.simplifyDDBJson"` como verdaderos al mismo tiempo. Para obtener más información, consulte [Simplificación del uso del JSON de exportación de DynamoDB](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.s3.bucket"`: (opcional) indica la ubicación del bucket de Simple Storage Service (Amazon S3) en el que debe llevarse a cabo el proceso `ExportTableToPointInTime` de DynamoDB. El formato de archivo para la exportación es DynamoDB JSON.
  + `"dynamodb.s3.prefix"`: (opcional) indica la ubicación del prefijo de Simple Storage Service (Amazon S3) dentro del bucket de Simple Storage Service (Amazon S3) en el que se almacenarán las cargas `ExportTableToPointInTime` de DynamoDB. Si no se especifica `dynamodb.s3.prefix` ni `dynamodb.s3.bucket`, estos valores adoptarán de manera predeterminada la ubicación del directorio temporal especificada en la configuración del trabajo de AWS Glue. Para obtener más información, consulte [Parámetros especiales utilizados por AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html).
  + `"dynamodb.s3.bucketOwner"`: indica el propietario del bucket que se necesita para el acceso entre cuentas de Simple Storage Service (Amazon S3).
+ `"dynamodb.sts.roleArn"`: (opcional) ARN del rol de IAM que se asumirá para el acceso entre cuentas o el acceso entre regiones para la tabla de DynamoDB. Nota: El mismo ARN del rol de IAM se utilizará para acceder a la ubicación de Simple Storage Service (Amazon S3) especificada para la solicitud `ExportTableToPointInTime`.
+ `"dynamodb.sts.roleSessionName"`: (opcional) nombre de sesión STS. El valor predeterminado se establece en “glue-dynamodb-read-sts-session”.
+ `"dynamodb.exportTime"` (Opcional) Valores válidos: cadenas que representan instantes de la norma ISO-8601. Un punto en el tiempo en el que debe realizarse la exportación. 
+ `"dynamodb.sts.region"`: (Obligatorio si se realiza una llamada entre regiones mediante un punto de conexión regional) La región que aloja la tabla de DynamoDB que desea leer.

### “connectionType”: “dynamodb” con el conector de ETL como receptor
<a name="etl-connect-dynamodb-as-sink"></a>

Utilice las siguientes opciones de conexión con `"connectionType": "dynamodb"` como receptor:
+ `"dynamodb.output.tableName"`: (obligatorio) tabla de DynamoDB en la que se va a escribir.
+ `"dynamodb.throughput.write.percent"`: (opcional) porcentaje de unidades de capacidad de escritura (WCU) que se usará. El valor predeterminado se establece en "0,5". Los valores aceptables abarcan de "0,1" a "1,5", inclusive.
  + `0.5` representa la tasa de escritura predeterminada, es decir que AWS Glue intentará consumir la mitad de la capacidad de escritura de la tabla. Si usted aumenta el valor por encima de 0,5, AWS Glue incrementará la tasa de solicitudes; si reduce el valor por debajo de 0,5, disminuirá la tasa de solicitudes de escritura. (La tasa de escritura real varía en función de diversos factores, tales como el hecho de que exista o no una distribución uniforme de claves en la tabla de DynamoDB).
  + Cuando la tabla de DynamoDB está en modo bajo demanda, AWS Glue maneja la capacidad de escritura de la tabla como `40000`. Para importar una tabla grande, recomendamos cambiar la tabla de DynamoDB al modo bajo demanda.
+ `"dynamodb.output.numParallelTasks"`: (opcional) define el número de tareas paralelas que escriben en DynamoDB al mismo tiempo. Se utiliza para calcular WCU permisiva por tarea de Spark. En la mayoría de los casos, AWS Glue calculará un valor predeterminado razonable para este valor. Para obtener más información, consulte [Configuración del paralelismo en las operaciones de DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.output.retry"`: (opcional) define el número de reintentos que realizamos cuando hay una `ProvisionedThroughputExceededException` de DynamoDB. El valor predeterminado se establece en “10”.
+ `"dynamodb.sts.roleArn"`: (opcional) el ARN de rol de IAM que se asumirá para el acceso entre cuentas.
+ `"dynamodb.sts.roleSessionName"`: (opcional) nombre de sesión STS. El valor predeterminado se establece en “glue-dynamodb-write-sts-session”.

# Acceso entre cuentas y entre regiones a tablas de DynamoDB
<a name="aws-glue-programming-etl-dynamo-db-cross-account"></a>

AWS Glue Los trabajos de ETL de soportan el acceso entre cuentas y entre regiones a tablas de DynamoDB. AWS Glue Los trabajos de ETL soportan tanto la lectura de datos de una tabla de DynamoDB de otra cuenta AWS, como la escritura de datos de una tabla de DynamoDB de otra cuenta AWS. AWS Glue también soporta la lectura de una tabla de DynamoDB en otra región y la escritura en una tabla de DynamoDB en otra región. En esta sección se proporcionan instrucciones sobre cómo configurar el acceso y se proporciona un script de ejemplo. 

Los procedimientos de esta sección hacen referencia a un tutorial de IAM para crear un rol de IAM y conceder acceso al rol. El tutorial también explica cómo asumir un rol, pero aquí usará un script de trabajo para asumir el rol en AWS Glue. Este tutorial también contiene información acerca de las prácticas generales entre cuentas. Para obtener más información, consulte [Tutorial: delegar el acceso entre cuentas de AWS mediante roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) en la *Guía del usuario de IAM*.

## Crear un rol
<a name="aws-glue-programming-etl-dynamo-db-create-role"></a>

Siga el [paso 1 en el tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-1) para crear un rol de IAM en la cuenta A. Al definir los permisos del rol, puede optar por asociar políticas existentes como `AmazonDynamoDBReadOnlyAccess` o `AmazonDynamoDBFullAccess` para permitir que el rol lea y escriba DynamoDB. En el siguiente ejemplo, se muestra cómo crear un rol llamado `DynamoDBCrossAccessRole`, con la política de permisos `AmazonDynamoDBFullAccess`.

## Conceder acceso al rol
<a name="aws-glue-programming-etl-dynamo-db-grant-access"></a>

Siga el [paso 2 en el tutorial](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-2) en la *Guía del usuario de IAM* para permitir que la cuenta B cambie al rol recién creado. En el siguiente ejemplo, se crea una nueva política con la siguiente instrucción:

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

****  

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

------

A continuación, puede asociar esta política al grupo/rol o usuario que desea utilizar para acceder a DynamoDB.

## Asumir el rol en el script de trabajo de AWS Glue
<a name="aws-glue-programming-etl-dynamo-db-assume-role"></a>

Ahora, puede iniciar sesión en la cuenta B y crear un trabajo de AWS Glue. Para crear un trabajo, consulte las instrucciones en [Configuración de las propiedades de trabajos para trabajos de Spark en AWS Glue](add-job.md). 

En el script de trabajo, debe usar el parámetro `dynamodb.sts.roleArn` para asumir el rol `DynamoDBCrossAccessRole`. Asumir este rol le permite obtener las credenciales temporales que deben utilizarse para acceder a DynamoDB en la cuenta B. Revise estos scripts de ejemplo.

Para una lectura entre cuentas entre regiones (conector 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()
```

Para una lectura entre cuentas entre regiones (conector ELT):

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

Para una lectura y escritura entre cuentas entre regiones:

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

# Conector de DynamoDB con compatibilidad con Spark DataFrame
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-support"></a>

El conector de DynamoDB con compatibilidad con Spark DataFrame permite leer y escribir en tablas de DynamoDB mediante las API de Spark DataFrame. Los pasos de configuración del conector son los mismos que los del conector basado en DynamicFrame y pueden consultarse [aquí](aws-glue-programming-etl-connect-dynamodb-home.md#aws-glue-programming-etl-connect-dynamodb-configure).

Para cargar la biblioteca del conector basado en DataFrame, asegúrese de adjuntar una conexión de DynamoDB a la tarea de Glue.

**nota**  
La interfaz de usuario (UI) de la consola de Glue actualmente no admite la creación de una conexión de DynamoDB. Puede usar la CLI de Glue ([CreateConnection](https://docs.aws.amazon.com/cli/latest/reference/glue/create-connection.html)) para crear una conexión de DynamoDB:  

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

Una vez creada la conexión de DynamoDB, puede adjuntarla a su tarea de Glue mediante la 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)) o directamente desde la página «Job details»:

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


Una vez que se asegure de que una conexión de tipo DYNAMODB esté adjunta a su tarea de Glue, podrá utilizar las siguientes operaciones de lectura, escritura y exportación del conector basado en DataFrame.

## Lectura y escritura en DynamoDB con el conector basado en DataFrame
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-read-write"></a>

En los siguientes ejemplos de código, se muestra cómo leer y escribir en tablas de DynamoDB mediante el conector basado en DataFrame. Demuestran la lectura de una tabla y la escritura en otra tabla.

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

------

## Uso de la exportación de DynamoDB mediante el conector basado en DataFrame
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-export"></a>

Se prefiere la operación de exportación a la de lectura para tablas de DynamoDB con tamaños superiores a 80 GB. En los siguientes ejemplos de código, se muestra cómo leer desde una tabla, exportar a S3 e imprimir el número de particiones mediante el conector basado en DataFrame.

**nota**  
La funcionalidad de exportación de DynamoDB está disponible a través del objeto Scala `DynamoDBExport`. Los usuarios de Python pueden acceder a esta funcionalidad mediante la interoperabilidad con la JVM de Spark o usar el AWS SDK para Python (boto3) con la 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()
  }
}
```

------

## Opciones de configuración
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-options"></a>

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


| Opción | Descripción | Valor predeterminado | 
| --- | --- | --- | 
| dynamodb.input.tableName | Nombre de la tabla de DynamoDB (obligatorio) | - | 
| dynamodb.throughput.read | Las unidades de capacidad de lectura (RCU) que se van a utilizar. Si no se especifica, dynamodb.throughput.read.ratio se utiliza para el cálculo. | - | 
| dynamodb.throughput.read.ratio | La proporción de unidades de capacidad de lectura (RCU) que se va a utilizar | 0,5 | 
| dynamodb.table.read.capacity | La capacidad de lectura de la tabla bajo demanda que se utiliza para calcular el rendimiento Este parámetro solo es efectivo en tablas con capacidad bajo demanda. Usa de forma predeterminada unidades de rendimiento de lectura en estado semiactivo. | - | 
| dynamodb.splits | Define cuántos segmentos se utilizan en operaciones de escaneo en paralelo. Si no se proporciona, el conector calculará un valor predeterminado razonable. | - | 
| dynamodb.consistentRead | Uso de lecturas altamente coherentes | FALSO | 
| dynamodb.input.retry | Define cuántos reintentos se realizan cuando se produce una excepción que admite reintento. | 10 | 

### Opciones de escritura
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-write-options"></a>


| Opción | Descripción | Valor predeterminado | 
| --- | --- | --- | 
| dynamodb.output.tableName | Nombre de la tabla de DynamoDB (obligatorio) | - | 
| dynamodb.throughput.write | Las unidades de capacidad de escritura (WCU) que se van a utilizar Si no se especifica, se utiliza dynamodb.throughput.write.ratio para el cálculo. | - | 
| dynamodb.throughput.write.ratio | La proporción de unidades de capacidad de escritura (WCU) que se va a utilizar | 0,5 | 
| dynamodb.table.write.capacity | La capacidad de escritura de la tabla bajo demanda que se utiliza para calcular el rendimiento. Este parámetro solo es efectivo en tablas con capacidad bajo demanda. Usa de forma predeterminada unidades de rendimiento de escritura en estado semiactivo. | - | 
| dynamodb.item.size.check.enabled | Si es «true», el conector calcula el tamaño del elemento e interrumpe la operación si dicho tamaño supera el tamaño máximo, antes de escribir en la tabla de DynamoDB. | TRUE | 
| dynamodb.output.retry | Define cuántos reintentos se realizan cuando se produce una excepción que admite reintento. | 10 | 

### Opciones de exportación
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-export-options"></a>


| Opción | Descripción | Valor predeterminado | 
| --- | --- | --- | 
| dynamodb.export | Si se configura como ddb, se habilita el conector de exportación de DynamoDB de AWS Glue, mediante el cual se invocará una nueva ExportTableToPointInTimeRequet durante la tarea de AWS Glue. Se generará una nueva exportación con la ubicación pasada desde dynamodb.s3.bucket y dynamodb.s3.prefix. Si se configura como s3, se habilita el conector de exportación de DynamoDB de AWS Glue, pero se omite la creación de una nueva exportación de DynamoDB y, en su lugar, se usan dynamodb.s3.bucket y dynamodb.s3.prefix como la ubicación en Amazon S3 de la exportación anterior de esa tabla. | ddb | 
| dynamodb.tableArn | La tabla de DynamoDB desde la que se va a leer Obligatorio si dynamodb.export se establece en ddb. |  | 
| dynamodb.simplifyDDBJson | Si se configura como true, realiza una transformación para simplificar el esquema de la estructura JSON de DynamoDB presente en las exportaciones. | FALSO | 
| dynamodb.s3.bucket | El bucket de S3 para almacenar datos temporales durante la exportación de DynamoDB (obligatorio). |  | 
| dynamodb.s3.prefix | El prefijo de S3 para almacenar datos temporales durante la exportación de DynamoDB |  | 
| dynamodb.s3.bucketOwner | Indica el propietario del bucket necesario para el acceso entre cuentas a Amazon S3. |  | 
| dynamodb.s3.sse.algorithm | El tipo de cifrado utilizado en el bucket donde se almacenarán los datos temporales Los valores válidos son AES256 y KMS. |  | 
| dynamodb.s3.sse.kmsKeyId | El ID de la clave administrada de AWS KMS utilizada para cifrar el bucket de S3 donde se almacenarán los datos temporales (si corresponde). |  | 
| dynamodb.exportTime | Un punto en el tiempo en el que debe realizarse la exportación. Valores válidos: cadenas que representan instantes ISO-8601 |  | 

### Opciones generales
<a name="aws-glue-programming-etl-connect-dynamodb-dataframe-general-options"></a>


| Opción | Descripción | Valor predeterminado | 
| --- | --- | --- | 
| dynamodb.sts.roleArn | El ARN del rol de IAM que se debe asumir para el acceso entre cuentas. | - | 
| dynamodb.sts.roleSessionName | Nombre de la sesión de STS | glue-dynamodb-sts-session | 
| dynamodb.sts.region | Región del cliente de STS (para la asunción de roles entre regiones) | Igual que la opción region |