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.
# Java
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Cette rubrique explique comment installer et utiliser la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB. Pour plus de détails sur la programmation avec le SDK AWS de chiffrement de base de données pour DynamoDB, consultez les exemples [Java dans aws-database-encryption-sdk le référentiel -dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) sur. GitHub
**Note**
Les rubriques suivantes portent sur la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
Notre bibliothèque de chiffrement côté client a été [renommée AWS Database Encryption SDK](DDBEC-rename.md). Le SDK AWS Database Encryption continue de prendre en charge les [anciennes versions du client de chiffrement DynamoDB](legacy-dynamodb-encryption-client.md).
**Topics**
+ [Conditions préalables](#ddb-java-prerequisites)
+ [Installation](#ddb-java-installation)
+ [Utilisation du client Java](ddb-java-using.md)
+ [Exemples Java](ddb-java-examples.md)
+ [Ajouter la version 3.x à une table existante](ddb-java-config-existing-table.md)
+ [Migrer vers la version 3.x](ddb-java-migrate.md)
## Conditions préalables
Avant d'installer la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB, assurez-vous de remplir les conditions préalables suivantes.
**Environnement de développement Java**
Vous aurez besoin de Java 8 ou version ultérieure. Sur le site web d'Oracle, consultez la page [Téléchargements Java SE](https://www.oracle.com/java/technologies/downloads/), puis téléchargez et installez le kit Java SE Development (JDK).
Si vous utilisez le kit JDK Oracle, vous devez également télécharger et installer les [fichiers Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK for Java 2.x**
Le SDK AWS de chiffrement de base de données pour DynamoDB nécessite [le module DynamoDB Enhanced Client du](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). AWS SDK for Java 2.x Vous pouvez installer la totalité du kit SDK ou le seul module.
Pour plus d'informations sur la mise à jour de votre version du AWS SDK pour Java, voir [Migration de la version 1.x vers la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) du. AWS SDK pour Java
AWS SDK pour Java Il est disponible via Apache Maven. Vous pouvez déclarer une dépendance pour l'ensemble AWS SDK pour Java ou uniquement pour le `dynamodb-enhanced` module.
**Installez le à l' AWS SDK pour Java aide d'Apache Maven**
+ Pour [importer tout le AWS SDK pour Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) en tant que dépendance, déclarez-le dans votre fichier `pom.xml`.
+ Pour créer une dépendance uniquement pour le module Amazon DynamoDB dans AWS SDK pour Java le, suivez les instructions [pour](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) spécifier des modules particuliers. Réglez le `groupId` to `software.amazon.awssdk` et le `artifactID` to`dynamodb-enhanced`.
**Note**
Si vous utilisez le AWS KMS trousseau de clés ou le trousseau de clés AWS KMS hiérarchique, vous devez également créer une dépendance pour le AWS KMS module. Réglez le `groupId` to `software.amazon.awssdk` et le `artifactID` to`kms`.
## Installation
Vous pouvez installer la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB de la manière suivante.
**Utilisation d'Apache Maven**
Le client de chiffrement Amazon DynamoDB pour Java est disponible [via Apache](https://maven.apache.org/) Maven avec la définition de dépendance suivante.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Utilisation de Gradle Kotlin**
Vous pouvez utiliser [Gradle](https://gradle.org/) pour déclarer une dépendance vis-à-vis du client de chiffrement Amazon DynamoDB pour Java en ajoutant ce qui suit *à* la section des dépendances de votre projet Gradle.
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Manuellement**
[Pour installer la bibliothèque de chiffrement côté client Java pour DynamoDB, clonez ou téléchargez le référentiel -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Après avoir installé le SDK, commencez par consulter l'exemple de code de ce guide et les [exemples Java du référentiel](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk -dynamodb sur. GitHub
# Utilisation de la bibliothèque de chiffrement côté client Java pour DynamoDB
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Cette rubrique décrit certaines des fonctions et classes d'assistance de la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
[Pour plus de détails sur la programmation avec la bibliothèque de chiffrement côté client Java pour DynamoDB, consultez les exemples Java, les [exemples Java](java-examples.md) dans le référentiel -dynamodb sur.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk GitHub
**Topics**
+ [Chiffreurs d'éléments](#ddb-item-encryptors)
+ [Actions d'attribut](#ddb-attribute-actions)
+ [Configuration du chiffrement](#ddb-config-encrypt)
+ [Mettre à jour des éléments](#ddb-update-items)
+ [Déchiffrer des sets signés](#ddb-java-signed-sets)
## Chiffreurs d'éléments
À la base, le SDK de chiffrement AWS de base de données pour DynamoDB est un outil de chiffrement d'éléments. Vous pouvez utiliser la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB afin de chiffrer, signer, vérifier et déchiffrer les éléments de votre table DynamoDB de la manière suivante.
**Le client amélioré DynamoDB**
Vous pouvez configurer le client [DynamoDB amélioré](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) pour chiffrer et signer automatiquement `DynamoDbEncryptionInterceptor` les éléments côté client avec vos demandes DynamoDB. `PutItem` Avec le client DynamoDB Enhanced, vous pouvez définir vos actions attributaires à l'aide d'[une](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) classe de données annotée. Nous vous recommandons d'utiliser le client DynamoDB amélioré dans la mesure du possible.
[Le client DynamoDB Enhanced ne prend pas en charge le chiffrement consultable.](searchable-encryption.md)
Le SDK AWS de chiffrement de base de données ne prend pas en charge les annotations sur les attributs [imbriqués](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
**L'API DynamoDB de bas niveau**
Vous pouvez configurer l'API [DynamoDB de bas niveau](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) pour chiffrer et signer automatiquement `DynamoDbEncryptionInterceptor` les éléments côté client avec vos demandes DynamoDB. `PutItem`
[Vous devez utiliser l'API DynamoDB de bas niveau pour utiliser le chiffrement consultable.](searchable-encryption.md)
**Le niveau inférieur `DynamoDbItemEncryptor`**
Le niveau inférieur chiffre, signe ou déchiffre et vérifie `DynamoDbItemEncryptor` directement les éléments de votre table sans appeler DynamoDB. Il n'émet pas de DynamoDB ni de `PutItem` requêtes`GetItem`. Par exemple, vous pouvez utiliser le niveau inférieur `DynamoDbItemEncryptor` pour déchiffrer et vérifier directement un élément DynamoDB que vous avez déjà récupéré.
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md).
## Actions relatives aux attributs dans le SDK de chiffrement AWS de base de données pour DynamoDB
Les [actions d'](concepts.md#crypt-actions)attribut déterminent quelles valeurs d'attribut sont cryptées et signées, lesquelles sont uniquement signées, lesquelles sont signées et incluses dans le contexte de chiffrement, et lesquelles sont ignorées.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Si vous utilisez l'API DynamoDB de bas niveau ou de `DynamoDbItemEncryptor` niveau inférieur, vous devez définir manuellement vos actions attributaires. [Si vous utilisez le client DynamoDB amélioré, vous pouvez soit définir manuellement vos actions attributaires, soit utiliser une classe de données annotée pour générer un. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Pour simplifier le processus de configuration, nous vous recommandons d'utiliser une classe de données annotée. Lorsque vous utilisez une classe de données annotée, vous ne devez modéliser votre objet qu'une seule fois.
**Note**
Après avoir défini les actions relatives aux attributs, vous devez définir quels attributs sont exclus des signatures. Pour faciliter l'ajout de nouveaux attributs non signés à l'avenir, nous vous recommandons de choisir un préfixe distinct (tel que `:` « ») pour identifier vos attributs non signés. Incluez ce préfixe dans le nom d'attribut pour tous les attributs marqués lorsque vous `DO_NOTHING` définissez votre schéma DynamoDB et vos actions d'attribut.
### Utiliser une classe de données annotée
Utilisez une [classe de données annotée](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) pour spécifier vos actions attributaires avec le client DynamoDB amélioré et. `DynamoDbEncryptionInterceptor` Le SDK AWS de chiffrement de base de données pour DynamoDB utilise les annotations d'attribut [DynamoDB standard qui définissent le type d'attribut](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) afin de déterminer comment protéger un attribut. Par défaut, tous les attributs sont chiffrés et signés à l'exception des clés primaires, qui sont signées, mais pas chiffrées.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Consultez [SimpleClass.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) dans le référentiel aws-database-encryption-sdk -dynamodb GitHub pour plus d'informations sur les annotations du client DynamoDB Enhanced.
Par défaut, les attributs de clé primaire sont signés mais pas chiffrés (`SIGN_ONLY`) et tous les autres attributs sont chiffrés et signés (`ENCRYPT_AND_SIGN`). Si vous définissez des attributs comme`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Pour spécifier des exceptions, utilisez les annotations de chiffrement définies dans la bibliothèque de chiffrement côté client Java pour DynamoDB. Par exemple, si vous souhaitez qu'un attribut particulier soit uniquement signé, utilisez l'`@DynamoDbEncryptionSignOnly`annotation. Si vous souhaitez qu'un attribut particulier soit signé et inclus dans le contexte de chiffrement, utilisez le`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Si vous souhaitez qu'un attribut particulier ne soit ni signé ni chiffré (`DO_NOTHING`), utilisez l'`@DynamoDbEncryptionDoNothing`annotation.
**Note**
Le SDK AWS de chiffrement de base de données ne prend pas en charge les annotations sur les attributs [imbriqués](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
L'exemple suivant montre les annotations utilisées pour définir `ENCRYPT_AND_SIGN` et `DO_NOTHING` attribuer des actions. `SIGN_ONLY` Pour un exemple illustrant les annotations utilisées pour définir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consultez le [SimpleClassfichier 4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
```
@DynamoDbBean
public class SimpleClass {
private String partitionKey;
private int sortKey;
private String attribute1;
private String attribute2;
private String attribute3;
@DynamoDbPartitionKey
@DynamoDbAttribute(value = "partition_key")
public String getPartitionKey() {
return this.partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
@DynamoDbSortKey
@DynamoDbAttribute(value = "sort_key")
public int getSortKey() {
return this.sortKey;
}
public void setSortKey(int sortKey) {
this.sortKey = sortKey;
}
public String getAttribute1() {
return this.attribute1;
}
public void setAttribute1(String attribute1) {
this.attribute1 = attribute1;
}
@DynamoDbEncryptionSignOnly
public String getAttribute2() {
return this.attribute2;
}
public void setAttribute2(String attribute2) {
this.attribute2 = attribute2;
}
@DynamoDbEncryptionDoNothing
public String getAttribute3() {
return this.attribute3;
}
@DynamoDbAttribute(value = ":attribute3")
public void setAttribute3(String attribute3) {
this.attribute3 = attribute3;
}
}
```
Utilisez votre classe de données annotée pour créer le, `TableSchema` comme indiqué dans l'extrait de code suivant.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Définissez manuellement les actions de vos attributs
Pour spécifier manuellement les actions d'attribut, créez un `Map` objet dans lequel les paires nom-valeur représentent les noms d'attributs et les actions spécifiées.
Spécifiez `ENCRYPT_AND_SIGN` le chiffrement et la signature d'un attribut. Spécifiez `SIGN_ONLY` pour signer un attribut, mais pas pour le chiffrer. Spécifiez `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` de signer un attribut et de l'inclure dans le contexte de chiffrement. Vous ne pouvez pas chiffrer un attribut sans le signer également. Spécifiez `DO_NOTHING` si un attribut doit être ignoré.
Les attributs de partition et de tri doivent être l'un `SIGN_ONLY` ou l'autre`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous définissez des attributs comme`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Note**
Pour utiliser l'action `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` cryptographique, vous devez utiliser la version 3.3 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de [mettre à jour votre modèle de données](ddb-update-data-model.md) pour l'inclure`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be signed
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
// The sort attribute must be signed
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute3", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put(":attribute4", CryptoAction.DO_NOTHING);
```
## Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB
Lorsque vous utilisez le SDK AWS Database Encryption, vous devez définir explicitement une configuration de chiffrement pour votre table DynamoDB. Les valeurs requises dans votre configuration de chiffrement varient selon que vous avez défini vos actions attributaires manuellement ou à l'aide d'une classe de données annotée.
L'extrait suivant définit une configuration de chiffrement de table DynamoDB à l'aide du client DynamoDB amélioré et autorise les attributs non signés définis par un préfixe distinct [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html).
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
// Optional: only required if you use beacons
.search(SearchConfig.builder()
.writeVersion(1) // MUST be 1
.versions(beaconVersions)
.build())
.build());
```
**Nom de table logique**
Nom de table logique pour votre table DynamoDB.
Le nom de table logique est lié de manière cryptographique à toutes les données stockées dans la table afin de simplifier les opérations de restauration DynamoDB. Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Vous devez toujours spécifier le même nom de table logique. Pour que le déchiffrement réussisse, le nom de la table logique doit correspondre au nom spécifié lors du chiffrement. Si le nom de votre table DynamoDB change après la [restauration de votre table DynamoDB à partir d'une sauvegarde, le nom logique de la table garantit que l'opération de déchiffrement](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) reconnaît toujours la table.
**Attributs non signés autorisés**
Les attributs marqués `DO_NOTHING` dans vos actions d'attributs.
Les attributs non signés autorisés indiquent au client quels attributs sont exclus des signatures. Le client suppose que tous les autres attributs sont inclus dans la signature. Ensuite, lors du déchiffrement d'un enregistrement, le client détermine les attributs qu'il doit vérifier et ceux à ignorer parmi les attributs non signés autorisés que vous avez spécifiés. Vous ne pouvez pas supprimer un attribut de vos attributs non signés autorisés.
Vous pouvez définir explicitement les attributs non signés autorisés en créant un tableau répertoriant tous vos `DO_NOTHING` attributs. Vous pouvez également spécifier un préfixe distinct lorsque vous nommez vos `DO_NOTHING` attributs et utiliser le préfixe pour indiquer au client quels attributs ne sont pas signés. Nous vous recommandons vivement de spécifier un préfixe distinct, car cela simplifie le processus d'ajout d'un nouvel `DO_NOTHING` attribut à l'avenir. Pour de plus amples informations, veuillez consulter [Mettre à jour votre modèle de données](ddb-update-data-model.md).
Si vous ne spécifiez pas de préfixe pour tous les `DO_NOTHING` attributs, vous pouvez configurer un `allowedUnsignedAttributes` tableau répertoriant explicitement tous les attributs que le client doit s'attendre à voir non signés lorsqu'il les rencontre lors du déchiffrement. Vous ne devez définir explicitement vos attributs non signés autorisés que si cela est absolument nécessaire.
**Configuration de la recherche (facultatif)**
`SearchConfig`Définit la [version de la balise](using-beacons.md#beacon-version).
Le `SearchConfig` doit être spécifié pour utiliser un [chiffrement consultable](searchable-encryption.md) ou des [balises signées](configure.md#signed-beacons).
**Suite d'algorithmes (facultatif)**
`algorithmSuiteId`Définit la suite d'algorithmes utilisée par le SDK AWS de chiffrement de base de données.
À moins que vous ne spécifiiez explicitement une suite d'algorithmes alternative, le SDK AWS de chiffrement de base de données utilise la [suite d'algorithmes par défaut](supported-algorithms.md#recommended-algorithms). [La suite d'algorithmes par défaut utilise l'algorithme AES-GCM avec dérivation de clés, [signatures numériques et engagement](concepts.md#digital-sigs) de clés.](concepts.md#key-commitment) Bien que la suite d'algorithmes par défaut soit susceptible de convenir à la plupart des applications, vous pouvez choisir une autre suite d'algorithmes. Par exemple, certains modèles de confiance seraient satisfaits par une suite d'algorithmes sans signature numérique. Pour plus d'informations sur les suites d'algorithmes prises en charge par le SDK AWS de chiffrement de base de données, consultez[Suites d'algorithmes prises en charge dans le SDK AWS de chiffrement de base de données](supported-algorithms.md).
Pour sélectionner la [suite d'algorithmes AES-GCM sans signature numérique ECDSA](supported-algorithms.md#other-algorithms), incluez l'extrait suivant dans votre configuration de chiffrement de table.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Mise à jour d'éléments avec le SDK AWS de chiffrement de base de données
Le SDK AWS de chiffrement de base de données ne prend pas en charge [ddb : UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) pour les éléments chiffrés ou signés. Pour mettre à jour un élément chiffré ou signé, vous devez utiliser [ddb : PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Lorsque vous spécifiez la même clé primaire qu'un élément existant dans votre `PutItem` demande, le nouvel élément remplace complètement l'élément existant. Vous pouvez également utiliser [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) pour effacer et remplacer tous les attributs lors de la sauvegarde après avoir mis à jour vos articles.
## Déchiffrer des sets signés
Dans les versions 3.0.0 et 3.1.0 du SDK de chiffrement de AWS base de données, si vous définissez un attribut de [type set](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) comme`SIGN_ONLY`, les valeurs de l'ensemble sont canonisées dans l'ordre dans lequel elles sont fournies. DynamoDB ne préserve pas l'ordre des ensembles. Par conséquent, il est possible que la validation de signature de l'élément contenant l'ensemble échoue. La validation de signature échoue lorsque les valeurs de l'ensemble sont renvoyées dans un ordre différent de celui dans lequel elles ont été fournies au SDK AWS Database Encryption, même si les attributs de l'ensemble contiennent les mêmes valeurs.
**Note**
Les versions 3.1.1 et ultérieures du SDK de chiffrement de AWS base de données canonisent les valeurs de tous les attributs de type défini, afin que les valeurs soient lues dans le même ordre que celui dans lequel elles ont été écrites dans DynamoDB.
Si la validation de signature échoue, l'opération de déchiffrement échoue et renvoie le message d'erreur suivant.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Aucune étiquette de destinataire ne correspond. |
Si le message d'erreur ci-dessus s'affiche et que vous pensez que l'élément que vous essayez de déchiffrer inclut un ensemble signé à l'aide de la version 3.0.0 ou 3.1.0, consultez le [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)répertoire du dépôt aws-database-encryption-sdk -dynamodb-java GitHub pour savoir comment valider correctement l'ensemble.
# Exemples Java
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Les exemples suivants montrent comment utiliser la bibliothèque de chiffrement côté client Java pour DynamoDB afin de protéger les éléments de table de votre application. Vous pouvez trouver d'autres exemples (et apporter les vôtres) dans les [exemples Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) du référentiel aws-database-encryption-sdk -dynamodb sur. GitHub
Les exemples suivants montrent comment configurer la bibliothèque de chiffrement côté client Java pour DynamoDB dans une nouvelle table Amazon DynamoDB non remplie. Si vous souhaitez configurer vos tables Amazon DynamoDB existantes pour le chiffrement côté client, consultez. [Ajouter la version 3.x à une table existante](ddb-java-config-existing-table.md)
**Topics**
+ [Utilisation du client amélioré DynamoDB](#ddb-java-enhanced-client-example)
+ [Utilisation de l'API DynamoDB de bas niveau](#ddb-java-lowlevel-API-example)
+ [Utiliser le niveau inférieur DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Utilisation du client amélioré DynamoDB
L'exemple suivant montre comment utiliser le client amélioré DynamoDB `DynamoDbEncryptionInterceptor` et [AWS KMS un](use-kms-keyring.md) trousseau de clés pour chiffrer des éléments de table DynamoDB dans le cadre de vos appels d'API DynamoDB.
Vous pouvez utiliser n'importe quel trousseau de [clés](keyrings.md) compatible avec le client DynamoDB amélioré, mais nous vous recommandons d'utiliser l'un des trousseaux de clés dans la mesure du AWS KMS possible.
**Note**
[Le client DynamoDB Enhanced ne prend pas en charge le chiffrement consultable.](searchable-encryption.md) Utilisez le `DynamoDbEncryptionInterceptor` avec l'API DynamoDB de bas niveau pour utiliser le chiffrement consultable.
**Voir l'exemple de code complet** : [EnhancedPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : Création d'un schéma de table à partir de la classe de données annotée**
L'exemple suivant utilise la classe de données annotée pour créer le`TableSchema`.
Cet exemple suppose que les actions de classe de données et d'attribut annotées ont été définies à l'aide du [SimpleClassfichier .java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) Pour plus d'informations sur l'annotation des actions de vos attributs, consultez[Utiliser une classe de données annotée](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
Le SDK AWS de chiffrement de base de données ne prend pas en charge les annotations sur les attributs [imbriqués](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Étape 4 : Création de la configuration de chiffrement**
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement de la table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Pour utiliser le [chiffrement consultable](searchable-encryption.md) ou les [balises signées](configure.md#signed-beacons), vous devez également les inclure [`SearchConfig`](ddb-java-using.md#ddb-search-config)dans votre configuration de chiffrement.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Étape 5 : Crée le `DynamoDbEncryptionInterceptor`**
L'exemple suivant en crée un nouveau `DynamoDbEncryptionInterceptor` à `tableConfigs` partir de l'**étape 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Étape 6 : créer un nouveau client DynamoDB du AWS SDK**
**L'exemple suivant crée un nouveau client DynamoDB du AWS SDK à l'aide `interceptor` de l'étape 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Étape 7 : Création du client DynamoDB amélioré et création d'une table**
L'exemple suivant crée le client DynamoDB amélioré à l'aide du client DynamoDB AWS SDK créé à l'**étape 6 et crée une table à l'aide de la classe** de données annotée.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Étape 8 : Chiffrer et signer un élément du tableau**
L'exemple suivant place un élément dans la table DynamoDB à l'aide du client DynamoDB amélioré. L'élément est chiffré et signé côté client avant d'être envoyé à DynamoDB.
```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");
table.putItem(item);
```
## Utilisation de l'API DynamoDB de bas niveau
L'exemple suivant montre comment utiliser l'API DynamoDB de bas niveau avec [AWS KMS un](use-kms-keyring.md) trousseau de clés pour chiffrer et signer automatiquement des éléments côté client avec vos demandes DynamoDB. `PutItem`
Vous pouvez utiliser n'importe quel [porte-clés](keyrings.md) compatible, mais nous vous recommandons d'utiliser l'un des AWS KMS porte-clés dans la mesure du possible.
**Voir l'exemple de code complet** : [BasicPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : configurer les actions de vos attributs**
L'exemple suivant définit une `attributeActionsOnEncrypt` carte qui représente des exemples d'[actions attributaires](concepts.md#crypt-actions) pour un élément de table.
L'exemple suivant ne définit aucun attribut en tant que`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Étape 4 : définir la configuration du chiffrement des tables DynamoDB**
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement pour cette table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Pour utiliser le [chiffrement consultable](searchable-encryption.md) ou les [balises signées](configure.md#signed-beacons), vous devez également les inclure [`SearchConfig`](ddb-java-using.md#ddb-search-config)dans votre configuration de chiffrement.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
tableConfigs.put(ddbTableName, config);
```
**Étape 5 : Création du `DynamoDbEncryptionInterceptor`**
L'exemple suivant crée le `DynamoDbEncryptionInterceptor` à l'aide `tableConfigs` de l'**étape 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Étape 6 : créer un nouveau client DynamoDB du AWS SDK**
**L'exemple suivant crée un nouveau client DynamoDB du AWS SDK à l'aide `interceptor` de l'étape 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Étape 7 : Chiffrer et signer un élément de table DynamoDB**
L'exemple suivant définit une `item` carte qui représente un exemple d'élément de table et place l'élément dans la table DynamoDB. L'élément est chiffré et signé côté client avant d'être envoyé à DynamoDB.
```
final HashMap item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final PutItemRequest putRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(item)
.build();
final PutItemResponse putResponse = ddb.putItem(putRequest);
```
## Utiliser le niveau inférieur DynamoDbItemEncryptor
L'exemple suivant montre comment utiliser le niveau inférieur `DynamoDbItemEncryptor` avec un [AWS KMS trousseau de clés](use-kms-keyring.md) pour chiffrer et signer directement des éléments de table. L'élément `DynamoDbItemEncryptor` n'est pas placé dans votre table DynamoDB.
Vous pouvez utiliser n'importe quel trousseau de [clés](keyrings.md) compatible avec le client DynamoDB amélioré, mais nous vous recommandons d'utiliser l'un des trousseaux de clés dans la mesure du AWS KMS possible.
**Note**
Le niveau inférieur `DynamoDbItemEncryptor` ne prend pas en charge le chiffrement [consultable](searchable-encryption.md). Utilisez le `DynamoDbEncryptionInterceptor` avec l'API DynamoDB de bas niveau pour utiliser le chiffrement consultable.
**Voir l'exemple de code complet** : [ItemEncryptDecryptExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)
**Étape 1 : Création du AWS KMS porte-clés**
L'exemple suivant permet de `CreateAwsKmsMrkMultiKeyring` créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Étape 2 : configurer les actions de vos attributs**
L'exemple suivant définit une `attributeActionsOnEncrypt` carte qui représente des exemples d'[actions attributaires](concepts.md#crypt-actions) pour un élément de table.
L'exemple suivant ne définit aucun attribut en tant que`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Étape 3 : définir les attributs exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client suppose que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Étape 4 : définir la `DynamoDbItemEncryptor` configuration**
L'exemple suivant définit la configuration de`DynamoDbItemEncryptor`.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
```
final DynamoDbItemEncryptorConfig config = DynamoDbItemEncryptorConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
```
**Étape 5 : Création du `DynamoDbItemEncryptor`**
L'exemple suivant en crée un nouveau à `DynamoDbItemEncryptor` l'aide de l'étape 4 `config` à partir de l'**étape 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Étape 6 : Chiffrer et signer directement un élément du tableau**
L'exemple suivant chiffre et signe directement un élément à l'aide du`DynamoDbItemEncryptor`. L'élément `DynamoDbItemEncryptor` n'est pas placé dans votre table DynamoDB.
```
final Map originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final Map encryptedItem = itemEncryptor.EncryptItem(
EncryptItemInput.builder()
.plaintextItem(originalItem)
.build()
).encryptedItem();
```
# Configurer une table DynamoDB existante pour utiliser AWS le SDK de chiffrement de base de données pour DynamoDB
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Avec la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB, vous pouvez configurer vos tables Amazon DynamoDB existantes pour le chiffrement côté client. Cette rubrique fournit des conseils sur les trois étapes à suivre pour ajouter la version 3. *x* vers une table DynamoDB existante et renseignée.
**Conditions préalables**
Version 3. *x* [de la bibliothèque de chiffrement côté client Java pour DynamoDB nécessite le client DynamoDB amélioré fourni dans.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) AWS SDK for Java 2.x Si vous utilisez toujours [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), vous devez effectuer la migration AWS SDK for Java 2.x vers le client DynamoDB amélioré.
Suivez les instructions de [migration de la version 1.x vers la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) du. AWS SDK pour Java
Suivez ensuite les instructions pour [commencer à utiliser l'API client améliorée DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Avant de configurer votre table pour utiliser la bibliothèque de chiffrement côté client Java pour DynamoDB, vous devez générer une `TableSchema` classe de [données annotée et créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) client amélioré.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)
## Étape 1 : Préparez-vous à lire et à écrire des éléments chiffrés
Procédez comme suit pour préparer votre client du SDK AWS Database Encryption à lire et à écrire des éléments chiffrés. Après avoir déployé les modifications suivantes, votre client continuera à lire et à écrire des éléments en texte brut. Il ne chiffrera ni ne signera aucun nouvel élément inscrit dans la table, mais il sera en mesure de déchiffrer les éléments chiffrés dès leur apparition. Ces modifications préparent le client à commencer à [chiffrer de nouveaux éléments](#ddb-java-add-step2). Les modifications suivantes doivent être déployées sur chaque lecteur avant de passer à l'étape suivante.
**1. Définissez vos [actions attributaires](concepts.md#crypt-actions)**
Mettez à jour votre classe de données annotée pour inclure des actions d'attribut qui définissent les valeurs d'attribut qui seront chiffrées et signées, celles qui seront uniquement signées et celles qui seront ignorées.
Consultez le [SimpleClassfichier .java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) dans le référentiel aws-database-encryption-sdk -dynamodb GitHub pour plus d'informations sur les annotations du client DynamoDB Enhanced.
Par défaut, les attributs de clé primaire sont signés mais pas chiffrés (`SIGN_ONLY`) et tous les autres attributs sont chiffrés et signés (`ENCRYPT_AND_SIGN`). Pour spécifier des exceptions, utilisez les annotations de chiffrement définies dans la bibliothèque de chiffrement côté client Java pour DynamoDB. Par exemple, si vous souhaitez qu'un attribut particulier soit un signe, utilisez uniquement l'`@DynamoDbEncryptionSignOnly`annotation. Si vous souhaitez qu'un attribut particulier soit signé et inclus dans le contexte de chiffrement, utilisez l'`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`annotation. Si vous souhaitez qu'un attribut particulier ne soit ni signé ni chiffré (`DO_NOTHING`), utilisez l'`@DynamoDbEncryptionDoNothing`annotation.
Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Pour un exemple illustrant les annotations utilisées pour définir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consultez le [SimpleClassfichier 4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
Pour des exemples d'annotations, voir[Utiliser une classe de données annotée](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**2. Définissez les attributs qui seront exclus des signatures**
L'exemple suivant suppose que tous les `DO_NOTHING` attributs partagent le préfixe distinct `:` « » et utilise le préfixe pour définir les attributs non signés autorisés. Le client supposera que tout nom d'attribut avec le préfixe `:` « » est exclu des signatures. Pour de plus amples informations, veuillez consulter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Créez un [porte-clés](keyrings.md)**
L'exemple suivant crée un [AWS KMS trousseau de clés.](use-kms-keyring.md) Le AWS KMS trousseau de clés utilise le chiffrement symétrique ou le RSA asymétrique AWS KMS keys pour générer, chiffrer et déchiffrer les clés de données.
Cet exemple permet `CreateMrkMultiKeyring` de créer un AWS KMS trousseau de clés avec une clé KMS de chiffrement symétrique. La `CreateAwsKmsMrkMultiKeyring` méthode garantit que le trousseau de clés gère correctement les clés à région unique et à régions multiples.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Définition de la configuration du chiffrement des tables DynamoDB **
L'exemple suivant définit une `tableConfigs` carte qui représente la configuration de chiffrement pour cette table DynamoDB.
[Cet exemple indique le nom de la table DynamoDB comme nom de table logique.](ddb-java-using.md#logical-table-name) Nous vous recommandons vivement de spécifier le nom de votre table DynamoDB comme nom de table logique lorsque vous définissez votre configuration de chiffrement pour la première fois. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement dans le SDK de chiffrement AWS de base de données pour DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Vous devez le spécifier `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` comme remplacement en texte brut. Cette politique continue de lire et d'écrire des éléments en texte brut, de lire des éléments chiffrés et de préparer le client à écrire des éléments chiffrés.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
**5. Créer le `DynamoDbEncryptionInterceptor`**
L'exemple suivant crée le `DynamoDbEncryptionInterceptor` à l'aide `tableConfigs` de l'**étape 3**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Étape 2 : Écrire des éléments chiffrés et signés
Mettez à jour la politique de texte brut dans votre `DynamoDbEncryptionInterceptor` configuration pour permettre au client d'écrire des éléments chiffrés et signés. Après avoir déployé la modification suivante, le client chiffre et signe les nouveaux éléments en fonction des actions d'attribut que vous avez configurées à l'**étape 1**. Le client pourra lire les éléments en texte brut et les éléments chiffrés et signés.
Avant de passer à l'[étape 3](#ddb-java-add-step3), vous devez chiffrer et signer tous les éléments en texte brut existants dans votre tableau. Il n'existe pas de métrique ou de requête unique que vous puissiez exécuter pour chiffrer rapidement vos éléments en texte brut existants. Utilisez le processus le mieux adapté à votre système. Par exemple, vous pouvez utiliser un processus asynchrone qui analyse lentement la table et réécrit les éléments à l'aide des actions attributaires et de la configuration de chiffrement que vous avez définies. Pour identifier les éléments en texte brut de votre tableau, nous vous recommandons de rechercher tous les éléments qui ne contiennent pas les `aws_dbe_foot` attributs `aws_dbe_head` et que le SDK de chiffrement de AWS base de données ajoute aux éléments lorsqu'ils sont chiffrés et signés.
L'exemple suivant met à jour la configuration de chiffrement des tables depuis **l'étape 1**. Vous devez mettre à jour le remplacement en texte brut avec. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Cette politique continue de lire les éléments en texte brut, mais également de lire et d'écrire des éléments chiffrés. Créez-en un nouveau `DynamoDbEncryptionInterceptor` à l'aide de la mise à jour`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
## Étape 3 : lire uniquement les éléments chiffrés et signés
Une fois que vous avez chiffré et signé tous vos éléments, mettez à jour la dérogation en texte brut dans votre `DynamoDbEncryptionInterceptor` configuration pour autoriser uniquement le client à lire et écrire des éléments chiffrés et signés. Après avoir déployé la modification suivante, le client chiffre et signe les nouveaux éléments en fonction des actions d'attribut que vous avez configurées à l'**étape 1**. Le client ne pourra lire que les éléments chiffrés et signés.
L'exemple suivant met à jour la configuration de chiffrement des tables depuis **l'étape 2**. Vous pouvez soit mettre à jour la règle de remplacement en texte brut, `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` soit la supprimer de votre configuration. Le client lit et écrit uniquement les éléments chiffrés et signés par défaut. Créez-en un nouveau `DynamoDbEncryptionInterceptor` à l'aide de la mise à jour`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
// Optional: you can also remove the plaintext policy from your configuration
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
# Migrer vers la version 3.x de la bibliothèque de chiffrement côté client Java pour DynamoDB
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB est une réécriture majeure du 2. base de code *x.* Il inclut de nombreuses mises à jour, telles qu'un nouveau format de données structuré, une prise en charge améliorée de la mutualisation, des modifications de schéma fluides et la prise en charge du chiffrement consultable. Cette rubrique fournit des conseils sur la façon de migrer votre code vers la version 3. *x.*
## Migration de la version 1.x vers la version 2.x
Migrez vers la version 2. *x* avant de migrer vers la version 3. *x.* Version 2. *x* a changé le symbole du fournisseur le plus récent de `MostRecentProvider` à`CachingMostRecentProvider`. Si vous utilisez actuellement la version 1. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB avec le `MostRecentProvider` symbole, vous devez mettre à jour le nom du symbole dans votre code en. `CachingMostRecentProvider` Pour plus d'informations, voir [Mises à jour du fournisseur le plus récent](most-recent-provider.md#mrp-versions).
## Migration de la version 2.x vers la version 3.x
Les procédures suivantes décrivent comment migrer votre code depuis la version 2. *x* vers la version 3. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
### Étape 1. Préparez-vous à lire les éléments dans le nouveau format
Procédez comme suit pour préparer votre client AWS Database Encryption SDK à lire les éléments dans le nouveau format. Après avoir déployé les modifications suivantes, votre client continuera à se comporter de la même manière que dans la version 2. *x.* Votre client continuera à lire et à écrire des éléments dans la version 2. format *x*, mais ces modifications préparent le client à [lire les éléments dans le nouveau format](#ddb-java-migrate-step2).
**Mettez à jour votre AWS SDK pour Java version 2.x**
Version 3. *x* [de la bibliothèque de chiffrement côté client Java pour DynamoDB nécessite le client DynamoDB amélioré.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Le client DynamoDB amélioré remplace le DBMapper Dynamo utilisé [dans les versions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) précédentes. Pour utiliser le client amélioré, vous devez utiliser le AWS SDK for Java 2.x.
Suivez les instructions de [migration de la version 1.x vers la version 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) du. AWS SDK pour Java
Pour plus d'informations sur les AWS SDK for Java 2.x modules requis, consultez[Conditions préalables](ddb-java.md#ddb-java-prerequisites).
**Configurez votre client pour lire les éléments chiffrés par les anciennes versions**
Les procédures suivantes fournissent une vue d'ensemble des étapes illustrées dans l'exemple de code ci-dessous.
1. Créez un [porte-clés.](keyrings.md)
Les porte-clés et les [gestionnaires de matériel cryptographique](concepts.md#crypt-materials-manager) remplacent les fournisseurs de matériel cryptographique utilisés dans les versions précédentes de la bibliothèque de chiffrement côté client Java pour DynamoDB.
**Important**
Les clés d'encapsulation que vous spécifiez lors de la création d'un jeu de clés doivent être les mêmes que celles que vous avez utilisées avec votre fournisseur de matériel cryptographique dans la version 2. *x.*
1. Créez un schéma de table au-dessus de votre classe annotée.
Cette étape définit les actions d'attribut qui seront utilisées lorsque vous commencerez à écrire des éléments dans le nouveau format.
*Pour obtenir des conseils sur l'utilisation du nouveau client DynamoDB amélioré, reportez-vous à la section [Generate `TableSchema` a du](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) guide du développeur.AWS SDK pour Java *
L'exemple suivant suppose que vous avez mis à jour votre classe annotée à partir de la version 2. *x* en utilisant les nouvelles annotations d'actions d'attribut. Pour plus d'informations sur l'annotation des actions de vos attributs, consultez[Utiliser une classe de données annotée](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**Note**
Si vous spécifiez des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributs, les attributs de partition et de tri doivent également l'être`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Pour un exemple illustrant les annotations utilisées pour définir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consultez [SimpleClass4.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java).
1. Définissez les [attributs exclus de la signature](ddb-java-using.md#allowed-unauth).
1. Configurez une carte explicite des actions d'attributs configurées dans votre classe modélisée de la version 2.x.
Cette étape définit les actions d'attribut utilisées pour écrire des éléments dans l'ancien format.
1. Configurez le `DynamoDBEncryptor` que vous avez utilisé dans la version 2. *x* de la bibliothèque de chiffrement côté client Java pour DynamoDB.
1. Configurez le comportement existant.
1. Créez un `DynamoDbEncryptionInterceptor`.
1. Créez un nouveau client AWS DynamoDB SDK.
1. Créez le `DynamoDBEnhancedClient` et créez un tableau avec votre classe modélisée.
Pour plus d'informations sur le client DynamoDB amélioré, [voir créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client amélioré.
```
public class MigrationExampleStep1 {
public static void MigrationStep1(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Create a Keyring.
// This example creates an AWS KMS Keyring that specifies the
// same kmsKeyId previously used in the version 2.x configuration.
// It uses the 'CreateMrkMultiKeyring' method to create the
// keyring, so that the keyring can correctly handle both single
// region and Multi-Region KMS Keys.
// Note that this example uses the AWS SDK for Java v2 KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
// 2. Create a Table Schema over your annotated class.
// For guidance on using the new attribute actions
// annotations, see SimpleClass.java in the
// aws-database-encryption-sdk-dynamodb GitHub repository.
// All primary key attributes must be signed but not encrypted
// and by default all non-primary key attributes
// are encrypted and signed (ENCRYPT_AND_SIGN).
// If you want a particular non-primary key attribute to be signed but
// not encrypted, use the 'DynamoDbEncryptionSignOnly' annotation.
// If you want a particular attribute to be neither signed nor encrypted
// (DO_NOTHING), use the 'DynamoDbEncryptionDoNothing' annotation.
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
// 3. Define which attributes the client should expect to be excluded
// from the signature when reading items.
// This value represents all unsigned attributes across the entire
// dataset.
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 4. Configure an explicit map of the attribute actions configured
// in your version 2.x modeled class.
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
// 5. Configure the DynamoDBEncryptor that you used in version 2.x.
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 6. Configure the legacy behavior.
// Input the DynamoDBEncryptor and attribute actions created in
// the previous steps. For Legacy Policy, use
// 'FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy continues to read
// and write items using the old format, but will be able to read
// items written in the new format as soon as they appear.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 7. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 8. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 7.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 9. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb client
// created in Step 8, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
### Étape 2. Écrire des éléments dans le nouveau format
Après avoir déployé les modifications apportées à l'étape 1 sur tous les lecteurs, effectuez les étapes suivantes pour configurer votre client AWS Database Encryption SDK afin d'écrire des éléments dans le nouveau format. Après avoir déployé les modifications suivantes, votre client continuera à lire les éléments dans l'ancien format et commencera à écrire et à lire des éléments dans le nouveau format.
Les procédures suivantes fournissent une vue d'ensemble des étapes illustrées dans l'exemple de code ci-dessous.
1. Continuez à configurer votre trousseau de clés, votre schéma de table, vos anciennes actions attributaires`allowedUnsignedAttributes`, `DynamoDBEncryptor` comme vous l'avez fait à l'[**étape 1**](#ddb-java-migrate-step1).
1. Mettez à jour votre ancien comportement pour n'écrire que les nouveaux éléments en utilisant le nouveau format.
1. Créer une `DynamoDbEncryptionInterceptor `
1. Créez un nouveau client AWS DynamoDB SDK.
1. Créez le `DynamoDBEnhancedClient` et créez un tableau avec votre classe modélisée.
Pour plus d'informations sur le client DynamoDB amélioré, [voir créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client amélioré.
```
public class MigrationExampleStep2 {
public static void MigrationStep2(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema, legacy
// attribute actions, allowedUnsignedAttributes, and
// DynamoDBEncryptor as you did in Step 1.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 2. Update your legacy behavior to only write new items using the new
// format.
// For Legacy Policy, use 'FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy
// continues to read items in both formats, but will only write items
// using the new format.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb Client created
// in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
Après avoir déployé les modifications de l'étape 2, vous devez rechiffrer tous les anciens éléments de votre tableau avec le nouveau format avant de [passer à l'étape](#ddb-java-migrate-step3) 3. Il n'existe pas de métrique ou de requête unique que vous puissiez exécuter pour chiffrer rapidement vos éléments existants. Utilisez le processus le mieux adapté à votre système. Par exemple, vous pouvez utiliser un processus asynchrone qui analyse lentement la table et réécrit les éléments à l'aide des nouvelles actions attributaires et de la nouvelle configuration de chiffrement que vous avez définies.
### Étape 3. Lisez et écrivez uniquement les éléments dans le nouveau format
Après avoir rechiffré tous les éléments de votre tableau avec le nouveau format, vous pouvez supprimer le comportement existant de votre configuration. Procédez comme suit pour configurer votre client de manière à ce qu'il lise et écrive uniquement les éléments dans le nouveau format.
Les procédures suivantes fournissent une vue d'ensemble des étapes illustrées dans l'exemple de code ci-dessous.
1. Continuez à configurer votre trousseau de clés, votre schéma de table, `allowedUnsignedAttributes` comme vous l'avez fait à l'[**étape 1**](#ddb-java-migrate-step1). Supprimez les anciennes actions attributaires et `DynamoDBEncryptor` supprimez-les de votre configuration.
1. Créez un `DynamoDbEncryptionInterceptor`.
1. Créez un nouveau client AWS DynamoDB SDK.
1. Créez le `DynamoDBEnhancedClient` et créez un tableau avec votre classe modélisée.
Pour plus d'informations sur le client DynamoDB amélioré, [voir créer un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client amélioré.
```
public class MigrationExampleStep3 {
public static void MigrationStep3(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema,
// and allowedUnsignedAttributes as you did in Step 1.
// Do not include the configurations for the DynamoDBEncryptor or
// the legacy attribute actions.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
// Do not configure any legacy behavior.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK Client
// created in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```