Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# DynamoDB Datenexport zu Amazon S3: Funktionsweise
Der DynamoDB-Export nach S3 ist eine vollständig verwaltete Lösung für den Export Ihrer DynamoDB-Daten in einen Amazon-S3-Bucket in großem Maßstab. Mithilfe des DynamoDB-Exports nach S3 können Sie Daten aus einer Amazon DynamoDB-Tabelle jederzeit innerhalb Ihres [point-in-time Wiederherstellungsfensters (PITR)](Point-in-time-recovery.md) in einen Amazon S3 S3-Bucket exportieren. Sie müssen PITR in Ihrer Tabelle aktivieren, um die Exportfunktion nutzen zu können. Mit dieser Funktion können Sie Analysen und komplexe Abfragen Ihrer Daten mithilfe anderer AWS Dienste wie Athena, Amazon SageMaker AI AWS Glue, Amazon EMR und durchführen. AWS Lake Formation
Mit dem DynamoDB-Export nach S3 können Sie sowohl vollständige als auch inkrementelle Daten aus Ihrer DynamoDB-Tabelle exportieren. Exporte sind asynchron, verbrauchen keine [Lesekapazitätseinheiten (RCUs)](provisioned-capacity-mode.md) und haben keine Auswirkungen auf die Tabellenleistung und Verfügbarkeit. Die unterstützten Exportdateiformate sind DynamoDB JSON und Amazon Ion. Sie können Daten auch in einen S3-Bucket exportieren, der einem anderen AWS Konto gehört, und in eine andere AWS Region. Ihre Daten sind immer verschlüsselt end-to-end.
Vollständige DynamoDB-Exporte werden auf der Grundlage der Größe der DynamoDB-Tabelle (Tabellendaten und lokale Sekundärindizes) zu dem Zeitpunkt berechnet, für den der Export ausgeführt wird. Inkrementelle DynamoDB-Exporte werden auf der Grundlage der Größe der Daten berechnet, die aus Ihren kontinuierlichen Backups für den exportierten Zeitraum verarbeitet wurden. Für den inkrementellen Export wird eine Mindestgebühr von 10 MB berechnet. Zusätzliche Gebühren fallen für das Speichern exportierter Daten in Amazon S3 und für `PUT`-Anfragen an Ihren Amazon-S3-Bucket an. Weitere Informationen zu diesen Gebühren finden Sie unter [Amazon-DynamoDB-Preise](https://aws.amazon.com/dynamodb/pricing/) und [Amazon-S3-Preise](https://aws.amazon.com/s3/pricing/).
Einzelheiten zu Servicekontingenten finden Sie unter [Exportieren von Tabellen zu Amazon S3](ServiceQuotas.md#limits-table-export).
**Topics**
+ [Anfordern eines Tabellenexports in DynamoDB](S3DataExport_Requesting.md)
+ [Export-Ausgabeformat für DynamoDB-Tabellen](S3DataExport.Output.md)
# Anfordern eines Tabellenexports in DynamoDB
DynamoDB-Tabellenexporte ermöglichen es Ihnen, Tabellendaten in einen Amazon S3 S3-Bucket zu exportieren, sodass Sie Analysen und komplexe Abfragen Ihrer Daten mithilfe anderer AWS Services wie Athena, Amazon SageMaker AI AWS Glue, Amazon EMR und durchführen können. AWS Lake Formation Sie können einen Tabellenexport mit der AWS-Managementkonsole, der oder der AWS CLI DynamoDB-API anfordern.
**Anmerkung**
Zahlung durch den Anforderer ist für Amazon-S3-Buckets nicht unterstützt.
DynamoDB unterstützt sowohl den vollständigen Export als auch den inkrementellen Export:
+ Mit **vollständigen Exporten** können Sie einen vollständigen Snapshot Ihrer Tabelle von einem beliebigen Zeitpunkt innerhalb des point-in-time Wiederherstellungsfensters (PITR) in Ihren Amazon S3 S3-Bucket exportieren.
+ Mit **inkrementellen Exporten** können Sie Daten aus Ihrer DynamoDB-Tabelle, die zwischen einem bestimmten Zeitraum geändert, aktualisiert oder gelöscht wurden, innerhalb Ihres PITR-Fensters in Ihren Amazon-S3-Bucket exportieren.
**Topics**
+ [Voraussetzungen](#S3DataExport_Requesting_Permissions)
+ [Beantragen eines Exports mit dem AWS-Managementkonsole](#S3DataExport_Requesting_Console)
+ [Details zu vergangenen Exporten finden Sie in AWS-Managementkonsole](#S3DataExport_Requesting_Console_Details)
+ [Einen Export mit dem AWS CLI und anfordern AWS SDKs](#S3DataExport_Requesting_CLI)
+ [Details zu vergangenen Exporten mit dem AWS CLI und abrufen AWS SDKs](#S3DataExport_Requesting_CLI_Details)
## Voraussetzungen
**Aktivieren von PITR**
PITR muss in Ihrer Tabelle aktiviert sein, um die Funktion zum Exportieren nach S3 verwenden zu können. Einzelheiten zur Aktivierung von PITR finden Sie unter [oint-in-timeP-Wiederherstellung](PointInTimeRecovery_Howitworks.md). Wenn Sie einen Export für eine Tabelle anfordern, für die PITR nicht aktiviert ist, schlägt Ihre Anfrage fehl und es wird eine Ausnahmemeldung angezeigt: „Beim Aufrufen des `ExportTableToPointInTime` Vorgangs ist ein Fehler aufgetreten (PointInTimeRecoveryUnavailableException): Die Point-in-Time-Wiederherstellung ist für die Tabelle 'my-dynamodb-tablenicht aktiviert“. Sie können einen Export nur für einen Zeitpunkt innerhalb Ihrer konfigurierten PITR-`RecoveryPeriodInDays` anfordern.
**Einrichten von S3-Berechtigungen**
Sie können Ihre Tabellendaten in jeden Amazon S3-Bucket exportieren, in den Sie schreiben dürfen. Der Ziel-Bucket muss sich nicht in derselben AWS Region befinden oder denselben Besitzer haben wie der Besitzer der Quelltabelle. Ihre AWS Identity and Access Management (IAM-) Richtlinie muss es Ihnen ermöglichen, S3-Aktionen (`s3:AbortMultipartUpload``s3:PutObject`, und`s3:PutObjectAcl`) und die DynamoDB-Exportaktion () auszuführen. `dynamodb:ExportTableToPointInTime` Hier ein Beispiel für eine Beispielrichtlinie, die Ihren Benutzern Berechtigungen zum Ausführen von Exporten in einen S3-Bucket gewährt.
------
#### [ 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/*"
}
]
}
```
------
Wenn Sie in einen Amazon S3-Bucket schreiben müssen, der sich in einem anderen Konto befindet, oder wenn Sie keine Schreibberechtigungen haben, muss der Eigentümer des Amazon S3-Buckets eine Bucket-Richtlinie hinzufügen, damit Sie von DynamoDB in diesen Bucket exportieren können. Hier sehen Sie eine Beispielrichtlinie für den Amazon S3-Zielbucket.
------
#### [ 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/*"
}
]
}
```
------
Das Widerrufen dieser Berechtigungen während eines Exports führt zu Teildateien.
**Anmerkung**
Wenn die Tabelle oder der Bucket, in die/den Sie exportieren, mit vom Kunden verwalteten Schlüsseln verschlüsselt ist, müssen die Richtlinien dieses KMS-Schlüssels DynamoDB die Berechtigung zur Verwendung erteilen. Diese Berechtigung wird über das IAM erteilt, das den Exportauftrag User/Role auslöst. Weitere Informationen zur Verschlüsselung, einschließlich Best Practices, finden Sie unter [So verwendet DynamoDB AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services-dynamodb.html) und [Using a custom KMS key](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html#managed-key-customer-managed) (Verwendung eines benutzerdefinierten KMS-Schlüssels).
## Beantragen eines Exports mit dem AWS-Managementkonsole
Das folgende Beispiel zeigt, wie Sie mit der DynamoDB-Konsole eine vorhandene Tabelle namens `MusicCollection` im Zustand eines bestimmten Zeitpunkts wiederherstellen.
**Anmerkung**
Bei diesem Verfahren wird davon ausgegangen, dass Sie die point-in-time Wiederherstellung aktiviert haben. Um es für die `MusicCollection` Tabelle zu aktivieren, wählen Sie auf der Registerkarte **Übersicht** der **Tabelle im Abschnitt Tabellendetails** die Option Für **oint-in-timeP-Wiederherstellung** **aktivieren** aus.
**So fordern Sie einen Tabellenexport an**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Klicken Sie im Navigationsbereich links in der Konsole auf **Exports to S3** (Exporte nach S3).
1. Wählen Sie die Schaltfläche **Nach S3 exportieren**.
1. Wählen Sie eine Quelltabelle und den Ziel-S3-Bucket aus. Wenn der Ziel-Bucket Ihrem Konto gehört, können Sie die Schaltfläche **Browse S3** (S3 durchsuchen) verwenden, um ihn zu finden. Geben Sie andernfalls die URL des Buckets ein und verwenden Sie dabei das `s3://bucketname/prefix format.` **prefix** ist ein optionaler Ordner, um Ihren Ziel-Bucket organisiert zu halten.
1. Wählen Sie **Vollständiger Export** oder **Inkrementeller Export**. Bei einem **vollständigen Export** wird der vollständige Tabellen-Snapshot Ihrer Tabelle so ausgegeben, wie er zu dem von Ihnen angegebenen Zeitpunkt war. Bei einem **inkrementellen Export** werden die Änderungen ausgegeben, die während des angegebenen Exportzeitraums an Ihrer Tabelle vorgenommen wurden. Ihre Ausgabe ist komprimiert, sodass sie nur den endgültigen Status des Elements aus dem Exportzeitraum enthält. Das Element wird nur einmal im Export angezeigt, auch wenn es innerhalb desselben Exportzeitraums mehrfach aktualisiert wurde.
------
#### [ Full export ]
1. Wählen Sie den Zeitpunkt aus, ab dem Sie den vollständigen Tabellen-Snapshot exportieren möchten. Dies kann ein beliebiger Zeitpunkt innerhalb des PITR-Zeitfensters sein. Alternativ können Sie **Aktuelle Zeit** auswählen, um den neuesten Snapshot zu exportieren.
1. Wählen Sie für **Exportiertes Dateiformat** zwischen **DynamoDB JSON** und **Amazon Ion**. Standardmäßig wird Ihre Tabelle ab dem letzten wiederherstellbaren Zeitpunkt im Point-in-Time-Wiederherstellungsfenster im DynamoDB JSON-Format exportiert und mit einem Amazon S3-Schlüssel (SSE-S3) verschlüsselt. Sie können diese Exporteinstellungen bei Bedarf ändern.
**Anmerkung**
Wenn Sie Ihren Export mit einem durch AWS Key Management Service (AWS KMS) geschützten Schlüssel verschlüsseln möchten, muss sich der Schlüssel in derselben Region wie der Ziel-S3-Bucket befinden.
------
#### [ Incremental export ]
1. Wählen Sie den **Exportzeitraum** aus, für den Sie die inkrementellen Daten exportieren möchten. Wählen Sie eine Startzeit innerhalb des PITR-Zeitfensters aus. Die Dauer des Exportzeitraums muss mindestens 15 Minuten betragen und darf nicht länger als 24 Stunden sein. Die Startzeit ist im Exportzeitraums enthalten, die Endzeit nicht.
1. Wählen Sie zwischen dem **Absoluten Modus** oder dem **Relativen Modus**.
1. Im **Absoluten Modus** werden inkrementelle Daten für den von Ihnen angegebenen Zeitraum exportiert.
1. Im **Relativen Modus** werden inkrementelle Daten für einen Exportzeitraum exportiert, der sich auf die Übermittlungszeit Ihres Exportauftrags bezieht.
1. Wählen Sie für **Exportiertes Dateiformat** zwischen **DynamoDB JSON** und **Amazon Ion**. Standardmäßig wird Ihre Tabelle ab dem letzten wiederherstellbaren Zeitpunkt im Point-in-Time-Wiederherstellungsfenster im DynamoDB JSON-Format exportiert und mit einem Amazon S3-Schlüssel (SSE-S3) verschlüsselt. Sie können diese Exporteinstellungen bei Bedarf ändern.
**Anmerkung**
Wenn Sie Ihren Export mit einem durch AWS Key Management Service (AWS KMS) geschützten Schlüssel verschlüsseln möchten, muss sich der Schlüssel in derselben Region wie der S3-Ziel-Bucket befinden.
1. Wählen Sie für den **Exportansichtstyp** entweder **Neue und alte Bilder** oder **Nur neue Bilder** aus. Neues Bild zeigt den aktuellen Status des Elements Altes Bild zeigt den Status des Elements unmittelbar vor dem angegebenen Startdatum und der angegebenen Startzeit Die Standardeinstellung ist **Neue und alte Bilder**. Weitere Informationen zu neuen und alten Bildern finden Sie unter [Inkrementelle Exportausgabe](S3DataExport.Output.md#incremental-export-output).
------
1. Klicken Sie auf **Exportieren**, um den Vorgang zu beginnen.
Die exportierten Daten sind nicht transaktional konsistent. Ihre Transaktionsoperationen können zwischen zwei Exportausgaben aufgeteilt werden. Ein Teil der Elemente kann durch eine Transaktionsoperation geändert und im Export widergespiegelt werden, während ein anderer Teil der Änderungen derselben Transaktion im selben Exportauftrag nicht enthalten ist. Die Exporte sind jedoch letztendlich konsistent. Wenn eine Transaktion während eines Exports aufgeteilt wird, wird der verbleibende Teil der Transaktion im nächsten zusammenhängenden Export enthalten sein – ohne Duplikate. Die für Exporte verwendeten Zeiträume basieren auf einer internen Systemuhr und können um eine Minute von der lokalen Uhr Ihrer Anwendung abweichen.
## Details zu vergangenen Exporten finden Sie in AWS-Managementkonsole
Informationen zu früheren Exportaufträgen finden Sie im Navigationsbereich unter dem Abschnitt **Exporte nach S3**. Dieser Abschnitt enthält eine Liste aller Exporte, die Sie in den letzten 90 Tagen erstellt haben. Wählen Sie die ARN eines in der Registerkarte **Exporte** aufgeführten Auftrags aus, um Informationen zu diesem Export abzurufen, einschließlich aller erweiterten Konfigurationseinstellungen, die Sie gewählt haben. Beachten Sie, dass die Metadaten für die Exportaufgabe nach 90 Tagen ablaufen und Aufträge, die älter sind als diese, in dieser Liste nicht mehr gefunden werden, die Objekte in Ihrem S3 Bucket so lange bleiben, wie es ihre Bucket-Richtlinien zulassen. DynamoDB löscht nie eines der Objekte, die es während eines Exports in Ihrem S3 Bucket erstellt hat.
## Einen Export mit dem AWS CLI und anfordern AWS SDKs
Die folgenden Beispiele zeigen, wie eine vorhandene Tabelle in einen S3-Bucket exportiert wird.
**Anmerkung**
Bei diesem Verfahren wird davon ausgegangen, dass Sie die point-in-time Wiederherstellung aktiviert haben. Führen Sie den folgenden Befehl aus, um diese Funktion für die Tabelle `MusicCollection` zu aktivieren.
```
aws dynamodb update-continuous-backups \
--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=True
```
**Vollständiger Export**
------
#### [ AWS CLI ]
**Anmerkung**
Wenn Sie einen kontenübergreifenden Tabellenexport anfordern, stellen Sie sicher, dass Sie die Option `--s3-bucket-owner` einfügen.
```
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,
})
```
------
**Inkrementeller Export**
------
#### [ 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,
})
```
------
**Anmerkung**
Wenn Sie Ihren Export mit einem durch AWS Key Management Service (AWS KMS) geschützten Schlüssel verschlüsseln möchten, muss sich der Schlüssel in derselben Region wie der S3-Ziel-Bucket befinden.
## Details zu vergangenen Exporten mit dem AWS CLI und abrufen AWS SDKs
Informationen zu Exportaufgaben, die Sie in der Vergangenheit ausgeführt haben, finden Sie mithilfe des `list-exports`-Befehls. Dieser Befehl gibt eine Liste aller Exporte zurück, die Sie in den letzten 90 Tagen erstellt haben. Beachten Sie, dass, obwohl die Metadaten der Exportaufgabe nach 90 Tagen ablaufen und Aufträge, die älter sind, nicht mehr vom `list-exports` Befehl zurückgegeben werden, die Objekte in Ihrem S3 Bucket so lange erhalten bleiben, wie es ihre Bucket-Richtlinien zulassen. DynamoDB löscht nie eines der Objekte, die es während eines Exports in Ihrem S3 Bucket erstellt hat.
Exporte haben den Status `PENDING`, bis sie entweder erfolgreich sind oder fehlschlagen. Wenn sie erfolgreich sind, ändert sich der Status zu `COMPLETED`. Wenn sie fehlschlagen, ändert sich der Status zu `FAILED` mit `failure_message` und `failure_reason`.
**Exporte auflisten**
------
#### [ 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)
```
------
**Beschreiben Sie den Export**
------
#### [ 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)
```
------
# Export-Ausgabeformat für DynamoDB-Tabellen
Ein DynamoDB-Tabellenexport umfasst Manifestdateien, zusätzlich zu den Dateien, die Ihre Tabellendaten enthalten. Diese Dateien werden alle in dem Amazon S3-Bucket gespeichert, den Sie in Ihrer [Exportanforderung](S3DataExport_Requesting.md) spezifizieren. Die folgenden Abschnitte beschreiben das Format und den Inhalt der einzelnen Ausgabeobjekte.
**Topics**
## Vollständige Exportausgabe
### Manifestdateien
DynamoDB erstellt Manifestdateien zusammen mit ihren Prüfsummendateien im angegebenen S3-Bucket für jede Exportanforderung.
```
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
```
Sie wählen ein **export-prefix**, wenn Sie einen Tabellenexport anfordern. Auf diese Weise können Sie Dateien im Ziel-S3-Bucket organisieren. Die **ExportId** ist ein eindeutiges vom Service generiertes Token, um sicherzustellen, dass mehrere Exporte in denselben S3-Bucket und `export-prefix` sich nicht gegenseitig überschreiben.
Bei dem Export wird mindestens 1 Datei pro Partition erstellt. Für leere Partitionen erstellt Ihre Exportanforderung eine leere Datei. Alle Elemente in jeder Datei stammen aus dem Hash-Keyspace der betreffenden Partition.
**Anmerkung**
DynamoDB erstellt auch eine leere Datei namens `_started`, die im selben Verzeichnis wie die Manifestdateien benannt ist. Diese Datei überprüft, ob der Ziel-Bucket beschreibbar ist und der Export begonnen hat. Es kann sicher gelöscht werden.
#### Das Übersichtsmanifest
Die `manifest-summary.json`-Datei enthält zusammenfassende Informationen zum Exportauftrag. Auf diese Weise können Sie feststellen, welche Datendateien im gemeinsam genutzten Datenordner mit diesem Export verknüpft sind. Das Format lautet folgendermaßen:
```
{
"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"
}
```
#### Die Manifestdateien
Die `manifest-files.json`-Datei enthält Informationen zu den Dateien, die Ihre exportierten Tabellendaten enthalten. Die Datei hat das [JSON-Lines](https://jsonlines.org/)-Format, was bedeutet, dass Zeilenumbrüche als Elementtrennzeichen verwendet werden. Im folgenden Beispiel werden die Details einer Datendatei aus einem Dateimanifest aus Gründen der Lesbarkeit in mehreren Zeilen formatiert.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/01693685827463-2d8752fd/data/asdl123dasas.json.gz"
}
```
### Datendateien
DynamoDB kann Ihre Tabellendaten in zwei Formaten exportieren: DynamoDB JSON und Amazon Ion. Unabhängig vom gewählten Format werden Ihre Daten in mehrere komprimierte Dateien geschrieben, die nach den Schlüsseln benannt sind. Diese Dateien sind auch in der `manifest-files.json`-Datei aufgeführt.
Die Verzeichnisstruktur Ihres Amazon S3-Buckets enthält nach einem vollständigen Export alle Ihre Manifestdateien und Datendateien im Ordner 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
Ein Tabellenexport im DynamoDB-JSON-Format besteht aus mehreren `Item`-Objekten. Jedes einzelne Objekt befindet sich im Standard-JSON-Format von DynamoDB.
Beachten Sie beim Erstellen benutzerdefinierter Parser für DynamoDB-JSON-Exportdaten, dass das Format [JSON Lines](https://jsonlines.org/) ist. Dies bedeutet, dass Zeilenumbrüche als Elementtrennzeichen verwendet werden. Viele AWS Dienste, wie Athena und AWS Glue, analysieren dieses Format automatisch.
Im folgenden Beispiel wurde ein einzelnes Element aus einem DynamoDB-JSON-Export aus Gründen der Lesbarkeit in mehreren Zeilen formatiert.
```
{
"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/) ist ein reich typisiertes, selbstbeschreibendes, hierarchisches Datenserialisierungsformat, das entwickelt wurde, um schnelle Entwicklungs-, Entkopplungs- und Effizienzprobleme zu bewältigen, denen sich täglich gegenübersehen, während umfangreiche, serviceorientierte Architekturen entwickelt werden. DynamoDB unterstützt den Export von Tabellendaten in [Textformat](http://amzn.github.io/ion-docs/docs/spec.html), die eine Obermenge von JSON ist.
Wenn Sie eine Tabelle in das Ion-Format exportieren, werden die in der Tabelle verwendeten DynamoDB-Datentypen [Ion-Datentypen](http://amzn.github.io/ion-docs/docs/spec.html) abgebildet. DynamoDB-Sets verwenden [Ion-Typ-Anmerkungen](http://amzn.github.io/ion-docs/docs/spec.html#annot), um den in der Quelltabelle verwendeten Datentyp zu verdeutlichen.
In der folgenden Tabelle ist die Zuordnung von DynamoDB-Datentypen zu Ion-Datentypen aufgeführt:
| DynamoDB-Datentyp | Ion-Darstellung |
| --- | --- |
| String (S) | Zeichenfolge |
| BOOLEAN (BOOL) | bool |
| Nummer (N) | decimal |
| Binary (B) | blob |
| Satz (SS, NS, BS) | Liste (mit Typannotation \$1DynamoDB\$1SS, \$1DynamoDB\$1NS oder \$1DynamoDB\$1Bs) |
| Liste | auflisten |
| Map | struct |
Elemente in einem Ionen-Export werden durch Zeilenumbrüche getrennt. Jede Zeile beginnt mit einer Ion-Versionsmarkierung, gefolgt von einem Element im Ionen-Format. Im folgenden Beispiel wurde ein Element aus einem Ion-Export aus Gründen der Lesbarkeit in mehreren Zeilen formatiert.
```
$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"
}
}
```
## Inkrementelle Exportausgabe
### Manifestdateien
DynamoDB erstellt Manifestdateien zusammen mit ihren Prüfsummendateien im angegebenen S3-Bucket für jede Exportanforderung.
```
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
```
Sie wählen ein **export-prefix**, wenn Sie einen Tabellenexport anfordern. Auf diese Weise können Sie Dateien im Ziel-S3-Bucket organisieren. Die **ExportId** ist ein eindeutiges vom Service generiertes Token, um sicherzustellen, dass mehrere Exporte in denselben S3-Bucket und `export-prefix` sich nicht gegenseitig überschreiben.
Bei dem Export wird mindestens 1 Datei pro Partition erstellt. Für leere Partitionen erstellt Ihre Exportanforderung eine leere Datei. Alle Elemente in jeder Datei stammen aus dem Hash-Keyspace der betreffenden Partition.
**Anmerkung**
DynamoDB erstellt auch eine leere Datei namens `_started`, die im selben Verzeichnis wie die Manifestdateien benannt ist. Diese Datei überprüft, ob der Ziel-Bucket beschreibbar ist und der Export begonnen hat. Es kann sicher gelöscht werden.
#### Das Übersichtsmanifest
Die `manifest-summary.json`-Datei enthält zusammenfassende Informationen zum Exportauftrag. Auf diese Weise können Sie feststellen, welche Datendateien im gemeinsam genutzten Datenordner mit diesem Export verknüpft sind. Das Format lautet folgendermaßen:
```
{
"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"
}
```
#### Die Manifestdateien
Die `manifest-files.json`-Datei enthält Informationen zu den Dateien, die Ihre exportierten Tabellendaten enthalten. Die Datei hat das [JSON-Lines](https://jsonlines.org/)-Format, was bedeutet, dass Zeilenumbrüche als Elementtrennzeichen verwendet werden. Im folgenden Beispiel werden die Details einer Datendatei aus einem Dateimanifest aus Gründen der Lesbarkeit in mehreren Zeilen formatiert.
```
{
"itemCount": 8,
"md5Checksum": "sQMSpEILNgoQmarvDFonGQ==",
"etag": "af83d6f217c19b8b0fff8023d8ca4716-1",
"dataFileS3Key": "AWSDynamoDB/data/sgad6417s6vss4p7owp0471bcq.json.gz"
}
```
### Datendateien
DynamoDB kann Ihre Tabellendaten in zwei Formaten exportieren: DynamoDB JSON und Amazon Ion. Unabhängig vom gewählten Format werden Ihre Daten in mehrere komprimierte Dateien geschrieben, die nach den Schlüsseln benannt sind. Diese Dateien sind auch in der `manifest-files.json`-Datei aufgeführt.
Die Datendateien für inkrementelle Exporte sind alle in einem gemeinsamen Datenordner in Ihrem S3-Bucket enthalten. Ihre Manifestdateien befinden sich in Ihrem Export-ID-Ordner.
```
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
│ ...
```
In Ihren Exportdateien enthält die Ausgabe jedes Elements einen Zeitstempel, der angibt, wann das Element in Ihrer Tabelle aktualisiert wurde, und eine Datenstruktur, die angibt, ob es sich um einen `insert`-, `update`- oder `delete`-Vorgang handelt. Der Zeitstempel basiert auf einer internen Systemuhr und kann von der Uhr Ihrer Anwendung abweichen. Für inkrementelle Exporte können Sie zwischen zwei Exportansichtstypen für Ihre Ausgabestruktur wählen: **neue und alte Bilder** oder **nur neue Bilder**.
+ **Neues Bild** zeigt den aktuellen Status des Elements
+ **Altes Bild** zeigt den Status des Elements unmittelbar vor dem angegebenen **Startdatum und der angegebenen Startzeit**
Ansichtstypen können hilfreich sein, wenn Sie sehen möchten, wie das Element innerhalb des Exportzeitraums geändert wurde. Sie können auch nützlich sein, um Ihre Downstream-Systeme effizient zu aktualisieren, insbesondere wenn diese Downstream-Systeme einen Partitionsschlüssel haben, der nicht mit Ihrem DynamoDB-Partitionsschlüssel identisch ist.
Anhand der Struktur der Ausgabe können Sie ableiten, ob es sich bei einem Element in Ihrer inkrementellen Exportausgabe um ein `insert`, `update` oder `delete` handelte. Die Struktur des inkrementellen Exports und die entsprechenden Operationen sind in der folgenden Tabelle für beide Exportansichtstypen zusammengefasst.
| Operation | Nur neue Bilder | Neue und alte Bilder |
| --- | --- | --- |
| Einfügen | Schlüssel \$1 neues Bild | Schlüssel \$1 neues Bild |
| Aktualisierung | Schlüssel \$1 neues Bild | Schlüssel \$1 neues Bild \$1 altes Bild |
| Delete | Schlüssel | Schlüssel \$1 altes Bild |
| Einfügen \$1 Löschen | Keine Ausgabe | Keine Ausgabe |
#### DynamoDB-JSON
Ein Tabellenexport im DynamoDB-JSON-Format besteht aus einem Metadaten-Zeitstempel, der die Schreibzeit des Elements angibt, gefolgt von den Schlüsseln des Elements und den Werten. Nachfolgend sehen Sie ein Beispiel für eine DynamoDB-JSON-Ausgabe mit dem Exportansichtstyp **Neue und alte Bilder**.
```
// 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/) ist ein reich typisiertes, selbstbeschreibendes, hierarchisches Datenserialisierungsformat, das entwickelt wurde, um schnelle Entwicklungs-, Entkopplungs- und Effizienzprobleme zu bewältigen, denen sich täglich gegenübersehen, während umfangreiche, serviceorientierte Architekturen entwickelt werden. DynamoDB unterstützt den Export von Tabellendaten in [Textformat](http://amzn.github.io/ion-docs/docs/spec.html), die eine Obermenge von JSON ist.
Wenn Sie eine Tabelle in das Ion-Format exportieren, werden die in der Tabelle verwendeten DynamoDB-Datentypen [Ion-Datentypen](http://amzn.github.io/ion-docs/docs/spec.html) abgebildet. DynamoDB-Sets verwenden [Ion-Typ-Anmerkungen](http://amzn.github.io/ion-docs/docs/spec.html#annot), um den in der Quelltabelle verwendeten Datentyp zu verdeutlichen.
In der folgenden Tabelle ist die Zuordnung von DynamoDB-Datentypen zu Ion-Datentypen aufgeführt:
| DynamoDB-Datentyp | Ion-Darstellung |
| --- | --- |
| String (S) | Zeichenfolge |
| BOOLEAN (BOOL) | bool |
| Nummer (N) | decimal |
| Binary (B) | blob |
| Satz (SS, NS, BS) | Liste (mit Typannotation \$1DynamoDB\$1SS, \$1DynamoDB\$1NS oder \$1DynamoDB\$1Bs) |
| Liste | auflisten |
| Map | struct |
Elemente in einem Ionen-Export werden durch Zeilenumbrüche getrennt. Jede Zeile beginnt mit einer Ion-Versionsmarkierung, gefolgt von einem Element im Ionen-Format. Im folgenden Beispiel wurde ein Element aus einem Ion-Export aus Gründen der Lesbarkeit in mehreren Zeilen formatiert.
```
$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"
}
}
}
```