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.
# Fonctionnement de l’exportation de données DynamoDB vers Amazon S3
L’exportation de DynamoDB vers S3 est une solution entièrement gérée permettant d’exporter à grande échelle vos données DynamoDB vers un compartiment Amazon S3. Grâce à l'exportation DynamoDB vers S3, vous pouvez exporter les données d'une table Amazon DynamoDB à tout moment au cours de [point-in-time votre fenêtre de restauration (PITR)](Point-in-time-recovery.md) vers un compartiment Amazon S3. Pour pouvoir utiliser la fonctionnalité d’exportation, vous devez activer PITR sur votre table. Cette fonctionnalité vous permet d'effectuer des analyses et des requêtes complexes sur vos données à l'aide d'autres AWS services tels qu'Athena, AWS Glue Amazon SageMaker AI, Amazon EMR et. AWS Lake Formation
L’exportation de DynamoDB vers S3 vous permet d’exporter des données complètes et incrémentielles depuis votre table DynamoDB. Les exportations sont asynchrones, elles ne consomment pas d'[unités de capacité de lecture (RCUs)](provisioned-capacity-mode.md) et n'ont aucun impact sur les performances et la disponibilité des tables. Les formats de fichiers d’exportation pris en charge sont les formats JSON de DynamoDB et Amazon Ion. Vous pouvez également exporter des données vers un compartiment S3 appartenant à un autre AWS compte et vers une autre AWS région. Vos données sont toujours cryptées end-to-end.
Les exportations complètes DynamoDB sont facturées en fonction de la taille de la table DynamoDB (données de table et index secondaires locaux) à l’instant pour lequel l’exportation est effectuée. Les exportations incrémentielles DynamoDB sont facturées en fonction de la taille des données traitées à partir de vos sauvegardes continues pour la période concernée par l’exportation. L’exportation incrémentielle a une facturation minimale de 10 Mo. Des frais supplémentaires s’appliquent pour le stockage des données exportées dans Amazon S3 et pour les demandes `PUT` adressées à votre compartiment Amazon S3. Pour en savoir plus sur ces frais, consultez [Tarification Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
Pour plus de détails sur les quotas de service, consultez [Exportation de table vers Amazon S3.](ServiceQuotas.md#limits-table-export).
**Topics**
+ [Demande d’exportation de table dans DynamoDB](S3DataExport_Requesting.md)
+ [Format de sortie d’exportation de table DynamoDB](S3DataExport.Output.md)
# Demande d’exportation de table dans DynamoDB
Les exportations de tables DynamoDB vous permettent d'exporter les données des tables vers un compartiment Amazon S3, ce qui vous permet d'effectuer des analyses et des requêtes complexes sur vos données à l'aide AWS d'autres services tels qu'Athena, AWS Glue Amazon AI SageMaker , Amazon EMR et. AWS Lake Formation Vous pouvez demander une exportation de table à l'aide de l' AWS Management Console AWS CLI API DynamoDB ou de l'API DynamoDB.
**Note**
Le demandeur paie les compartiments Amazon S3 qui ne sont pas pris en charge.
DynamoDB prend en charge à la fois l’exportation complète et l’exportation incrémentielle :
+ Avec **les exportations complètes**, vous pouvez exporter un instantané complet de votre table à tout moment pendant la fenêtre de point-in-time restauration (PITR) vers votre compartiment Amazon S3.
+ Avec les **exportations incrémentielles**, vous pouvez exporter vers votre compartiment Amazon S3 les données de votre table DynamoDB qui ont été modifiées, mises à jour ou supprimées au cours d’une période spécifiée dans votre fenêtre PITR.
**Topics**
+ [Conditions préalables](#S3DataExport_Requesting_Permissions)
+ [Demande d'exportation à l'aide du AWS Management Console](#S3DataExport_Requesting_Console)
+ [Pour en savoir plus sur les exportations passées, consultez le AWS Management Console](#S3DataExport_Requesting_Console_Details)
+ [Demande d'exportation à l'aide du AWS CLI et AWS SDKs](#S3DataExport_Requesting_CLI)
+ [Obtenir des informations sur les exportations passées à l'aide AWS CLI des AWS SDKs](#S3DataExport_Requesting_CLI_Details)
## Conditions préalables
**Activer PITR**
Pour utiliser la fonctionnalité d’exportation vers S3, vous devez activer la PITR sur votre table. Pour plus de détails sur l'activation du PITR, consultez la section [P oint-in-time recovery](PointInTimeRecovery_Howitworks.md). Si vous demandez l'exportation d'une table pour laquelle le PITR n'est pas activé, votre demande échouera avec un message d'exception : « Une erreur s'est produite (PointInTimeRecoveryUnavailableException) lors de l'appel de l'`ExportTableToPointInTime`opération : la restauration instantanée n'est pas activée pour la table 'my-dynamodb-table». Vous ne pouvez demander et exporter qu’à partir d’un point dans le temps correspondant à la PITR `RecoveryPeriodInDays` configurée.
**Configuration des autorisations S3**
Vous pouvez exporter vos données de table vers n’importe quel compartiment Amazon S3 dans lequel vous êtes autorisé à écrire. Il n'est pas nécessaire que le compartiment de destination se trouve dans la même AWS région ou qu'il ait le même propriétaire que le propriétaire de la table source. Votre politique Gestion des identités et des accès AWS (IAM) doit vous permettre d'effectuer des actions S3 (`s3:AbortMultipartUpload`,`s3:PutObject`, et`s3:PutObjectAcl`) et l'action d'exportation DynamoDB (). `dynamodb:ExportTableToPointInTime` Voici un exemple de stratégie qui accorde à vos utilisateurs les autorisations nécessaires pour effectuer des exportations vers un compartiment 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 vous devez écrire dans un compartiment S3 qui se trouve dans un autre compte ou si vous n’êtes pas autorisé à y écrire, le propriétaire du compartiment S3 doit ajouter une stratégie de compartiment pour vous permettre d’exporter de DynamoDB vers ce compartiment. Voici un exemple de stratégie sur le compartiment S3 cible.
------
#### [ 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/*"
}
]
}
```
------
La révocation de ces autorisations pendant une exportation entraînera la création de fichiers partiels.
**Note**
Si la table ou le compartiment vers lequel vous effectuez l’exportation est chiffré à l’aide de clés gérées par le client, les politiques associées à cette clé KMS doivent accorder à DynamoDB l’autorisation de l’utiliser. Cette autorisation est accordée par le biais de l'IAM User/Role qui déclenche la tâche d'exportation. Pour plus d’informations sur le chiffrement, notamment sur les bonnes pratiques en la matière, consultez [Comment DynamoDB utilise AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services-dynamodb.html) et [Using a custom KMS key](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html#managed-key-customer-managed) (Utilisation d’une clé KMS personnalisée).
## Demande d'exportation à l'aide du AWS Management Console
L’exemple suivant montre comment utiliser la console DynamoDB pour exporter une table existante nommée `MusicCollection`.
**Note**
Cette procédure part du principe que vous avez activé point-in-time la restauration. Pour l'activer pour la `MusicCollection` table, dans l'onglet **Vue d'ensemble** de la table, dans la section **Détails de la table**, choisissez **Activer** pour la **oint-in-timerestauration P.**
**Pour demander une exportation de table**
1. Connectez-vous à la console DynamoDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Dans le panneau de navigation sur le côté gauche de la console, choisissez **Exportations vers S3**.
1. Sélectionnez le bouton **Exporter vers S3**.
1. Choisissez une table source et un compartiment S3 de destination. Si le compartiment de destination appartient à votre compte, vous pouvez utiliser le bouton **Browse S3** (Parcourir S3) pour le trouver. Sinon, saisissez l’URL du compartiment à l’aide du `s3://bucketname/prefix format.`. Le **prefix** est un dossier facultatif qui vous permet de garder votre compartiment de destination organisé.
1. Choisissez **Exportation complète** ou **Exportation incrémentielle**. Une **exportation complète** sort l’instantané complet de votre table telle qu’elle était à l’instant spécifié. Une **exportation incrémentielle** sort les modifications apportées à votre table au cours de la période d’exportation spécifiée. Votre sortie est compactée de telle sorte qu’elle contienne uniquement l’état final de l’élément de la période d’exportation. L’élément n’apparaît qu’une seule fois dans l’exportation, même s’il a été mis à jour plusieurs fois au cours de la même période d’exportation.
------
#### [ Full export ]
1. Sélectionnez l’instant précis à partir duquel vous voulez que l’instantané complet de la table soit exporté. Cela peut être n’importe quel instant de la fenêtre PITR. Vous pouvez également sélectionner **Heure actuelle** pour exporter l’instantané le plus récent.
1. Pour **Format de fichier exporté**, choisissez entre **JSON DynamoDB** et **Amazon Ion**. Par défaut, votre table sera exportée au format JSON DynamoDB à partir de la dernière heure restaurable dans la fenêtre de restauration à un instant dans le passé, et chiffrée à l'aide d'une clé Amazon S3 (SSE-S3). Vous pouvez modifier ces paramètres d’exportation si nécessaire.
**Note**
Si vous choisissez de chiffrer votre exportation à l'aide d'une clé protégée par AWS Key Management Service (AWS KMS), la clé doit se trouver dans la même région que le compartiment S3 de destination.
------
#### [ Incremental export ]
1. Sélectionnez la **Période d’exportation** pour laquelle vous souhaitez exporter les données incrémentielles. Choisissez une heure de début dans la fenêtre PITR. La durée de la période d’exportation doit être au minimum de 15 minutes et ne pas dépasser 24 heures. L’heure de début de la période d’exportation est incluse et l’heure de fin est exclue.
1. Choisissez entre le **Mode absolu** et le **Mode relatif**.
1. Le **Mode absolu** exporte les données incrémentielles correspondant à la période que vous spécifiez.
1. Le **Mode relatif** exporte les données incrémentielles pour une période d’exportation relative à la date de soumission de votre tâche d’exportation.
1. Pour **Format de fichier exporté**, choisissez entre **JSON DynamoDB** et **Amazon Ion**. Par défaut, votre table sera exportée au format JSON DynamoDB à partir de la dernière heure restaurable dans la fenêtre de restauration à un instant dans le passé, et chiffrée à l'aide d'une clé Amazon S3 (SSE-S3). Vous pouvez modifier ces paramètres d’exportation si nécessaire.
**Note**
Si vous choisissez de chiffrer votre exportation à l'aide d'une clé protégée par AWS Key Management Service (AWS KMS), la clé doit se trouver dans la même région que le compartiment S3 de destination.
1. Pour **Type de vue d’exportation**, sélectionnez **Ancienne et nouvelle images** ou **Nouvelles images uniquement**. Nouvelle image indique l’état le plus récent de l’élément. Ancienne image indique l’état de l’élément juste avant les « date et heure de début » spécifiées. Le paramètre par défaut est **Ancienne et nouvelle images**. Pour en savoir plus sur les nouvelles et anciennes images, consultez [Sortie d’une exportation incrémentielle](S3DataExport.Output.md#incremental-export-output).
------
1. Choisissez **Exporter** pour commencer.
Les données exportées ne sont pas cohérentes du point de vue des transactions. Vos opérations de transaction peuvent être réparties sur deux sorties d’exportation. Il est possible qu’un sous-ensemble d’éléments modifiés par une opération de transaction apparaisse dans l’exportation, mais qu’un autre sous-ensemble de modifications relevant de la même transaction n’apparaisse pas dans la même demande d’exportation. Cependant, les exportations sont cohérentes au final. Si une transaction est divisée lors d’une exportation, la transaction restante sera intégrée à votre prochaine exportation contiguë, sans doublons. Les périodes de temps utilisées pour les exportations reposent sur une horloge système interne et peuvent varier d’une minute par rapport à l’horloge locale de votre application.
## Pour en savoir plus sur les exportations passées, consultez le AWS Management Console
Vous pouvez trouver des informations sur les tâches d’exportation que vous avez exécutées antérieurement en choisissant la section **Exportations vers S3** de la barre latérale de navigation. Cette section contient la liste de toutes les exportations que vous avez créées au cours des 90 derniers jours. Sélectionnez l’ARN d’une tâche répertoriée sous l’onglet **Exportations** pour extraire les informations relatives à cette exportation, dont les paramètres de configuration avancés que vous avez choisis. Notez que, bien que les métadonnées de tâche d’exportation expirent après 90 jours et que les tâches plus anciennes ne figurent plus dans cette liste, les objets restent dans votre compartiment S3 aussi longtemps que leurs politiques de compartiment le permettent. DynamoDB ne supprime jamais aucun des objets qu’il crée dans votre compartiment S3 lors d’une exportation.
## Demande d'exportation à l'aide du AWS CLI et AWS SDKs
Les exemples suivants montrent comment exporter une table existante vers un compartiment S3.
**Note**
Cette procédure part du principe que vous avez activé point-in-time la restauration. Pour l’activer pour la table `MusicCollection`, exécutez la commande suivante.
```
aws dynamodb update-continuous-backups \
--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True
```
**Exportation complète**
------
#### [ AWS CLI ]
**Note**
Si vous demandez une exportation de table entre comptes, veillez à inclure l’option `--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,
})
```
------
**Exportation incrémentielle**
------
#### [ 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,
})
```
------
**Note**
Si vous choisissez de chiffrer votre exportation à l'aide d'une clé protégée par AWS Key Management Service (AWS KMS), la clé doit se trouver dans la même région que le compartiment S3 de destination.
## Obtenir des informations sur les exportations passées à l'aide AWS CLI des AWS SDKs
Vous pouvez trouver des informations sur des demandes d’exportation que vous avez exécutées antérieurement à l’aide de la commande `list-exports`. Cette commande envoie la liste de toutes les exportations que vous avez effectuées au cours des 90 derniers jours. Notez que, bien que les métadonnées de tâche d’exportation expirent après 90 jours et que la commande `list-exports` ne renvoie plus les tâches plus anciennes, les objets restent dans votre compartiment S3 aussi longtemps que leurs politiques de compartiment le permettent. DynamoDB ne supprime jamais aucun des objets qu'il crée dans votre compartiment S3 lors d'une exportation.
Les exportations ont le statut `PENDING` tant qu’elles n’ont pas abouti ou échoué. En cas de réussite, le statut passe à `COMPLETED`. En cas d’échec, le statut passe à `FAILED` avec un `failure_message` et un `failure_reason`.
**Exportations de listes**
------
#### [ 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)
```
------
**Décrire l'exportation**
------
#### [ 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)
```
------
# Format de sortie d’exportation de table DynamoDB
Une exportation de table DynamoDB comprend des fichiers manifeste en plus des fichiers contenant les données de votre table. Ces fichiers sont enregistrés dans le compartiment Amazon S3 que vous spécifiez dans votre [demande d’exportation](S3DataExport_Requesting.md). Les sections suivantes décrivent le format et le contenu de chaque objet en sortie.
**Topics**
## Sortie d’une exportation complète
### Fichiers manifestes
DynamoDB crée des fichiers manifeste, ainsi que leurs fichiers de somme de contrôle, dans le compartiment S3 spécifié pour chaque demande d’exportation.
```
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
```
Vous choisissez un **export-prefix** lorsque vous demandez une exportation de table. Cela vous aide à organiser les fichiers dans le compartiment S3 de destination. L’**ExportId** est un jeton unique généré par le service qui vise à éviter que plusieurs exportations vers un même compartiment S3 et `export-prefix` ne se remplacent les unes les autres.
L’exportation crée au moins un fichier par partition. Pour les partitions vides, votre demande d’exportation crée un fichier vide. Tous les éléments de chaque fichier proviennent de l’espace de clés haché de cette partition particulière.
**Note**
DynamoDB crée également un fichier vide nommé `_started` dans le même répertoire que les fichiers manifestes. Ce fichier vérifie que le compartiment de destination est accessible en écriture et que l’exportation a commencé. Il peut être supprimé en toute sécurité.
#### Manifeste de récapitulatif
Le fichier `manifest-summary.json` contient des informations récapitulatives sur la tâche d'exportation. Cela vous permet de savoir quels fichiers de données du dossier de données partagé sont associés à cette exportation. Son format est le suivant :
```
{
"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"
}
```
#### Manifeste de fichiers
Le fichier `manifest-files.json` contient des informations sur les fichiers contenant les données de votre table exportée. Le fichier étant au format [JSON Lines](https://jsonlines.org/), de nouvelles lignes sont utilisées comme délimiteurs d’éléments. Dans l'exemple suivant, les détails relatifs à un fichier de données extraits d'un manifeste de fichiers sont mis en forme sur plusieurs lignes par souci de lisibilité.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/01693685827463-2d8752fd/data/asdl123dasas.json.gz"
}
```
### Fichiers de données
DynamoDB peut exporter les données de votre table dans deux formats : DynamoDB JSON et Amazon Ion. Quel que soit le format que vous choisissez, vos données sont écrites dans plusieurs fichiers compressés nommés par les clés. Ces fichiers sont également répertoriés dans le fichier `manifest-files.json`.
La structure du répertoire de votre compartiment Amazon S3 après une exportation complète contient l’ensemble de vos fichiers manifeste et fichiers de données sous le dossier d’ID de l’exportation.
```
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
```
#### JSON DynamoDB
Une exportation de table au format JSON DynamoDB comprend plusieurs objets `Item`. Chaque objet est au format JSON regroupé standard de DynamoDB.
Lorsque des analyseurs personnalisés sont créés pour les données d’exportation JSON DynamoDB, le format est [JSON Lines](https://jsonlines.org/). Cela signifie que des sauts de ligne sont utilisés en tant que délimiteurs d’éléments. De nombreux AWS services, tels qu'Athena et AWS Glue, analyseront automatiquement ce format.
Dans l’exemple suivant, un élément d’une exportation JSON DynamoDB a été mis en forme sur plusieurs lignes par souci de lisibilité.
```
{
"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/) est un format de sérialisation de données hiérarchique riche, auto-descriptif et conçu pour répondre aux défis de développement rapide, de découplage et d'efficacité rencontrés lors de la conception d'architectures orientées service à grande échelle. DynamoDB prend en charge l’exportation de données de table au [format texte](http://amzn.github.io/ion-docs/docs/spec.html) d’Ion, qui est un sur-ensemble de JSON.
Lorsque vous exportez une table au format Ion, les types de données DynamoDB utilisés dans la table sont mappés à des [types de données Ion](http://amzn.github.io/ion-docs/docs/spec.html). Les ensembles DynamoDB utilisent des [annotations de type Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot) pour clarifier type de données utilisé dans la table source.
Le tableau suivant répertorie le mappage des types de données DynamoDB aux types de données Ion :
| Type de données DynamoDB | Représentation Ion |
| --- | --- |
| String (S) | string |
| Boolean (BOOL) | bool |
| Number (N) | décimal |
| Binary (B) | blob |
| Set (SS, NS, BS) | list (avec annotation de type \$1DynamoDB\$1SS, \$1DynamoDB\$1ns ou \$1DynamoDB\$1bs) |
| List | list |
| Map | struct |
Les éléments dans une exportation Ion sont délimités par des sauts de ligne. Chaque ligne commence par un marqueur de version Ion, suivi d'un élément au format Ion. Dans l'exemple suivant, un élément d'une exportation Ion a été mis en forme sur plusieurs lignes par souci de lisibilité.
```
$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"
}
}
```
## Sortie d’une exportation incrémentielle
### Fichiers manifestes
DynamoDB crée des fichiers manifeste, ainsi que leurs fichiers de somme de contrôle, dans le compartiment S3 spécifié pour chaque demande d’exportation.
```
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
```
Vous choisissez un **export-prefix** lorsque vous demandez une exportation de table. Cela vous aide à organiser les fichiers dans le compartiment S3 de destination. L’**ExportId** est un jeton unique généré par le service qui vise à éviter que plusieurs exportations vers un même compartiment S3 et `export-prefix` ne se remplacent les unes les autres.
L’exportation crée au moins un fichier par partition. Pour les partitions vides, votre demande d’exportation crée un fichier vide. Tous les éléments de chaque fichier proviennent de l’espace de clés haché de cette partition particulière.
**Note**
DynamoDB crée également un fichier vide nommé `_started` dans le même répertoire que les fichiers manifestes. Ce fichier vérifie que le compartiment de destination est accessible en écriture et que l’exportation a commencé. Il peut être supprimé en toute sécurité.
#### Manifeste de récapitulatif
Le fichier `manifest-summary.json` contient des informations récapitulatives sur la tâche d'exportation. Cela vous permet de savoir quels fichiers de données du dossier de données partagé sont associés à cette exportation. Son format est le suivant :
```
{
"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"
}
```
#### Manifeste de fichiers
Le fichier `manifest-files.json` contient des informations sur les fichiers contenant les données de votre table exportée. Le fichier étant au format [JSON Lines](https://jsonlines.org/), de nouvelles lignes sont utilisées comme délimiteurs d’éléments. Dans l'exemple suivant, les détails relatifs à un fichier de données extraits d'un manifeste de fichiers sont mis en forme sur plusieurs lignes par souci de lisibilité.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/data/sgad6417s6vss4p7owp0471bcq.json.gz"
}
```
### Fichiers de données
DynamoDB peut exporter les données de votre table dans deux formats : DynamoDB JSON et Amazon Ion. Quel que soit le format que vous choisissez, vos données sont écrites dans plusieurs fichiers compressés nommés par les clés. Ces fichiers sont également répertoriés dans le fichier `manifest-files.json`.
Les fichiers de données dans le cas des exportations incrémentielles sont tous contenus dans un dossier de données commun au sein de votre compartiment S3. Vos fichiers manifeste se trouvent sous le dossier d’ID de votre exportation.
```
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
│ ...
```
Dans les fichiers de votre exportation, la sortie de chaque élément comprend un horodatage qui représente le moment auquel cet élément a été mis à jour dans votre table et une structure de données qui indique s’il s’agissait d’une opération `insert`, `update` ou `delete`. L’horodatage est basé sur une horloge système interne et peut varier par rapport à l’horloge de votre application. Pour les exportations incrémentielles, vous pouvez choisir entre deux types de vue d’exportation pour votre structure de sortie : **ancienne et nouvelle images** ou **nouvelles images uniquement**.
+ **Nouvelle image** indique l’état le plus récent de l’élément
+ **Ancienne image** indique l’état de l’élément juste avant la **date et l’heure de début** spécifiées
Les types de vue peuvent être utiles si vous souhaitez voir comment l’élément a changé durant la période d’exportation. Cela peut aussi s’avérer utile pour mettre à jour efficacement vos systèmes en aval, en particulier si leur clé de partition est différente de votre clé de partition DynamoDB.
Vous pouvez déterminer si un élément de la sortie de votre exportation incrémentielle était une opération `insert`, `update` ou `delete` en examinant la structure de la sortie. La structure de l’exportation incrémentielle et ses opérations correspondantes sont résumées dans le tableau ci-dessous pour les deux types de vue d’exportation.
| Opération | Nouvelles images uniquement | Ancienne et nouvelle images |
| --- | --- | --- |
| Insert | Clés \$1 nouvelle image | Clés \$1 nouvelle image |
| Mettre à jour | Clés \$1 nouvelle image | Clés \$1 nouvelle image \$1 ancienne image |
| Suppression | Clés | Clés \$1 ancienne image |
| Insert \$1 delete | Pas de sortie | Pas de sortie |
#### JSON DynamoDB
Une exportation de table au format JSON de DynamoDB comprend un horodatage des métadonnées qui indique l’heure d’écriture de l’élément, suivi des clés de l’élément et des valeurs. Voici un exemple de sortie JSON DynamoDB utilisant le type de vue d’exportation **Ancienne et nouvelle images**.
```
// 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/) est un format de sérialisation de données hiérarchique riche, auto-descriptif et conçu pour répondre aux défis de développement rapide, de découplage et d'efficacité rencontrés lors de la conception d'architectures orientées service à grande échelle. DynamoDB prend en charge l’exportation de données de table au [format texte](http://amzn.github.io/ion-docs/docs/spec.html) d’Ion, qui est un sur-ensemble de JSON.
Lorsque vous exportez une table au format Ion, les types de données DynamoDB utilisés dans la table sont mappés à des [types de données Ion](http://amzn.github.io/ion-docs/docs/spec.html). Les ensembles DynamoDB utilisent des [annotations de type Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot) pour clarifier type de données utilisé dans la table source.
Le tableau suivant répertorie le mappage des types de données DynamoDB aux types de données Ion :
| Type de données DynamoDB | Représentation Ion |
| --- | --- |
| String (S) | string |
| Boolean (BOOL) | bool |
| Number (N) | décimal |
| Binary (B) | blob |
| Set (SS, NS, BS) | list (avec annotation de type \$1DynamoDB\$1SS, \$1DynamoDB\$1ns ou \$1DynamoDB\$1bs) |
| List | list |
| Map | struct |
Les éléments dans une exportation Ion sont délimités par des sauts de ligne. Chaque ligne commence par un marqueur de version Ion, suivi d'un élément au format Ion. Dans l'exemple suivant, un élément d'une exportation Ion a été mis en forme sur plusieurs lignes par souci de lisibilité.
```
$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"
}
}
}
```