# Como funciona a exportação de dados do DynamoDB para o Amazon S3
A exportação do DynamoDB para o S3 é uma solução totalmente gerenciada para exportar dados do DynamoDB para um bucket do Amazon S3 em grande escala. Usando a exportação do DynamoDB para o S3, é possível exportar dados de uma tabela do Amazon DynamoDB para um bucket do Amazon S3 a qualquer momento dentro da janela de [recuperação para um ponto no tempo (PITR)](Point-in-time-recovery.md). Você precisa habilitar a PITR na tabela para usar a funcionalidade de exportação. Esse recurso permite que você realize analytics e consultas complexas nos dados usando outros serviços da AWS, como Athena, AWS Glue, IA do Amazon SageMaker, Amazon EMR e AWS Lake Formation.
A exportação do DynamoDB para o S3 permite que você exporte dados completos e incrementais da tabela do DynamoDB. As exportações são assíncronas, não consomem [unidade de capacidade de leitura (RCUs)](provisioned-capacity-mode.md) e não têm impacto na performance e na disponibilidade da tabela. Os formatos de arquivo de exportação aceitos são os formatos DynamoDB JSON e Amazon Ion. Também é possível exportar dados de tabela para um bucket do S3 pertencente a outra conta da AWS e para uma região da AWS diferente. Seus dados são sempre criptografados de ponta a ponta.
As exportações completas do DynamoDB são cobradas com base no tamanho da tabela do DynamoDB (dados da tabela e índices secundários locais) no momento em que a exportação é feita. As exportações incrementais do DynamoDB são cobradas com base no tamanho dos dados processados nos backups contínuos durante o período que está sendo exportado. A exportação incremental tem um custo mínimo de 10 MB. Cobranças adicionais se aplicam ao armazenamento de dados exportados no Amazon S3 e às solicitações `PUT` feitas no bucket do Amazon S3. Para obter mais informações sobre essas cobranças, consulte [Preço do Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/) e [Definição de preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
Para obter detalhes sobre cotas de serviço, consulte [Exportação de tabela para o Amazon S3](ServiceQuotas.md#limits-table-export).
**Topics**
+ [Solicitação de uma exportação de tabela no DynamoDB](S3DataExport_Requesting.md)
+ [Formato de saída de exportação da tabela do DynamoDB](S3DataExport.Output.md)
# Solicitação de uma exportação de tabela no DynamoDB
As exportações de tabelas do DynamoDB permitem exportar dados de tabela para um bucket do Amazon S3, o que possibilita que você execute analytics e consultas complexas nos dados usando outros serviços da AWS, como Athena, AWS Glue, IA do Amazon SageMaker, Amazon EMR e AWS Lake Formation. Você pode solicitar uma exportação de tabela usando o Console de gerenciamento da AWS, a AWS CLI ou a API do DynamoDB.
**nota**
Buckets do Amazon S3 pagos pelo solicitante não são aceitos.
O DynamoDB comporta exportação completa e exportação incremental:
+ Nas **exportações completas**, é possível exportar um snapshot completo da tabela para o bucket do Amazon S3 em qualquer momento na janela de recuperação para um ponto no tempo (PITR).
+ Nas **exportações incrementais**, você pode exportar para o bucket do Amazon S3 dados da tabela do DynamoDB que foram alterados, atualizados ou excluídos entre um espaço de tempo especificado, dentro da janela de PITR.
**Topics**
+ [Pré-requisitos](#S3DataExport_Requesting_Permissions)
+ [Solicitação de uma exportação usando o Console de gerenciamento da AWS](#S3DataExport_Requesting_Console)
+ [Obtenção de detalhes sobre exportações anteriores no Console de gerenciamento da AWS](#S3DataExport_Requesting_Console_Details)
+ [Solicitar uma exportação usando a AWS CLI e SDKs da AWS](#S3DataExport_Requesting_CLI)
+ [Obter detalhes sobre exportações anteriores usando a AWS CLI e SDKs da AWS](#S3DataExport_Requesting_CLI_Details)
## Pré-requisitos
**Habilitar a PITR**
Para usar o recurso de exportação para o S3, você precisará habilitar a PITR na tabela. Para ter detalhes sobre como habilitar a PITR, consulte [Habilitar a recuperação para um ponto no tempo](PointInTimeRecovery_Howitworks.md). Se você solicitar uma exportação para uma tabela que não tenha a PITR habilitada, a solicitação falhará com uma mensagem de exceção: “Ocorreu um erro (PointInTimeRecoveryUnavailableException) ao chamar a operação `ExportTableToPointInTime`: a recuperação para um ponto no tempo não é ativada para ‘my-dynamodb-table’ da tabela”. Só é possível solicitar e exportar de um ponto no tempo que esteja dentro do `RecoveryPeriodInDays` da PITR configurada.
**Configurar permissões do S3**
É possível exportar os dados da tabela para qualquer bucket do Amazon S3 em que se tenha permissão para gravar. O bucket de destino não precisa estar na mesma região da AWS nem ter o mesmo proprietário que a tabela de origem. Sua política do AWS Identity and Access Management (IAM) precisa permitir que você realize ações do S3 (`s3:AbortMultipartUpload`, `s3:PutObject` e`s3:PutObjectAcl`) e a ação de exportação do DynamoDB (`dynamodb:ExportTableToPointInTime`). Veja um exemplo de uma política que concederá permissões ao usuário para realizar exportações para um bucket do 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 você precisar gravar em um bucket do Amazon S3 que esteja em outra conta ou não tiver permissões para gravar, o proprietário do bucket do Amazon S3 precisará adicionar uma política de bucket para permitir que você exporte do DynamoDB para esse bucket. Veja um exemplo de política no bucket do 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/*"
}
]
}
```
------
Revogar essas permissões enquanto uma exportação estiver em andamento resultará em arquivos parciais.
**nota**
Se a tabela ou o bucket para o qual você está exportando estiver criptografado com chaves gerenciadas pelo cliente, as políticas de chave do KMS deverão conceder ao DynamoDB permissão para usá-lo. Essa permissão é concedida por meio do usuário/perfil do IAM que aciona o trabalho de exportação. Para obter mais informações sobre criptografia, inclusive práticas recomendadas, consulte “[Como o DynamoDB usa o AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services-dynamodb.html)” e “[Usar uma chave do KMS personalizada](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html#managed-key-customer-managed)”.
## Solicitação de uma exportação usando o Console de gerenciamento da AWS
O exemplo a seguir demonstra como usar o console do DynamoDB para restaurar uma tabela existente chamada `MusicCollection`.
**nota**
Esse procedimento supõe que você habilitou a recuperação em um ponto anterior no tempo. Para habilitá-la para a tabela `MusicCollection`, na guia **Overview** (Visão geral) da tabela, na seção **Table details** (Detalhes da tabela), selecione **Enable** (Habilitar) para **Point-in-time recovery** (Recuperação em um ponto anterior no tempo).
**Para solicitar uma exportação de tabela**
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. No painel de navegação, no lado esquerdo do console, escolha **Export to S3** (Exportar para o S3).
1. Selecione o botão **Exportar para o S3**.
1. Escolha uma tabela de origem e um bucket do S3 como destino. Se o bucket de destino pertencer à sua conta, você poderá usar o botão **Browse S3** (Procurar no S3) para encontrá-lo. Caso contrário, insira o URL do bucket usando o `s3://bucketname/prefix format.`. O **prefix** é uma pasta opcional para ajudar a manter o bucket de destino organizado.
1. Escolha **Exportação completa** ou **Exportação incremental**. A **Exportação completa** gera o snapshot completo da tabela tal como ela estava no momento especificado. A **Exportação incremental** gera as alterações feitas na tabela durante o período de exportação especificado. A saída é compactada de forma que contenha apenas o estado final do item do período de exportação. O item só aparecerá uma vez na exportação, mesmo que tenha várias atualizações no mesmo período de exportação.
------
#### [ Full export ]
1. Selecione o momento do qual você deseja exportar o snapshot completo da tabela. Isso pode ocorrer em qualquer momento dentro da janela de PITR. Você também pode selecionar **Hora atual** para exportar o snapshot mais recente.
1. Com relação ao **Formato de arquivo exportado**, escolha entre **DynamoDB JSON** e **Amazon Ion**. Por padrão, sua tabela será exportada no formato JSON do DynamoDB a partir da hora restaurável mais recente na janela de recuperação em um ponto anterior no tempo e criptografada usando uma chave do Amazon S3 (SSE-S3). Você pode alterar essas configurações de exportação, se necessário.
**nota**
Se você optar por criptografar a exportação usando uma chave protegida pelo AWS Key Management Service (AWS KMS), a chave deverá estar na mesma região que o bucket do S3 de destino.
------
#### [ Incremental export ]
1. Selecione o **Período de exportação** em que você deseja que os dados incrementais sejam exportados. Escolha uma hora de início na janela de PITR. A duração do período de exportação deve ser de pelo menos 15 minutos e não superior a 24 horas. A hora de início do período de exportação é inclusiva e a hora de término é excludente.
1. Escolha entre o **Modo absoluto** ou o **Modo relativo**.
1. O **Modo absoluto** exportará dados incrementais de acordo com o período especificado.
1. **O modo relativo** exportará dados incrementais de acordo com um período de exportação que é relativo ao tempo de envio do trabalho de exportação.
1. Com relação ao **Formato de arquivo exportado**, escolha entre **DynamoDB JSON** e **Amazon Ion**. Por padrão, sua tabela será exportada no formato JSON do DynamoDB a partir da hora restaurável mais recente na janela de recuperação em um ponto anterior no tempo e criptografada usando uma chave do Amazon S3 (SSE-S3). Você pode alterar essas configurações de exportação, se necessário.
**nota**
Se você optar por criptografar a exportação usando uma chave protegida pelo AWS Key Management Service (AWS KMS), a chave deverá estar na mesma região que o bucket do S3 de destino.
1. Em **Exportar tipo de visualização**, selecione **Imagens novas e antigas** ou **Somente novas imagens**. Imagem nova fornece o estado mais recente do item Imagem antiga fornece o estado do item imediatamente antes da “data e hora de início” especificadas A configuração padrão é **Imagens novas e antigas**. Para obter mais informações sobre imagens novas e imagens antigas, consulte [Saída de exportação Incremental](S3DataExport.Output.md#incremental-export-output).
------
1. Escolha **Exportar** para começar.
Os dados exportados não são consistentes do ponto de vista transacional. As operações de transação podem ser divididas entre duas saídas de exportação. Um subconjunto de itens pode ser modificado por uma operação de transação refletido na exportação, enquanto outro subconjunto de modificações na mesma transação não é refletido na mesma solicitação de exportação. No entanto, as exportações acabam sendo consistentes. Se uma transação for interrompida durante uma exportação, você terá a transação restante na próxima exportação contígua, sem duplicações. Os períodos usados para exportações são baseados em um relógio interno do sistema e podem variar em um minuto em relação ao relógio local da aplicação.
## Obtenção de detalhes sobre exportações anteriores no Console de gerenciamento da AWS
É possível encontrar informações sobre tarefas de exportação realizadas no passado selecionando a seção **Exportações para o S3** na barra de navegação lateral. Essa seção contém uma lista de todas as exportações que você criou nos últimos 90 dias. Selecione o ARN de uma tarefa listada na guia **Exportações** para recuperar informações sobre essa exportação, incluindo quaisquer configurações avançadas escolhidas. Observe que, embora os metadados da tarefa de exportação expirem após 90 dias e os trabalhos mais antigos não sejam mais encontrados nesta lista, os objetos no bucket do S3 permanecerão disponíveis enquanto suas políticas de bucket permitirem. O DynamoDB jamais exclui os objetos que ele cria no bucket do S3 durante uma exportação.
## Solicitar uma exportação usando a AWS CLI e SDKs da AWS
Os exemplos a seguir mostram como exportar uma tabela existente para um bucket do S3.
**nota**
Esse procedimento supõe que você habilitou a recuperação em um ponto anterior no tempo. Para habilitar esse recurso para a tabela `MusicCollection`, execute o seguinte comando.
```
aws dynamodb update-continuous-backups \
--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True
```
**Exportação completa**
------
#### [ AWS CLI ]
**nota**
Se solicitar uma exportação de tabela entre contas, inclua a opção `--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,
})
```
------
**Exportação 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**
Se você optar por criptografar a exportação usando uma chave protegida pelo AWS Key Management Service (AWS KMS), a chave deverá estar na mesma região que o bucket do S3 de destino.
## Obter detalhes sobre exportações anteriores usando a AWS CLI e SDKs da AWS
Você pode encontrar informações sobre solicitações de exportação que executou no passado usando o comando `list-exports`. Esse comando retorna uma lista de todas as exportações que você criou nos últimos 90 dias. Observe que, embora os metadados da tarefa de exportação expirem após 90 dias e os trabalhos mais antigos não sejam mais retornados pelo `list-exports` comando, os objetos em seu bucket do S3 permanecerão disponíveis enquanto suas políticas de bucket permitirem. O DynamoDB jamais exclui os objetos que ele cria no bucket do S3 durante uma exportação.
As exportações permanecem no status `PENDING` até serem concluídas com sucesso ou falha. Se forem bem-sucedidas, o status mudará para `COMPLETED`. Se falharem, o status mudará para `FAILED` com uma `failure_message` e um `failure_reason`.
**Listar exportações**
------
#### [ 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)
```
------
**Descrever a exportação**
------
#### [ 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 saída de exportação da tabela do DynamoDB
Uma exportação de tabela do DynamoDB inclui arquivos de manifesto, além dos arquivos que contêm os dados da tabela. Esses arquivos são salvos no bucket do Amazon S3 especificado por você na [solicitação de exportação](S3DataExport_Requesting.md). As seções a seguir descrevem o formato e o conteúdo de cada objeto de saída.
**Topics**
## Saída de exportação completa
### Arquivos de manifesto
O DynamoDB cria arquivos de manifesto, bem como os respectivos arquivos de soma de verificação, no bucket do S3 especificado para cada solicitação de exportação.
```
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
```
Você escolhe um **export-prefix** ao solicitar uma exportação de tabela. Isso ajuda a manter os arquivos no bucket do S3 de destino organizados. O **ExportId** é um token exclusivo gerado pelo serviço para garantir que várias exportações para o mesmo bucket do S3 e `export-prefix` não se sobreponham.
Essa exportação cria pelo menos um arquivo por partição. Para partições vazias, a solicitação de exportação criará um arquivo vazio. Todos os itens em cada arquivo são do espaço de chave com hash dessa partição específica.
**nota**
O DynamoDB também cria um arquivo vazio chamado `_started` no mesmo diretório dos arquivos de manifesto.’ Esse arquivo verifica se o bucket de destino pode ser gravado e se a exportação foi iniciada. Ele pode ser excluído com segurança.
#### O manifesto resumido
O arquivo `manifest-summary.json` contém informações resumidas sobre o trabalho de exportação. Isso permite que você saiba quais arquivos de dados na pasta de dados compartilhada estão associados a essa exportação. Seu formato é o seguinte:
```
{
"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"
}
```
#### O manifesto de arquivos
O arquivo `manifest-files.json` contém informações sobre os arquivos que contêm os dados da tabela exportada. Como o arquivo está no formato [linhas JSON](https://jsonlines.org/), novas linhas são usadas como delimitadores de itens. No exemplo a seguir, os detalhes de um arquivo de dados de um manifesto de arquivos são formatados em várias linhas por razões de legibilidade.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/01693685827463-2d8752fd/data/asdl123dasas.json.gz"
}
```
### Arquivos de dados
O DynamoDB pode exportar os dados da tabela em dois formatos: DynamoDB JSON e Amazon Ion. Independentemente do formato escolhido, os dados serão gravados em vários arquivos compactados nomeados pelas chaves. Esses arquivos também estão listados no arquivo `manifest-files.json`.
A estrutura de diretórios do bucket do Amazon S3 após uma exportação completa conterá todos os arquivos de manifesto e arquivos de dados na pasta de ID de exportação.
```
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
Uma exportação de tabela no formato JSON do DynamoDB consiste em vários objetos `Item`. Cada objeto individual está no formato JSON organizado padrão do DynamoDB.
Ao criar analisadores personalizados para dados de exportação JSON do DynamoDB, o formato é [linhas JSON](https://jsonlines.org/). Isso significa que as novas linhas são usadas como delimitadores de item. Muitos serviços da AWS, como Athena e AWS Glue, analisarão esse formato automaticamente.
No exemplo a seguir, um único item de uma exportação DynamoDB JSON foi formatado em várias linhas para fins de legibilidade.
```
{
"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
O [Amazon Ion](http://amzn.github.io/ion-docs/) é um formato de serialização de dados hierárquico, autodescritivo e altamente compatível com vários tipos de declaração e criado para lidar com os desafios de desacoplamento, desenvolvimento rápido e eficiência enfrentados todos os dias na criação de arquiteturas orientadas a serviços em grande escala. O DynamoDB oferece suporte à exportação de dados de tabelas no [formato de texto](http://amzn.github.io/ion-docs/docs/spec.html) do Ion, o qual é um superconjunto do JSON.
Quando você exporta uma tabela para o formato Ion, os tipos de dados do DynamoDB usados na tabela são mapeados em [tipos de dados Ion](http://amzn.github.io/ion-docs/docs/spec.html). O DynamoDB define o uso de [anotações do tipo Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot) para eliminar ambiguidades do tipo de dados usado na tabela de origem.
A tabela a seguir lista o mapeamento entre os tipos de dados do DynamoDB e os tipos de dados do Ion:
| Tipo de dados do DynamoDB | Representação no Ion |
| --- | --- |
| string (S) | string |
| Boolean (BOOL) | bool |
| número (N) | decimal |
| binário (B) | blob |
| Conjunto (SS, NS, BS) | list (com anotação de tipo \$1dynamodb\$1SS, \$1dynamodb\$1NS ou \$1dynamodb\$1BS) |
| Lista | list |
| Mapa | struct |
Os itens em uma exportação do Ion são delimitados por novas linhas. Cada linha começa com um marcador de versão do Ion, seguido por um item no formato Ion. No exemplo a seguir, um item de uma exportação ION foi formatado em várias linhas para fins de legibilidade.
```
$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"
}
}
```
## Saída de exportação Incremental
### Arquivos de manifesto
O DynamoDB cria arquivos de manifesto, bem como os respectivos arquivos de soma de verificação, no bucket do S3 especificado para cada solicitação de exportação.
```
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
```
Você escolhe um **export-prefix** ao solicitar uma exportação de tabela. Isso ajuda a manter os arquivos no bucket do S3 de destino organizados. O **ExportId** é um token exclusivo gerado pelo serviço para garantir que várias exportações para o mesmo bucket do S3 e `export-prefix` não se sobreponham.
Essa exportação cria pelo menos um arquivo por partição. Para partições vazias, a solicitação de exportação criará um arquivo vazio. Todos os itens em cada arquivo são do espaço de chave com hash dessa partição específica.
**nota**
O DynamoDB também cria um arquivo vazio chamado `_started` no mesmo diretório dos arquivos de manifesto.’ Esse arquivo verifica se o bucket de destino pode ser gravado e se a exportação foi iniciada. Ele pode ser excluído com segurança.
#### O manifesto resumido
O arquivo `manifest-summary.json` contém informações resumidas sobre o trabalho de exportação. Isso permite que você saiba quais arquivos de dados na pasta de dados compartilhada estão associados a essa exportação. Seu formato é o seguinte:
```
{
"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"
}
```
#### O manifesto de arquivos
O arquivo `manifest-files.json` contém informações sobre os arquivos que contêm os dados da tabela exportada. Como o arquivo está no formato [linhas JSON](https://jsonlines.org/), novas linhas são usadas como delimitadores de itens. No exemplo a seguir, os detalhes de um arquivo de dados de um manifesto de arquivos são formatados em várias linhas por razões de legibilidade.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/data/sgad6417s6vss4p7owp0471bcq.json.gz"
}
```
### Arquivos de dados
O DynamoDB pode exportar os dados da tabela em dois formatos: DynamoDB JSON e Amazon Ion. Independentemente do formato escolhido, os dados serão gravados em vários arquivos compactados nomeados pelas chaves. Esses arquivos também estão listados no arquivo `manifest-files.json`.
Os arquivos de dados para exportações incrementais estão todos contidos em uma pasta de dados comum no bucket do S3. Os arquivos de manifesto estão na pasta de ID de exportação.
```
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
│ ...
```
Nos arquivos de exportação, a saída de cada item inclui um carimbo de data/hora que representa quando o item foi atualizado na tabela e uma estrutura de dados que indica se foi uma operação `insert`, `update` ou `delete`. O carimbo de data/hora baseia-se em um relógio interno do sistema e pode divergir do relógio da aplicação. Para exportações incrementais, você pode escolher entre dois tipos de visualização de exportação para a estrutura de saída: **Imagens novas e antigas** ou **Somente novas imagens**.
+ **Imagem nova** fornece o estado mais recente do item
+ **Imagem antiga** fornece o estado do item imediatamente antes da **data e hora de início** especificadas
Os tipos de visualização podem ser úteis se você quiser ver como o item foi alterado no período de exportação. Também pode ser útil para atualizar com eficiência os sistemas subsequentes, especialmente se esses sistemas tiverem uma chave de partição diferente da chave de partição do DynamoDB.
Você pode inferir se um item na saída de exportação incremental era `insert`, `update` ou `delete` observando a estrutura da saída. A estrutura de exportação incremental e as operações correspondentes estão resumidas na tabela abaixo para os dois tipos de visualização de exportação.
| Operation | Somente novas imagens | Imagens novas e antigas |
| --- | --- | --- |
| Inserir | Chaves \$1 imagem nova | Chaves \$1 imagem nova |
| Atualizar | Chaves \$1 imagem nova | Chaves \$1 imagem nova \$1 imagem antiga |
| Excluir | Chaves | Chaves \$1 imagem antiga |
| Inserir \$1 excluir | Sem saída | Sem saída |
#### DynamoDB JSON
Uma exportação de tabela no formato JSON do DynamoDB consiste em um carimbo de data/hora de metadados que indica a hora de gravação do item, seguido das chaves do item e dos valores. Veja a seguir um exemplo de saída JSON do DynamoDB usando o tipo de visualização de exportação como **Imagens novas e antigas**.
```
// 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
O [Amazon Ion](http://amzn.github.io/ion-docs/) é um formato de serialização de dados hierárquico, autodescritivo e altamente compatível com vários tipos de declaração e criado para lidar com os desafios de desacoplamento, desenvolvimento rápido e eficiência enfrentados todos os dias na criação de arquiteturas orientadas a serviços em grande escala. O DynamoDB oferece suporte à exportação de dados de tabelas no [formato de texto](http://amzn.github.io/ion-docs/docs/spec.html) do Ion, o qual é um superconjunto do JSON.
Quando você exporta uma tabela para o formato Ion, os tipos de dados do DynamoDB usados na tabela são mapeados em [tipos de dados Ion](http://amzn.github.io/ion-docs/docs/spec.html). O DynamoDB define o uso de [anotações do tipo Ion](http://amzn.github.io/ion-docs/docs/spec.html#annot) para eliminar ambiguidades do tipo de dados usado na tabela de origem.
A tabela a seguir lista o mapeamento entre os tipos de dados do DynamoDB e os tipos de dados do Ion:
| Tipo de dados do DynamoDB | Representação no Ion |
| --- | --- |
| string (S) | string |
| Boolean (BOOL) | bool |
| número (N) | decimal |
| binário (B) | blob |
| Conjunto (SS, NS, BS) | list (com anotação de tipo \$1dynamodb\$1SS, \$1dynamodb\$1NS ou \$1dynamodb\$1BS) |
| Lista | list |
| Mapa | struct |
Os itens em uma exportação do Ion são delimitados por novas linhas. Cada linha começa com um marcador de versão do Ion, seguido por um item no formato Ion. No exemplo a seguir, um item de uma exportação ION foi formatado em várias linhas para fins de legibilidade.
```
$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"
}
}
}
```