

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.

# Amazon DynamoDB-Tabellen mithilfe einer benutzerdefinierten Implementierung kontenübergreifend kopieren
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation"></a>

*Ramkumar Ramanujam, Amazon Web Services*

## Zusammenfassung
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-summary"></a>

Bei der Arbeit mit Amazon DynamoDB auf Amazon Web Services (AWS) besteht ein häufiger Anwendungsfall darin, DynamoDB-Tabellen in Entwicklungs-, Test- oder Staging-Umgebungen mit den Tabellendaten in der Produktionsumgebung zu kopieren oder zu synchronisieren. Standardmäßig verwendet jede Umgebung ein anderes AWS-Konto.

DynamoDB unterstützt jetzt kontoübergreifende Backups mit AWS Backup. Informationen zu den damit verbundenen Speicherkosten bei der Nutzung von AWS Backup finden Sie unter [AWS Backup Backup-Preise](https://aws.amazon.com/backup/pricing/). Wenn Sie AWS Backup zum Kopieren zwischen Konten verwenden, müssen die Quell- und Zielkonten Teil einer Organisation von AWS Organizations sein. Es gibt andere Lösungen für kontoübergreifende Sicherung und Wiederherstellung mithilfe von AWS-Services wie AWS Glue. Die Verwendung dieser Lösungen erhöht jedoch den Anwendungsbedarf, da mehr AWS-Services bereitgestellt und verwaltet werden müssen. 

Sie können Amazon DynamoDB Streams auch verwenden, um Tabellenänderungen im Quellkonto zu erfassen. Anschließend können Sie eine AWS Lambda Lambda-Funktion initiieren und die entsprechenden Änderungen in der Zieltabelle im Zielkonto vornehmen. Diese Lösung gilt jedoch für Anwendungsfälle, in denen Quell- und Zieltabellen immer synchron gehalten werden müssen. Sie gilt möglicherweise nicht für Entwicklungs-, Test- und Staging-Umgebungen, in denen Daten häufig aktualisiert werden.

Dieses Muster enthält Schritte zur Implementierung einer benutzerdefinierten Lösung zum Kopieren einer Amazon DynamoDB-Tabelle von einem Konto in ein anderes. Dieses Muster kann mit gängigen Programmiersprachen wie C\$1, Java und Python implementiert werden. Wir empfehlen die Verwendung einer Sprache, die von einem [AWS-SDK](https://aws.amazon.com/tools/) unterstützt wird.

## Voraussetzungen und Einschränkungen
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-prereqs"></a>

**Voraussetzungen**
+ Zwei aktive AWS-Konten
+ DynamoDB-Tabellen in beiden Konten
+ Kenntnis der Rollen und Richtlinien von AWS Identity and Access Management (IAM)
+ Kenntnis des Zugriffs auf Amazon DynamoDB-Tabellen mit einer gängigen Programmiersprache wie C\$1, Java oder Python

**Einschränkungen**

Dieses Muster gilt für DynamoDB-Tabellen mit einer Größe von etwa 2 GB oder weniger. Es verfügt über zusätzliche Logik zur Behandlung von Verbindungs- oder Sitzungsunterbrechungen, Drosselungen sowie Ausfällen und Wiederholungsversuchen und kann daher für größere Tabellen verwendet werden.

Der DynamoDB-Scanvorgang, der Elemente aus der Quelltabelle liest, kann in einem einzigen Aufruf nur bis zu 1 MB an Daten abrufen. Bei größeren Tabellen, die größer als 2 GB sind, kann diese Beschränkung die Gesamtzeit bis zum vollständigen Kopieren der Tabelle verlängern.

## Architektur
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-architecture"></a>

Das folgende Diagramm zeigt die benutzerdefinierte Implementierung zwischen den AWS-Quell- und Zielkonten. Bei der benutzerdefinierten Implementierung werden IAM-Richtlinien und Sicherheitstoken verwendet. Daten werden aus Amazon DynamoDB im Quellkonto gelesen und im Zielkonto in DynamoDB geschrieben.

![\[Quell- und Zielkontoarchitektur für das Kopieren mithilfe der benutzerdefinierten Implementierung.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/ba8175be-9809-4c2e-b2d1-6b9180ed056c/images/d9d4c2c8-ff04-443f-9137-e37b8e23ccb5.png)


 

**Automatisierung und Skalierung**

Dieses Muster gilt für DynamoDB-Tabellen, die kleiner sind, etwa 2 GB. 

Um dieses Muster auf größere Tabellen anzuwenden, beheben Sie die folgenden Probleme:
+ Während des Tabellenkopiervorgangs werden zwei aktive Sitzungen aufrechterhalten, wobei unterschiedliche Sicherheitstoken verwendet werden. Wenn der Vorgang zum Kopieren der Tabelle länger dauert als die Ablaufzeiten der Token, müssen Sie eine Logik zur Aktualisierung der Sicherheitstoken einrichten. 
+ Wenn nicht genügend Lesekapazitätseinheiten (RCUs) und Schreibkapazitätseinheiten (WCUs) bereitgestellt werden, werden Lese- oder Schreibvorgänge in der Quell- oder Zieltabelle möglicherweise gedrosselt. Achten Sie darauf, diese Ausnahmen zu erkennen und zu behandeln. 
+ Behandeln Sie alle anderen Fehler oder Ausnahmen und richten Sie einen Wiederholungsmechanismus ein, um es erneut zu versuchen oder an der Stelle fortzusetzen, an der der Kopiervorgang fehlgeschlagen ist.

## Tools
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-tools"></a>

**Tools**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) — Amazon DynamoDB ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung mit nahtloser Skalierbarkeit bietet. 
+ Welche zusätzlichen Tools erforderlich sind, hängt von der Programmiersprache ab, die Sie für die Implementierung auswählen. Wenn Sie beispielsweise C\$1 verwenden, benötigen Sie Microsoft Visual Studio und die folgenden NuGet Pakete:
  + `AWSSDK`
  + `AWSSDK.DynamoDBv2`

**Code**

Der folgende Python-Codeausschnitt löscht eine DynamoDB-Tabelle mithilfe der Boto3-Bibliothek und erstellt sie neu.

Verwenden Sie nicht das `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY` eines IAM-Benutzers, da es sich dabei um langfristige Anmeldeinformationen handelt, die für den programmatischen Zugriff auf AWS-Services vermieden werden sollten. Weitere Informationen zu temporären Anmeldeinformationen finden Sie im Abschnitt *Bewährte Methoden*.

Die im folgenden Codeausschnitt `TEMPORARY_SESSION_TOKEN` verwendeten `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, und sind temporäre Anmeldeinformationen, die vom AWS Security Token Service (AWS STS) abgerufen wurden.

```
import boto3
import sys
import json

#args = input-parameters = GLOBAL_SEC_INDEXES_JSON_COLLECTION, ATTRIBUTES_JSON_COLLECTION, TARGET_DYNAMODB_NAME, TARGET_REGION, ...

#Input param: GLOBAL_SEC_INDEXES_JSON_COLLECTION
#[{"IndexName":"Test-index","KeySchema":[{"AttributeName":"AppId","KeyType":"HASH"},{"AttributeName":"AppType","KeyType":"RANGE"}],"Projection":{"ProjectionType":"INCLUDE","NonKeyAttributes":["PK","SK","OwnerName","AppVersion"]}}]

#Input param: ATTRIBUTES_JSON_COLLECTION
#[{"AttributeName":"PK","AttributeType":"S"},{"AttributeName":"SK","AttributeType":"S"},{"AttributeName":"AppId","AttributeType":"S"},{"AttributeName":"AppType","AttributeType":"N"}]

region = args['TARGET_REGION']
target_ddb_name = args['TARGET_DYNAMODB_NAME']

global_secondary_indexes = json.loads(args['GLOBAL_SEC_INDEXES_JSON_COLLECTION'])
attribute_definitions = json.loads(args['ATTRIBUTES_JSON_COLLECTION'])

# Drop and create target DynamoDB table
dynamodb_client = boto3.Session(
        aws_access_key_id=args['AWS_ACCESS_KEY_ID'],
        aws_secret_access_key=args['AWS_SECRET_ACCESS_KEY'],
        aws_session_token=args['TEMPORARY_SESSION_TOKEN'],
    ).client('dynamodb')
    
# Delete table
print('Deleting table: ' + target_ddb_name + ' ...')

try:
    dynamodb_client.delete_table(TableName=target_ddb_name)

    #Wait for table deletion to complete
    waiter = dynamodb_client.get_waiter('table_not_exists')
    waiter.wait(TableName=target_ddb_name)
    print('Table deleted.')
except dynamodb_client.exceptions.ResourceNotFoundException:
    print('Table already deleted / does not exist.')
    pass

print('Creating table: ' + target_ddb_name + ' ...')

table = dynamodb_client.create_table(
    TableName=target_ddb_name,
    KeySchema=[
        {
            'AttributeName': 'PK',
            'KeyType': 'HASH'  # Partition key
        },
        {
            'AttributeName': 'SK',
            'KeyType': 'RANGE'  # Sort key
        }
    ],
    AttributeDefinitions=attribute_definitions,
    GlobalSecondaryIndexes=global_secondary_indexes,
    BillingMode='PAY_PER_REQUEST'
)
    
waiter = dynamodb_client.get_waiter('table_exists')
waiter.wait(TableName=target_ddb_name)
    
print('Table created.')
```

## Best Practices
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-best-practices"></a>

**Temporäre Anmeldeinformationen**

Aus Sicherheitsgründen sollten Sie beim programmgesteuerten Zugriff auf AWS-Services die Verwendung `AWS_SECRET_ACCESS_KEY` des `AWS_ACCESS_KEY_ID` und eines IAM-Benutzers vermeiden, da es sich dabei um langfristige Anmeldeinformationen handelt. Versuchen Sie immer, temporäre Anmeldeinformationen zu verwenden, um programmgesteuert auf AWS-Services zuzugreifen.

Beispielsweise kodiert ein Entwickler während der Entwicklung das `AWS_ACCESS_KEY_ID` Ende eines IAM-Benutzers in `AWS_SECRET_ACCESS_KEY` der Anwendung fest, kann die hartcodierten Werte jedoch nicht entfernen, bevor die Änderungen in das Code-Repository übertragen werden. Diese offengelegten Anmeldeinformationen können von unbeabsichtigten oder böswilligen Benutzern verwendet werden, was schwerwiegende Folgen haben kann (insbesondere, wenn die offengelegten Anmeldeinformationen Administratorrechte haben). Diese offengelegten Anmeldeinformationen sollten sofort mithilfe der IAM-Konsole oder der AWS-Befehlszeilenschnittstelle (AWS CLI) deaktiviert oder gelöscht werden.

Verwenden Sie AWS STS, um temporäre Anmeldeinformationen für den programmatischen Zugriff auf AWS-Services zu erhalten. Temporäre Anmeldeinformationen sind nur für die angegebene Zeit gültig (von 15 Minuten bis zu 36 Stunden). Die maximal zulässige Dauer temporärer Anmeldeinformationen hängt von Faktoren wie Rolleneinstellungen und Rollenverkettung ab. Weitere Informationen zu AWS STS finden Sie in der [Dokumentation](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html).

## Epen
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-epics"></a>

### DynamoDB-Tabellen einrichten
<a name="set-up-dynamodb-tables"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie DynamoDB-Tabellen. | Erstellen Sie DynamoDB-Tabellen mit Indizes in AWS-Quell- und Zielkonten.Stellen Sie die Kapazitätsbereitstellung auf den On-Demand-Modus ein, sodass DynamoDB read/write Kapazitäten dynamisch auf der Grundlage der Arbeitslast skalieren kann. Alternativ können Sie die bereitgestellte Kapazität mit 4000 und 4000 verwenden. RCUs WCUs | App-Entwickler, DBA, Migrationsingenieur | 
| Füllen Sie die Quelltabelle aus. | Füllen Sie die DynamoDB-Tabelle im Quellkonto mit Testdaten auf. Wenn Sie mindestens 50 MB an Testdaten haben, können Sie den Spitzenwert und den RCUs Durchschnittsverbrauch beim Kopieren der Tabelle ermitteln. Anschließend können Sie die Kapazitätsbereitstellung nach Bedarf ändern. | App-Entwickler, DBA, Migrationsingenieur | 

### Anmeldeinformationen für den Zugriff auf die DynamoDB-Tabellen einrichten
<a name="set-up-credentials-to-access-the-dynamodb-tables"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie IAM-Rollen für den Zugriff auf die DynamoDB-Quell- und Zieltabellen. | Erstellen Sie eine IAM-Rolle im Quellkonto mit Berechtigungen für den Zugriff (das Lesen) der DynamoDB-Tabelle im Quellkonto.Fügen Sie das Quellkonto als vertrauenswürdige Entität für diese Rolle hinzu.Erstellen Sie eine IAM-Rolle im Zielkonto mit Zugriffsberechtigungen (Erstellen, Lesen, Aktualisieren, Löschen) auf die DynamoDB-Tabelle im Zielkonto.  Fügen Sie das Zielkonto als vertrauenswürdige Entität für diese Rolle hinzu. | App-Entwickler, AWS DevOps | 

### Kopieren Sie Tabellendaten von einem Konto in ein anderes
<a name="copy-table-data-from-one-account-to-another"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Besorgen Sie sich temporäre Anmeldeinformationen für die IAM-Rollen. | Rufen Sie temporäre Anmeldeinformationen für die IAM-Rolle ab, die im Quellkonto erstellt wurde.Rufen Sie temporäre Anmeldeinformationen für die im Zielkonto erstellte IAM-Rolle ab.Eine Möglichkeit, die temporären Anmeldeinformationen für die IAM-Rolle abzurufen, besteht darin, AWS STS über die AWS-CLI zu verwenden.<pre>aws sts assume-role --role-arn arn:aws:iam::<account-id>:role/<role-name> --role-session-name <session-name> --profile <profile-name></pre>Verwenden Sie das entsprechende AWS-Profil (entspricht dem Quell- oder Zielkonto).Weitere Informationen zu den verschiedenen Möglichkeiten, temporäre Anmeldeinformationen zu erhalten, finden Sie im Folgenden:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html) | App-Entwickler, Migrationsingenieur | 
| Initialisieren Sie die DynamoDB-Clients für den Quell- und Ziel-DynamoDB-Zugriff. | Initialisieren Sie die DynamoDB-Clients, die vom AWS-SDK bereitgestellt werden, für die DynamoDB-Quell- und Zieltabellen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Weitere Informationen zum Stellen von Anfragen mithilfe temporärer IAM-Anmeldeinformationen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AuthUsingTempSessionToken.html). | App-Developer | 
| Löschen Sie die Zieltabelle und erstellen Sie sie neu. | Löschen Sie die DynamoDB-Zieltabelle (zusammen mit den Indizes) im Zielkonto und erstellen Sie sie neu, indem Sie den DynamoDB-Client für das Zielkonto verwenden.Das Löschen aller Datensätze aus einer DynamoDB-Tabelle ist ein kostspieliger Vorgang, da dafür bereitgestellte Daten verbraucht werden. WCUs Durch das Löschen und Neuerstellen der Tabelle werden diese zusätzlichen Kosten vermieden.Sie können einer Tabelle Indizes hinzufügen, nachdem Sie sie erstellt haben, aber das dauert 2—5 Minuten länger. Das Erstellen von Indizes während der Tabellenerstellung, indem die Indexsammlung an den `createTable` Aufruf übergeben wird, ist effizienter. | App-Developer | 
| Führen Sie die Tabellenkopie durch. | Wiederholen Sie die folgenden Schritte, bis alle Daten kopiert sind:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)*Weitere Informationen finden Sie in der Referenzimplementierung in C\$1 (zum Löschen, Erstellen und Auffüllen von Tabellen) im Abschnitt Anlagen.* Ein Beispiel für eine JavaScript Objektnotationsdatei (JSON) für die Tabellenkonfiguration ist ebenfalls angehängt. | App-Developer | 

## Zugehörige Ressourcen
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-resources"></a>
+ [Dokumentation zu Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html)
+ [Einen IAM-Benutzer in Ihrem AWS-Konto erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html)
+ [AWS SDKs](https://aws.amazon.com/tools/)
+ [Temporäre Anmeldeinformationen mit AWS-Ressourcen verwenden](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html)

## Zusätzliche Informationen
<a name="copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation-additional"></a>

Dieses Muster wurde mithilfe von C\$1 implementiert, um eine DynamoDB-Tabelle mit 200.000 Elementen (durchschnittliche Elementgröße von 5 KB und Tabellengröße von 250 MB) zu kopieren. Die DynamoDB-Zieltabelle wurde mit einer bereitgestellten Kapazität von 4000 und 4000 RCUs eingerichtet. WCUs

Das vollständige Kopieren der Tabelle (vom Quellkonto zum Zielkonto), einschließlich Löschen und Neuerstellen der Tabelle, dauerte 5 Minuten. Insgesamt verbrauchte Kapazitätseinheiten: 30.000 RCUs und etwa 400.000 WCUs.

Weitere Informationen zu DynamoDB-Kapazitätsmodi finden Sie unter [Kapazitätsmodus Lesen/Schreiben](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html) in der AWS-Dokumentation.

## Anlagen
<a name="attachments-ba8175be-9809-4c2e-b2d1-6b9180ed056c"></a>

[Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/ba8175be-9809-4c2e-b2d1-6b9180ed056c/attachments/attachment.zip)