Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esportazione dei dati DynamoDB in Amazon S3: come funziona
L'esportazione da DynamoDB in S3 è una soluzione completamente gestita per esportare i dati DynamoDB in un bucket Amazon S3 su larga scala. Utilizzando l'esportazione da DynamoDB in S3, puoi esportare dati da una tabella Amazon DynamoDB da qualsiasi momento all'interno della finestra di ripristino ([PITR) verso un point-in-time bucket](Point-in-time-recovery.md) Amazon S3. Devi abilitare PITR sulla tabella per utilizzare la funzionalità di esportazione. Questa funzionalità ti consente di eseguire analisi e query complesse sui tuoi dati utilizzando altri AWS servizi come Athena AWS Glue, Amazon AI, SageMaker Amazon EMR e. AWS Lake Formation
L'esportazione da DynamoDB a S3 consente di esportare dati completi e incrementali dalla tabella DynamoDB. Le esportazioni sono asincrone, non consumano [unità di capacità di lettura (RCUs) e non hanno alcun impatto sulle prestazioni](provisioned-capacity-mode.md) e sulla disponibilità delle tabelle. I formati di file di esportazione supportati sono i formati DynamoDB JSON e Amazon Ion. Puoi anche esportare i dati in un bucket S3 di proprietà di un altro AWS account e in un'altra regione. AWS I tuoi dati sono sempre crittografati. end-to-end
Le esportazioni complete di DynamoDB vengono addebitate in base alle dimensioni della tabella DynamoDB (dati della tabella e indici secondari locali) nel point-in-time in cui viene effettuata l'esportazione. Le esportazioni incrementali di DynamoDB vengono addebitate in base alla dimensione dei dati elaborati dai backup continui per il periodo di tempo esportato. L’esportazione incrementale ha un costo minimo di 10 MB. Sono previsti costi aggiuntivi per l'archiviazione dei dati esportati in Amazon S3 e per le richieste `PUT` effettuate sul bucket Amazon S3. Per ulteriori informazioni su questi costi, consulta [Prezzi di Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
Per informazioni specifiche sulle quote di servizio, consulta [Esportazione delle tabelle in Amazon S3](ServiceQuotas.md#limits-table-export).
**Topics**
+ [Richiesta di esportazione di una tabella in DynamoDB](S3DataExport_Requesting.md)
+ [Formato di output di esportazione della tabella DynamoDB](S3DataExport.Output.md)
# Richiesta di esportazione di una tabella in DynamoDB
Le esportazioni di tabelle DynamoDB ti consentono di esportare i dati delle tabelle in un bucket Amazon S3, consentendoti di eseguire analisi e query complesse sui tuoi dati utilizzando altri servizi AWS come Athena, Amazon AI, Amazon AWS Glue EMR e. SageMaker AWS Lake Formation Puoi richiedere l'esportazione di una tabella utilizzando Console di gestione AWS l' AWS CLI API DynamoDB.
**Nota**
Il richiedente paga i bucket Amazon S3 non sono supportati.
DynamoDB supporta sia l'esportazione completa che l'esportazione incrementale:
+ Con **le esportazioni complete**, puoi esportare un'istantanea completa della tabella da qualsiasi momento all'interno della finestra di point-in-time ripristino (PITR) nel tuo bucket Amazon S3.
+ Con le **esportazioni incrementali**, puoi esportare i dati dalla tabella DynamoDB che sono stati modificati, aggiornati o eliminati in un periodo di tempo specificato, all'interno della finestra PITR, nel bucket Amazon S3.
**Topics**
+ [Prerequisiti](#S3DataExport_Requesting_Permissions)
+ [Richiedere un'esportazione utilizzando il Console di gestione AWS](#S3DataExport_Requesting_Console)
+ [Ottenere dettagli sulle esportazioni passate in Console di gestione AWS](#S3DataExport_Requesting_Console_Details)
+ [Richiedere un'esportazione utilizzando e AWS CLI AWS SDKs](#S3DataExport_Requesting_CLI)
+ [Ottenere dettagli sulle esportazioni passate utilizzando e AWS CLI AWS SDKs](#S3DataExport_Requesting_CLI_Details)
## Prerequisiti
**Abilitazione del PITR**
Per utilizzare la funzionalità di esportazione in S3, è necessario abilitare il PITR sulla tabella. [Per dettagli su come abilitare PITR, consulta P recovery. oint-in-time](PointInTimeRecovery_Howitworks.md) Se richiedi un'esportazione per una tabella che non ha PITR abilitato, la richiesta avrà esito negativo e verrà visualizzato un messaggio di eccezione: «Si è verificato un errore (PointInTimeRecoveryUnavailableException) durante la chiamata dell'`ExportTableToPointInTime`operazione: Il ripristino in tempo reale non è abilitato per la tabella '». my-dynamodb-table È possibile effettuare richieste ed esportare solo da un punto temporale all’interno del PITR `RecoveryPeriodInDays` configurato.
**Impostazione delle autorizzazioni S3**
È possibile esportare i dati della tabella in qualsiasi bucket Amazon S3 per cui si ha l'autorizzazione di scrittura. Non è necessario che il bucket di destinazione si trovi nella stessa AWS regione o abbia lo stesso proprietario del proprietario della tabella di origine. La tua policy AWS Identity and Access Management (IAM) deve consentirti di eseguire le azioni S3 (`s3:AbortMultipartUpload``s3:PutObject`, e`s3:PutObjectAcl`) e l'azione di esportazione di DynamoDB (). `dynamodb:ExportTableToPointInTime` Ecco una di policy di esempio che concederà all’utente le autorizzazioni per eseguire esportazioni in un bucket 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/*"
}
]
}
```
------
Se si necessita di scrivere su un bucket Amazon S3 che si trova in un altro account o non si dispone delle autorizzazioni di scrittura, il proprietario del bucket Amazon S3 dovrà aggiungere una policy di bucket che consenta di esportare da DynamoDB verso quel bucket. Ecco un esempio di policy sul bucket Amazon S3 di destinazione.
------
#### [ 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 revoca di queste autorizzazioni mentre è in corso un'esportazione comporterà la creazione di file parziali.
**Nota**
Se la tabella o il bucket che stai esportando sono crittografati con chiavi gestite dal cliente, è necessario che le policy della chiave KMS forniscano a DynamoDB l'autorizzazione a usarla. Questa autorizzazione viene concessa tramite l'IAM User/Role che attiva il processo di esportazione. Per ulteriori informazioni sulla crittografia, comprese le best practice, consulta gli articoli relativi a [come DynamoDB utilizza AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services-dynamodb.html) e all'[utilizzo di una chiave KMS personalizzata](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html#managed-key-customer-managed).
## Richiedere un'esportazione utilizzando il Console di gestione AWS
Nell'esempio seguente viene mostrato come utilizzare la console DynamoDB per esportare una tabella esistente denominata `MusicCollection`.
**Nota**
Questa procedura presuppone che sia stato point-in-time abilitato il ripristino. Per abilitarla per la `MusicCollection` tabella, nella scheda **Panoramica** della tabella, nella sezione **Dettagli della tabella**, scegli **Abilita** il **oint-in-timeripristino P.**
**Come richiedere l'esportazione di una tabella**
1. Accedi Console di gestione AWS e apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Nel riquadro di navigazione sul lato sinistro della console, scegli **Exports to S3** (Esportazioni su S3).
1. Seleziona il pulsante **Esporta in S3**.
1. Scegli una tabella di origine e un bucket S3 di destinazione. Se il bucket di destinazione è di proprietà dell'account, è possibile utilizzare il pulsante **Browse S3** (Sfoglia S3) per trovarlo. In caso contrario, immetti l'URL del bucket utilizzando il `s3://bucketname/prefix format.`. **prefix** è una cartella facoltativa che consente di mantenere organizzato il bucket di destinazione.
1. Scegli **Esportazione completa** o **Esportazione incrementale**. Un'**esportazione completa** restituisce lo snapshot dell'intera tabella così com'era nel point-in-time specificato. Un'**esportazione incrementale** restituisce le modifiche apportate alla tabella durante il periodo di esportazione specificato. L’output viene compattato in modo tale da contenere solo lo stato finale dell’elemento relativo al periodo di esportazione. L'elemento verrà visualizzato solo una volta nell'esportazione anche se presenta più aggiornamenti nello stesso periodo di esportazione.
------
#### [ Full export ]
1. Seleziona il point-in-time di cui desideri esportare lo snapshot completo della tabella. Questo può avvenire in qualsiasi point-in-time all'interno della finestra PITR. In alternativa, puoi selezionare **Ora corrente** per esportare lo snapshot più recente.
1. Per **Formato di file esportato**, scegli tra **DynamoDB JSON** e **Amazon Ion**. Per impostazione predefinita, la tabella verrà esportata in formato DynamoDB JSON dall'ultima ora ripristinabile nella finestra di ripristino point-in-time (PITR) e sarà crittografata utilizzando una chiave Amazon S3 (SSE-S3). Se necessario, puoi modificare queste impostazioni di esportazione.
**Nota**
Se scegli di crittografare l'esportazione utilizzando una chiave protetta da AWS Key Management Service (AWS KMS), la chiave deve trovarsi nella stessa regione del bucket S3 di destinazione.
------
#### [ Incremental export ]
1. Seleziona il **Periodo di esportazione** di cui desideri esportare i dati incrementali. Scegli un'ora di inizio nella finestra PITR. La durata del periodo di esportazione deve essere di almeno 15 minuti e non superiore a 24 ore. L'ora di inizio del periodo di esportazione è inclusa e l'ora di fine è esclusa.
1. Scegli tra **Modalità assoluta** o **Modalità relativa**.
1. **Modalità assoluta** esporterà i dati incrementali per il periodo di tempo specificato.
1. **Modalità relativa** esporterà i dati incrementali per un periodo di esportazione relativo all'ora di invio del processo di esportazione.
1. Per **Formato di file esportato**, scegli tra **DynamoDB JSON** e **Amazon Ion**. Per impostazione predefinita, la tabella verrà esportata in formato DynamoDB JSON dall'ultima ora ripristinabile nella finestra di ripristino point-in-time (PITR) e sarà crittografata utilizzando una chiave Amazon S3 (SSE-S3). Se necessario, puoi modificare queste impostazioni di esportazione.
**Nota**
Se scegli di crittografare l'esportazione utilizzando una chiave protetta da AWS Key Management Service (AWS KMS), la chiave deve trovarsi nella stessa regione del bucket S3 di destinazione.
1. Per **Esporta il tipo di visualizzazione**, seleziona **Nuove e vecchie immagini** o **Solo nuove immagini**. La nuova immagine fornisce lo stato più recente dell'elemento. La vecchia immagine mostra lo stato dell'elemento subito prima della "data e ora di inizio" specificate. L'impostazione predefinita è **Nuove e vecchie immagini**. Per ulteriori informazioni su nuove e vecchie immagini, consulta [Output di esportazione incrementale](S3DataExport.Output.md#incremental-export-output).
------
1. Seleziona **Esporta** per iniziare.
I dati esportati non sono coerenti a livello di transazione. Le operazioni di transazione possono essere suddivise tra due output di esportazione. Un sottoinsieme di elementi modificati da un’operazione di transazione può riflettersi nell’esportazione, mentre un altro sottoinsieme di modifiche nella stessa transazione non si riflette nella stessa richiesta di esportazione. Tuttavia, le esportazioni presentano tutte una consistenza finale. Se una transazione viene interrotta durante un’esportazione, la restante transazione sarà presente nella prossima esportazione contigua, senza duplicati. I periodi di tempo utilizzati per le esportazioni si basano su un orologio di sistema interno e possono variare di un minuto rispetto all'orologio locale dell'applicazione.
## Ottenere dettagli sulle esportazioni passate in Console di gestione AWS
Per informazioni sui processi di esportazione eseguiti in passato, seleziona **Esportazioni in S3** nella barra laterale di navigazione. Questa scheda contiene un elenco di tutte le esportazioni create negli ultimi 90 giorni. Seleziona l’ARN di un processo elencato nella scheda **Esportazioni** per recuperare le informazioni relative all’esportazione, incluse le impostazioni di configurazione avanzate scelte. Notare che, sebbene i metadati delle attività di esportazione scadano dopo 90 giorni e i processi più vecchi non siano più presenti in questo elenco, gli oggetti nel bucket S3 rimangono finché le relative policy di bucket lo consentono. DynamoDB non elimina mai alcun oggetto creato nel bucket S3 durante un'esportazione.
## Richiedere un'esportazione utilizzando e AWS CLI AWS SDKs
Gli esempi seguenti mostrano come esportare una tabella esistente in un bucket S3.
**Nota**
Questa procedura presuppone che tu abbia abilitato il ripristino. point-in-time Per abilitarlo per la tabella `MusicCollection`, emettere il comando seguente.
```
aws dynamodb update-continuous-backups \
--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True
```
**Esportazione completa**
------
#### [ AWS CLI ]
**Nota**
Se si richiede l'esportazione di una tabella tra più account, assicurarsi di includere l'opzione `--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,
})
```
------
**Esportazione incrementale**
------
#### [ 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**
Se scegli di crittografare l'esportazione utilizzando una chiave protetta da AWS Key Management Service (AWS KMS), la chiave deve trovarsi nella stessa regione del bucket S3 di destinazione.
## Ottenere dettagli sulle esportazioni passate utilizzando e AWS CLI AWS SDKs
Le informazioni sulle richieste di esportazione eseguite in passato possono essere recuperate utilizzando il comando `list-exports`. Questo comando restituisce un elenco di tutte le esportazioni create negli ultimi 90 giorni. Notare che, sebbene i metadati dei processi di esportazione scadano dopo 90 giorni e i processi più vecchi non siano restituiti dal comando `list-exports`, gli oggetti nel bucket S3 rimangono finché le relative policy di bucket lo consentono. DynamoDB non elimina mai alcun oggetto creato nel bucket S3 durante un'esportazione.
Lo stato delle esportazioni è `PENDING` fino a quando non hanno esito positivo o negativo. In caso di esito positivo, lo stato cambierà in `COMPLETED`. In caso di esito negativo, lo stato passerà a `FAILED` con `failure_message` e `failure_reason`.
**Elenco delle esportazioni**
------
#### [ 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)
```
------
**Descrizione dell'esportazione**
------
#### [ 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 di output di esportazione della tabella DynamoDB
Un'esportazione di tabelle DynamoDB, oltre ai file contenenti i dati della tabella, include file manifesto. Tutti questi file vengono salvati nel bucket Amazon S3 specificato nella [richiesta di esportazione](S3DataExport_Requesting.md). Nelle sezioni seguenti sono descritti il formato e il contenuto di ciascun oggetto di output.
**Topics**
## Output di esportazione completo
### File manifesto
Per ogni richiesta di esportazione, oltre ai file checksum, DynamoDB crea file manifesto nel bucket S3 specificato.
```
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
```
Quando si richiede l'esportazione di una tabella viene scelto un parametro **export-prefix**. Questo ti aiuta a mantenere organizzati i file nel bucket S3 di destinazione. L'**ExportId** è un token univoco generato dal servizio per garantire che più esportazioni nello stesso bucket S3 e `export-prefix` non si sovrascrivano l'un l'altro.
L'esportazione crea anche almeno 1 file per partizione. Per le partizioni vuote, la richiesta di esportazione creerà un file vuoto. Tutti gli elementi di ogni file provengono dal keyspace con hash di quella particolare partizione.
**Nota**
DynamoDB crea anche un file vuoto denominato `_started` nella stessa directory dei file manifesto. Questo file verifica che il bucket di destinazione sia scrivibile e che l'esportazione sia iniziata. Può essere tranquillamente eliminato.
#### Il manifesto di riepilogo
Il file `manifest-summary.json` contiene le informazioni di riepilogo del processo di esportazione. Ciò consente di sapere quali file di dati nella cartella di dati condivisa sono associati a questa esportazione. Il formato è il seguente:
```
{
"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"
}
```
#### I file manifesto
Il file `manifest-files.json` contiene informazioni sui file contenenti i dati della tabella esportati. Il file ha un formato [JSON lines](https://jsonlines.org/), pertanto le nuove righe vengono utilizzate come delimitatori di elementi. Nell'esempio seguente, i dettagli di un file di dati dai file manifesto vengono formattati su più righe per motivi di leggibilità.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/01693685827463-2d8752fd/data/asdl123dasas.json.gz"
}
```
### File di dati
DynamoDB può esportare i dati della tabella in due formati: DynamoDB JSON e Amazon Ion. Indipendentemente dal formato scelto, i dati verranno scritti in più file compressi denominati dalle chiavi. Anche questi file sono elencati nel file `manifest-files.json`.
La struttura di directory del bucket Amazon S3 dopo un’esportazione completa conterrà tutti i file manifesto e i file di dati nella cartella Export ID.
```
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
Un'esportazione di tabella in formato DynamoDB JSON è costituita da più oggetti `Item`. Ogni singolo oggetto è nel formato JSON di marshalling standard di DynamoDB.
Quando si creano parser personalizzati per i dati di esportazione in DynamoDB JSON, il formato generato è [JSON lines](https://jsonlines.org/). Ciò significa che le nuove righe saranno utilizzate come delimitatori di elementi. Molti AWS servizi, come Athena e AWS Glue, analizzeranno automaticamente questo formato.
Nell'esempio seguente, un singolo elemento da un'esportazione DynamoDB JSON è stato formattato su più righe per motivi di leggibilità.
```
{
"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/) è un formato gerarchico di serializzazione dei dati particolarmente tipizzato, autodescrittivo, creato per le esigenze di sviluppo rapido, disaccoppiamento ed efficienza quotidianamente associate alla progettazione di architetture orientate ai servizi su larga scala. DynamoDB supporta l'esportazione dei dati delle tabelle in [formato di testo](http://amzn.github.io/ion-docs/docs/spec.html) di Ion, che è un superset di JSON.
Quando si esporta una tabella in formato Ion, i tipi di dati DynamoDB utilizzati nella tabella vengono mappati ai [tipi di dati Ion](http://amzn.github.io/ion-docs/docs/spec.html). I set DynamoDB usano [annotazioni del tipo Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot)per disambiguare il tipo di dati utilizzato nella tabella di origine.
La tabella seguente elenca la mappatura dei tipi di dati DynamoDB con tipi di dati Ion:
| Tipo di dati DynamoDB | Rappresentazione Ion |
| --- | --- |
| String (S) | string |
| Boolean (BOOL) | bool |
| Number (N) | decimal |
| Binary (B) | blob |
| Set (SS, NS, BS) | list (con annotazione del tipo \$1dynamodb\$1SS, \$1dynamodb\$1NS o \$1dynamodb\$1BS) |
| List | list |
| Map | struct |
Gli elementi in un'esportazione Ion sono delimitati da nuove righe. Ogni riga inizia con un evidenziatore della versione Ion, seguito da un elemento in formato Ion. Nell'esempio seguente, un singolo elemento da un'esportazione DynamoDB JSON è stato formattato su più righe per motivi di leggibilità.
```
$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"
}
}
```
## Output di esportazione incrementale
### File manifesto
Per ogni richiesta di esportazione, oltre ai file checksum, DynamoDB crea file manifesto nel bucket S3 specificato.
```
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
```
Quando si richiede l'esportazione di una tabella viene scelto un parametro **export-prefix**. Questo ti aiuta a mantenere organizzati i file nel bucket S3 di destinazione. L'**ExportId** è un token univoco generato dal servizio per garantire che più esportazioni nello stesso bucket S3 e `export-prefix` non si sovrascrivano l'un l'altro.
L'esportazione crea anche almeno 1 file per partizione. Per le partizioni vuote, la richiesta di esportazione creerà un file vuoto. Tutti gli elementi di ogni file provengono dal keyspace con hash di quella particolare partizione.
**Nota**
DynamoDB crea anche un file vuoto denominato `_started` nella stessa directory dei file manifesto. Questo file verifica che il bucket di destinazione sia scrivibile e che l'esportazione sia iniziata. Può essere tranquillamente eliminato.
#### Il manifesto di riepilogo
Il file `manifest-summary.json` contiene le informazioni di riepilogo del processo di esportazione. Ciò consente di sapere quali file di dati nella cartella di dati condivisa sono associati a questa esportazione. Il formato è il seguente:
```
{
"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"
}
```
#### I file manifesto
Il file `manifest-files.json` contiene informazioni sui file contenenti i dati della tabella esportati. Il file ha un formato [JSON lines](https://jsonlines.org/), pertanto le nuove righe vengono utilizzate come delimitatori di elementi. Nell'esempio seguente, i dettagli di un file di dati dai file manifesto vengono formattati su più righe per motivi di leggibilità.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/data/sgad6417s6vss4p7owp0471bcq.json.gz"
}
```
### File di dati
DynamoDB può esportare i dati della tabella in due formati: DynamoDB JSON e Amazon Ion. Indipendentemente dal formato scelto, i dati verranno scritti in più file compressi denominati dalle chiavi. Anche questi file sono elencati nel file `manifest-files.json`.
I file di dati per le esportazioni incrementali sono tutti contenuti in una cartella di dati comune nel bucket S3. I file manifesto si trovano nella cartella Export ID.
```
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
│ ...
```
Nei file di esportazione, l'output di ogni elemento include un timestamp che indica quando quell'elemento è stato aggiornato nella tabella e una struttura di dati che indica se si è trattato di un'operazione `insert`, `update` o `delete`. Il timestamp si basa su un orologio di sistema interno e può differire dall'orologio dell'applicazione. Per le esportazioni incrementali, puoi scegliere tra due tipi di visualizzazione di esportazione per la struttura di output: **immagini nuove e vecchie** o **solo immagini nuove**.
+ La **nuova immagine** fornisce lo stato più recente dell'elemento
+ La **vecchia immagine** mostra lo stato dell'elemento subito prima della **data e dell'ora di inizio** specificate
I tipi di visualizzazione possono essere utili se desideri vedere come è stato modificato l'elemento durante il periodo di esportazione. Possono anche essere utili per aggiornare in modo efficiente i sistemi downstream, specialmente se tali sistemi hanno una chiave di partizione diversa dalla chiave di partizione di DynamoDB.
È possibile dedurre se un elemento dell'output di esportazione incrementale era `insert`, `update` o `delete` osservando la struttura dell'output. La struttura di esportazione incrementale e le operazioni corrispondenti sono riepilogate nella tabella seguente per entrambi i tipi di visualizzazione di esportazione.
| Operation | Solo nuove immagini | Immagini nuove e vecchie |
| --- | --- | --- |
| Insert | Chiavi \$1 nuova immagine | Chiavi \$1 nuova immagine |
| Aggiorna | Chiavi \$1 nuova immagine | Chiave \$1 nuova immagine \$1 vecchia immagine |
| Elimina | Chiavi | Chiavi \$1 vecchia immagine |
| Insert \$1 delete | Nessun output | Nessun output |
#### DynamoDB JSON
Un'esportazione di tabelle in formato DynamoDB JSON è costituita da un timestamp dei metadati che indica il tempo di scrittura dell'elemento, seguito dalle chiavi dell'elemento e dai valori. Di seguito viene illustrato un esempio di output JSON di DynamoDB che utilizza il tipo di visualizzazione di esportazione come **Immagini nuove e vecchie**.
```
// 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/) è un formato gerarchico di serializzazione dei dati particolarmente tipizzato, autodescrittivo, creato per le esigenze di sviluppo rapido, disaccoppiamento ed efficienza quotidianamente associate alla progettazione di architetture orientate ai servizi su larga scala. DynamoDB supporta l'esportazione dei dati delle tabelle in [formato di testo](http://amzn.github.io/ion-docs/docs/spec.html) di Ion, che è un superset di JSON.
Quando si esporta una tabella in formato Ion, i tipi di dati DynamoDB utilizzati nella tabella vengono mappati ai [tipi di dati Ion](http://amzn.github.io/ion-docs/docs/spec.html). I set DynamoDB usano [annotazioni del tipo Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot)per disambiguare il tipo di dati utilizzato nella tabella di origine.
La tabella seguente elenca la mappatura dei tipi di dati DynamoDB con tipi di dati Ion:
| Tipo di dati DynamoDB | Rappresentazione Ion |
| --- | --- |
| String (S) | string |
| Boolean (BOOL) | bool |
| Number (N) | decimal |
| Binary (B) | blob |
| Set (SS, NS, BS) | list (con annotazione del tipo \$1dynamodb\$1SS, \$1dynamodb\$1NS o \$1dynamodb\$1BS) |
| List | list |
| Map | struct |
Gli elementi in un'esportazione Ion sono delimitati da nuove righe. Ogni riga inizia con un evidenziatore della versione Ion, seguito da un elemento in formato Ion. Nell'esempio seguente, un singolo elemento da un'esportazione DynamoDB JSON è stato formattato su più righe per motivi di leggibilità.
```
$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"
}
}
}
```