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 DynamoDB-Verschlüsselungsclient für Java
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema wird erklärt, wie Sie den Amazon DynamoDB Encryption Client für Java installieren und verwenden. Einzelheiten zur Programmierung mit dem DynamoDB Encryption Client finden Sie in den [Java-Beispielen, den [Beispielen](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)](java-examples.md) im aws-dynamodb-encryption-java Repository auf GitHub und im [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) für den DynamoDB Encryption Client.
**Anmerkung**
Versionen 1. *x.* *x* des DynamoDB Encryption Client für Java sind ab Juli 2022 in der [end-of-support Phase](what-is-database-encryption-sdk.md#support). Führen Sie so bald wie möglich ein Upgrade auf eine neuere Version durch.
**Topics**
+ [Voraussetzungen](#java-prerequisites)
+ [Installation](#java-installation)
+ [Verwenden des DynamoDB Encryption Client für Java](java-using.md)
+ [Java-Beispiele](java-examples.md)
## Voraussetzungen
Bevor Sie den Amazon DynamoDB Encryption Client für Java installieren, 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 für Java**
Der DynamoDB Encryption Client benötigt das DynamoDB-Modul von, AWS SDK für Java auch wenn Ihre Anwendung nicht mit DynamoDB interagiert. Sie können das gesamte SDK oder nur dieses Modul installieren. Wenn Sie Maven verwenden, fügen Sie `aws-java-sdk-dynamodb` Ihrer `pom.xml`-Datei hinzu.
Weitere Informationen zur Installation und Konfiguration von finden Sie unter. AWS SDK für Java[AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html)
## Installation
Sie können den Amazon DynamoDB Encryption Client für Java auf folgende Weise installieren.
**manuell**
Um den Amazon DynamoDB Encryption Client für Java zu installieren, klonen Sie das [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub Repository oder laden Sie es herunter.
**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.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Nachdem Sie das SDK installiert haben, schauen Sie sich zunächst den Beispielcode in diesem Handbuch und den [DynamoDB Encryption Client Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) an. GitHub
# Verwenden des DynamoDB Encryption Client für Java
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema werden einige Funktionen des DynamoDB Encryption Client in Java erklärt, die in anderen Programmiersprachenimplementierungen möglicherweise nicht zu finden sind.
Einzelheiten zur Programmierung mit dem DynamoDB Encryption Client finden Sie in den [Java-Beispielen, den [Beispielen](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)](java-examples.md) im `aws-dynamodb-encryption-java repository` on GitHub und im [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) für den DynamoDB Encryption Client.
**Topics**
+ [Elementverschlüssler](#attribute-encryptor)
+ [Konfigurieren des Speicherverhaltens](#save-behavior)
+ [Attributaktionen in Java](#attribute-actions-java)
+ [Überschreiben von Tabellennamen](#override-table-name)
## Elementverschlüsseler: und Dynamo AttributeEncryptor DBEncryptor
[Der DynamoDB Encryption Client in Java hat zwei [Elementverschlüsseler](DDBEC-legacy-concepts.md#item-encryptor): den Dynamo auf niedrigerer Ebene und den. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
Das `AttributeEncryptor` ist eine Hilfsklasse, die Ihnen hilft, [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK für Java zusammen mit dem DBMapper `DynamoDB Encryptor` im DynamoDB Encryption Client zu verwenden. Wenn Sie den `AttributeEncryptor` mit dem `DynamoDBMapper` verwenden, verschlüsselt und signiert er Ihre Elemente transparent, wenn Sie sie speichern. Außerdem werden Ihre Elemente transparent überprüft und entschlüsselt, wenn Sie sie laden.
## Konfigurieren des Speicherverhaltens
Sie können das `AttributeEncryptor` und verwenden`DynamoDBMapper`, um Tabellenelemente durch Attribute hinzuzufügen oder zu ersetzen, die nur signiert oder verschlüsselt und signiert sind. Für diese Aufgaben wird empfohlen, dass Sie sie so konfigurieren, dass das `PUT`-Speicherverhalten verwendet wird, wie im folgenden Beispiel gezeigt. Andernfalls können Sie Ihre Daten möglicherweise nicht entschlüsseln.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Wenn Sie das standardmäßige Speicherverhalten verwenden, bei dem nur die Attribute aktualisiert werden, die im Tabellenelement modelliert sind, sind Attribute, die nicht modelliert sind, nicht in der Signatur enthalten und werden auch nicht durch Tabellenschreibvorgänge geändert. Daher wird die Signatur bei späteren Lesevorgängen aller Attribute nicht validiert, da sie keine nicht modellierten Attribute enthält.
Sie können auch das `CLOBBER`-Speicherverhalten verwenden. Dieses Verhalten stimmt mit dem `PUT`-Speicherverhalten überein, mit der Ausnahme, dass es die optimistische Sperre deaktiviert und das Element in der Tabelle überschreibt.
Um Signaturfehler zu vermeiden, löst der DynamoDB Encryption Client eine Laufzeitausnahme aus, wenn ein mit einem verwendet `AttributeEncryptor` wird`DynamoDBMapper`, das nicht mit dem Speicherverhalten oder konfiguriert ist. `CLOBBER` `PUT`
Um zu sehen, wie dieser Code in einem Beispiel verwendet wird, siehe [Verwenden von Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) und das [AwsKmsEncryptedObject.java-Beispiel](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) im Repository unter. `aws-dynamodb-encryption-java` GitHub
## Attributaktionen in Java
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) bestimmen, welche Attributwerte verschlüsselt und signiert, welche nur signiert und welche ignoriert werden. [Die Methode, mit der Sie Attributaktionen angeben, hängt davon ab`AttributeEncryptor`, ob Sie das `DynamoDBMapper` und oder Dynamo auf niedrigerer Ebene verwenden. DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**Wichtig**
Nachdem Sie die Attributaktionen zum Verschlüsseln der Tabellenelemente verwendet haben, kann das Hinzufügen oder Entfernen von Attributen zu oder aus Ihrem Datenmodell einen Signaturvalidierungsfehler verursachen, der ein Entschlüsseln Ihrer Daten verhindert. Eine detaillierte Beschreibung finden Sie unter [Ändern Ihres Datenmodells](data-model.md).
### Attributaktionen für den Dynamo DBMapper
Bei Einsatz des `DynamoDBMapper` und `AttributeEncryptor` verwenden Sie Annotationen zum Angeben der Attributaktionen. Der DynamoDB Encryption Client verwendet die [standardmäßigen DynamoDB-Attributanmerkungen, die den Attributtyp](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.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**
Verschlüsseln Sie den Wert von Attributen nicht mit der [@Dynamo DBVersion Attribut-Annotation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), obwohl Sie sie signieren können (und sollten). Andernfalls haben Bedingungen, die ihren Wert verwenden, unbeabsichtigte Auswirkungen.
```
// Attributes are encrypted and signed
@DynamoDBAttribute(attributeName="Description")
// Partition keys are signed but not encrypted
@DynamoDBHashKey(attributeName="Title")
// Sort keys are signed but not encrypted
@DynamoDBRangeKey(attributeName="Author")
```
Um Ausnahmen anzugeben, verwenden Sie die Verschlüsselungsanmerkungen, die im DynamoDB Encryption Client für Java definiert sind. Wenn Sie sie auf Klassenebene angeben, werden sie zum Standardwert für die Klasse.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Beispielsweise signieren diese Annotationen das `PublicationYear`-Attribut, verschlüsseln es aber nicht, und sie verschlüsseln und signieren den `ISBN`-Attributwert nicht.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Attributaktionen für den Dynamo DBEncryptor
Um Attributaktionen anzugeben, wenn Sie [Dynamo DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) direkt verwenden, erstellen Sie ein `HashMap` Objekt, in dem die Name-Wert-Paare für Attributnamen und die angegebenen Aktionen stehen.
Die gültigen Werte für die Attribut-Aktionen sind unter im Aufzählungstyp `EncryptionFlags` definiert. Sie können `ENCRYPT` und `SIGN` gemeinsam oder `SIGN` alleine verwenden, oder beides weglassen. Wenn Sie den DynamoDB Encryption Client jedoch `ENCRYPT` alleine verwenden, gibt er einen Fehler aus. Ein Attribut, das Sie nicht signieren, können Sie nicht verschlüsseln.
```
ENCRYPT
SIGN
```
**Warnung**
Verschlüsseln Sie die primären Schlüsselattribute nicht. Sie müssen im Klartext bleiben, damit DynamoDB das Element finden kann, ohne einen vollständigen Tabellenscan ausführen zu müssen.
Wenn Sie einen Primärschlüssel im Verschlüsselungskontext angeben und dann `ENCRYPT` in der Attributaktion für eines der Primärschlüsselattribute angeben, löst der DynamoDB Encryption Client eine Ausnahme aus.
Der folgende Java-Code erstellt beispielsweise eine `actions` HashMap , die alle Attribute im Element verschlüsselt und signiert. `record` Ausnahmen sind die Partitionsschlüssel- und Sortierschlüsselattribute, die zwar signiert, aber nicht verschlüsselt sind, sowie das `test`-Attribut, das weder signiert noch verschlüsselt ist.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // no break; falls through to next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Don't encrypt or sign
break;
default:
// Encrypt and sign everything else
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Wenn Sie dann die [encryptRecord](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html#encryptRecord-java.util.Map-java.util.Map-com.amazonaws.services.dynamodbv2.datamodeling.encryption.EncryptionContext-)-Methode des `DynamoDBEncryptor` aufrufen, geben Sie die Map als Wert des Parameters `attributeFlags` an. Der folgende Aufruf von `encryptRecord` beispielsweise verwendet die `actions`-Map.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Überschreiben von Tabellennamen
Im DynamoDB Encryption Client ist der Name der DynamoDB-Tabelle ein Element des [DynamoDB-Verschlüsselungskontextes, das an die Verschlüsselungs](concepts.md#encryption-context) - und Entschlüsselungsmethoden übergeben wird. Wenn Sie Tabellenelemente verschlüsseln oder signieren, ist der DynamoDB-Verschlüsselungskontext, einschließlich des Tabellennamens, kryptografisch an den Chiffretext gebunden. Wenn der DynamoDB-Verschlüsselungskontext, der an die Entschlüsselungsmethode übergeben wird, nicht mit dem DynamoDB-Verschlüsselungskontext übereinstimmt, der an die Verschlüsselungsmethode übergeben wurde, schlägt der Entschlüsselungsvorgang fehl.
[Gelegentlich ändert sich der Name einer Tabelle, z. B. wenn Sie eine Tabelle sichern oder eine Wiederherstellung durchführen. point-in-time ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) Wenn Sie die Signatur dieser Elemente entschlüsseln oder überprüfen, müssen Sie denselben DynamoDB-Verschlüsselungskontext übergeben, der zum Verschlüsseln und Signieren der Elemente verwendet wurde, einschließlich des ursprünglichen Tabellennamens. Der aktuelle Tabellenname wird nicht benötigt.
Wenn Sie den verwenden`DynamoDBEncryptor`, stellen Sie den DynamoDB-Verschlüsselungskontext manuell zusammen. Wenn Sie jedoch den verwenden, `AttributeEncryptor` erstellt der den `DynamoDBMapper` DynamoDB-Verschlüsselungskontext für Sie, einschließlich des aktuellen Tabellennamens. Um dem `AttributeEncryptor` mitzuteilen, einen Verschlüsselungskontext mit einem anderen Tabellennamen zu erstellen, verwenden Sie den `EncryptionContextOverrideOperator`.
Der folgende Code erstellt beispielsweise Instances des Anbieters von kryptographischen Materialien (Cryptographic Materials Provider (CMP)) und des `DynamoDBEncryptor`. Dann ruft er die Methode `setEncryptionContextOverrideOperator` des `DynamoDBEncryptor` auf. Er verwendet den Operator `overrideEncryptionContextTableName`, der einen Tabellennamen überschreibt. Wenn es auf diese Weise konfiguriert ist, `AttributeEncryptor` erstellt das einen DynamoDB-Verschlüsselungskontext, der anstelle von Folgendes umfasst`newTableName`. `oldTableName` [Ein vollständiges Beispiel finden Sie unter EncryptionContextOverridesWithDynamo DBMapper .java.](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/EncryptionContextOverridesWithDynamoDBMapper.java)
```
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
encryptor.setEncryptionContextOverrideOperator(EncryptionContextOperators.overrideEncryptionContextTableName(
oldTableName, newTableName));
```
Wenn Sie die Load-Methode von `DynamoDBMapper` aufrufen, die das Element entschlüsselt und überprüft, geben Sie den ursprünglichen Tabellennamen an.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Sie können auch den Operator `overrideEncryptionContextTableNameUsingMap` verwenden, der mehrere Tabellennamen überschreibt.
Beim Entschlüsseln von Daten und beim Überprüfen von Signaturen werden in der Regel Operatoren zum Überschreiben des Tabellennamens verwendet. Sie können sie jedoch verwenden, um den Tabellennamen im DynamoDB-Verschlüsselungskontext beim Verschlüsseln und Signieren auf einen anderen Wert festzulegen.
Setzen Sie nicht die Operatoren zum Überschreiben des Tabellennamens ein, wenn Sie den `DynamoDBEncryptor` verwenden. Erstellen Sie stattdessen einen Verschlüsselungskontext mit dem ursprünglichen Tabellennamen und senden Sie ihn an die Entschlüsselungsmethode.
# Beispielcode für den DynamoDB Encryption Client für Java
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Die folgenden Beispiele zeigen Ihnen, wie Sie den DynamoDB Encryption Client für Java verwenden, um DynamoDB-Tabellenelemente in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie im Beispielverzeichnis des [Repositorys](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) unter. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Topics**
+ [Verwenden von Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Verwenden von Dynamo DBMapper](#java-example-dynamodb-mapper)
## Verwenden von Dynamo DBEncryptor
[Dieses Beispiel zeigt, wie [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) auf niedrigerer Ebene DBEncryptor mit dem Direct KMS Provider verwendet wird.](direct-kms-provider.md) Der Direct KMS-Anbieter generiert und schützt seine kryptografischen Materialien unter einem von Ihnen angegebenen Wert [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS).
Sie können jeden kompatiblen [Anbieter für kryptografisches Material](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) mit dem verwenden`DynamoDBEncryptor`, und Sie können den Direct KMS-Anbieter mit und verwenden. `DynamoDBMapper` [AttributeEncryptor](java-using.md#attribute-encryptor)
**Sehen Sie sich das vollständige Codebeispiel** [an: .java AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
Schritt 1: Erstellen Sie den Direct KMS Provider
Erstellen Sie eine Instanz des AWS KMS Clients mit der angegebenen Region. Verwenden Sie dann die Client-Instanz, um eine Instanz des Direct KMS Providers mit Ihrem bevorzugten zu erstellen AWS KMS key.
In diesem Beispiel wird der Amazon-Ressourcenname (ARN) verwendet, um den zu identifizieren AWS KMS key, aber Sie können [jeden gültigen Schlüsselbezeichner](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn) verwenden.
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Schritt 2: Erstellen Sie ein Element
In diesem Beispiel wird a definiert `record` HashMap , das ein Beispieltabellenelement darstellt.
```
final String partitionKeyName = "partition_attribute";
final String sortKeyName = "sort_attribute";
final Map record = new HashMap<>();
record.put(partitionKeyName, new AttributeValue().withS("value1"));
record.put(sortKeyName, new AttributeValue().withN("55"));
record.put("example", new AttributeValue().withS("data"));
record.put("numbers", new AttributeValue().withN("99"));
record.put("binary", new AttributeValue().withB(ByteBuffer.wrap(new byte[]{0x00, 0x01, 0x02})));
record.put("test", new AttributeValue().withS("test-value"));
```
Schritt 3: Erstellen Sie einen Dynamo DBEncryptor
Erstellen Sie eine Instance von `DynamoDBEncryptor` mit dem Direct KMS Provider.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Schritt 4: Erstellen Sie einen DynamoDB-Verschlüsselungskontext
Der [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) enthält Informationen über die Tabellenstruktur und wie sie verschlüsselt und signiert ist. Wenn Sie den `DynamoDBMapper`verwenden, erstellt der `AttributeEncryptor` den Verschlüsselungskontext für Sie.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Schritt 5: Erstellen Sie das Attribut-Aktionen-Objekt
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) bestimmen, welche Attribute des Elements verschlüsselt und signiert sind, welche nur signiert und welche nicht verschlüsselt oder signiert sind.
In Java erstellen Sie zur Angabe von Attributaktionen eine Kombination HashMap aus Attributnamen und `EncryptionFlags` Wertepaaren.
Der folgende Java-Code erstellt beispielsweise eine, `actions` HashMap die alle Attribute im `record` Element verschlüsselt und signiert, mit Ausnahme der Partitionsschlüssel- und Sortierschlüsselattribute, die signiert, aber nicht verschlüsselt sind, und des `test` Attributs, das nicht signiert oder verschlüsselt ist.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // fall through to the next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Neither encrypted nor signed
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Schritt 6: Verschlüsseln und signieren Sie das Element
Um das Tabellenelement zu verschlüsseln und zu signieren, rufen Sie die Methode `encryptRecord` für die Instance des `DynamoDBEncryptor` auf. Geben Sie das Tabellenelement (`record`), die Attribut-Aktionen (`actions`) und den Verschlüsselungskontext (`encryptionContext`) an.
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Schritt 7: Fügen Sie das Element in die DynamoDB-Tabelle ein
Fügen Sie abschließend das verschlüsselte und signierte Element in die DynamoDB-Tabelle ein.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Verwenden von Dynamo DBMapper
Das folgende Beispiel zeigt Ihnen, wie Sie die DynamoDB-Mapper-Hilfsklasse mit dem [Direct KMS](direct-kms-provider.md) Provider verwenden. Der Direct KMS-Anbieter generiert und schützt seine kryptografischen Materialien unter einem von Ihnen angegebenen Wert [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS).
Sie können jeden kompatiblen [Cryptographic Materials Provider](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) mit dem `DynamoDBMapper` und den Direct KMS Provider mit dem untergeordneten `DynamoDBEncryptor` verwenden.
**[Sehen Sie sich das vollständige Codebeispiel an: .java AwsKmsEncryptedObject](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)**
Schritt 1: Erstellen Sie den Direct KMS Provider
Erstellen Sie eine Instanz des AWS KMS Clients mit der angegebenen Region. Verwenden Sie dann die Client-Instanz, um eine Instanz des Direct KMS Providers mit Ihrem bevorzugten zu erstellen AWS KMS key.
In diesem Beispiel wird der Amazon-Ressourcenname (ARN) verwendet, um den zu identifizieren AWS KMS key, aber Sie können [jeden gültigen Schlüsselbezeichner](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) verwenden.
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Schritt 2: DynamoDB Encryptor und Dynamo erstellen DBMapper
Verwenden Sie den Direct KMS Provider, den Sie im vorherigen Schritt erstellt haben, um eine Instanz von [DynamoDB](java-using.md#attribute-encryptor) Encryptor zu erstellen. Sie müssen den DynamoDB Encryptor auf niedrigerer Ebene instanziieren, um den DynamoDB Mapper verwenden zu können.
Erstellen Sie als Nächstes eine Instanz Ihrer DynamoDB-Datenbank und eine Mapper-Konfiguration und verwenden Sie diese, um eine Instanz des DynamoDB-Mappers zu erstellen.
Wenn Sie den `DynamoDBMapper` zum Hinzufügen oder Bearbeiten signierter (oder verschlüsselter und signierter) Elemente verwenden, konfigurieren Sie ihn für die [Nutzung eines Speicherverhaltens](java-using.md#save-behavior), z. B. `PUT`, das alle Attribute enthält, wie im folgenden Beispiel gezeigt. Andernfalls können Sie Ihre Daten möglicherweise nicht entschlüsseln.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp)
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Schritt 3: Definieren Sie Ihre DynamoDB-Tabelle
Definieren Sie als Nächstes Ihre DynamoDB-Tabelle. Verwenden Sie Anmerkungen zum Angeben der [Attributaktionen](java-using.md#attribute-actions-java). In diesem Beispiel werden eine DynamoDB-Tabelle und eine `DataPoJo` Klasse erstellt`ExampleTable`, die Tabellenelemente darstellt.
In dieser Beispiel-Tabelle werden die primären Schlüsselattribute signiert, aber nicht verschlüsselt. Dies gilt für das `partition_attribute`, das mit `@DynamoDBHashKey` und dem `sort_attribute` versehen ist, das mit `@DynamoDBRangeKey` versehen ist.
Attribute, die mit `@DynamoDBAttribute` versehen sind, z. B. `some numbers`, werden verschlüsselt und signiert. Ausnahmen sind Attribute, die die vom `@DoNotEncrypt` DynamoDB Encryption Client definierten Verschlüsselungsanmerkungen `@DoNotTouch` (nur signieren) oder (nicht verschlüsseln oder signieren) verwenden. Beispiel: Da das `leave me`-Attribut eine `@DoNotTouch`-Anmerkung hat, wird es nicht verschlüsselt oder signiert.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String example;
private long someNumbers;
private byte[] someBinary;
private String leaveMe;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "example")
public String getExample() {
return example;
}
public void setExample(String example) {
this.example = example;
}
@DynamoDBAttribute(attributeName = "some numbers")
public long getSomeNumbers() {
return someNumbers;
}
public void setSomeNumbers(long someNumbers) {
this.someNumbers = someNumbers;
}
@DynamoDBAttribute(attributeName = "and some binary")
public byte[] getSomeBinary() {
return someBinary;
}
public void setSomeBinary(byte[] someBinary) {
this.someBinary = someBinary;
}
@DynamoDBAttribute(attributeName = "leave me")
@DoNotTouch
public String getLeaveMe() {
return leaveMe;
}
public void setLeaveMe(String leaveMe) {
this.leaveMe = leaveMe;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ", sortAttribute="
+ sortAttribute + ", example=" + example + ", someNumbers=" + someNumbers
+ ", someBinary=" + Arrays.toString(someBinary) + ", leaveMe=" + leaveMe + "]";
}
}
```
Schritt 4: Ein Tabellenelement verschlüsseln und speichern
Wenn Sie jetzt ein Tabellenelement erstellen und es mit dem DynamoDB-Mapper speichern, wird das Element automatisch verschlüsselt und signiert, bevor es der Tabelle hinzugefügt wird.
In diesem Beispiel wird ein Tabellenelement mit der Bezeichnung `record` definiert. Bevor es in der Tabelle gespeichert wird, werden seine Attribute verschlüsselt und basierend auf den Anmerkungen in der `DataPoJo`-Klasse signiert. In diesem Fall werden alle Attribute mit Ausnahme von `PartitionAttribute`, `SortAttribute` und `LeaveMe` verschlüsselt und signiert. `PartitionAttribute` und `SortAttributes` werden nur signiert. Das `LeaveMe`-Attribut ist nicht verschlüsselt oder signiert.
Rufen Sie die `save`-Methode der `DynamoDBMapper`-Klasse auf, um das `record`-Element zu verschlüsseln und zu signieren und es dann zur `ExampleTable` hinzuzufügen. Da Ihr DynamoDB-Mapper für die Verwendung des `PUT` Speicherverhaltens konfiguriert ist, ersetzt das Element jedes Element mit denselben Primärschlüsseln, anstatt es zu aktualisieren. Auf diese Weise wird sichergestellt, dass die Signaturen übereinstimmen, und Sie können das Element entschlüsseln, wenn Sie es aus der Tabelle abrufen.
```
DataPoJo record = new DataPoJo();
record.setPartitionAttribute("is this");
record.setSortAttribute(55);
record.setExample("data");
record.setSomeNumbers(99);
record.setSomeBinary(new byte[]{0x00, 0x01, 0x02});
record.setLeaveMe("alone");
mapper.save(record);
```