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.
# Verfügbare Programmiersprachen für Amazon DynamoDB Encryption Client
**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).
Der Amazon DynamoDB Encryption Client ist für die folgenden Programmiersprachen verfügbar. Die sprachspezifischen Bibliotheken sind unterschiedlich, aber die daraus resultierenden Implementierungen sind interoperabel. Beispielsweise können Sie ein Element mit dem Java-Client verschlüsseln (und signieren) und das Element mit dem Python-Client entschlüsseln.
Weitere Informationen finden Sie unter den entsprechenden Themen.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# 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);
```
# DynamoDB-Verschlüsselungsclient für Python
**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 DynamoDB Encryption Client für Python installieren und verwenden. Sie finden den Code im [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)Repository unter GitHub, einschließlich des vollständigen und getesteten [Beispielcodes](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples), der Ihnen den Einstieg erleichtert.
**Anmerkung**
Versionen 1. *x.* *x* und 2. *x.* *x* des DynamoDB Encryption Client für Python 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](#python-prerequisites)
+ [Installation](#python-installation)
+ [Den DynamoDB Encryption Client für Python verwenden](python-using.md)
+ [Python-Beispiele](python-examples.md)
## Voraussetzungen
Bevor Sie den Amazon DynamoDB Encryption Client für Python installieren, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
**Eine unterstützte Version von Python**
Python 3.8 oder höher ist für den Amazon DynamoDB Encryption Client für Python-Versionen 3.3.0 und höher erforderlich. Weitere Informationen zum Download von Python finden Sie unter [Python-Downloads](https://www.python.org/downloads/).
Frühere Versionen des Amazon DynamoDB Encryption Client für Python unterstützen Python 2.7 und Python 3.4 und höher, wir empfehlen jedoch, die neueste Version des DynamoDB Encryption Client zu verwenden.
**Das pip-Installationstool for Python**
Python 3.6 und höher enthalten **Pip**, obwohl Sie es möglicherweise aktualisieren möchten. Weitere Informationen zum Aktualisieren oder Installieren von pip finden Sie unter [Installation](https://pip.pypa.io/en/latest/installation/) in der Dokumentation zu **pip**.
## Installation
Verwenden Sie **pip**, um den Amazon DynamoDB Encryption Client für Python zu installieren, wie in den folgenden Beispielen gezeigt.
**Installieren der neuesten Version**
```
pip install dynamodb-encryption-sdk
```
Weitere Informationen zur Verwendung von **pip** für die Installation und die Aktualisierung von Paketen finden Sie unter [Pakete installieren](https://packaging.python.org/tutorials/installing-packages/).
Der DynamoDB Encryption Client benötigt die [Kryptografiebibliothek auf allen Plattformen](https://cryptography.io/en/latest/). Alle Versionen von **pip** installieren und erstellen die **Kryptographie**-Bibliothek unter Windows. **pip** 8.1 und höher installiert und erstellt **cryptography** auf Linux. Wenn Sie eine frühere Version von **pip** verwenden und Ihre Linux-Umgebung nicht über die erforderlichen Tools zum Erstellen der **Kryptographie**-Bibliothek verfügt, müssen Sie sie installieren. Weitere Informationen finden Sie unter [Kryptographie unter Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
Sie können die neueste Entwicklungsversion des DynamoDB Encryption Client am aus dem [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)Repository herunterladen. GitHub
Nachdem Sie den DynamoDB Encryption Client installiert haben, schauen Sie sich zunächst den Python-Beispielcode in diesem Handbuch an.
# Den DynamoDB Encryption Client für Python verwenden
**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 für Python erläutert, die in anderen Programmiersprachenimplementierungen möglicherweise nicht zu finden sind. Diese Funktionen sollen es einfacher machen, den DynamoDB Encryption Client auf die sicherste Weise zu verwenden. Wenn Sie keinen ungewöhnlichen Anwendungsfall haben, empfehlen wir Ihnen, sie zu verwenden.
Einzelheiten zur Programmierung mit dem DynamoDB Encryption Client finden Sie in den [Python-Beispielen](python-examples.md) in diesem Handbuch, in den [Beispielen](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) im aws-dynamodb-encryption-python Repository auf GitHub und in der [Python-Dokumentation](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) für den DynamoDB Encryption Client.
**Topics**
+ [Client-Helferklassen](#python-helpers)
+ [TableInfo Klasse](#table-info)
+ [Attributaktionen in Python](#python-attribute-actions)
## Client-Helferklassen
Der DynamoDB Encryption Client für Python umfasst mehrere Client-Hilfsklassen, die die Boto 3-Klassen für DynamoDB widerspiegeln. Diese Hilfsklassen sollen das Hinzufügen von Verschlüsselung und Signierung zu Ihrer vorhandenen DynamoDB-Anwendung vereinfachen und die häufigsten Probleme wie folgt vermeiden:
+ Verhindern Sie, dass Sie den Primärschlüssel in Ihrem Element verschlüsseln, indem Sie dem [AttributeActions](#python-attribute-actions)Objekt entweder eine Aktion zum Überschreiben des Primärschlüssels hinzufügen oder indem Sie eine Ausnahme auslösen, wenn Ihr `AttributeActions` Objekt den Client ausdrücklich auffordert, den Primärschlüssel zu verschlüsseln. Wenn die Standardaktion in Ihrem `AttributeActions`-Objekt `DO_NOTHING` ist, verwenden die Client-Helferklassen diese Aktion für den Primärschlüssel. Andernfalls verwenden sie `SIGN_ONLY`.
+ Erstellen Sie ein [TableInfo Objekt](#python-helpers) und füllen Sie den [DynamoDB-Verschlüsselungskontext auf der Grundlage eines DynamoDB-Aufrufs](concepts.md#encryption-context) auf. Auf diese Weise können Sie sicherstellen, dass Ihr DynamoDB-Verschlüsselungskontext korrekt ist und der Client den Primärschlüssel identifizieren kann.
+ Support Sie Methoden wie `put_item` und`get_item`, die Ihre Tabellenelemente transparent ver- und entschlüsseln, wenn Sie in eine DynamoDB-Tabelle schreiben oder aus einer DynamoDB-Tabelle lesen. Nur die Methode `update_item` wird nicht unterstützt.
Sie können die Client-Helferklassen verwenden, anstatt direkt mit dem untergeordneten [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) zu interagieren. Verwenden Sie diese Klassen, es sei denn, Sie müssen erweiterte Optionen im Elementverschlüssler festlegen.
Zu den Client-Helferklassen gehören:
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)für Anwendungen, die die [Tabellenressource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) in DynamoDB verwenden, um jeweils eine Tabelle zu verarbeiten.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)für Anwendungen, die die [Service Resource-Klasse](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) in DynamoDB für die Batchverarbeitung verwenden.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)für Anwendungen, die den [Lower-Level-Client](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client) in DynamoDB verwenden.
Um die Client-Hilfsklassen verwenden zu können, muss der Aufrufer die Berechtigung haben, den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang in der Zieltabelle aufzurufen.
## TableInfo Klasse
Die [TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)Klasse ist eine Hilfsklasse, die eine DynamoDB-Tabelle darstellt, komplett mit Feldern für den Primärschlüssel und die Sekundärindizes. Sie hilft Ihnen, genaue Informationen über die Tabelle in Echtzeit zu erhalten.
Wenn Sie eine [Client-Helferklasse](#python-helpers) verwenden, erstellt und verwendet sie ein `TableInfo`-Objekt für Sie. Ansonsten können Sie explizit ein solches anlegen. Ein Beispiel finden Sie unter [Verwendung des Elementverschlüsslers](python-examples.md#python-example-item-encryptor).
Wenn Sie die `refresh_indexed_attributes` Methode für ein `TableInfo` Objekt aufrufen, füllt sie die Eigenschaftswerte des Objekts auf, indem sie den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang aufruft. Die Abfrage der Tabelle ist wesentlich zuverlässiger als eine feste Codierung von Indexnamen. Die `TableInfo` Klasse enthält auch eine `encryption_context_values` Eigenschaft, die die erforderlichen Werte für den [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) bereitstellt.
Um die `refresh_indexed_attributes` Methode verwenden zu können, muss der Aufrufer über die Berechtigung verfügen, den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang in der Zieltabelle aufzurufen.
## Attributaktionen in Python
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll. Um Attribut-Aktionen in Python anzugeben, legen Sie ein `AttributeActions`-Objekt mit einer Standardaktion und Ausnahmen für bestimmte Attribute an. Die gültigen Werte sind im Aufzählungstyp `CryptoAction` definiert.
**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).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Beispielsweise richtet dieses `AttributeActions`-Objekt `ENCRYPT_AND_SIGN` als Standard für alle Attribute ein und gibt Ausnahmen für die Attribute `ISBN` und `PublicationYear` an.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Wenn Sie eine [Client-Helferklasse](#python-helpers) verwenden, müssen Sie keine Attribut-Aktion für die Primärschlüsselattribute angeben. Die Client-Helferklassen verhindern, dass Sie Ihren Primärschlüssel verschlüsseln.
Wenn Sie keine Client-Helferklasse verwenden und die Standardaktion `ENCRYPT_AND_SIGN` ist, müssen Sie eine Aktion für den Primärschlüssel angeben. Die empfohlene Aktion für Primärschlüssel ist `SIGN_ONLY`. Um dies zu vereinfachen, verwenden Sie die Methode `set_index_keys`, die SIGN\$1ONLY für Primärschlüssel verwendet, oder DO\$1NOTHING, wenn dies die Standardaktion ist.
**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.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Beispielcode für den DynamoDB Encryption Client für Python
**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 Python verwenden, um DynamoDB-Daten in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie im Beispielverzeichnis des [Repositorys](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) unter. [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/) GitHub
**Topics**
+ [Verwenden Sie die EncryptedTable Client-Helper-Klasse](#python-example-table)
+ [Verwendung des Elementverschlüsslers](#python-example-item-encryptor)
## Verwenden Sie die EncryptedTable Client-Helper-Klasse
Das folgende Beispiel zeigt Ihnen, wie Sie den [Direct KMS Provider](direct-kms-provider.md) mit der `EncryptedTable`[-Client-Helferklasse](python-using.md#python-helpers) verwenden. Dieses Beispiel verwendet denselben [Anbieter von Verschlüsselungsdaten](DDBEC-legacy-concepts.md#concept-material-provider) wie das nachfolgende Beispiel [Verwendung des Elementverschlüsslers](#python-example-item-encryptor). Es verwendet jedoch die Klasse `EncryptedTable`, statt direkt mit dem untergeordneten [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) zusammenzuarbeiten.
Durch den Vergleich dieser Beispiele erkennen Sie, was die Client-Helferklasse für Sie erledigt. Dazu gehört die Erstellung des [DynamoDB-Verschlüsselungskontextes](concepts.md#encryption-context) und die Sicherstellung, dass die Primärschlüsselattribute immer signiert, aber niemals verschlüsselt sind. Um den Verschlüsselungskontext zu erstellen und den Primärschlüssel zu ermitteln, rufen die Client-Hilfsklassen den DynamoDB-Vorgang [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)auf. Um diesen Code ausführen zu können, müssen Sie die Berechtigung haben, diese Operation aufzurufen.
**Das vollständige Codebeispiel finden Sie unter**: [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
Schritt 1: Erstellen der Tabelle
Erstellen Sie zunächst eine Instanz einer DynamoDB-Standardtabelle mit dem Tabellennamen.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Schritt 2: Erstellen Sie einen Anbieter für Verschlüsselungsdaten
Erstellen Sie eine Instance des [Anbieters für Verschlüsselungsdaten (CMP, Cryptographic Materials Provider)](crypto-materials-providers.md), den Sie ausgewählt haben.
Dieses Beispiel verwendet den [Direct KMS Provider](direct-kms-provider.md), Sie können aber jeden beliebigen kompatiblen CMP verwenden. Um einen Direct KMS-Anbieter zu erstellen, geben Sie einen an. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) In diesem Beispiel wird der Amazon-Ressourcenname (ARN) von verwendet AWS KMS key, Sie können jedoch jeden gültigen Schlüsselbezeichner verwenden.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Schritt 3: Erstellen Sie das Attribut-Aktionen-Objekt
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll. Das `AttributeActions`-Objekt in diesem Beispiel verschlüsselt und signiert alle Elemente außer dem Attribut `test`, das ignoriert wird.
Geben Sie keine Attribut-Aktionen für die Primärschlüsselattribute an, wenn Sie eine Client-Helferklasse verwenden. Die `EncryptedTable`-Klassen signiert die Primärschlüsselattribute, verschlüsselt sie aber nie.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Schritt 4: Erstellen Sie die verschlüsselte Tabelle
Legen Sie die verschlüsselte Tabelle mit der Standardtabelle, dem Direct KMS Provider und den Attribut-Aktionen an. Dieser Schritt schließt die Konfiguration ab.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Schritt 5: Legen Sie das Klartext-Element in der Tabelle ab
Wenn Sie die `put_item` Methode für aufrufen`encrypted_table`, werden Ihre Tabellenelemente transparent verschlüsselt, signiert und zu Ihrer DynamoDB-Tabelle hinzugefügt.
Definieren Sie zunächst das Tabellenelement.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Anschließend legen Sie es in der Tabelle ab.
```
encrypted_table.put_item(Item=plaintext_item)
```
Um das Element in verschlüsselter Form aus der DynamoDB-Tabelle abzurufen, rufen Sie die `get_item` Methode für das Objekt auf. `table` Um das verschlüsselte Element abzurufen, rufen Sie die Methode `get_item` für das Objekt `encrypted_table` auf.
## Verwendung des Elementverschlüsslers
Dieses Beispiel zeigt Ihnen, wie Sie beim [Verschlüsseln von Tabellenelementen direkt mit dem Elementverschlüsseler](DDBEC-legacy-concepts.md#item-encryptor) im DynamoDB Encryption Client interagieren können, anstatt die [Client-Hilfsklassen](python-using.md#python-helpers) zu verwenden, die für Sie mit dem Elementverschlüsseler interagieren.
Wenn Sie diese Technik verwenden, erstellen Sie den DynamoDB-Verschlüsselungskontext und das Konfigurationsobjekt (`CryptoConfig`) manuell. Außerdem verschlüsseln Sie die Elemente in einem Aufruf und fügen sie in einem separaten Aufruf in Ihre DynamoDB-Tabelle ein. Auf diese Weise können Sie Ihre `put_item` Aufrufe anpassen und den DynamoDB Encryption Client verwenden, um strukturierte Daten zu verschlüsseln und zu signieren, die niemals an DynamoDB gesendet werden.
Dieses Beispiel verwendet den [Direct KMS Provider](direct-kms-provider.md), Sie können aber jeden beliebigen kompatiblen CMP verwenden.
**Das vollständige Codebeispiel finden Sie unter**: [aws\$1kms\$1encrypted\$1item.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
Schritt 1: Erstellen der Tabelle
Erstellen Sie zunächst eine Instanz einer standardmäßigen DynamoDB-Tabellenressource mit dem Tabellennamen.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Schritt 2: Erstellen Sie einen Anbieter für Verschlüsselungsdaten
Erstellen Sie eine Instance des [Anbieters für Verschlüsselungsdaten (CMP, Cryptographic Materials Provider)](crypto-materials-providers.md), den Sie ausgewählt haben.
Dieses Beispiel verwendet den [Direct KMS Provider](direct-kms-provider.md), Sie können aber jeden beliebigen kompatiblen CMP verwenden. Um einen Direct KMS-Anbieter zu erstellen, geben Sie einen an. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) In diesem Beispiel wird der Amazon-Ressourcenname (ARN) von verwendet AWS KMS key, Sie können jedoch jeden gültigen Schlüsselbezeichner verwenden.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Schritt 3: Verwenden Sie die TableInfo Helper-Klasse
Um Informationen über die Tabelle von DynamoDB zu erhalten, erstellen Sie eine Instanz der [TableInfo](python-using.md#python-helpers)Hilfsklasse. Wenn Sie direkt mit dem Elementverschlüssler arbeiten, müssen Sie eine `TableInfo`-Instance erstellen und deren Methoden aufrufen. Dies erledigt die [Client-Helferklasse](python-using.md#python-helpers) für Sie.
Die `refresh_indexed_attributes` Methode von `TableInfo` verwendet den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang, um in Echtzeit genaue Informationen über die Tabelle abzurufen. Dazu gehören ihre Primärschlüssel und ihre lokalen und globalen Sekundärindizes. Der Aufrufer benötigt die Berechtigung, `DescribeTable` aufzurufen.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Schritt 4: DynamoDB-Verschlüsselungskontext erstellen
Der [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) enthält Informationen über die Tabellenstruktur und wie sie verschlüsselt und signiert ist. In diesem Beispiel wird explizit ein DynamoDB-Verschlüsselungskontext erstellt, da er mit dem Elementverschlüsseler interagiert. Die [Client-Hilfsklassen](python-using.md#python-helpers) erstellen den DynamoDB-Verschlüsselungskontext für Sie.
Um den Partitionsschlüssel und den Sortierschlüssel abzurufen, können Sie die Eigenschaften der [TableInfo](python-using.md#python-helpers)Hilfsklasse verwenden.
```
index_key = {
'partition_attribute': 'value1',
'sort_attribute': 55
}
encryption_context = EncryptionContext(
table_name=table_name,
partition_key_name=table_info.primary_index.partition,
sort_key_name=table_info.primary_index.sort,
attributes=dict_to_ddb(index_key)
)
```
Schritt 5: Erstellen Sie das Attribut-Aktionen-Objekt
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll. Das `AttributeActions`-Objekt in diesem Beispiel verschlüsselt und signiert alle Elemente mit Ausnahme der Primärschlüsselattribute, die signiert, aber nicht verschlüsselt sind, und des Attributs `test`, das ignoriert wird.
Wenn Sie direkt mit dem Elementverschlüsseler interagieren und Ihre Standardaktion `ENCRYPT_AND_SIGN` ist, müssen Sie eine alternative Aktion für den Primärschlüssel angeben. Sie können die `set_index_keys`-Methode verwenden, die `SIGN_ONLY` für den Primärschlüssel verwendet, oder `DO_NOTHING`, wenn es die Standardaktion ist.
Um den Primärschlüssel anzugeben, verwendet dieses Beispiel die Indexschlüssel im [TableInfo](python-using.md#python-helpers)Objekt, das durch einen Aufruf von DynamoDB aufgefüllt wird. Diese Technik ist sicherer als die Verwendung fest codierter Primärschlüsselnamen.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Schritt 6: Erstellen Sie die Konfiguration für das Element
Um den DynamoDB Encryption Client zu konfigurieren, verwenden Sie die Objekte, die Sie gerade in einer [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)Konfiguration für das Tabellenelement erstellt haben. Die Client-Hilfsklassen erstellen das CryptoConfig für Sie.
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Schritt 7: Verschlüsseln Sie das Element
Dieser Schritt verschlüsselt und signiert das Element, fügt es jedoch nicht in die DynamoDB-Tabelle ein.
Wenn Sie eine Client-Hilfsklasse verwenden, werden Ihre Elemente transparent verschlüsselt und signiert und dann zu Ihrer DynamoDB-Tabelle hinzugefügt, wenn Sie die `put_item` Methode der Hilfsklasse aufrufen. Wenn Sie den Elementverschlüsseler direkt verwenden, sind die Verschlüsselungs- und Put-Aktionen voneinander unabhängig.
Erstellen Sie zunächst ein Klartext-Element.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Anschließend verschlüsseln und signieren Sie es. Für die `encrypt_python_item`-Methode ist das `CryptoConfig`-Konfigurationsobjekt erforderlich.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Schritt 8: Legen Sie das Element in der Tabelle ab
In diesem Schritt wird das verschlüsselte und signierte Element in die DynamoDB-Tabelle eingefügt.
```
table.put_item(Item=encrypted_item)
```
Um das verschlüsselte Element anzuzeigen, rufen Sie die `get_item`-Methode für das ursprünglichen `table`-Objekt statt für das `encrypted_table`-Objekt auf. Sie ruft das Element aus der DynamoDB-Tabelle ab, ohne es zu verifizieren und zu entschlüsseln.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
Das folgende Bild zeigt einen Teil eines verschlüsselten und signierten Beispiel-Tabellenelements.
Die verschlüsselten Attributwerte sind Binärdaten. Die Namen und Werte der Primärschlüsselattribute (`partition_attribute` und `sort_attribute`) und das `test`-Attribut verbleiben im Klartext. Die Ausgabe zeigt auch das Attribut, das die Signatur (`*amzn-ddb-map-sig*`) und das [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`) enthält.
![\[Auszug aus einem verschlüsselten und signierten Element\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)