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 Java
**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 Java afin de protéger les éléments de table 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-java/tree/master/examples) du [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/)référentiel sur GitHub.
**Topics**
+ [Utilisation de la Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Utilisation de la Dynamo DBMapper](#java-example-dynamodb-mapper)
## Utilisation de la Dynamo DBEncryptor
Cet exemple montre comment utiliser le [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) de niveau inférieur DBEncryptor avec le fournisseur [Direct KMS](direct-kms-provider.md). Le fournisseur Direct KMS génère et protège son matériel cryptographique sous un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) que vous spécifiez.
Vous pouvez utiliser n'importe quel [fournisseur de matériel cryptographique](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatible avec le`DynamoDBEncryptor`, et vous pouvez utiliser le fournisseur Direct KMS avec le `DynamoDBMapper` et. [AttributeEncryptor](java-using.md#attribute-encryptor)
**Voir l'exemple de code complet** : [AwsKmsEncryptedItem.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
Étape 1 : Créer le fournisseur KMS direct
Créez une instance du AWS KMS client avec la région spécifiée. Utilisez ensuite l'instance client pour créer une instance du fournisseur Direct KMS selon vos préférences AWS KMS key.
Cet exemple utilise l'Amazon Resource Name (ARN) pour identifier le AWS KMS key, mais vous pouvez utiliser [n'importe quel identifiant de clé valide](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn).
```
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);
```
Étape 2 : Créer un élément
Cet exemple définit un `record` HashMap qui représente un exemple d'élément de table.
```
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"));
```
Étape 3 : Création d'une dynamo DBEncryptor
Créez une instance de `DynamoDBEncryptor` avec le fournisseur KMS direct.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Étape 4 : Création d'un 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. Si vous utilisez `DynamoDBMapper`, `AttributeEncryptor` crée automatiquement le contexte de chiffrement.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Étape 5 : Créer l'objet actions d'attribut
Les [actions d'attribut](DDBEC-legacy-concepts.md#legacy-attribute-actions) déterminent quels attributs de l'élément sont chiffrés et signés, lesquels sont uniquement signés et lesquels ne sont ni chiffrés ni signés.
En Java, pour spécifier des actions d'attribut, vous créez des paires HashMap de nom d'attribut et de `EncryptionFlags` valeur.
Par exemple, le code Java suivant crée un `actions` HashMap qui chiffre et signe tous les attributs de l'`record`élément, à l'exception des attributs de clé de partition et de clé de tri, qui sont signés, mais non chiffrés, et de l'`test`attribut, qui n'est ni signé ni chiffré.
```
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;
}
}
```
Étape 6 : Chiffrer et signer l'élément
Pour chiffrer et signer l'élément de table, appelez la méthode `encryptRecord` sur l'instance de `DynamoDBEncryptor`. Spécifiez l'élément de table (`record`), les actions d'attribut (`actions`) et le contexte de chiffrement (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Étape 7 : Placer l'élément dans la table DynamoDB
Enfin, placez l'élément chiffré et signé dans la table DynamoDB.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Utilisation de la Dynamo DBMapper
[L'exemple suivant montre comment utiliser la classe d'assistance du mappeur DynamoDB avec le fournisseur Direct KMS.](direct-kms-provider.md) Le fournisseur Direct KMS génère et protège son matériel cryptographique sous un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) que vous spécifiez.
Vous pouvez utiliser tout [fournisseur CMP](DDBEC-legacy-concepts.md#concept-material-provider) compatible avec `DynamoDBMapper`, et vous pouvez utiliser le fournisseur KMS direct avec le `DynamoDBEncryptor` de bas niveau.
**Voir l'exemple de code complet** : [AwsKmsEncryptedObject.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)
Étape 1 : Créer le fournisseur KMS direct
Créez une instance du AWS KMS client avec la région spécifiée. Utilisez ensuite l'instance client pour créer une instance du fournisseur Direct KMS selon vos préférences AWS KMS key.
Cet exemple utilise l'Amazon Resource Name (ARN) pour identifier le AWS KMS key, mais vous pouvez utiliser [n'importe quel identifiant de clé valide](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id).
```
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);
```
Étape 2 : Création du chiffreur DynamoDB et de Dynamo DBMapper
Utilisez le fournisseur Direct KMS que vous avez créé à l'étape précédente pour créer une instance de [DynamoDB Encryptor](java-using.md#attribute-encryptor). Vous devez instancier le chiffreur DynamoDB de niveau inférieur pour utiliser le mappeur DynamoDB.
Créez ensuite une instance de votre base de données DynamoDB et une configuration de mappeur, puis utilisez-les pour créer une instance du mappeur DynamoDB.
Lorsque vous utilisez `DynamoDBMapper` pour ajouter ou modifier des éléments signés (ou chiffrés et signés), configurez-le pour qu'il [utilise un comportement d'enregistrement](java-using.md#save-behavior), par exemple `PUT`, qui inclut tous les attributs, comme illustré dans l'exemple suivant. Sinon, il est possible que vous ne puissiez pas déchiffrer vos données.
```
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));
```
Étape 3 : définition de votre table DynamoDB
Définissez ensuite votre table DynamoDB. Utilisez des annotations pour spécifier les [actions d'attribut](java-using.md#attribute-actions-java). Cet exemple crée une table DynamoDB et une classe qui `ExampleTable` représente les éléments `DataPoJo` de la table.
Dans cet exemple de table, les attributs de la clé primaire seront signés, mais pas chiffrés. Cela s'applique à l'attribut `partition_attribute`, qui est annoté avec `@DynamoDBHashKey`, et l'attribut `sort_attribute`, qui est annoté avec `@DynamoDBRangeKey`.
Les attributs qui sont annotés avec `@DynamoDBAttribute`, par exemple `some numbers`, seront chiffrés et signés. Les exceptions sont les attributs qui utilisent les annotations de chiffrement `@DoNotEncrypt` (signer uniquement) ou `@DoNotTouch` (ne pas chiffrer ni signer) définies par le client de chiffrement DynamoDB. Par exemple, étant donné que l'attribut `leave me` comporte une annotation `@DoNotTouch`, il ne sera ni chiffré ni signé.
```
@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 + "]";
}
}
```
Étape 4 : Chiffrer et enregistrer un élément de table
Désormais, lorsque vous créez un élément de table et que vous utilisez le mappeur DynamoDB pour l'enregistrer, l'élément est automatiquement chiffré et signé avant d'être ajouté à la table.
Cet exemple définit un élément de table appelé `record`. Avant qu'il soit enregistré dans la table, ses attributs sont chiffrées et signés selon les annotations de la classe `DataPoJo`. Dans le cas présent, tous les attributs à l'exception de `PartitionAttribute`, `SortAttribute` et `LeaveMe` sont chiffrés et signés. `PartitionAttribute` et `SortAttributes` sont seulement signés. L'attribut `LeaveMe` n'est ni chiffré ni signé.
Pour chiffrer et signer l'élément `record`, puis l'ajouter à `ExampleTable`, appelez la méthode `save` de la classe `DynamoDBMapper`. Votre mappeur DynamoDB étant configuré pour utiliser `PUT` le comportement d'enregistrement, l'élément remplace tout élément possédant les mêmes clés primaires, au lieu de le mettre à jour. Cela garantit que les signatures correspondent et que vous pouvez déchiffrer l'élément lorsque vous le récupérez de la table.
```
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);
```