Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemple de code pour le client de chiffrement DynamoDB pour Python
**Note**
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). La rubrique suivante fournit des informations sur les versions 1. *x* —2. *x* du client de chiffrement DynamoDB pour Java et versions 1. *x* —3. *x* du client de chiffrement DynamoDB pour Python. Pour plus d'informations, consultez la section [SDK AWS de chiffrement de base de données pour la prise en charge des versions DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Les exemples suivants montrent comment utiliser le client de chiffrement DynamoDB pour Python afin de protéger les données DynamoDB dans votre application. Vous pouvez trouver d'autres exemples (et apporter les vôtres) dans le répertoire des [exemples](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) du [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)référentiel sur GitHub.
**Topics**
+ [Utiliser la classe d'assistance EncryptedTable client](#python-example-table)
+ [Utilisation du chiffreur d'élément](#python-example-item-encryptor)
## Utiliser la classe d'assistance EncryptedTable client
L'exemple suivant montre comment utiliser le [fournisseur KMS direct](direct-kms-provider.md) avec la `EncryptedTable` [classe d'annotations cliente](python-using.md#python-helpers). Cet exemple utilise le même [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) que l'exemple [Utilisation du chiffreur d'élément](#python-example-item-encryptor) qui suit. Cependant, il utilise la classe `EncryptedTable` au lieu d'interagir directement avec le [chiffreur d'élément](DDBEC-legacy-concepts.md#item-encryptor) de bas niveau.
En comparant ces exemples, vous pouvez voir le travail que la classe d'annotations cliente effectue à votre place. Cela implique de créer le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) et de s'assurer que les attributs de clé primaire sont toujours signés, mais jamais chiffrés. Pour créer le contexte de chiffrement et découvrir la clé primaire, les classes d'assistance client appellent l'opération DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Pour exécuter ce code, vous devez avoir l'autorisation d'appeler cette opération.
**Consultez l'exemple de code complet** : [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)
Étape 1 : Créer la table
Commencez par créer une instance d'une table DynamoDB standard avec le nom de la table.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Étape 2 : Créer un fournisseur CMP
Créez une instance du [fournisseur CMP](crypto-materials-providers.md) que vous avez sélectionné.
Cet exemple utilise le [fournisseur KMS direct](direct-kms-provider.md), mais vous pouvez utiliser n'importe quel fournisseur CMP compatible. Pour créer un fournisseur KMS direct, spécifiez un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys). Cet exemple utilise le Amazon Resource Name (ARN) du AWS KMS key, mais vous pouvez utiliser n'importe quel identifiant de clé valide.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Étape 3 : Créer l'objet actions d'attribut
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) informent le chiffreur d'élément des actions à exécuter sur chaque attribut de l'élément. L'objet `AttributeActions` de l'exemple chiffre et signe tous les éléments à l'exception de l'attribut `test`, qui est ignoré.
Ne spécifiez pas d'actions d'attribut pour les attributs de clé primaire quand vous utilisez une classe d'annotations cliente. La classe `EncryptedTable` signe, mais ne chiffre jamais, les attributs de clé primaire.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Étape 4 : Créer la table chiffrée
Créez la table chiffrée à l'aide de la table standard, du fournisseur KMS direct et des actions d'attribut. Cette étape termine la configuration.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Étape 5 : Placer l'élément en texte brut dans la table
Lorsque vous appelez la `put_item` méthode sur le`encrypted_table`, les éléments de votre table sont chiffrés, signés et ajoutés de manière transparente à votre table DynamoDB.
Tout d'abord, définissez l'élément de table.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Puis, insérez-le dans la table.
```
encrypted_table.put_item(Item=plaintext_item)
```
Pour obtenir l'élément de la table DynamoDB sous sa forme cryptée, appelez `get_item` la méthode sur l'objet. `table` Pour obtenir l'élément chiffré, appelez la méthode `get_item` sur l'objet `encrypted_table`.
## Utilisation du chiffreur d'élément
Cet exemple montre comment interagir directement avec le chiffreur d'[éléments dans le client de chiffrement DynamoDB lors du chiffrement d'éléments de table, au lieu d'utiliser les classes d'[assistance du client qui interagissent avec le](python-using.md#python-helpers) crypteur](DDBEC-legacy-concepts.md#item-encryptor) d'éléments à votre place.
Lorsque vous utilisez cette technique, vous créez le contexte de chiffrement DynamoDB et l'objet `CryptoConfig` de configuration () manuellement. Vous cryptez également les éléments lors d'un appel et vous les placez dans votre table DynamoDB lors d'un appel distinct. Cela vous permet de personnaliser vos `put_item` appels et d'utiliser le client de chiffrement DynamoDB pour chiffrer et signer les données structurées qui ne sont jamais envoyées à DynamoDB.
Cet exemple utilise le [fournisseur KMS direct](direct-kms-provider.md), mais vous pouvez utiliser n'importe quel fournisseur CMP compatible.
**Voir l'exemple de code complet** : [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)
Étape 1 : Créer la table
Commencez par créer une instance d'une ressource de table DynamoDB standard avec le nom de la table.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Étape 2 : Créer un fournisseur CMP
Créez une instance du [fournisseur CMP](crypto-materials-providers.md) que vous avez sélectionné.
Cet exemple utilise le [fournisseur KMS direct](direct-kms-provider.md), mais vous pouvez utiliser n'importe quel fournisseur CMP compatible. Pour créer un fournisseur KMS direct, spécifiez un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys). Cet exemple utilise le Amazon Resource Name (ARN) du AWS KMS key, mais vous pouvez utiliser n'importe quel identifiant de clé valide.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Étape 3 : Utiliser la classe TableInfo d'assistance
Pour obtenir des informations sur la table à partir de DynamoDB, créez une instance de [TableInfo](python-using.md#python-helpers)la classe d'assistance. Lorsque vous travaillez directement avec le chiffreur d'élément, vous devez créer une instance `TableInfo` et appeler ses méthodes. Les [classes d'annotation clientes](python-using.md#python-helpers) le font pour vous.
La `refresh_indexed_attributes` méthode `TableInfo` utilise l'opération [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB pour obtenir des informations précises et en temps réel sur la table. Elles incluent la clé primaire et ses index secondaires locaux et globaux. L'appelant doit avoir l'autorisation d'appeler `DescribeTable`.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Étape 4 : Création du contexte de chiffrement DynamoDB
Le contexte de [chiffrement DynamoDB](concepts.md#encryption-context) contient des informations sur la structure de la table et sur la manière dont elle est chiffrée et signée. Cet exemple crée un contexte de chiffrement DynamoDB de manière explicite, car il interagit avec le chiffreur d'éléments. Les [classes d'assistance client](python-using.md#python-helpers) créent le contexte de chiffrement DynamoDB pour vous.
Pour obtenir la clé de partition et la clé de tri, vous pouvez utiliser les propriétés de la classe d'[TableInfo](python-using.md#python-helpers)assistance.
```
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)
)
```
Étape 5 : Créer l'objet actions d'attribut
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) informent le chiffreur d'élément des actions à exécuter sur chaque attribut de l'élément. L'objet `AttributeActions` de l'exemple chiffre et signe tous les éléments à l'exception des attributs de clé primaire, qui sont signés, mais pas chiffrés, et de l'attribut `test`, qui est ignoré.
Lorsque vous interagissez directement avec le chiffreur d'élément et que votre action par défaut est `ENCRYPT_AND_SIGN`, vous devez spécifier une autre action pour la clé primaire. Vous pouvez utiliser la méthode `set_index_keys`, qui utilise `SIGN_ONLY` pour la clé primaire, ou `DO_NOTHING` s'il s'agit de l'action par défaut.
Pour spécifier la clé primaire, cet exemple utilise les clés d'index de l'[TableInfo](python-using.md#python-helpers)objet, qui sont renseignées par un appel à DynamoDB. Cette technique est plus sûre que le codage en dur des noms de clé primaire.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Étape 6 : Créer la configuration pour l'élément
Pour configurer le client de chiffrement DynamoDB, utilisez les objets que vous venez de créer dans [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)une configuration pour l'élément de table. Les classes d'assistance client créent le CryptoConfig pour vous.
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Étape 7 : Chiffrer l'élément
Cette étape chiffre et signe l'élément, mais ne le place pas dans la table DynamoDB.
Lorsque vous utilisez une classe d'assistance client, vos éléments sont chiffrés et signés de manière transparente, puis ajoutés à votre table DynamoDB lorsque vous appelez la méthode de la `put_item` classe d'assistance. Lorsque vous utilisez le chiffreur d'élément directement, les actions de chiffrage et de placement sont indépendantes.
Tout d'abord, créez un élément en texte brut.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Puis, chiffrez-le et signez-le. La méthode `encrypt_python_item` requiert l'objet de configuration `CryptoConfig`.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Étape 8 : Placer l'élément dans la table
Cette étape place l'élément chiffré et signé dans la table DynamoDB.
```
table.put_item(Item=encrypted_item)
```
Pour afficher l'élément chiffré, appelez la méthode `get_item` sur l'objet original `table`, et non sur l'objet `encrypted_table`. Elle obtient l'élément de la table DynamoDB sans le vérifier et le déchiffrer.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
L'illustration suivante présente une partie d'un exemple d'élément de table chiffré et signé.
Les valeurs des attributs chiffrés sont des données binaires. Les noms et valeurs des attributs de clé primaire (`partition_attribute` et `sort_attribute`) et l'attribut `test` demeurent en texte brut. La sortie affiche aussi l'attribut qui contient la signature (`*amzn-ddb-map-sig*`) et l'[attribut de description des matériaux](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`).
![\[Extrait d'un élément de table chiffré et signé\]](http://docs.aws.amazon.com/fr_fr/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)