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.
# Java
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
In diesem Thema wird erklärt, wie Version 3 installiert und verwendet wird. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB. Einzelheiten zur Programmierung mit dem AWS Database Encryption SDK für DynamoDB finden Sie in den [Java-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) im aws-database-encryption-sdk -dynamodb-Repository unter. GitHub
**Anmerkung**
Die folgenden Themen konzentrieren sich auf Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
[Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS](DDBEC-rename.md) Das AWS Database Encryption SDK unterstützt weiterhin [ältere Versionen des DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md).
**Topics**
+ [Voraussetzungen](#ddb-java-prerequisites)
+ [Installation](#ddb-java-installation)
+ [Verwenden des Java-Clients](ddb-java-using.md)
+ [Java-Beispiele](ddb-java-examples.md)
+ [Fügen Sie Version 3.x zu einer vorhandenen Tabelle hinzu](ddb-java-config-existing-table.md)
+ [Migrieren Sie auf Version 3.x](ddb-java-migrate.md)
## Voraussetzungen
Bevor Sie Version 3 installieren. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
**Eine Java-Entwicklungsumgebung**
Sie benötigen Java 8 oder höher. Klicken Sie auf der Oracle-Website auf [Java SE Downloads](https://www.oracle.com/java/technologies/downloads/) und laden und installieren Sie anschließend das Java SE Development Kit (JDK).
Wenn Sie das Oracle JDK verwenden, müssen Sie auch die [Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files](http://www.oracle.com/java/technologies/javase-jce8-downloads.html) herunterladen und installieren.
**AWS SDK for Java 2.x**
Das AWS Database Encryption SDK für DynamoDB erfordert das [DynamoDB Enhanced Client-Modul](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) von. AWS SDK for Java 2.x Sie können das gesamte SDK oder nur dieses Modul installieren.
Informationen zur Aktualisierung Ihrer Version von finden Sie unter [Migration von Version 1.x auf 2.x von](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK für Java AWS SDK für Java
Das AWS SDK für Java ist über Apache Maven verfügbar. Sie können eine Abhängigkeit für das gesamte AWS SDK für Java Modul oder nur für das `dynamodb-enhanced` Modul deklarieren.
**Installieren Sie das AWS SDK für Java mit Apache Maven**
+ Um [das gesamte AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) als Abhängigkeit zu importieren, deklarieren Sie es in Ihrer `pom.xml`-Datei.
+ Um eine Abhängigkeit nur für das Amazon DynamoDB DynamoDB-Modul in der zu erstellen AWS SDK für Java, folgen Sie den Anweisungen zur [Angabe bestimmter](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) Module. Stellen Sie „`groupId`bis“ `software.amazon.awssdk` und „Bis“ ein. `artifactID` `dynamodb-enhanced`
**Anmerkung**
Wenn Sie den AWS KMS Schlüsselbund oder den AWS KMS hierarchischen Schlüsselbund verwenden, müssen Sie auch eine Abhängigkeit für das Modul erstellen. AWS KMS Stellen Sie „bis“ `software.amazon.awssdk` und „`groupId`Bis“ ein. `artifactID` `kms`
## Installation
Sie können Version 3 installieren. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB auf folgende Weise.
**Verwenden von Apache Maven**
Der Amazon DynamoDB Encryption Client für Java ist über [Apache Maven](https://maven.apache.org/) mit der folgenden Abhängigkeitsdefinition verfügbar.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Verwenden von Gradle Kotlin**
Sie können [Gradle](https://gradle.org/) verwenden, um eine Abhängigkeit vom Amazon DynamoDB Encryption Client for Java zu deklarieren, indem Sie Folgendes zum Abschnitt mit den *Abhängigkeiten* Ihres Gradle-Projekts hinzufügen.
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**manuell**
[Um die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB zu installieren, klonen Sie das -dynamodb-Repository oder laden Sie es herunter. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Nachdem Sie das SDK installiert haben, schauen Sie sich zunächst den Beispielcode in diesem Handbuch und die [Java-Beispiele](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) im -dynamodb-Repository an. aws-database-encryption-sdk GitHub
# Verwendung der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
In diesem Thema werden einige der Funktionen und Hilfsklassen in Version 3 erklärt. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
Einzelheiten zur Programmierung mit der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB finden Sie in den Java-Beispielen, in den [Java-Beispielen](java-examples.md) [im -dynamodb-Repository](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) unter. aws-database-encryption-sdk GitHub
**Topics**
+ [Elementverschlüssler](#ddb-item-encryptors)
+ [Attributaktionen](#ddb-attribute-actions)
+ [Verschlüsselungskonfiguration](#ddb-config-encrypt)
+ [Artikel werden aktualisiert](#ddb-update-items)
+ [Signierte Sets entschlüsseln](#ddb-java-signed-sets)
## Elementverschlüssler
Im Kern ist das AWS Database Encryption SDK für DynamoDB ein Elementverschlüsseler. Sie können Version 3 verwenden. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB, um Ihre DynamoDB-Tabellenelemente auf folgende Weise zu verschlüsseln, zu signieren, zu verifizieren und zu entschlüsseln.
**Der erweiterte DynamoDB-Client**
Sie können den [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) so konfigurieren, `DynamoDbEncryptionInterceptor` dass er Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen verschlüsselt und signiert. `PutItem` Mit dem DynamoDB Enhanced Client können Sie Ihre Attributaktionen mithilfe einer [annotierten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) Datenklasse definieren. Wir empfehlen, wann immer möglich den DynamoDB Enhanced Client zu verwenden.
Der DynamoDB Enhanced Client unterstützt keine [durchsuchbare](searchable-encryption.md) Verschlüsselung.
[Das AWS Database Encryption SDK unterstützt keine Anmerkungen zu verschachtelten Attributen.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
**Die DynamoDB-API auf niedriger Ebene**
Sie können die [Low-Level-DynamoDB-API so konfigurieren, `DynamoDbEncryptionInterceptor` dass Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) verschlüsselt und signiert werden. `PutItem`
[Sie müssen die Low-Level-DynamoDB-API verwenden, um durchsuchbare Verschlüsselung zu verwenden.](searchable-encryption.md)
**Die untergeordnete Ebene `DynamoDbItemEncryptor`**
Die untergeordnete Ebene verschlüsselt und signiert oder entschlüsselt und verifiziert Ihre Tabellenelemente `DynamoDbItemEncryptor` direkt, ohne DynamoDB aufzurufen. Es stellt keine DynamoDB `PutItem` oder `GetItem` Anfragen. Sie können beispielsweise die untergeordnete Ebene verwenden, `DynamoDbItemEncryptor` um ein DynamoDB-Element, das Sie bereits abgerufen haben, direkt zu entschlüsseln und zu verifizieren.
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung`DynamoDbItemEncryptor`.](searchable-encryption.md)
## Attributaktionen im AWS Database Encryption SDK für DynamoDB
[Attributaktionen](concepts.md#crypt-actions) bestimmen, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert sind, welche signiert und in den Verschlüsselungskontext aufgenommen werden und welche ignoriert werden.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Wenn Sie die Low-Level-DynamoDB-API oder die Low-Level-API verwenden`DynamoDbItemEncryptor`, müssen Sie Ihre Attributaktionen manuell definieren. [Wenn Sie den DynamoDB Enhanced Client verwenden, können Sie Ihre Attributaktionen entweder manuell definieren oder Sie können eine annotierte Datenklasse verwenden, um eine zu generieren. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Um den Konfigurationsprozess zu vereinfachen, empfehlen wir die Verwendung einer annotierten Datenklasse. Wenn Sie eine annotierte Datenklasse verwenden, müssen Sie Ihr Objekt nur einmal modellieren.
**Anmerkung**
Nachdem Sie Ihre Attributaktionen definiert haben, müssen Sie definieren, welche Attribute von den Signaturen ausgeschlossen werden. Um das future Hinzufügen neuer Attribute ohne Vorzeichen zu vereinfachen, empfehlen wir, ein eindeutiges Präfix (wie "`:`„) zu wählen, um Ihre vorzeichenlosen Attribute zu identifizieren. Nehmen Sie dieses Präfix in den Attributnamen für alle Attribute auf, die Sie bei der Definition Ihres DynamoDB-Schemas und Ihrer Attributaktionen markiert `DO_NOTHING` haben.
### Verwenden Sie eine Datenklasse mit Anmerkungen
Verwenden Sie eine [annotierte Datenklasse](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean), um Ihre Attributaktionen mit dem DynamoDB Enhanced Client und zu spezifizieren. `DynamoDbEncryptionInterceptor` Das AWS Database Encryption SDK für DynamoDB verwendet die [standardmäßigen DynamoDB-Attributanmerkungen, die den Attributtyp](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) definieren, um zu bestimmen, wie ein Attribut geschützt werden soll. Standardmäßig sind alle Attribute verschlüsselt und signiert, mit Ausnahme der Primärschlüssel, die zwar signiert, aber nicht verschlüsselt sind.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des Database Encryption SDK verwenden. AWS Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Weitere Hinweise zu den aws-database-encryption-sdk DynamoDB Enhanced Client-Anmerkungen finden Sie unter [SimpleClass GitHub .java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) im -dynamodb-Repository unter.
Standardmäßig sind Primärschlüsselattribute signiert, aber nicht verschlüsselt (`SIGN_ONLY`), und alle anderen Attribute sind verschlüsselt und signiert (). `ENCRYPT_AND_SIGN` Wenn Sie Attribute als definieren`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Um Ausnahmen anzugeben, verwenden Sie die Verschlüsselungsanmerkungen, die in der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB definiert sind. Wenn Sie beispielsweise möchten, dass ein bestimmtes Attribut nur signiert wird, verwenden Sie die Anmerkung. `@DynamoDbEncryptionSignOnly` Wenn Sie möchten, dass ein bestimmtes Attribut signiert und in den Verschlüsselungskontext aufgenommen wird, verwenden Sie die`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Wenn Sie möchten, dass ein bestimmtes Attribut weder signiert noch verschlüsselt (`DO_NOTHING`) wird, verwenden Sie die `@DynamoDbEncryptionDoNothing` Anmerkung.
**Anmerkung**
Das AWS Database Encryption SDK unterstützt keine Anmerkungen zu [verschachtelten Attributen](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
Das folgende Beispiel zeigt die Anmerkungen, die zur Definition von `ENCRYPT_AND_SIGN``SIGN_ONLY`, und `DO_NOTHING` Attributaktionen verwendet werden. [Ein Beispiel, das die zur Definition verwendeten Anmerkungen zeigt`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, finden Sie unter SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
```
@DynamoDbBean
public class SimpleClass {
private String partitionKey;
private int sortKey;
private String attribute1;
private String attribute2;
private String attribute3;
@DynamoDbPartitionKey
@DynamoDbAttribute(value = "partition_key")
public String getPartitionKey() {
return this.partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
@DynamoDbSortKey
@DynamoDbAttribute(value = "sort_key")
public int getSortKey() {
return this.sortKey;
}
public void setSortKey(int sortKey) {
this.sortKey = sortKey;
}
public String getAttribute1() {
return this.attribute1;
}
public void setAttribute1(String attribute1) {
this.attribute1 = attribute1;
}
@DynamoDbEncryptionSignOnly
public String getAttribute2() {
return this.attribute2;
}
public void setAttribute2(String attribute2) {
this.attribute2 = attribute2;
}
@DynamoDbEncryptionDoNothing
public String getAttribute3() {
return this.attribute3;
}
@DynamoDbAttribute(value = ":attribute3")
public void setAttribute3(String attribute3) {
this.attribute3 = attribute3;
}
}
```
Verwenden Sie Ihre annotierte Datenklasse, um die zu erstellen, `TableSchema` wie im folgenden Codeausschnitt gezeigt.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Definieren Sie Ihre Attributaktionen manuell
Um Attributaktionen manuell zu spezifizieren, erstellen Sie ein `Map` Objekt, in dem die Name-Wert-Paare für Attributnamen und die angegebenen Aktionen stehen.
Geben Sie `ENCRYPT_AND_SIGN` an, dass ein Attribut verschlüsselt und signiert werden soll. Geben Sie `SIGN_ONLY` an, dass ein Attribut signiert, aber nicht verschlüsselt werden soll. Geben Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` an, dass ein Attribut signiert und in den Verschlüsselungskontext aufgenommen werden soll. Sie können ein Attribut nicht verschlüsseln, ohne es auch zu signieren. Geben Sie `DO_NOTHING` an, ob ein Attribut ignoriert werden soll.
Die Partitions- und Sortierattribute müssen entweder `SIGN_ONLY` oder lauten`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie Attribute als definieren`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be signed
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
// The sort attribute must be signed
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute3", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put(":attribute4", CryptoAction.DO_NOTHING);
```
## Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB
Wenn Sie das AWS Database Encryption SDK verwenden, müssen Sie explizit eine Verschlüsselungskonfiguration für Ihre DynamoDB-Tabelle definieren. Die in Ihrer Verschlüsselungskonfiguration erforderlichen Werte hängen davon ab, ob Sie Ihre Attributaktionen manuell oder mit einer annotierten Datenklasse definiert haben.
Der folgende Ausschnitt definiert eine DynamoDB-Tabellenverschlüsselungskonfiguration unter Verwendung des DynamoDB Enhanced Client und erlaubte unsignierte Attribute [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html), die durch ein eindeutiges Präfix definiert sind.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
// Optional: only required if you use beacons
.search(SearchConfig.builder()
.writeVersion(1) // MUST be 1
.versions(beaconVersions)
.build())
.build());
```
**Logischer Tabellenname**
Ein logischer Tabellenname für Ihre DynamoDB-Tabelle.
Der logische Tabellenname ist kryptografisch an alle in der Tabelle gespeicherten Daten gebunden, um DynamoDB-Wiederherstellungsvorgänge zu vereinfachen. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Sie müssen immer denselben logischen Tabellennamen angeben. Damit die Entschlüsselung erfolgreich ist, muss der Name der logischen Tabelle mit dem Namen übereinstimmen, der bei der Verschlüsselung angegeben wurde. Falls sich Ihr DynamoDB-Tabellenname nach dem [Wiederherstellen Ihrer DynamoDB-Tabelle aus einer Sicherung](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) ändert, stellt der logische Tabellenname sicher, dass der Entschlüsselungsvorgang die Tabelle weiterhin erkennt.
**Zulässige Attribute ohne Vorzeichen**
Die `DO_NOTHING` in Ihren Attributaktionen markierten Attribute.
Die zulässigen Attribute ohne Vorzeichen teilen dem Client mit, welche Attribute von den Signaturen ausgeschlossen sind. Der Client geht davon aus, dass alle anderen Attribute in der Signatur enthalten sind. Beim Entschlüsseln eines Datensatzes bestimmt der Client dann aus den von Ihnen angegebenen zulässigen unsignierten Attributen, welche er überprüfen muss und welche ignoriert werden sollen. Sie können kein Attribut aus Ihren zulässigen Attributen ohne Vorzeichen entfernen.
Sie können die zulässigen Attribute ohne Vorzeichen explizit definieren, indem Sie ein Array erstellen, das alle Ihre `DO_NOTHING` Attribute auflistet. Sie können bei der Benennung Ihrer `DO_NOTHING` Attribute auch ein eindeutiges Präfix angeben und das Präfix verwenden, um dem Client mitzuteilen, welche Attribute vorzeichenlos sind. Wir empfehlen dringend, ein eindeutiges Präfix anzugeben, da dies das Hinzufügen eines neuen `DO_NOTHING` Attributs in der future vereinfacht. Weitere Informationen finden Sie unter [Aktualisierung Ihres Datenmodells](ddb-update-data-model.md).
Wenn Sie kein Präfix für alle `DO_NOTHING` Attribute angeben, können Sie ein `allowedUnsignedAttributes` Array konfigurieren, das explizit alle Attribute auflistet, von denen der Client erwarten sollte, dass sie nicht signiert sind, wenn er sie bei der Entschlüsselung findet. Sie sollten Ihre erlaubten vorzeichenlosen Attribute nur dann explizit definieren, wenn dies unbedingt erforderlich ist.
**Suchkonfiguration (optional)**
Das `SearchConfig` definiert die [Beacon-Version](using-beacons.md#beacon-version).
Der `SearchConfig` muss angegeben werden, um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte](configure.md#signed-beacons) Beacons verwenden zu können.
**Algorithm Suite (optional)**
Die `algorithmSuiteId` definiert, welche Algorithmus-Suite das AWS Database Encryption SDK verwendet.
Sofern Sie nicht explizit eine alternative Algorithmussuite angeben, verwendet das AWS Database Encryption SDK die [Standard-Algorithmussuite](supported-algorithms.md#recommended-algorithms). [Die Standard-Algorithmussuite verwendet den AES-GCM-Algorithmus mit Schlüsselableitung, [digitalen Signaturen](concepts.md#digital-sigs) und Schlüsselzusage.](concepts.md#key-commitment) Obwohl die Standard-Algorithmus-Suite wahrscheinlich für die meisten Anwendungen geeignet ist, können Sie auch eine alternative Algorithmussuite wählen. Einige Vertrauensmodelle würden beispielsweise durch eine Algorithmus-Suite ohne digitale Signaturen erfüllt. Hinweise zu den Algorithmus-Suites, die das AWS Database Encryption SDK unterstützt, finden Sie unter[Unterstützte Algorithmus-Suiten im AWS Database Encryption SDK](supported-algorithms.md).
Um die [AES-GCM-Algorithmussuite ohne digitale ECDSA-Signaturen](supported-algorithms.md#other-algorithms) auszuwählen, nehmen Sie den folgenden Ausschnitt in Ihre Tabellenverschlüsselungskonfiguration auf.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Elemente mit dem Database Encryption SDK aktualisieren AWS
Das AWS Database Encryption SDK unterstützt [ddb:](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) nicht UpdateItem für Elemente, die verschlüsselt oder signiert wurden. Um ein verschlüsseltes oder signiertes Element zu aktualisieren, müssen Sie [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html): verwenden. PutItem Wenn Sie in Ihrer `PutItem` Anfrage denselben Primärschlüssel wie ein vorhandenes Element angeben, ersetzt das neue Element das vorhandene Element vollständig. Sie können [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) auch verwenden, um alle Attribute beim Speichern zu löschen und zu ersetzen, nachdem Sie Ihre Artikel aktualisiert haben.
## Signierte Sets entschlüsseln
Wenn Sie in den Versionen 3.0.0 und 3.1.0 des AWS Database Encryption SDK ein [Set-Typ-Attribut](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) als definieren`SIGN_ONLY`, werden die Werte des Satzes in der Reihenfolge kanonisiert, in der sie bereitgestellt werden. DynamoDB behält die Reihenfolge der Sätze nicht bei. Daher besteht die Möglichkeit, dass die Signaturvalidierung des Elements, das den Satz enthält, fehlschlägt. Die Signaturvalidierung schlägt fehl, wenn die Werte des Satzes in einer anderen Reihenfolge zurückgegeben werden, als sie dem AWS Database Encryption SDK zur Verfügung gestellt wurden, auch wenn die Satzattribute dieselben Werte enthalten.
**Anmerkung**
Versionen 3.1.1 und höher des AWS Database Encryption SDK kanonisieren die Werte aller festgelegten Typattribute, sodass die Werte in derselben Reihenfolge gelesen werden, in der sie in DynamoDB geschrieben wurden.
Wenn die Signaturvalidierung fehlschlägt, schlägt der Entschlüsselungsvorgang fehl und es wird die folgende Fehlermeldung zurückgegeben.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Es wurde kein Empfänger-Tag gefunden. |
Wenn Sie die obige Fehlermeldung erhalten und glauben, dass das Element, das Sie zu entschlüsseln versuchen, einen Satz enthält, der mit Version 3.0.0 oder 3.1.0 signiert wurde, finden Sie im [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)Verzeichnis des aws-database-encryption-sdk -dynamodb-java-Repositorys weitere Informationen GitHub zur erfolgreichen Validierung des Satzes.
# Java-Beispiele
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Die folgenden Beispiele zeigen Ihnen, wie Sie die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB verwenden, um die Tabellenelemente in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie in den [Java-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) im -dynamodb-Repository unter aws-database-encryption-sdk. GitHub
Die folgenden Beispiele zeigen, wie die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB in einer neuen, nicht aufgefüllten Amazon DynamoDB-Tabelle konfiguriert wird. Wenn Sie Ihre vorhandenen Amazon DynamoDB-Tabellen für die clientseitige Verschlüsselung konfigurieren möchten, finden Sie weitere Informationen unter. [Fügen Sie Version 3.x zu einer vorhandenen Tabelle hinzu](ddb-java-config-existing-table.md)
**Topics**
+ [Verwenden des erweiterten DynamoDB-Clients](#ddb-java-enhanced-client-example)
+ [Verwenden der Low-Level-DynamoDB-API](#ddb-java-lowlevel-API-example)
+ [Verwenden Sie die untergeordnete Ebene DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Verwenden des erweiterten DynamoDB-Clients
Das folgende Beispiel zeigt, wie Sie den DynamoDB Enhanced Client und `DynamoDbEncryptionInterceptor` mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um DynamoDB-Tabellenelemente als Teil Ihrer DynamoDB-API-Aufrufe zu verschlüsseln.
Sie können jeden unterstützten [Schlüsselbund](keyrings.md) mit dem DynamoDB Enhanced Client verwenden, wir empfehlen jedoch, wann immer möglich, einen der AWS KMS Schlüsselringe zu verwenden.
**Anmerkung**
Der DynamoDB Enhanced Client unterstützt keine [durchsuchbare](searchable-encryption.md) Verschlüsselung. Verwenden Sie die `DynamoDbEncryptionInterceptor` zusammen mit der Low-Level-DynamoDB-API, um eine durchsuchbare Verschlüsselung zu verwenden.
**Sehen Sie sich das vollständige Codebeispiel an**[: .java EnhancedPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Erstellen Sie ein Tabellenschema aus der annotierten Datenklasse**
Im folgenden Beispiel wird die annotierte Datenklasse verwendet, um die zu erstellen. `TableSchema`
[In diesem Beispiel wird davon ausgegangen, dass die mit Anmerkungen versehenen Datenklassen- und Attributaktionen mithilfe der SimpleClass Datei .java definiert wurden.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) Weitere Hinweise zum Kommentieren Ihrer Attributaktionen finden Sie unter. [Verwenden Sie eine Datenklasse mit Anmerkungen](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
Das AWS Database Encryption SDK unterstützt keine Anmerkungen zu [verschachtelten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html) Attributen.
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Schritt 4: Erstellen Sie die Verschlüsselungskonfiguration**
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für die DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte Beacons](configure.md#signed-beacons) zu verwenden, müssen Sie die auch [`SearchConfig`](ddb-java-using.md#ddb-search-config)in Ihre Verschlüsselungskonfiguration aufnehmen.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Schritt 5: Erstellt das `DynamoDbEncryptionInterceptor`**
Im folgenden Beispiel wird `DynamoDbEncryptionInterceptor` mit dem `tableConfigs` aus **Schritt 4** ein neues erstellt.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Schritt 6: Einen neuen AWS SDK-DynamoDB-Client erstellen**
Im folgenden Beispiel wird ein neuer AWS SDK-DynamoDB-Client mit dem `interceptor` aus **Schritt** 5 erstellt.
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Schritt 7: DynamoDB Enhanced Client erstellen und eine Tabelle erstellen**
Im folgenden Beispiel wird der DynamoDB Enhanced Client mithilfe des AWS SDK-DynamoDB-Clients erstellt, der in **Schritt 6** erstellt wurde, und es wird eine Tabelle mit der annotierten Datenklasse erstellt.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Schritt 8: Verschlüsseln und signieren Sie ein Tabellenelement**
Im folgenden Beispiel wird mithilfe des DynamoDB Enhanced Client ein Element in die DynamoDB-Tabelle eingefügt. Das Element wird clientseitig verschlüsselt und signiert, bevor es an DynamoDB gesendet wird.
```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");
table.putItem(item);
```
## Verwenden der Low-Level-DynamoDB-API
Das folgende Beispiel zeigt, wie Sie die Low-Level-DynamoDB-API mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen zu verschlüsseln und zu signieren. `PutItem`
Sie können jeden unterstützten [Schlüsselbund verwenden, wir empfehlen jedoch, wann immer möglich, einen der Schlüsselbunde](keyrings.md) zu verwenden. AWS KMS
**Sehen Sie sich das vollständige Codebeispiel** [an: .java BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Konfigurieren Sie Ihre Attributaktionen**
Das folgende Beispiel definiert eine `attributeActionsOnEncrypt` Map, die [Beispiel-Attributaktionen](concepts.md#crypt-actions) für ein Tabellenelement darstellt.
Das folgende Beispiel definiert keine Attribute als`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Schritt 4: Definieren Sie die Konfiguration der DynamoDB-Tabellenverschlüsselung**
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für diese DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte Beacons](configure.md#signed-beacons) zu verwenden, müssen Sie die auch [`SearchConfig`](ddb-java-using.md#ddb-search-config)in Ihre Verschlüsselungskonfiguration aufnehmen.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
tableConfigs.put(ddbTableName, config);
```
**Schritt 5: Erstellen Sie das `DynamoDbEncryptionInterceptor`**
Im folgenden Beispiel wird das `DynamoDbEncryptionInterceptor` mit dem `tableConfigs` aus **Schritt 4** erstellt.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Schritt 6: Einen neuen AWS SDK-DynamoDB-Client erstellen**
Im folgenden Beispiel wird ein neuer AWS SDK-DynamoDB-Client mit dem `interceptor` aus **Schritt** 5 erstellt.
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Schritt 7: Verschlüsseln und Signieren eines DynamoDB-Tabellenelements**
Das folgende Beispiel definiert eine `item` Map, die ein Beispieltabellenelement darstellt, und platziert das Element in der DynamoDB-Tabelle. Das Element wird clientseitig verschlüsselt und signiert, bevor es an DynamoDB gesendet wird.
```
final HashMap item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final PutItemRequest putRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(item)
.build();
final PutItemResponse putResponse = ddb.putItem(putRequest);
```
## Verwenden Sie die untergeordnete Ebene DynamoDbItemEncryptor
Das folgende Beispiel zeigt, wie Sie die untergeordnete Ebene `DynamoDbItemEncryptor` mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um Tabellenelemente direkt zu verschlüsseln und zu signieren. Das `DynamoDbItemEncryptor` fügt das Element nicht in Ihre DynamoDB-Tabelle ein.
Sie können jeden unterstützten [Schlüsselbund](keyrings.md) mit dem DynamoDB Enhanced Client verwenden, wir empfehlen jedoch, wann immer möglich, einen der AWS KMS Schlüsselringe zu verwenden.
**Anmerkung**
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung. `DynamoDbItemEncryptor`](searchable-encryption.md) Verwenden Sie die `DynamoDbEncryptionInterceptor` zusammen mit der Low-Level-DynamoDB-API, um eine durchsuchbare Verschlüsselung zu verwenden.
**Sehen Sie sich das vollständige Codebeispiel an**[: .java ItemEncryptDecryptExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Konfigurieren Sie Ihre Attributaktionen**
Das folgende Beispiel definiert eine `attributeActionsOnEncrypt` Map, die [Beispiel-Attributaktionen](concepts.md#crypt-actions) für ein Tabellenelement darstellt.
Das folgende Beispiel definiert keine Attribute als`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Schritt 4: Definieren Sie die `DynamoDbItemEncryptor` Konfiguration**
Das folgende Beispiel definiert die Konfiguration für die`DynamoDbItemEncryptor`.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
```
final DynamoDbItemEncryptorConfig config = DynamoDbItemEncryptorConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
```
**Schritt 5: Erstellen Sie das `DynamoDbItemEncryptor`**
Im folgenden Beispiel wird `DynamoDbItemEncryptor` mit dem `config` aus **Schritt 4** ein neues erstellt.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Schritt 6: Verschlüsseln und signieren Sie ein Tabellenelement direkt**
Im folgenden Beispiel wird ein Element direkt verschlüsselt und signiert mit dem. `DynamoDbItemEncryptor` Das `DynamoDbItemEncryptor` fügt das Element nicht in Ihre DynamoDB-Tabelle ein.
```
final Map originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final Map encryptedItem = itemEncryptor.EncryptItem(
EncryptItemInput.builder()
.plaintextItem(originalItem)
.build()
).encryptedItem();
```
# Konfigurieren Sie eine bestehende DynamoDB-Tabelle für die Verwendung des AWS Database Encryption SDK für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Mit Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB können Sie Ihre vorhandenen Amazon DynamoDB-Tabellen für die clientseitige Verschlüsselung konfigurieren. Dieses Thema enthält Anleitungen zu den drei Schritten, die Sie ausführen müssen, um Version 3 hinzuzufügen. *x* zu einer vorhandenen, gefüllten DynamoDB-Tabelle.
**Voraussetzungen**
Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB erfordert den DynamoDB Enhanced Client, der unter [bereitgestellt](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) wird. AWS SDK for Java 2.x Wenn Sie [Dynamo weiterhin verwendenDBMapper, müssen Sie auf den DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK for Java 2.x Enhanced Client migrieren.
Folgen Sie den Anweisungen für die [Migration von Version 1.x auf 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) von. AWS SDK für Java
Folgen Sie dann den Anweisungen [unter Erste Schritte mit der DynamoDB Enhanced Client API](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Bevor Sie Ihre Tabelle für die Verwendung der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB konfigurieren, müssen Sie eine [Datenklasse `TableSchema` mit Anmerkungen generieren und einen erweiterten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) Client erstellen.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)
## Schritt 1: Bereiten Sie das Lesen und Schreiben verschlüsselter Elemente vor
Gehen Sie wie folgt vor, um Ihren AWS Database Encryption SDK-Client auf das Lesen und Schreiben verschlüsselter Elemente vorzubereiten. Nachdem Sie die folgenden Änderungen vorgenommen haben, liest und schreibt Ihr Client weiterhin Klartext-Elemente. Neue Elemente, die in die Tabelle geschrieben werden, werden nicht verschlüsselt oder signiert, aber es kann verschlüsselte Elemente entschlüsseln, sobald sie erscheinen. Diese Änderungen bereiten den Client darauf vor, mit der [Verschlüsselung](#ddb-java-add-step2) neuer Elemente zu beginnen. Die folgenden Änderungen müssen auf jedem Lesegerät installiert werden, bevor Sie mit dem nächsten Schritt fortfahren.
**1. Definieren Sie Ihre [Attributaktionen](concepts.md#crypt-actions)**
Aktualisieren Sie Ihre Datenklasse mit Anmerkungen, sodass sie Attributaktionen enthält, die definieren, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert und welche ignoriert werden.
Weitere Hinweise zu den aws-database-encryption-sdk DynamoDB Enhanced Client-Anmerkungen finden Sie unter [SimpleClass GitHub.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) im -dynamodb-Repository unter.
Standardmäßig sind Primärschlüsselattribute signiert, aber nicht verschlüsselt (`SIGN_ONLY`), und alle anderen Attribute sind verschlüsselt und signiert (). `ENCRYPT_AND_SIGN` Um Ausnahmen anzugeben, verwenden Sie die Verschlüsselungsanmerkungen, die in der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB definiert sind. Wenn Sie beispielsweise möchten, dass ein bestimmtes Attribut nur ein Zeichen sein soll, verwenden Sie die Anmerkung. `@DynamoDbEncryptionSignOnly` Wenn Sie möchten, dass ein bestimmtes Attribut signiert und in den Verschlüsselungskontext aufgenommen wird, verwenden Sie die `@DynamoDbEncryptionSignAndIncludeInEncryptionContext` Anmerkung. Wenn Sie möchten, dass ein bestimmtes Attribut weder signiert noch verschlüsselt (`DO_NOTHING`) wird, verwenden Sie die `@DynamoDbEncryptionDoNothing` Anmerkung.
Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Ein Beispiel, das die zur Definition verwendeten Anmerkungen zeigt`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, finden Sie unter [SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
Ein Beispiel für Anmerkungen finden Sie unter. [Verwenden Sie eine Datenklasse mit Anmerkungen](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**2. Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Das folgende Beispiel geht davon aus, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Erstellen Sie einen [Schlüsselbund](keyrings.md)**
Im folgenden Beispiel wird ein [AWS KMS Schlüsselbund](use-kms-keyring.md) erstellt. Der AWS KMS Schlüsselbund verwendet symmetrische Verschlüsselung oder asymmetrisches RSA, um Datenschlüssel AWS KMS keys zu generieren, zu verschlüsseln und zu entschlüsseln.
In diesem Beispiel wird ein AWS KMS Schlüsselbund `CreateMrkMultiKeyring` mit einem KMS-Schlüssel mit symmetrischer Verschlüsselung erstellt. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Definieren Sie die Konfiguration der DynamoDB-Tabellenverschlüsselung **
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für diese DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Sie müssen `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` als Klartext-Override angeben. Diese Richtlinie liest und schreibt weiterhin Klartext-Elemente, liest verschlüsselte Elemente und bereitet den Client darauf vor, verschlüsselte Elemente zu schreiben.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
**5. Erstellen der `DynamoDbEncryptionInterceptor`**
Im folgenden Beispiel wird das `DynamoDbEncryptionInterceptor` mit dem `tableConfigs` aus **Schritt 3** erstellten erstellt.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Schritt 2: Schreiben Sie verschlüsselte und signierte Elemente
Aktualisieren Sie die Klartext-Richtlinie in Ihrer `DynamoDbEncryptionInterceptor` Konfiguration, damit der Client verschlüsselte und signierte Elemente schreiben kann. Nachdem Sie die folgende Änderung implementiert haben, verschlüsselt und signiert der Client neue Elemente auf der Grundlage der Attributaktionen, die Sie in **Schritt** 1 konfiguriert haben. Der Client kann Klartext-Elemente sowie verschlüsselte und signierte Elemente lesen.
Bevor Sie mit [Schritt 3](#ddb-java-add-step3) fortfahren, müssen Sie alle vorhandenen Klartextelemente in Ihrer Tabelle verschlüsseln und signieren. Es gibt keine einzelne Metrik oder Abfrage, die Sie ausführen können, um Ihre vorhandenen Klartextelemente schnell zu verschlüsseln. Verwenden Sie den Prozess, der für Ihr System am sinnvollsten ist. Sie könnten beispielsweise einen asynchronen Prozess verwenden, der die Tabelle langsam scannt und dann die Elemente mithilfe der von Ihnen definierten Attributaktionen und der Verschlüsselungskonfiguration neu schreibt. Um die Klartext-Elemente in Ihrer Tabelle zu identifizieren, empfehlen wir, nach allen Elementen zu suchen, die nicht die `aws_dbe_foot` Attribute `aws_dbe_head` und enthalten, die das AWS Database Encryption SDK Elementen hinzufügt, wenn sie verschlüsselt und signiert sind.
Im folgenden Beispiel wird die Konfiguration der Tabellenverschlüsselung aus **Schritt 1** aktualisiert. Sie müssen die Klartext-Override mit `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` aktualisieren. Diese Richtlinie liest weiterhin Klartext-Elemente, liest und schreibt aber auch verschlüsselte Elemente. Erstellen Sie ein neues `DynamoDbEncryptionInterceptor` mit dem aktualisierten`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
## Schritt 3: Nur verschlüsselte und signierte Elemente lesen
Nachdem Sie alle Ihre Elemente verschlüsselt und signiert haben, aktualisieren Sie die Klartext-Überschreibung in Ihrer `DynamoDbEncryptionInterceptor` Konfiguration, sodass der Client nur verschlüsselte und signierte Elemente lesen und schreiben kann. Nachdem Sie die folgende Änderung implementiert haben, verschlüsselt und signiert der Client neue Elemente auf der Grundlage der Attributaktionen, die Sie in **Schritt** 1 konfiguriert haben. Der Client kann nur verschlüsselte und signierte Elemente lesen.
Im folgenden Beispiel wird die Konfiguration der Tabellenverschlüsselung aus **Schritt 2** aktualisiert. Sie können entweder die Klartext-Override mit der Klartext-Richtlinie aktualisieren `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` oder die Klartext-Richtlinie aus Ihrer Konfiguration entfernen. Der Client liest und schreibt standardmäßig nur verschlüsselte und signierte Elemente. Erstellen Sie ein neues `DynamoDbEncryptionInterceptor` mit dem aktualisierten`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
// Optional: you can also remove the plaintext policy from your configuration
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
# Migrieren Sie auf Version 3.x der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in AWS Database Encryption SDK umbenannt. Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB ist eine grundlegende Neufassung der 2. *x-Codebasis*. Es enthält viele Updates, wie z. B. ein neues strukturiertes Datenformat, verbesserte Mehrmandantenunterstützung, nahtlose Schemaänderungen und Unterstützung für durchsuchbare Verschlüsselung. Dieses Thema enthält Anleitungen zur Migration Ihres Codes auf Version 3. *x.*
## Migration von Version 1.x auf 2.x
Migrieren Sie auf Version 2. *x* bevor Sie auf Version 3 migrieren. *x.* Ausführung 2. *x* hat das Symbol für den neuesten Anbieter von `MostRecentProvider` zu geändert`CachingMostRecentProvider`. Wenn Sie derzeit Version 1 verwenden. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB mit dem `MostRecentProvider` Symbol, auf das Sie den Symbolnamen in Ihrem Code aktualisieren müssen. `CachingMostRecentProvider` Weitere Informationen finden Sie unter [Updates für den neuesten Anbieter](most-recent-provider.md#mrp-versions).
## Migration von Version 2.x auf 3.x
Die folgenden Verfahren beschreiben, wie Sie Ihren Code von Version 2 migrieren. *x* auf Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
### Schritt 1. Bereiten Sie sich darauf vor, Elemente im neuen Format zu lesen
Gehen Sie wie folgt vor, um Ihren AWS Database Encryption SDK-Client darauf vorzubereiten, Elemente im neuen Format zu lesen. Nachdem Sie die folgenden Änderungen implementiert haben, wird sich Ihr Client weiterhin genauso verhalten wie in Version 2. *x.* Ihr Kunde wird weiterhin Elemente in der Version 2 lesen und schreiben. *X-Format*, aber diese Änderungen bereiten den Client darauf vor, [Elemente im neuen Format zu lesen](#ddb-java-migrate-step2).
**Aktualisieren Sie Ihre Version AWS SDK für Java auf Version 2.x**
Version 3. *x* [der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB erfordert den DynamoDB Enhanced Client.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Der DynamoDB Enhanced Client ersetzt den in früheren Versionen DBMapper verwendeten [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html). Um den erweiterten Client zu verwenden, müssen Sie den verwenden. AWS SDK for Java 2.x
Folgen Sie den Anweisungen für die [Migration von Version 1.x auf 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) von. AWS SDK für Java
Weitere Informationen darüber, welche AWS SDK for Java 2.x Module erforderlich sind, finden Sie unter. [Voraussetzungen](ddb-java.md#ddb-java-prerequisites)
**Konfigurieren Sie Ihren Client so, dass er Elemente liest, die mit älteren Versionen verschlüsselt wurden**
Die folgenden Verfahren bieten einen Überblick über die Schritte, die im folgenden Codebeispiel demonstriert werden.
1. Erstellen Sie einen [Schlüsselbund](keyrings.md).
Keyrings und [Cryptographic Materials Manager](concepts.md#crypt-materials-manager) ersetzen die Anbieter für kryptografisches Material, die in früheren Versionen der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB verwendet wurden.
**Wichtig**
Die Umschließungsschlüssel, die Sie bei der Erstellung eines Schlüsselbunds angeben, müssen dieselben Wickelschlüssel sein, die Sie in Version 2 mit Ihrem Anbieter für kryptografisches Material verwendet haben. *x.*
1. Erstellen Sie ein Tabellenschema über Ihrer annotierten Klasse.
In diesem Schritt werden die Attributaktionen definiert, die verwendet werden, wenn Sie mit dem Schreiben von Elementen im neuen Format beginnen.
Anleitungen zur Verwendung des neuen DynamoDB Enhanced Client finden Sie unter [Generate a `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) im *AWS SDK für Java Developer* Guide.
Im folgenden Beispiel wird davon ausgegangen, dass Sie Ihre annotierte Klasse aus Version 2 aktualisiert haben. *x* verwendet die neuen Anmerkungen zu Attributaktionen. Weitere Hinweise zum Kommentieren Ihrer Attributaktionen finden Sie unter. [Verwenden Sie eine Datenklasse mit Anmerkungen](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**Anmerkung**
Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Ein Beispiel, das die zur Definition verwendeten Anmerkungen zeigt`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, finden Sie unter [SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
1. Definieren Sie, [welche Attribute von der Signatur ausgeschlossen werden](ddb-java-using.md#allowed-unauth).
1. Konfigurieren Sie eine explizite Zuordnung der Attributaktionen, die in Ihrer modellierten Klasse von Version 2.x konfiguriert sind.
In diesem Schritt werden die Attributaktionen definiert, die zum Schreiben von Elementen im alten Format verwendet wurden.
1. Konfigurieren `DynamoDBEncryptor` Sie die, die Sie in Version 2 verwendet haben. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
1. Konfigurieren Sie das ältere Verhalten.
1. Erstellen Sie einen `DynamoDbEncryptionInterceptor`.
1. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client.
1. Erstellen Sie die `DynamoDBEnhancedClient` und erstellen Sie eine Tabelle mit Ihrer modellierten Klasse.
Weitere Informationen zum DynamoDB Enhanced Client finden Sie unter [Erstellen eines erweiterten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) Clients.
```
public class MigrationExampleStep1 {
public static void MigrationStep1(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Create a Keyring.
// This example creates an AWS KMS Keyring that specifies the
// same kmsKeyId previously used in the version 2.x configuration.
// It uses the 'CreateMrkMultiKeyring' method to create the
// keyring, so that the keyring can correctly handle both single
// region and Multi-Region KMS Keys.
// Note that this example uses the AWS SDK for Java v2 KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
// 2. Create a Table Schema over your annotated class.
// For guidance on using the new attribute actions
// annotations, see SimpleClass.java in the
// aws-database-encryption-sdk-dynamodb GitHub repository.
// All primary key attributes must be signed but not encrypted
// and by default all non-primary key attributes
// are encrypted and signed (ENCRYPT_AND_SIGN).
// If you want a particular non-primary key attribute to be signed but
// not encrypted, use the 'DynamoDbEncryptionSignOnly' annotation.
// If you want a particular attribute to be neither signed nor encrypted
// (DO_NOTHING), use the 'DynamoDbEncryptionDoNothing' annotation.
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
// 3. Define which attributes the client should expect to be excluded
// from the signature when reading items.
// This value represents all unsigned attributes across the entire
// dataset.
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 4. Configure an explicit map of the attribute actions configured
// in your version 2.x modeled class.
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
// 5. Configure the DynamoDBEncryptor that you used in version 2.x.
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 6. Configure the legacy behavior.
// Input the DynamoDBEncryptor and attribute actions created in
// the previous steps. For Legacy Policy, use
// 'FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy continues to read
// and write items using the old format, but will be able to read
// items written in the new format as soon as they appear.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 7. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 8. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 7.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 9. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb client
// created in Step 8, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
### Schritt 2. Schreiben Sie Elemente im neuen Format
Nachdem Sie die Änderungen aus Schritt 1 für alle Leser bereitgestellt haben, führen Sie die folgenden Schritte aus, um Ihren AWS Database Encryption SDK-Client so zu konfigurieren, dass er Elemente im neuen Format schreibt. Nachdem Sie die folgenden Änderungen implementiert haben, liest Ihr Client weiterhin Elemente im alten Format und beginnt, Elemente im neuen Format zu schreiben und zu lesen.
Die folgenden Verfahren bieten einen Überblick über die Schritte, die im folgenden Codebeispiel demonstriert werden.
1. Fahren Sie mit der Konfiguration Ihres Schlüsselbundes, des Tabellenschemas`allowedUnsignedAttributes`, der veralteten Attributaktionen und `DynamoDBEncryptor` wie in [**Schritt 1 fort**](#ddb-java-migrate-step1).
1. Aktualisieren Sie Ihr bisheriges Verhalten, sodass nur neue Elemente mit dem neuen Format geschrieben werden.
1. Erstellen eines `DynamoDbEncryptionInterceptor `
1. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client.
1. Erstellen Sie die `DynamoDBEnhancedClient` und erstellen Sie eine Tabelle mit Ihrer modellierten Klasse.
Weitere Informationen zum DynamoDB Enhanced Client finden Sie unter [Erstellen eines erweiterten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) Clients.
```
public class MigrationExampleStep2 {
public static void MigrationStep2(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema, legacy
// attribute actions, allowedUnsignedAttributes, and
// DynamoDBEncryptor as you did in Step 1.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 2. Update your legacy behavior to only write new items using the new
// format.
// For Legacy Policy, use 'FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy
// continues to read items in both formats, but will only write items
// using the new format.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb Client created
// in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
[Nach der Bereitstellung der Änderungen in Schritt 2 müssen Sie alle alten Elemente in Ihrer Tabelle erneut mit dem neuen Format verschlüsseln, bevor Sie mit Schritt 3 fortfahren können.](#ddb-java-migrate-step3) Es gibt keine einzelne Metrik oder Abfrage, die Sie ausführen können, um Ihre vorhandenen Elemente schnell zu verschlüsseln. Verwenden Sie den Prozess, der für Ihr System am sinnvollsten ist. Sie könnten beispielsweise einen asynchronen Prozess verwenden, der die Tabelle langsam scannt und dann die Elemente mithilfe der neuen Attributaktionen und der Verschlüsselungskonfiguration, die Sie definiert haben, neu schreibt.
### Schritt 3. Nur Elemente im neuen Format lesen und schreiben
Nachdem Sie alle Elemente in Ihrer Tabelle mit dem neuen Format erneut verschlüsselt haben, können Sie das alte Verhalten aus Ihrer Konfiguration entfernen. Gehen Sie wie folgt vor, um Ihren Client so zu konfigurieren, dass er nur Elemente im neuen Format liest und schreibt.
Die folgenden Verfahren bieten einen Überblick über die Schritte, die im folgenden Codebeispiel demonstriert werden.
1. Fahren Sie mit der Konfiguration Ihres Schlüsselbundes und des `allowedUnsignedAttributes` Tabellenschemas wie in [**Schritt 1 fort**](#ddb-java-migrate-step1). Entfernen Sie die veralteten Attributaktionen und `DynamoDBEncryptor` aus Ihrer Konfiguration.
1. Erstellen Sie einen `DynamoDbEncryptionInterceptor`.
1. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client.
1. Erstellen Sie die `DynamoDBEnhancedClient` und erstellen Sie eine Tabelle mit Ihrer modellierten Klasse.
Weitere Informationen zum DynamoDB Enhanced Client finden Sie unter [Erstellen eines erweiterten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) Clients.
```
public class MigrationExampleStep3 {
public static void MigrationStep3(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema,
// and allowedUnsignedAttributes as you did in Step 1.
// Do not include the configurations for the DynamoDBEncryptor or
// the legacy attribute actions.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
// Do not configure any legacy behavior.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK Client
// created in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```