Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# DynamoDB-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)