# Exportación de datos de DynamoDB a Amazon S3: cómo funciona
La exportación de DynamoDB a S3 es una solución completamente administrada para exportar sus datos de DynamoDB a un bucket de S3 de Amazon a escala. Mediante la exportación de DynamoDB a S3, puede exportar datos de una tabla de Amazon DynamoDB en cualquier momento dado dentro de su periodo de [recuperación en un momento dado (PITR)](Point-in-time-recovery.md) a un bucket de S3 de Amazon. Debe activar PITR en su tabla para utilizar la función de exportación. Esta característica le permite realizar análisis y consultas complejas de los datos con otros servicios de AWS como Athena, AWS Glue, Amazon SageMaker AI, Amazon EMR y AWS Lake Formation.
La exportación de DynamoDB a S3 le permite exportar datos completos e incrementales de su tabla de DynamoDB. Las exportaciones son asíncronas, no consumen [unidades de capacidad de lectura (RCU)](provisioned-capacity-mode.md) y no tienen ningún impacto en el rendimiento y la disponibilidad de las tablas. Los formatos de archivo de exportación compatibles son los formatos JSON de DynamoDB y Amazon Ion. También puede exportar datos a un bucket de S3 propiedad de otra cuenta de AWS y a una región de AWS diferente. Los datos siempre se cifran en ambos extremos.
Las exportaciones completas de DynamoDB se cobran en función del tamaño de la tabla de DynamoDB (datos de la tabla e índices secundarios locales) en el momento en que se realiza la exportación. Las exportaciones incrementales de DynamoDB se cobran en función del tamaño de los datos procesados de sus copias de seguridad continuas correspondientes al periodo de tiempo que se exporta. La exportación incremental tiene un costo mínimo de 10 MB. Se aplican cargos adicionales por el almacenamiento de los datos exportados en Amazon S3 y por las solicitudes de `PUT` realizadas en su bucket de S3. Para obtener más información sobre estos cargos, consulte los [precios de Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) y los [precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
Para obtener información específica sobre las cuotas de servicio, consulte [Exportar tablas a Amazon S3](ServiceQuotas.md#limits-table-export).
**Topics**
+ [Solicitar una exportación de tabla en DynamoDB](S3DataExport_Requesting.md)
+ [Formato de salida de exportación de tabla de DynamoDB](S3DataExport.Output.md)
# Solicitar una exportación de tabla en DynamoDB
La exportación de una tabla de DynamoDB le permite exportar datos de la tabla a un bucket de Amazon S3, habilitándolo para realizar análisis y consultas complejas sobre los datos mediante otros servicios de AWS como Athena, AWS Glue, Amazon SageMaker AI, Amazon EMR y AWS Lake Formation. Puede solicitar la exportación de una tabla de DynamoDB mediante la Consola de administración de AWS, la AWS CLI o la API de DynamoDB.
**nota**
No se admite el pago de buckets de Amazon S3 por parte del solicitante.
DynamoDB admite tanto la exportación completa como la exportación incremental:
+ Con las **exportaciones completas**, puede exportar una instantánea completa de su tabla desde cualquier momento dado dentro del periodo de recuperación en un momento dado (PITR) a su bucket de S3 de Amazon.
+ Con las **exportaciones incrementales**, puede exportar datos de su tabla de DynamoDB que se hayan modificado, actualizado o eliminado entre un periodo de tiempo especificado, dentro de su ventana PITR, a su bucket de S3 de Amazon.
**Topics**
+ [Requisitos previos](#S3DataExport_Requesting_Permissions)
+ [Solicitar una exportación mediante la Consola de administración de AWS](#S3DataExport_Requesting_Console)
+ [Obtención de detalles sobre exportaciones pasadas en la Consola de administración de AWS](#S3DataExport_Requesting_Console_Details)
+ [Solicitud de exportación mediante la AWS CLI y los AWS SDK](#S3DataExport_Requesting_CLI)
+ [Obtención de detalles sobre exportaciones pasadas mediante la AWS CLI y los AWS SDK](#S3DataExport_Requesting_CLI_Details)
## Requisitos previos
**Habilitar PITR**
Para utilizar la característica de exportación a S3, debe activar PITR en su tabla. Para más detalles sobre cómo activar PITR, consulte [Recuperación en un momento dado](PointInTimeRecovery_Howitworks.md). Si solicita una exportación para una tabla que no tiene PITR activado, su solicitud no se realizará correctamente y aparecerá el mensaje de excepción: “An error occurred (PointInTimeRecoveryUnavailableException) when calling the `ExportTableToPointInTime` operation: Point in time recovery is not enabled for table 'my-dynamodb-table’”. Solo puede solicitar y exportar desde un momento determinado que se encuentre dentro de los `RecoveryPeriodInDays` de PITR configurados.
**Configuración de permisos de S3**
Puede exportar los datos de la tabla a cualquier bucket de Amazon S3 en el que tenga permiso para escribir. El bucket de destino no tiene por qué estar en la misma región de AWS o tener el mismo propietario que la tabla de origen. Su política de AWS Identity and Access Management (IAM) debe permitirle realizar acciones S3 (`s3:AbortMultipartUpload`, `s3:PutObject` y`s3:PutObjectAcl` ) y la acción de exportación DynamoDB (`dynamodb:ExportTableToPointInTime`). He aquí un ejemplo de una política de muestra que concederá a su usuario permisos para realizar exportaciones a un bucket de S3.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDynamoDBExportAction",
"Effect": "Allow",
"Action": "dynamodb:ExportTableToPointInTime",
"Resource": "arn:aws:dynamodb:us-east-1:111122223333:table/my-table"
},
{
"Sid": "AllowS3BucketWrites",
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
------
Si necesita escribir en un bucket de Amazon S3 que esté en otra cuenta o en el que no tenga permisos de escritura, el propietario del bucket de Amazon S3 debe agregar una política de buckets para permitirle exportar desde DynamoDB a ese bucket. He aquí un ejemplo de política en el bucket de Amazon S3 de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExampleStatement",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/Dave"
},
"Action": [
"s3:AbortMultipartUpload",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
------
Revocar estos permisos mientras se lleva a cabo una exportación dará como resultado archivos parciales.
**nota**
Si la tabla o el bucket al que realiza la exportación está cifrado con claves administradas por el cliente, las políticas de esa clave KMS deben dar permiso a DynamoDB para que la utilice. Este permiso se concede a través del usuario o rol de IAM que desencadena el trabajo de exportación. Para obtener más información sobre el cifrado, incluidas las prácticas recomendadas, consulte [¿Cómo Amazon DynamoDB utiliza AWS KMS?](https://docs.aws.amazon.com/kms/latest/developerguide/services-dynamodb.html) y [Using a custom KMS key](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html#managed-key-customer-managed) (Cómo utilizar una clave KMS personalizada).
## Solicitar una exportación mediante la Consola de administración de AWS
En el siguiente ejemplo, se muestra cómo utilizar la consola de DynamoDB para exportar una tabla llamada `MusicCollection`.
**nota**
En este procedimiento se presupone que ha habilitado la recuperación a un momento dado. Para habilitar esta función en la tabla `MusicCollection`, dentro de la tabla, diríjase a la pestaña **Overview (Información general)** de la sección **Table details (Detalles de la tabla)** y seleccione la opción **Enable (Habilitar)** en **Point-in-time recovery (Recuperación a un momento dado)**.
**Para solicitar una exportación de tabla**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de DynamoDB en [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. En el panel de navegación del lado izquierdo de la consola, elija **Exports to S3** (Exportación a S3).
1. Seleccione el botón **Exportar a S3**.
1. Elija una tabla de origen y un bucket de S3 de destino. Si el bucket de destino es propiedad de la cuenta, puede utilizar el botón **Browse S3** (Examinar S3) para encontrarlo. En caso contrario, ingrese la URL del bucket con el comando `s3://bucketname/prefix format.`. El **prefix** es una carpeta opcional para ayudarle a mantener el bucket de destino organizado.
1. Elija **Exportación completa** o **Exportación incremental**. Una **exportación completa** genera la instantánea completa de la tabla tal y como estaba en el momento que especifique. Una **exportación incremental** da salida a los cambios realizados en su tabla durante el periodo de exportación especificado. Su salida está compactada de tal manera que solo contiene el estado final del elemento del periodo de exportación. El elemento solo aparecerá una vez en la exportación aunque tenga varias actualizaciones en el mismo periodo de exportación.
------
#### [ Full export ]
1. Seleccione el momento a partir del cual desea exportar la instantánea de la tabla completa. Puede ser en cualquier momento dentro del periodo de PITR. También puede seleccionar **Hora actual** para exportar la última instantánea.
1. Para **Formato de archivo exportado**, elija entre **DynamoDB JSON** y **Amazon Ion**. De forma predeterminada, la tabla se exportará en formato DynamoDB JSON a partir del último tiempo restaurable en la ventana de recuperación a un momento dado y se cifrará con una clave de Amazon S3 (SSE-S3). Puede modificar esta configuración de exportación si es necesario.
**nota**
Si elige cifrar la exportación usando una clave protegida por AWS Key Management Service (AWS KMS), la clave debe estar en la misma región que el bucket de S3 de destino.
------
#### [ Incremental export ]
1. Seleccione el **periodo de exportación** para el que desea exportar los datos incrementales. Seleccione una hora de inicio en el periodo de PITR. La duración del periodo de exportación debe ser de al menos 15 minutos y no debe superar las 24 horas. La hora de inicio del periodo de exportación es inclusiva y la hora de finalización es exclusiva.
1. Elija entre **Modo absoluto** o **Modo relativo**.
1. **Modo absoluto** exportará datos incrementales para el periodo de tiempo que especifique.
1. **Modo relativo** exportará los datos incrementales durante un período de exportación relativo al tiempo de envío del trabajo de exportación.
1. Para **Formato de archivo exportado**, elija entre **DynamoDB JSON** y **Amazon Ion**. De forma predeterminada, la tabla se exportará en formato DynamoDB JSON a partir del último tiempo restaurable en la ventana de recuperación a un momento dado y se cifrará con una clave de Amazon S3 (SSE-S3). Puede modificar esta configuración de exportación si es necesario.
**nota**
Si elige cifrar la exportación usando una clave protegida por AWS Key Management Service (AWS KMS), la clave debe estar en la misma región que el bucket de S3 de destino.
1. Para **Tipo de vista de exportación**, seleccione **Imágenes nuevas y antiguas** o **Solo imágenes nuevas**. La nueva imagen proporciona el último estado del elemento. La imagen antigua proporciona el estado del elemento justo antes de la “fecha y hora de inicio” especificadas. La configuración predeterminada es **Imágenes nuevas y antiguas**. Para obtener más información sobre imágenes nuevas e imágenes antiguas, consulte [Salida de exportación incremental](S3DataExport.Output.md#incremental-export-output).
------
1. Seleccione **Exportar** para empezar.
Los datos exportados no son coherentes con las transacciones. Sus operaciones de transacción pueden dividirse en dos salidas de exportación. Una operación de transacción reflejada en la exportación puede modificar un subconjunto de elementos, mientras que otro subconjunto de modificaciones de la misma transacción no se refleja en la misma solicitud de exportación. No obstante, las exportaciones son finalmente coherentes. Si se interrumpe una transacción durante una exportación, tendrá la transacción restante en su siguiente exportación contigua, sin duplicados. Los periodos de tiempo utilizados para las exportaciones se basan en un reloj interno del sistema y pueden variar en un minuto del reloj local de su aplicación.
## Obtención de detalles sobre exportaciones pasadas en la Consola de administración de AWS
Puede encontrar información sobre las tareas de exportación que ha ejecutado en el pasado en la sección **Exportaciones a S3** de la barra lateral de navegación. Esta sección contiene una lista de todas las exportaciones que ha creado en los últimos 90 días. Seleccione el ARN de una tarea enumerada en la pestaña **Exportaciones** para recuperar información sobre esa exportación, incluida la configuración avanzada que haya elegido. Tenga en cuenta que aunque los metadatos de la tarea de exportación vencen tras 90 días y los trabajos anteriores a eso ya no se encuentran en esta lista, los objetos de su bucket de S3 permanecen siempre que lo permitan las políticas de bucket. DynamoDB nunca elimina ninguno de los objetos que crea en su bucket de S3 durante una exportación.
## Solicitud de exportación mediante la AWS CLI y los AWS SDK
En los siguientes ejemplos, se muestra cómo exportar una tabla existente a un bucket de S3.
**nota**
En este procedimiento se presupone que ha habilitado la recuperación a un momento dado. Para habilitarlo en la tabla `MusicCollection`, ejecute el siguiente comando.
```
aws dynamodb update-continuous-backups \
--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True
```
**Exportación completa**
------
#### [ AWS CLI ]
**nota**
Si solicita una exportación de tablas entre cuentas, asegúrese de incluir la opción `--s3-bucket-owner`.
```
aws dynamodb export-table-to-point-in-time \
--table-arn arn:aws:dynamodb:us-west-2:111122223333:table/MusicCollection \
--s3-bucket ddb-export-musiccollection-9012345678 \
--s3-prefix 2020-Nov \
--export-format DYNAMODB_JSON \
--export-time 1604632434 \
--s3-bucket-owner 9012345678 \
--s3-sse-algorithm AES256
```
------
#### [ Python ]
```
import boto3
from datetime import datetime
client = boto3.client('dynamodb')
client.export_table_to_point_in_time(
TableArn='arn:aws:dynamodb:us-east-1:111122223333:table/TABLE',
ExportTime=datetime(2023, 9, 20, 12, 0, 0),
S3Bucket='bucket',
S3Prefix='prefix',
S3SseAlgorithm='AES256',
ExportFormat='DYNAMODB_JSON'
)
```
------
#### [ Java ]
```
DynamoDbClient client = DynamoDbClient.create();
client.exportTableToPointInTime(b -> b
.tableArn("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE")
.exportTime(Instant.parse("2023-09-20T12:00:00Z"))
.s3Bucket("bucket")
.s3Prefix("prefix")
.s3SseAlgorithm(S3SseAlgorithm.AES256)
.exportFormat(ExportFormat.DYNAMODB_JSON));
```
------
#### [ .NET ]
```
var client = new AmazonDynamoDBClient();
await client.ExportTableToPointInTimeAsync(new ExportTableToPointInTimeRequest
{
TableArn = "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE",
ExportTime = new DateTime(2023, 9, 20, 12, 0, 0, DateTimeKind.Utc),
S3Bucket = "bucket",
S3Prefix = "prefix",
S3SseAlgorithm = S3SseAlgorithm.AES256,
ExportFormat = ExportFormat.DYNAMODB_JSON
});
```
------
#### [ JavaScript ]
```
import { DynamoDBClient, ExportTableToPointInTimeCommand } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient();
await client.send(new ExportTableToPointInTimeCommand({
TableArn: "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE",
ExportTime: new Date("2023-09-20T12:00:00Z"),
S3Bucket: "bucket",
S3Prefix: "prefix",
S3SseAlgorithm: "AES256",
ExportFormat: "DYNAMODB_JSON"
}));
```
------
#### [ Go ]
```
cfg, _ := config.LoadDefaultConfig(context.TODO())
client := dynamodb.NewFromConfig(cfg)
exportTime := time.Date(2023, 9, 20, 12, 0, 0, 0, time.UTC)
client.ExportTableToPointInTime(context.TODO(), &dynamodb.ExportTableToPointInTimeInput{
TableArn: aws.String("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE"),
ExportTime: &exportTime,
S3Bucket: aws.String("bucket"),
S3Prefix: aws.String("prefix"),
S3SseAlgorithm: types.S3SseAlgorithmAes256,
ExportFormat: types.ExportFormatDynamodbJson,
})
```
------
**Exportación incremental**
------
#### [ AWS CLI ]
```
aws dynamodb export-table-to-point-in-time \
--table-arn arn:aws:dynamodb:REGION:ACCOUNT:table/TABLENAME \
--s3-bucket BUCKET --s3-prefix PREFIX \
--incremental-export-specification ExportFromTime=1693569600,ExportToTime=1693656000,ExportViewType=NEW_AND_OLD_IMAGES \
--export-type INCREMENTAL_EXPORT
```
------
#### [ Python ]
```
import boto3
from datetime import datetime
client = boto3.client('dynamodb')
client.export_table_to_point_in_time(
TableArn='arn:aws:dynamodb:us-east-1:111122223333:table/TABLE',
IncrementalExportSpecification={
'ExportFromTime': datetime(2023, 9, 20, 12, 0, 0),
'ExportToTime': datetime(2023, 9, 20, 13, 0, 0),
'ExportViewType': 'NEW_AND_OLD_IMAGES'
},
ExportType='INCREMENTAL_EXPORT',
S3Bucket='bucket',
S3Prefix='prefix',
S3SseAlgorithm='AES256',
ExportFormat='DYNAMODB_JSON'
)
```
------
#### [ Java ]
```
DynamoDbClient client = DynamoDbClient.create();
client.exportTableToPointInTime(b -> b
.tableArn("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE")
.exportType(ExportType.INCREMENTAL_EXPORT)
.incrementalExportSpecification(i -> i
.exportFromTime(Instant.parse("2023-09-20T12:00:00Z"))
.exportToTime(Instant.parse("2023-09-20T13:00:00Z"))
.exportViewType(ExportViewType.NEW_AND_OLD_IMAGES))
.s3Bucket("bucket")
.s3Prefix("prefix")
.s3SseAlgorithm(S3SseAlgorithm.AES256)
.exportFormat(ExportFormat.DYNAMODB_JSON));
```
------
#### [ .NET ]
```
var client = new AmazonDynamoDBClient();
await client.ExportTableToPointInTimeAsync(new ExportTableToPointInTimeRequest
{
TableArn = "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE",
ExportType = ExportType.INCREMENTAL_EXPORT,
IncrementalExportSpecification = new IncrementalExportSpecification
{
ExportFromTime = new DateTime(2023, 9, 20, 12, 0, 0, DateTimeKind.Utc),
ExportToTime = new DateTime(2023, 9, 20, 13, 0, 0, DateTimeKind.Utc),
ExportViewType = ExportViewType.NEW_AND_OLD_IMAGES
},
S3Bucket = "bucket",
S3Prefix = "prefix",
S3SseAlgorithm = S3SseAlgorithm.AES256,
ExportFormat = ExportFormat.DYNAMODB_JSON
});
```
------
#### [ JavaScript ]
```
import { DynamoDBClient, ExportTableToPointInTimeCommand } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient();
await client.send(new ExportTableToPointInTimeCommand({
TableArn: "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE",
ExportType: "INCREMENTAL_EXPORT",
IncrementalExportSpecification: {
ExportFromTime: new Date("2023-09-20T12:00:00Z"),
ExportToTime: new Date("2023-09-20T13:00:00Z"),
ExportViewType: "NEW_AND_OLD_IMAGES"
},
S3Bucket: "bucket",
S3Prefix: "prefix",
S3SseAlgorithm: "AES256",
ExportFormat: "DYNAMODB_JSON"
}));
```
------
#### [ Go ]
```
cfg, _ := config.LoadDefaultConfig(context.TODO())
client := dynamodb.NewFromConfig(cfg)
fromTime := time.Date(2023, 9, 20, 12, 0, 0, 0, time.UTC)
toTime := time.Date(2023, 9, 20, 13, 0, 0, 0, time.UTC)
client.ExportTableToPointInTime(context.TODO(), &dynamodb.ExportTableToPointInTimeInput{
TableArn: aws.String("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE"),
ExportType: types.ExportTypeIncrementalExport,
IncrementalExportSpecification: &types.IncrementalExportSpecification{
ExportFromTime: &fromTime,
ExportToTime: &toTime,
ExportViewType: types.ExportViewTypeNewAndOldImages,
},
S3Bucket: aws.String("bucket"),
S3Prefix: aws.String("prefix"),
S3SseAlgorithm: types.S3SseAlgorithmAes256,
ExportFormat: types.ExportFormatDynamodbJson,
})
```
------
**nota**
Si elige cifrar la exportación usando una clave protegida por AWS Key Management Service (AWS KMS), la clave debe estar en la misma región que el bucket de S3 de destino.
## Obtención de detalles sobre exportaciones pasadas mediante la AWS CLI y los AWS SDK
Puede encontrar información acerca de las solicitudes de exportación que ha ejecutado en el pasado mediante el comando `list-exports`. Este comando devuelve una lista de todas las exportaciones que ha creado en los últimos 90 días. Tenga en cuenta que aunque los metadatos de la tarea de exportación vencen después de 90 días y los trabajos anteriores a eso ya no se regresan por medio del comando `list-exports`, los objetos de su bucket de S3 permanecen siempre que lo permitan las políticas de bucket. DynamoDB nunca elimina ninguno de los objetos que crea en su bucket de S3 durante una exportación.
Las exportaciones tienen un estado de `PENDING` hasta que se realizan o no correctamente. Si se realizan correctamente, el estado cambia a `COMPLETED`. Si no se realizan correctamente, el estado cambia a `FAILED` con un `failure_message` y una `failure_reason`.
**Muestra de exportaciones**
------
#### [ AWS CLI ]
```
aws dynamodb list-exports \
--table-arn arn:aws:dynamodb:us-east-1:111122223333:table/ProductCatalog
```
------
#### [ Python ]
```
import boto3
client = boto3.client('dynamodb')
print(
client.list_exports(
TableArn='arn:aws:dynamodb:us-east-1:111122223333:table/TABLE',
)
)
```
------
#### [ Java ]
```
DynamoDbClient client = DynamoDbClient.create();
ListExportsResponse response = client.listExports(b -> b
.tableArn("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE"));
response.exportSummaries().forEach(System.out::println);
```
------
#### [ .NET ]
```
var client = new AmazonDynamoDBClient();
var response = await client.ListExportsAsync(new ListExportsRequest
{
TableArn = "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE"
});
response.ExportSummaries.ForEach(Console.WriteLine);
```
------
#### [ JavaScript ]
```
import { DynamoDBClient, ListExportsCommand } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient();
const response = await client.send(new ListExportsCommand({
TableArn: "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE"
}));
console.log(response.ExportSummaries);
```
------
#### [ Go ]
```
cfg, _ := config.LoadDefaultConfig(context.TODO())
client := dynamodb.NewFromConfig(cfg)
response, _ := client.ListExports(context.TODO(), &dynamodb.ListExportsInput{
TableArn: aws.String("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE"),
})
fmt.Println(response.ExportSummaries)
```
------
**Descripción de la exportación**
------
#### [ AWS CLI ]
```
aws dynamodb describe-export \
--export-arn arn:aws:dynamodb:us-east-1:111122223333:table/ProductCatalog/export/01695353076000-a1b2c3d4
```
------
#### [ Python ]
```
import boto3
client = boto3.client('dynamodb')
print(
client.describe_export(
ExportArn='arn:aws:dynamodb:us-east-1:111122223333:table/TABLE/export/01695353076000-06e2188f',
)['ExportDescription']
)
```
------
#### [ Java ]
```
DynamoDbClient client = DynamoDbClient.create();
DescribeExportResponse response = client.describeExport(b -> b
.exportArn("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE/export/01695353076000-06e2188f"));
System.out.println(response.exportDescription());
```
------
#### [ .NET ]
```
var client = new AmazonDynamoDBClient();
var response = await client.DescribeExportAsync(new DescribeExportRequest
{
ExportArn = "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE/export/01695353076000-06e2188f"
});
Console.WriteLine(response.ExportDescription);
```
------
#### [ JavaScript ]
```
import { DynamoDBClient, DescribeExportCommand } from "@aws-sdk/client-dynamodb";
const client = new DynamoDBClient();
const response = await client.send(new DescribeExportCommand({
ExportArn: "arn:aws:dynamodb:us-east-1:111122223333:table/TABLE/export/01695353076000-06e2188f"
}));
console.log(response.ExportDescription);
```
------
#### [ Go ]
```
cfg, _ := config.LoadDefaultConfig(context.TODO())
client := dynamodb.NewFromConfig(cfg)
response, _ := client.DescribeExport(context.TODO(), &dynamodb.DescribeExportInput{
ExportArn: aws.String("arn:aws:dynamodb:us-east-1:111122223333:table/TABLE/export/01695353076000-06e2188f"),
})
fmt.Println(response.ExportDescription)
```
------
# Formato de salida de exportación de tabla de DynamoDB
Una exportación de tabla de DynamoDB incluye archivos de manifiesto además de los archivos que contienen los datos de su tabla. Todos estos archivos se guardan en el bucket de Amazon S3 que especifique en su [solicitud de exportación](S3DataExport_Requesting.md). En las siguientes secciones se describe el formato y el contenido de cada objeto de salida.
**Topics**
## Salida de exportación completa
### Archivos de manifiesto
DynamoDB crea archivos de manifiesto, junto con sus archivos de suma de comprobación, en el bucket de S3 especificado para cada solicitud de exportación.
```
export-prefix/AWSDynamoDB/ExportId/manifest-summary.json
export-prefix/AWSDynamoDB/ExportId/manifest-summary.checksum
export-prefix/AWSDynamoDB/ExportId/manifest-files.json
export-prefix/AWSDynamoDB/ExportId/manifest-files.checksum
```
Usted elige un **export-prefix** cuando solicita una exportación de tabla. Esto le ayuda a mantener organizados los archivos del bucket de S3 de destino. **ExportId** es un token único generado por el servicio para garantizar que varias exportaciones al mismo bucket de S3 y `export-prefix` no se sobrescriban entre sí.
La exportación crea al menos un archivo por partición. En el caso de las particiones que estén vacías, su solicitud de exportación creará un archivo vacío. Todos los elementos de cada archivo provienen del espacio de claves hash de esa partición en particular.
**nota**
DynamoDB también crea un archivo vacío denominado `_started` en el mismo directorio que los archivos de manifiesto. Este archivo comprueba que en el bucket de destino se puede escribir y que la exportación ha comenzado. Se puede eliminar de forma segura.
#### El manifiesto resumido
El archivo `manifest-summary.json` contiene información de resumen sobre el trabajo de exportación. Esto le permite saber qué archivos de datos de la carpeta de datos compartidos están asociados a esta exportación. Su formato es el siguiente:
```
{
"version": "2020-06-30",
"exportArn": "arn:aws:dynamodb:us-east-1:123456789012:table/ProductCatalog/export/01234567890123-a1b2c3d4",
"startTime": "2020-11-04T07:28:34.028Z",
"endTime": "2020-11-04T07:33:43.897Z",
"tableArn": "arn:aws:dynamodb:us-east-1:123456789012:table/ProductCatalog",
"tableId": "12345a12-abcd-123a-ab12-1234abc12345",
"exportTime": "2020-11-04T07:28:34.028Z",
"s3Bucket": "ddb-productcatalog-export",
"s3Prefix": "2020-Nov",
"s3SseAlgorithm": "AES256",
"s3SseKmsKeyId": null,
"manifestFilesS3Key": "AWSDynamoDB/01693685827463-2d8752fd/manifest-files.json",
"billedSizeBytes": 0,
"itemCount": 8,
"outputFormat": "DYNAMODB_JSON",
"exportType": "FULL_EXPORT"
}
```
#### El manifiesto de archivos
El archivo `manifest-files.json` contiene información sobre los archivos que contienen los datos de la tabla exportados. El archivo está en formato [Líneas JSON](https://jsonlines.org/), por lo que las líneas nuevas se utilizan como delimitadores de elementos. En el siguiente ejemplo, los detalles de un archivo de datos de un manifiesto de archivos tienen formato en varias líneas para facilitar la legibilidad.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/01693685827463-2d8752fd/data/asdl123dasas.json.gz"
}
```
### Archivos de datos
DynamoDB puede exportar los datos de la tabla en dos formatos: DynamoDB JSON y Amazon Ion. Independientemente del formato que elija, sus datos se escribirán en varios archivos comprimidos con los nombres de las claves. Estos archivos también aparecen en el archivo `manifest-files.json`.
La estructura de directorios de su bucket de Amazon S3 después de una exportación completa contendrá todos sus archivos de manifiesto y archivos de datos bajo la carpeta ID de exportación.
```
amzn-s3-demo-bucket/DestinationPrefix
.
└── AWSDynamoDB
├── 01693685827463-2d8752fd // the single full export
│ ├── manifest-files.json // manifest points to files under 'data' subfolder
│ ├── manifest-files.checksum
│ ├── manifest-summary.json // stores metadata about request
│ ├── manifest-summary.md5
│ ├── data // The data exported by full export
│ │ ├── asdl123dasas.json.gz
│ │ ...
│ └── _started // empty file for permission check
```
#### DynamoDB JSON
Una exportación de tabla en formato DynamoDB JSON consta de varios objetos `Item`. Cada objeto individual está en el formato JSON dirigido estándar de DynamoDB.
Al crear analizadores personalizados para los datos de exportación de DynamoDB JSON, el formato es [Líneas JSON](https://jsonlines.org/). Esto significa que las líneas nuevas se utilizan como delimitadores de elementos. Muchos servicios de AWS, como Athena y AWS Glue, analizarán este formato automáticamente.
En el siguiente ejemplo, se ha dado formato a un único elemento de una exportación de DynamoDB JSON en varias líneas para facilitar la legibilidad.
```
{
"Item":{
"Authors":{
"SS":[
"Author1",
"Author2"
]
},
"Dimensions":{
"S":"8.5 x 11.0 x 1.5"
},
"ISBN":{
"S":"333-3333333333"
},
"Id":{
"N":"103"
},
"InPublication":{
"BOOL":false
},
"PageCount":{
"N":"600"
},
"Price":{
"N":"2000"
},
"ProductCategory":{
"S":"Book"
},
"Title":{
"S":"Book 103 Title"
}
}
}
```
#### Amazon Ion
[Amazon Ion](http://amzn.github.io/ion-docs/) es un formato de serialización de datos jerárquico, autodescriptivo y altamente digitado, creado para abordar los desafíos rápidos de desarrollo, desacoplamiento y eficiencia que surgen todos los días mientras se diseñan arquitecturas a gran escala orientadas a servicios. DynamoDB admite la exportación de datos de tabla en [formato de texto](http://amzn.github.io/ion-docs/docs/spec.html) de Ion, que es un superconjunto de JSON.
Al exportar una tabla al formato Ion, los tipos de datos de DynamoDB utilizados en la tabla se asignan a los [tipos de datos Ion](http://amzn.github.io/ion-docs/docs/spec.html). Los conjuntos de DynamoDB utilizan [anotaciones de tipo Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot) para desambiguar el tipo de datos utilizado en la tabla de origen.
En la siguiente tabla se muestra la asignación de los tipos de datos de DynamoDB a los tipos de datos de iones:
| Tipo de dato de DynamoDB | Representación Ion |
| --- | --- |
| Cadena (S) | cadena |
| Booleano (BOOL) | bool |
| Número (N) | decimal |
| Binario (B) | blob |
| Conjunto (SS, NS, BS) | lista (con anotación de tipo \$1dynamodb\$1SS, \$1dynamodb\$1NS o \$1dynamodb\$1BS) |
| Enumeración | list |
| Asignación | struct |
Los elementos de una exportación de Ion están delimitados por nuevas líneas. Cada línea comienza con un marcador de versión Ion, seguido de un elemento en formato Ion. En el siguiente ejemplo, se ha dado formato a un elemento de una exportación de Ion en varias líneas para facilitar la legibilidad.
```
$ion_1_0 {
Item:{
Authors:$dynamodb_SS::["Author1","Author2"],
Dimensions:"8.5 x 11.0 x 1.5",
ISBN:"333-3333333333",
Id:103.,
InPublication:false,
PageCount:6d2,
Price:2d3,
ProductCategory:"Book",
Title:"Book 103 Title"
}
}
```
## Salida de exportación incremental
### Archivos de manifiesto
DynamoDB crea archivos de manifiesto, junto con sus archivos de suma de comprobación, en el bucket de S3 especificado para cada solicitud de exportación.
```
export-prefix/AWSDynamoDB/ExportId/manifest-summary.json
export-prefix/AWSDynamoDB/ExportId/manifest-summary.checksum
export-prefix/AWSDynamoDB/ExportId/manifest-files.json
export-prefix/AWSDynamoDB/ExportId/manifest-files.checksum
```
Usted elige un **export-prefix** cuando solicita una exportación de tabla. Esto le ayuda a mantener organizados los archivos del bucket de S3 de destino. **ExportId** es un token único generado por el servicio para garantizar que varias exportaciones al mismo bucket de S3 y `export-prefix` no se sobrescriban entre sí.
La exportación crea al menos un archivo por partición. En el caso de las particiones que estén vacías, su solicitud de exportación creará un archivo vacío. Todos los elementos de cada archivo provienen del espacio de claves hash de esa partición en particular.
**nota**
DynamoDB también crea un archivo vacío denominado `_started` en el mismo directorio que los archivos de manifiesto. Este archivo comprueba que en el bucket de destino se puede escribir y que la exportación ha comenzado. Se puede eliminar de forma segura.
#### El manifiesto resumido
El archivo `manifest-summary.json` contiene información de resumen sobre el trabajo de exportación. Esto le permite saber qué archivos de datos de la carpeta de datos compartidos están asociados a esta exportación. Su formato es el siguiente:
```
{
"version": "2023-08-01",
"exportArn": "arn:aws:dynamodb:us-east-1:599882009758:table/export-test/export/01695097218000-d6299cbd",
"startTime": "2023-09-19T04:20:18.000Z",
"endTime": "2023-09-19T04:40:24.780Z",
"tableArn": "arn:aws:dynamodb:us-east-1:599882009758:table/export-test",
"tableId": "b116b490-6460-4d4a-9a6b-5d360abf4fb3",
"exportFromTime": "2023-09-18T17:00:00.000Z",
"exportToTime": "2023-09-19T04:00:00.000Z",
"s3Bucket": "jason-exports",
"s3Prefix": "20230919-prefix",
"s3SseAlgorithm": "AES256",
"s3SseKmsKeyId": null,
"manifestFilesS3Key": "20230919-prefix/AWSDynamoDB/01693685934212-ac809da5/manifest-files.json",
"billedSizeBytes": 20901239349,
"itemCount": 169928274,
"outputFormat": "DYNAMODB_JSON",
"outputView": "NEW_AND_OLD_IMAGES",
"exportType": "INCREMENTAL_EXPORT"
}
```
#### El manifiesto de archivos
El archivo `manifest-files.json` contiene información sobre los archivos que contienen los datos de la tabla exportados. El archivo está en formato [Líneas JSON](https://jsonlines.org/), por lo que las líneas nuevas se utilizan como delimitadores de elementos. En el siguiente ejemplo, los detalles de un archivo de datos de un manifiesto de archivos tienen formato en varias líneas para facilitar la legibilidad.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/data/sgad6417s6vss4p7owp0471bcq.json.gz"
}
```
### Archivos de datos
DynamoDB puede exportar los datos de la tabla en dos formatos: DynamoDB JSON y Amazon Ion. Independientemente del formato que elija, sus datos se escribirán en varios archivos comprimidos con los nombres de las claves. Estos archivos también aparecen en el archivo `manifest-files.json`.
Los archivos de datos para las exportaciones incrementales están todos en una carpeta de datos común en su bucket de S3. Sus archivos de manifiesto se encuentran en su carpeta de ID de exportación.
```
amzn-s3-demo-bucket/DestinationPrefix
.
└── AWSDynamoDB
├── 01693685934212-ac809da5 // an incremental export ID
│ ├── manifest-files.json // manifest points to files under 'data' folder
│ ├── manifest-files.checksum
│ ├── manifest-summary.json // stores metadata about request
│ ├── manifest-summary.md5
│ └── _started // empty file for permission check
├── 01693686034521-ac809da5
│ ├── manifest-files.json
│ ├── manifest-files.checksum
│ ├── manifest-summary.json
│ ├── manifest-summary.md5
│ └── _started
├── data // stores all the data files for incremental exports
│ ├── sgad6417s6vss4p7owp0471bcq.json.gz
│ ...
```
En sus archivos de exportación, la salida de cada elemento incluye una marca temporal que representa cuándo se actualizó ese elemento en su tabla y una estructura de datos que indica si fue una operación `insert`, `update` o `delete`. La marca temporal se basa en un reloj interno del sistema y puede variar con respecto al reloj de su aplicación. En el caso de las exportaciones incrementales, puede elegir entre dos tipos de vistas de exportación para su estructura de salida: **imágenes nuevas y antiguas** o **solo imágenes nuevas**.
+ La **nueva imagen** proporciona el último estado del elemento
+ La **imagen antigua** proporciona el estado del elemento justo antes de la **fecha y hora de inicio** especificadas
Los tipos de vista pueden ser útiles si desea ver cómo se modificó el elemento en el periodo de exportación. También puede ser útil para actualizar eficazmente sus sistemas descendentes, especialmente si dichos sistemas tienen una clave de partición que no es la misma que su clave de partición de DynamoDB.
Puede deducir si un elemento de su salida de exportación incremental era una operación `insert`, `update` o `delete` examinando la estructura de la salida. La estructura de la exportación incremental y sus operaciones correspondientes se resumen en la tabla siguiente para ambos tipos de vistas de exportación.
| Operación | Solo imágenes nuevas | Imágenes nuevas y antiguas |
| --- | --- | --- |
| Inserción | Claves \$1 nueva imagen | Claves \$1 nueva imagen |
| Actualización | Claves \$1 nueva imagen | Claves \$1 imagen nueva \$1 imagen antigua |
| Eliminar | Claves | Claves \$1 imagen antigua |
| Insertar \$1 eliminar | Sin salida | Sin salida |
#### DynamoDB JSON
Una exportación de tabla en formato JSON de DynamoDB consta de una marca temporal de metadatos que indica la hora de escritura del elemento, seguida de las claves del elemento y los valores. En el siguiente ejemplo se muestra una salida JSON de DynamoDB mediante la exportación del tipo de vista como **imágenes nuevas y antiguas**.
```
// Ex 1: Insert
// An insert means the item did not exist before the incremental export window
// and was added during the incremental export window
{
"Metadata": {
"WriteTimestampMicros": "1680109764000000"
},
"Keys": {
"PK": {
"S": "CUST#100"
}
},
"NewImage": {
"PK": {
"S": "CUST#100"
},
"FirstName": {
"S": "John"
},
"LastName": {
"S": "Don"
}
}
}
// Ex 2: Update
// An update means the item existed before the incremental export window
// and was updated during the incremental export window.
// The OldImage would not be present if choosing "New images only".
{
"Metadata": {
"WriteTimestampMicros": "1680109764000000"
},
"Keys": {
"PK": {
"S": "CUST#200"
}
},
"OldImage": {
"PK": {
"S": "CUST#200"
},
"FirstName": {
"S": "Mary"
},
"LastName": {
"S": "Grace"
}
},
"NewImage": {
"PK": {
"S": "CUST#200"
},
"FirstName": {
"S": "Mary"
},
"LastName": {
"S": "Smith"
}
}
}
// Ex 3: Delete
// A delete means the item existed before the incremental export window
// and was deleted during the incremental export window
// The OldImage would not be present if choosing "New images only".
{
"Metadata": {
"WriteTimestampMicros": "1680109764000000"
},
"Keys": {
"PK": {
"S": "CUST#300"
}
},
"OldImage": {
"PK": {
"S": "CUST#300"
},
"FirstName": {
"S": "Jose"
},
"LastName": {
"S": "Hernandez"
}
}
}
// Ex 4: Insert + Delete
// Nothing is exported if an item is inserted and deleted within the
// incremental export window.
```
#### Amazon Ion
[Amazon Ion](http://amzn.github.io/ion-docs/) es un formato de serialización de datos jerárquico, autodescriptivo y altamente digitado, creado para abordar los desafíos rápidos de desarrollo, desacoplamiento y eficiencia que surgen todos los días mientras se diseñan arquitecturas a gran escala orientadas a servicios. DynamoDB admite la exportación de datos de tabla en [formato de texto](http://amzn.github.io/ion-docs/docs/spec.html) de Ion, que es un superconjunto de JSON.
Al exportar una tabla al formato Ion, los tipos de datos de DynamoDB utilizados en la tabla se asignan a los [tipos de datos Ion](http://amzn.github.io/ion-docs/docs/spec.html). Los conjuntos de DynamoDB utilizan [anotaciones de tipo Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot) para desambiguar el tipo de datos utilizado en la tabla de origen.
En la siguiente tabla se muestra la asignación de los tipos de datos de DynamoDB a los tipos de datos de iones:
| Tipo de dato de DynamoDB | Representación Ion |
| --- | --- |
| Cadena (S) | cadena |
| Booleano (BOOL) | bool |
| Número (N) | decimal |
| Binario (B) | blob |
| Conjunto (SS, NS, BS) | lista (con anotación de tipo \$1dynamodb\$1SS, \$1dynamodb\$1NS o \$1dynamodb\$1BS) |
| Enumeración | list |
| Asignación | struct |
Los elementos de una exportación de Ion están delimitados por nuevas líneas. Cada línea comienza con un marcador de versión Ion, seguido de un elemento en formato Ion. En el siguiente ejemplo, se ha dado formato a un elemento de una exportación de Ion en varias líneas para facilitar la legibilidad.
```
$ion_1_0 {
Record:{
Keys:{
ISBN:"333-3333333333"
},
Metadata:{
WriteTimestampMicros:1684374845117899.
},
OldImage:{
Authors:$dynamodb_SS::["Author1","Author2"],
ISBN:"333-3333333333",
Id:103.,
InPublication:false,
ProductCategory:"Book",
Title:"Book 103 Title"
},
NewImage:{
Authors:$dynamodb_SS::["Author1","Author2"],
Dimensions:"8.5 x 11.0 x 1.5",
ISBN:"333-3333333333",
Id:103.,
InPublication:true,
PageCount:6d2,
Price:2d3,
ProductCategory:"Book",
Title:"Book 103 Title"
}
}
}
```