Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Java
****
| |
| --- |
| Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de AWS bases de datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). |
En este tema se explica cómo instalar y usar la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB. Para obtener más información sobre la programación con el SDK AWS de cifrado de bases de datos para DynamoDB, consulte los ejemplos de [Java en el repositorio -dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) en aws-database-encryption-sdk. GitHub
**nota**
Los siguientes temas se centran en la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB.
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). El SDK AWS de cifrado de bases de datos sigue siendo compatible con las versiones [antiguas de DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md).
**Topics**
+ [Requisitos previos](#ddb-java-prerequisites)
+ [Instalación](#ddb-java-installation)
+ [Uso de la biblioteca de cliente de Java](ddb-java-using.md)
+ [Ejemplos de Java](ddb-java-examples.md)
+ [Agregar la versión 3.x a una tabla existente](ddb-java-config-existing-table.md)
+ [Migrar a la versión 3.x](ddb-java-migrate.md)
## Requisitos previos
Antes de instalar la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB, asegúrese de cumplir los siguientes requisitos previos.
**Un entorno de desarrollo de Java**
Necesitará Java 8 o una versión posterior. En el sitio web de Oracle, vaya a la página de [descargas de Java SE](https://www.oracle.com/java/technologies/downloads/) y, a continuación, descargue e instale el Java SE Development Kit (JDK).
Si utiliza el JDK de Oracle, también debe descargar e instalar los [archivos de políticas de jurisdicción de seguridad ilimitada de la extensión de criptografía de Java (JCE)](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK for Java 2.x**
El SDK AWS de cifrado de bases de datos para DynamoDB requiere el módulo [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) del. AWS SDK for Java 2.x Puede instalar todo el SDK o solo este módulo.
Para obtener información sobre cómo actualizar su versión de AWS SDK para Java, consulte [Migración de la versión 1.x a la 2.x del](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK para Java
AWS SDK para Java Está disponible a través de Apache Maven. Puede declarar una dependencia para todo AWS SDK para Java el `dynamodb-enhanced` módulo o solo para él.
**Instálelo AWS SDK para Java con Apache Maven**
+ Para [importar todo AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) como una dependencia declárelo en el archivo `pom.xml`.
+ Para crear una dependencia solo para el módulo Amazon DynamoDB en el AWS SDK para Java, siga las instrucciones para [especificar módulos concretos](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies). Establece el `groupId` para y el para.`software.amazon.awssdk` `artifactID` `dynamodb-enhanced`
**nota**
Si usa el anillo de AWS KMS claves o el anillo de claves AWS KMS jerárquico, también necesita crear una dependencia para el módulo. AWS KMS Establece el `groupId` en `software.amazon.awssdk` y el `artifactID` en `kms`.
## Instalación
Puede instalar la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB de las siguientes maneras.
**Con Apache Maven**
El Cliente de encriptación de Amazon DynamoDB para Java está disponible en [Apache Maven](https://maven.apache.org/) con la siguiente definición de dependencias.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Uso de Gradle Kotlin**
Puede usar [Gradle](https://gradle.org/) para declarar una dependencia en el Cliente de encriptación de Amazon DynamoDB para Java añadiendo lo siguiente *a* la sección de dependencias de su proyecto de Gradle.
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Manualmente**
[Para instalar la biblioteca de cifrado del lado del cliente de Java para DynamoDB, clone o descargue el repositorio -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Tras instalar el SDK, comience por consultar el código de ejemplo de esta guía y los ejemplos de [Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) del repositorio -dynamodb de. aws-database-encryption-sdk GitHub
# Usar la biblioteca de cifrado del cliente de Java para DynamoDB
****
| |
| --- |
| Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de AWS bases de datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). |
En este tema se explican algunas de las funciones y clases de ayuda de la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB.
[Para obtener más información sobre la programación con la biblioteca de cifrado del lado del cliente de Java para DynamoDB, consulte los ejemplos de Java y los [ejemplos de Java](java-examples.md) en el repositorio -dynamodb de.](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**
+ [Encriptadores de elementos](#ddb-item-encryptors)
+ [Acciones de atributo](#ddb-attribute-actions)
+ [La configuración de cifrado](#ddb-config-encrypt)
+ [Actualización de un elemento](#ddb-update-items)
+ [Descifrado de conjuntos firmados](#ddb-java-signed-sets)
## Encriptadores de elementos
En esencia, el SDK de cifrado AWS de bases de datos para DynamoDB es un cifrador de elementos. Puede utilizar la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB para cifrar, firmar, verificar y descifrar los elementos de la tabla de DynamoDB de las siguientes maneras.
**El cliente mejorado de DynamoDB**
Puede configurar el [cliente mejorado de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) con el `DynamoDbEncryptionInterceptor` para cifrar y firmar automáticamente los elementos del lado del cliente con sus solicitudes `PutItem` de DynamoDB. Con el cliente mejorado de DynamoDB, puede definir las acciones de sus atributos mediante [una](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) clase de datos anotada. Recomendamos utilizar el cliente mejorado de DynamoDB siempre que sea posible.
El cliente mejorado de DynamoDB no admite [el cifrado con capacidad de búsqueda.](searchable-encryption.md)
[El SDK AWS de cifrado de bases de datos no admite anotaciones en atributos anidados.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
**API de bajo nivel de DynamoDB**
Puede configurar la API de [DynamoDB de bajo nivel](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) para cifrar y firmar automáticamente los elementos `DynamoDbEncryptionInterceptor` del lado del cliente con sus solicitudes de DynamoDB. `PutItem`
Debe usar la API de DynamoDB de bajo nivel para utilizar el cifrado [con capacidad de búsqueda](searchable-encryption.md).
**El nivel inferior `DynamoDbItemEncryptor`**
El nivel inferior cifra y firma o descifra y verifica `DynamoDbItemEncryptor` directamente los elementos de la tabla sin llamar a DynamoDB. No realiza DynamoDB ni `PutItem` solicitudes`GetItem`. Por ejemplo, puede usar el nivel inferior `DynamoDbItemEncryptor` para descifrar y verificar directamente un elemento de DynamoDB que ya haya recuperado.
El nivel inferior `DynamoDbItemEncryptor` no admite el cifrado [con capacidad de búsqueda.](searchable-encryption.md)
## Acciones de atributos en el SDK de cifrado AWS de bases de datos para DynamoDB
[Las acciones de atributos](concepts.md#crypt-actions) determinan qué valores de atributo están cifrados y firmados, cuáles solo están firmados, cuáles están firmados e incluidos en el contexto de cifrado y cuáles se ignoran.
**nota**
Para utilizar la acción `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, debe utilizar la versión 3.3 o posterior del SDK de cifrado de AWS bases de datos. Implemente la nueva versión en todos los lectores antes de [actualizar su modelo de datos](ddb-update-data-model.md) para `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` incluirla.
Si utiliza la API de DynamoDB de bajo nivel o el `DynamoDbItemEncryptor` nivel inferior, debe definir manualmente las acciones de los atributos. Si usa el cliente mejorado de DynamoDB, puede definir manualmente las acciones de sus atributos o puede usar una clase de datos anotada para [generar un. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Para simplificar el proceso de configuración, se recomienda utilizar una clase de datos anotada. Cuando utiliza una clase de datos anotada, solo tiene que modelar el objeto una vez.
**nota**
Tras definir las acciones de los atributos, debe definir qué atributos se excluyen de las firmas. Para facilitar la adición de nuevos atributos sin firmar en el futuro, recomendamos elegir un prefijo distinto (como “`:`“) para identificar los atributos sin firmar. Incluya este prefijo en el nombre del atributo para todos los atributos marcados `DO_NOTHING` al definir el esquema y las acciones de atributos de DynamoDB.
### Utilice una clase de datos anotada
Utilice una [clase de datos anotada](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) para especificar las acciones de sus atributos con el cliente mejorado de DynamoDB y. `DynamoDbEncryptionInterceptor` El SDK de cifrado de bases de datos de AWS para DynamoDB utiliza las anotaciones de atributo estándar de DynamoDB [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html)que definen el tipo de atributo para determinar cómo proteger un atributo. De forma predeterminada, todos los atributos están cifrados y firmados, excepto las claves principales, que están firmadas, pero no cifradas.
**nota**
Para usar la acción `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, debe usar la versión 3.3 o posterior del SDK de cifrado de AWS bases de datos. Implemente la nueva versión en todos los lectores antes de [actualizar su modelo de datos](ddb-update-data-model.md) para `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` incluirla.
Consulte [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) en el repositorio aws-database-encryption-sdk -dynamodb GitHub para obtener más información sobre las anotaciones del cliente mejorado de DynamoDB.
De forma predeterminada, los atributos de la clave principal están firmados pero no cifrados (`SIGN_ONLY`) y todos los demás atributos están cifrados y firmados `ENCRYPT_AND_SIGN`(). Si define algún atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, los atributos de partición y ordenación también deben serlo. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Para especificar las excepciones, utilice las anotaciones de cifrado que se definen en la biblioteca de cifrado del cliente de Java para DynamoDB. Por ejemplo, si desea que un atributo concreto solo esté firmado, utilice la `@DynamoDbEncryptionSignOnly` anotación. Si desea que un atributo concreto se firme e incluya en el contexto de cifrado, utilice el`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Si desea que un atributo concreto no esté firmado ni cifrado (`DO_NOTHING`), utilice la anotación `@DynamoDbEncryptionDoNothing`.
**nota**
El SDK AWS de cifrado de bases de datos no admite anotaciones en atributos [anidados](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
En el siguiente ejemplo, se muestran las anotaciones utilizadas para definir y `ENCRYPT_AND_SIGN` `SIGN_ONLY` `DO_NOTHING` atribuir acciones. [Para ver un ejemplo que muestre las anotaciones utilizadas para definir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consulte SimpleClass 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;
}
}
```
Utilice la clase de datos anotada para crearla tal y `TableSchema` como se muestra en el siguiente fragmento.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Defina manualmente las acciones de sus atributos
Para especificar las acciones de atributo cuando se utiliza el DynamoDBEncryptor directamente, cree un objeto `Map` en el que las parejas de nombre-valor representen nombres de atributo y las acciones especificadas.
Especifique `ENCRYPT_AND_SIGN` si desea cifrar y firmar un atributo. Especifique `SIGN_ONLY` firmar, pero no cifrar, un atributo. Especifique si `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` desea firmar un atributo e incluirlo en el contexto de cifrado. No se puede cifrar un atributo sin firmarlo también. Especifique `DO_NOTHING` que se omita un atributo.
Los atributos de partición y ordenación deben ser uno de `SIGN_ONLY` los dos`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Si define algún atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, los atributos de partición y ordenación también deben serlo`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**nota**
Para utilizar la acción `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, debe utilizar la versión 3.3 o posterior del SDK de cifrado de AWS bases de datos. Implemente la nueva versión en todos los lectores antes de [actualizar su modelo de datos](ddb-update-data-model.md) para `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` incluirla.
```
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);
```
## Configuración de cifrado en el SDK de cifrado AWS de bases de datos para DynamoDB
Al utilizar el SDK de cifrado AWS de bases de datos, debe definir explícitamente una configuración de cifrado para la tabla de DynamoDB. Los valores necesarios en la configuración de cifrado dependen de si ha definido las acciones de los atributos manualmente o con una clase de datos anotada.
El siguiente fragmento define una configuración de cifrado de tablas de DynamoDB mediante el cliente mejorado de DynamoDB y los atributos no firmados permitidos definidos por un prefijo [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)distinto.
```
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());
```
**Nombre de la tabla lógica**
Un nombre de tabla lógico para la tabla de DynamoDB.
El nombre de la tabla lógica está enlazado criptográficamente a todos los datos almacenados en la tabla para simplificar las operaciones de restauración de DynamoDB. Se recomienda encarecidamente especificar el nombre de la tabla de DynamoDB como nombre de la tabla lógica cuando defina por primera vez la configuración de cifrado. Debe especificar siempre el mismo nombre de tabla lógica. Para que el descifrado se realice correctamente, el nombre de la tabla lógica debe coincidir con el nombre especificado en el cifrado. En caso de que el nombre de la tabla de DynamoDB cambie después de [restaurar la tabla de DynamoDB a partir de una copia de seguridad, el nombre de la tabla](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) lógica garantiza que la operación de descifrado siga reconociendo la tabla.
**Atributos no firmados permitidos**
Los atributos marcados `DO_NOTHING` en tus acciones de atributos.
Los atributos no firmados permitidos indican al cliente qué atributos están excluidos de las firmas. El cliente asume que todos los demás atributos están incluidos en la firma. A continuación, al descifrar un registro, el cliente determina qué atributos debe verificar y cuáles debe ignorar de los atributos no firmados permitidos que especificó. No puede eliminar un atributo de los atributos no firmados permitidos.
Puede definir los atributos no firmados permitidos de forma explícita mediante la creación de una matriz que enumere todos sus `DO_NOTHING` atributos. También puedes especificar un prefijo distinto al asignar un nombre a tus `DO_NOTHING` atributos y usar el prefijo para indicar al cliente qué atributos no están firmados. Recomendamos encarecidamente especificar un prefijo distinto porque simplifica el proceso de añadir un nuevo `DO_NOTHING` atributo en el futuro. Para obtener más información, consulte [Actualización de su modelo de datos](ddb-update-data-model.md).
Si no especifica un prefijo para todos los `DO_NOTHING` atributos, puede configurar una `allowedUnsignedAttributes` matriz que enumere de forma explícita todos los atributos que el cliente debería esperar que no estén firmados cuando los encuentre al descifrarlos. Solo debe definir de forma explícita los atributos no firmados permitidos si es absolutamente necesario.
**Configuración de búsqueda (opcional)**
`SearchConfig`Define la [versión de baliza](using-beacons.md#beacon-version).
`SearchConfig`Debe especificarse para utilizar [balizas firmadas](configure.md#signed-beacons) o [cifradas con capacidad de búsqueda](searchable-encryption.md).
**Conjunto de algoritmos (opcional)**
El `algorithmSuiteId` define qué conjunto de algoritmos utiliza el SDK de cifrado de bases de datos de AWS .
A menos que especifique explícitamente un conjunto de algoritmos alternativo, el SDK AWS de cifrado de bases de datos utiliza el [conjunto de algoritmos predeterminado](supported-algorithms.md#recommended-algorithms). [El conjunto de algoritmos predeterminado utiliza el algoritmo AES-GCM con la derivación de claves, [las firmas digitales](concepts.md#digital-sigs) y el compromiso de claves.](concepts.md#key-commitment) Aunque es probable que el conjunto de algoritmos predeterminado sea adecuado para la mayoría de las aplicaciones, puede elegir un conjunto de algoritmos alternativo. Por ejemplo, algunos modelos de confianza quedarían satisfechos con un conjunto de algoritmos sin firmas digitales. Para obtener información sobre los conjuntos de algoritmos compatibles con el SDK AWS de cifrado de bases de datos, consulte[Conjuntos de algoritmos compatibles en el SDK de cifrado AWS de bases de datos](supported-algorithms.md).
Para seleccionar el [conjunto de algoritmos AES-GCM sin firmas digitales ECDSA](supported-algorithms.md#other-algorithms), incluya el siguiente fragmento en la configuración de cifrado de la tabla.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Actualización de elementos con el SDK de cifrado de bases de datos AWS
El SDK AWS de cifrado de bases de datos no admite [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) para elementos cifrados o firmados. Para actualizar un elemento cifrado o firmado, debe usar [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html):. PutItem Cuando se especifica la misma clave principal que un elemento existente en la solicitud `PutItem`, el nuevo elemento sustituye completamente al existente. También puedes usar [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) para borrar y reemplazar todos los atributos al guardar después de actualizar tus artículos.
## Descifrado de conjuntos firmados
En las versiones 3.0.0 y 3.1.0 del SDK de cifrado de AWS bases de datos, si define un atributo de [tipo de conjunto](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) como`SIGN_ONLY`, los valores del conjunto se canonicalizan en el orden en que se proporcionan. DynamoDB no mantiene el orden de los conjuntos. Como resultado, existe la posibilidad de que se produzca un error al intentar la firma del elemento que contiene el conjunto. La validación de firmas falla cuando los valores del conjunto se devuelven en un orden diferente al que se proporcionaron al SDK de cifrado de AWS bases de datos, incluso si los atributos del conjunto contienen los mismos valores.
**nota**
Las versiones 3.1.1 y posteriores del SDK de cifrado de AWS bases de datos canonicalizan los valores de todos los atributos de tipo establecido, de modo que los valores se leen en el mismo orden en que se escribieron en DynamoDB.
Si se produce un error durante la validación de la firma, la operación de descifrado también sufre un error y devuelve el siguiente mensaje de error.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: No hay ninguna etiqueta de destinatario coincidente. |
Si recibe el mensaje de error anterior y cree que el elemento que está intentando descifrar incluye un conjunto que se firmó con las versiones 3.0.0 o 3.1.0, consulte el [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)directorio del repositorio aws-database-encryption-sdk -dynamodb-java GitHub para obtener más información sobre cómo validar correctamente el conjunto.
# Ejemplos de Java
****
| |
| --- |
| Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de AWS bases de datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). |
Los siguientes ejemplos muestran cómo utilizar la biblioteca de cifrado del cliente de Java para DynamoDB para proteger los elementos de tabla en su aplicación. Puedes encontrar más ejemplos (y añadir los tuyos propios) en los [ejemplos de Java del repositorio](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 de. GitHub
Los siguientes ejemplos muestran cómo configurar la biblioteca de cifrado del cliente de Java para DynamoDB en una tabla de Amazon DynamoDB nueva y sin rellenar. Si desea configurar las tablas de Amazon DynamoDB existentes para el cifrado del cliente, consulte. [Agregar la versión 3.x a una tabla existente](ddb-java-config-existing-table.md)
**Topics**
+ [Uso del cliente mejorado de DynamoDB](#ddb-java-enhanced-client-example)
+ [API de bajo nivel de DynamoDB](#ddb-java-lowlevel-API-example)
+ [Usando el nivel inferior DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Uso del cliente mejorado de DynamoDB
En el siguiente ejemplo, se muestra cómo utilizar el cliente mejorado de DynamoDB y el `DynamoDbEncryptionInterceptor` con un [conjunto de claves de AWS KMS](use-kms-keyring.md) para cifrar los elementos de la tabla de DynamoDB como parte de las llamadas a la API de DynamoDB.
Puede utilizar cualquier conjunto de [claves compatible con el cliente mejorado de DynamoDB, pero le recomendamos que utilice uno de los anillos](keyrings.md) de AWS KMS claves siempre que sea posible.
**nota**
El cliente mejorado de DynamoDB no admite [el cifrado con capacidad de búsqueda.](searchable-encryption.md) Úselo `DynamoDbEncryptionInterceptor` con el API de bajo nivel de DynamoDB para usar el cifrado con capacidad de búsqueda.
**Consulte el ejemplo de código completo**[: .java EnhancedPutGetExample](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)
**Paso 1: Crea el llavero AWS KMS **
El siguiente ejemplo se utiliza `CreateAwsKmsMrkMultiKeyring` para crear un AWS KMS anillo de claves con una clave KMS de cifrado simétrico. El método `CreateAwsKmsMrkMultiKeyring` garantiza que el conjunto de claves maneje correctamente las claves de una sola región y de múltiples regiones.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Paso 2: crear un esquema de tabla a partir de la clase de datos anotados**
En el siguiente ejemplo, se utiliza la clase de datos anotada para crear la `TableSchema`.
[En este ejemplo, se supone que las acciones de clase y atributo de datos anotados se definieron mediante .java. SimpleClass](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) Para obtener más información sobre cómo anotar las acciones de los atributos, consulte [Utilice una clase de datos anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
[El SDK AWS de cifrado de bases de datos no admite anotaciones en atributos anidados.](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);
```
**Paso 3: defina qué atributos se excluyen de las firmas**
En el ejemplo siguiente, se supone que todos los atributos `DO_NOTHING` comparten el prefijo distinto "`:`" y se utiliza el prefijo para definir los atributos no firmados permitidos. El cliente asume que cualquier nombre de atributo con el prefijo “`:`” está excluido de las firmas. Para obtener más información, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Paso 4: crear el contexto de cifrado**
En el siguiente ejemplo, se define un mapa `tableConfigs` que representa la configuración de cifrado de la tabla de DynamoDB.
En este ejemplo, se especifica el nombre de la tabla de DynamoDB como [nombre de la tabla lógica](ddb-java-using.md#logical-table-name). Se recomienda encarecidamente especificar el nombre de la tabla de DynamoDB como nombre de la tabla lógica cuando defina por primera vez la configuración de cifrado. Para obtener más información, consulte [Configuración de cifrado en el SDK de cifrado AWS de bases de datos para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Para utilizar [balizas firmadas](configure.md#signed-beacons) o [cifrado con capacidad de búsqueda](searchable-encryption.md), también debe incluirlos [`SearchConfig`](ddb-java-using.md#ddb-search-config)en la configuración de cifrado.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Paso 5: Cree la `DynamoDbEncryptionInterceptor`**
En el siguiente ejemplo, se crea un nuevo `DynamoDbEncryptionInterceptor` con la `tableConfigs` del **Paso 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Paso 6: Crear un nuevo cliente AWS SDK de DynamoDB**
**En el siguiente ejemplo, se crea un nuevo cliente AWS SDK de DynamoDB mediante `interceptor` el paso 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Paso 7: Crear el cliente mejorado de DynamoDB y crear una tabla**
En el siguiente ejemplo, se crea el cliente mejorado DynamoDB mediante el cliente del SDK DynamoDB de AWS creado en el **Paso 6** y se crea una tabla con la clase de datos anotados.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Paso 8: Cifrar y guardar un elemento de la tabla**
En el siguiente ejemplo, se coloca un elemento en la tabla de DynamoDB mediante el cliente mejorado de DynamoDB. El elemento se cifra y se firma en el lado del cliente antes de enviarlo a 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);
```
## API de bajo nivel de DynamoDB
En el siguiente ejemplo, se muestra cómo utilizar la API de DynamoDB de bajo nivel con un [conjunto de claves de AWS KMS](use-kms-keyring.md) para cifrar y firmar automáticamente los elementos del lado del cliente con las solicitudes de DynamoDB de `PutItem`.
Puede utilizar cualquier [llavero](keyrings.md) compatible, pero le recomendamos que utilice uno de los AWS KMS llaveros siempre que sea posible.
**[Consulta el ejemplo de código completo: .java BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)**
**Paso 1: Crea el llavero AWS KMS **
El siguiente ejemplo se utiliza `CreateAwsKmsMrkMultiKeyring` para crear un AWS KMS anillo de claves con una clave KMS de cifrado simétrico. El método `CreateAwsKmsMrkMultiKeyring` garantiza que el conjunto de claves maneje correctamente las claves de una sola región y de múltiples regiones.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Paso 2: configurar las acciones de sus atributos**
En el siguiente ejemplo, se define un mapa `attributeActionsOnEncrypt` que representa ejemplos de [acciones de atributos](concepts.md#crypt-actions) para un elemento de la tabla.
En el siguiente ejemplo no se define ningún atributo como. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Si especifica algún `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, los atributos de partición y ordenación también deben serlo`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);
```
**Paso 3: defina qué atributos se excluyen de las firmas**
En el ejemplo siguiente, se supone que todos los atributos `DO_NOTHING` comparten el prefijo distinto "`:`" y se utiliza el prefijo para definir los atributos no firmados permitidos. El cliente asume que cualquier nombre de atributo con el prefijo “`:`” está excluido de las firmas. Para obtener más información, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Paso 4: definir la configuración de cifrado de la tabla de DynamoDB**
El siguiente ejemplo define un mapa `tableConfigs` que representa la configuración de cifrado de esta tabla de DynamoDB.
En este ejemplo, se especifica el nombre de la tabla de DynamoDB como [nombre de la tabla lógica](ddb-java-using.md#logical-table-name). Se recomienda encarecidamente especificar el nombre de la tabla de DynamoDB como nombre de la tabla lógica cuando defina por primera vez la configuración de cifrado. Para obtener más información, consulte [Configuración de cifrado en el SDK de cifrado AWS de bases de datos para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Para utilizar [balizas firmadas](configure.md#signed-beacons) o [cifrado con capacidad de búsqueda](searchable-encryption.md), también debe incluir [`SearchConfig`](ddb-java-using.md#ddb-search-config) en la configuración de cifrado.
```
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);
```
**Paso 5: Crear el `DynamoDbEncryptionInterceptor`**
En el siguiente ejemplo, se crea el `DynamoDbEncryptionInterceptor` con la `tableConfigs` del **Paso 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Paso 6: Crear un nuevo cliente AWS SDK de DynamoDB**
**En el siguiente ejemplo, se crea un nuevo cliente AWS SDK de DynamoDB mediante `interceptor` el paso 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Paso 7: Cifrar y firmar un elemento de la tabla de DynamoDB**
En el siguiente ejemplo, se define un mapa `item` que representa un elemento de tabla de ejemplo y se coloca el elemento en la tabla de DynamoDB. El elemento se cifra y se firma en el lado del cliente antes de enviarlo a 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);
```
## Usando el nivel inferior DynamoDbItemEncryptor
En el siguiente ejemplo, se muestra cómo utilizar el nivel inferior `DynamoDbItemEncryptor` con un [conjunto de claves de AWS KMS](use-kms-keyring.md) para cifrar y firmar directamente los elementos de la tabla. `DynamoDbItemEncryptor` No coloca el elemento en la tabla de DynamoDB.
Puede utilizar cualquier conjunto de [claves compatible con el cliente mejorado de DynamoDB, pero le recomendamos que utilice uno de los anillos](keyrings.md) de AWS KMS claves siempre que sea posible.
**nota**
El nivel inferior `DynamoDbItemEncryptor` no admite el cifrado [con capacidad de búsqueda.](searchable-encryption.md) Úselo `DynamoDbEncryptionInterceptor` con el API de bajo nivel de DynamoDB para usar el cifrado con capacidad de búsqueda.
**Consulte el ejemplo de código completo**[: .java ItemEncryptDecryptExample](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)
**Paso 1: Crea el llavero AWS KMS **
El siguiente ejemplo se utiliza `CreateAwsKmsMrkMultiKeyring` para crear un AWS KMS anillo de claves con una clave KMS de cifrado simétrico. El método `CreateAwsKmsMrkMultiKeyring` garantiza que el conjunto de claves maneje correctamente las claves de una sola región y de múltiples regiones.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Paso 2: configurar las acciones de sus atributos**
En el siguiente ejemplo, se define un mapa `attributeActionsOnEncrypt` que representa ejemplos de [acciones de atributos](concepts.md#crypt-actions) para un elemento de la tabla.
En el siguiente ejemplo no se define ningún atributo como. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Si especifica algún `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, los atributos de partición y ordenación también deben serlo`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);
```
**Paso 3: defina qué atributos se excluyen de las firmas**
En el ejemplo siguiente, se supone que todos los atributos `DO_NOTHING` comparten el prefijo distinto "`:`" y se utiliza el prefijo para definir los atributos no firmados permitidos. El cliente asume que cualquier nombre de atributo con el prefijo “`:`” está excluido de las firmas. Para obtener más información, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Paso 4: defina la configuración de `DynamoDbItemEncryptor`**
En el siguiente ejemplo, se consulta la configuración de `DynamoDbItemEncryptor`.
En este ejemplo, se especifica el nombre de la tabla de DynamoDB como [nombre de la tabla lógica](ddb-java-using.md#logical-table-name). Se recomienda encarecidamente especificar el nombre de la tabla de DynamoDB como nombre de la tabla lógica cuando defina por primera vez la configuración de cifrado. Para obtener más información, consulte [Configuración de cifrado en el SDK de cifrado AWS de bases de datos para 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();
```
**Paso 5: Crear el `DynamoDbItemEncryptor`**
En el siguiente ejemplo, se crea un nuevo `DynamoDbItemEncryptor`, con la `config` del **Paso 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Paso 6: cifrar y firmar directamente un elemento de la tabla**
En el siguiente ejemplo, se cifra y firma directamente un elemento mediante el `DynamoDbItemEncryptor`. `DynamoDbItemEncryptor` no coloca el elemento en la tabla de 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();
```
# Configurar una tabla de DynamoDB existente para usar AWS el SDK de cifrado de bases de datos para DynamoDB
****
| |
| --- |
| Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de bases de datos. AWS En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). |
Con la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB, puede configurar las tablas de Amazon DynamoDB existentes para el cifrado del cliente. En este tema se proporcionan instrucciones sobre los tres pasos que debe seguir para añadir la versión 3.*x* a una tabla de DynamoDB existente y rellenada.
**Requisitos previos**
Versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB requiere el cliente mejorado de [DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) incluido en AWS SDK for Java 2.x . Si aún usa [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), debe migrar AWS SDK for Java 2.x para usar DynamoDB Enhanced Client.
Siga las instrucciones para [migrar de la versión 1.x a la 2.x de AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).
A continuación, siga las instrucciones para [empezar a utilizar la API de cliente mejorada de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Antes de configurar la tabla para que utilice la biblioteca de cifrado del cliente de Java para DynamoDB, debe generar una `TableSchema`[mediante una clase de datos anotada y crear 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) cliente mejorado.](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)
## Paso 1: prepararse para leer y escribir elementos cifrados
Complete los siguientes pasos para preparar su cliente del SDK de cifrado AWS de bases de datos para leer y escribir elementos cifrados. Tras implementar los siguientes cambios, el cliente seguirá leyendo y escribiendo elementos de texto no cifrado. No cifrará ni firmará ningún elemento nuevo escrito en la tabla, pero podrá descifrar los elementos cifrados en cuanto aparezcan. Estos cambios preparan al cliente para empezar a [cifrar nuevos elementos.](#ddb-java-add-step2) Los siguientes cambios deben implementarse en cada lector antes de continuar con el siguiente paso.
**1. Defina las [acciones de sus atributos](concepts.md#crypt-actions)**
Actualice la clase de datos anotada para incluir acciones de atributos que definan qué valores de atributo se cifrarán y firmarán, cuáles solo se firmarán y cuáles se ignorarán.
Consulte el [SimpleClassarchivo.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) en el repositorio aws-database-encryption-sdk -dynamodb GitHub para obtener más información sobre las anotaciones del cliente mejorado de DynamoDB.
De forma predeterminada, los atributos de la clave principal están firmados pero no cifrados (`SIGN_ONLY`) y todos los demás atributos están cifrados y firmados `ENCRYPT_AND_SIGN`(). Para especificar las excepciones, utiliza las anotaciones de cifrado que se definen en la biblioteca de cifrado del cliente de Java para DynamoDB. Por ejemplo, si desea que un atributo concreto sea de solo firmar, utilice únicamente la anotación `@DynamoDbEncryptionSignOnly`. Si desea que un atributo concreto se firme e incluya en el contexto de cifrado, utilice la anotación. `@DynamoDbEncryptionSignAndIncludeInEncryptionContext` Si desea que un atributo concreto no esté firmado ni cifrado (`DO_NOTHING`), utilice la anotación `@DynamoDbEncryptionDoNothing`.
Si especifica algún `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, los atributos de partición y ordenación también deben serlo`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Para ver un ejemplo que muestre las anotaciones utilizadas para definir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consulte [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).
Para ver anotaciones de ejemplo, consulte [Utilice una clase de datos anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**2. Defina qué atributos se excluirán de las firmas**
En el ejemplo siguiente, se supone que todos los atributos `DO_NOTHING` comparten el prefijo distinto "`:`" y se utiliza el prefijo para definir los atributos no firmados permitidos. El cliente asumirá que cualquier nombre de atributo con el prefijo "`:`" está excluido de las firmas. Para obtener más información, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Cree un [conjunto de claves](keyrings.md)**
El siguiente ejemplo crea un [conjunto de claves de AWS KMS](use-kms-keyring.md). El AWS KMS anillo de claves utiliza un cifrado simétrico o un RSA asimétrico AWS KMS keys para generar, cifrar y descifrar las claves de datos.
En este ejemplo, se utiliza `CreateMrkMultiKeyring` para crear un conjunto de claves de AWS KMS con una clave de KMS de cifrado simétrico. El método `CreateAwsKmsMrkMultiKeyring` garantiza que el conjunto de claves maneje correctamente las claves de una sola región y de múltiples regiones.
```
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. Definir la configuración de cifrado de la tabla de DynamoDB **
El siguiente ejemplo define un mapa `tableConfigs` que representa la configuración de cifrado de esta tabla de DynamoDB.
En este ejemplo, se especifica el nombre de la tabla de DynamoDB como [nombre de la tabla lógica](ddb-java-using.md#logical-table-name). Se recomienda encarecidamente especificar el nombre de la tabla de DynamoDB como nombre de la tabla lógica cuando defina por primera vez la configuración de cifrado. Para obtener más información, consulte [Configuración de cifrado en el SDK de cifrado AWS de bases de datos para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Debe especificarlo `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` como modificación de texto no cifrado. Esta política sigue leyendo y escribiendo elementos de texto no cifrado, lee los elementos cifrados y prepara al cliente para escribir elementos cifrados.
```
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. Crear el `DynamoDbEncryptionInterceptor`**
En el siguiente ejemplo, se crea el `DynamoDbEncryptionInterceptor` con la misma `tableConfigs` del **Paso 3**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Paso 2: escribir elementos cifrados y firmados
Actualice la política de texto no cifrado de su `DynamoDbEncryptionInterceptor` configuración para permitir que el cliente escriba elementos cifrados y firmados. Tras implementar el siguiente cambio, el cliente cifrará y firmará los nuevos elementos en función de las acciones de atributos que configuró en el **paso** 1. El cliente podrá leer los elementos en texto no cifrado y los elementos cifrados y firmados.
Antes de continuar con el [Paso 3](#ddb-java-add-step3), debe cifrar y firmar todos los elementos de texto no cifrado existentes en la tabla. No existe una métrica o consulta única que pueda ejecutar para cifrar rápidamente los elementos de texto no cifrado existentes. Utilice el proceso que mejor se adapte a su sistema. Por ejemplo, puede utilizar un proceso asíncrono que escanee lentamente la tabla y reescriba los elementos mediante las acciones de los atributos y la configuración de cifrado que haya definido. Para identificar los elementos de texto sin formato de la tabla, se recomienda buscar todos los elementos que no contengan los `aws_dbe_foot` atributos que el SDK de cifrado de AWS bases de datos agrega a los elementos cuando están cifrados `aws_dbe_head` y firmados.
En el siguiente ejemplo, se actualiza la configuración de cifrado de la tabla desde el **paso 1**. Debe actualizar la anulación de texto no cifrado con `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT`. Esta política sigue leyendo los elementos de texto no cifrado, pero también lee y escribe los elementos cifrados. Cree una nueva `DynamoDbEncryptionInterceptor` con la actualización`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);
```
## Paso 3: Lee solo los elementos cifrados y firmados
Una vez cifrados y firmados todos los elementos, actualice la modificación del texto no cifrado de la `DynamoDbEncryptionInterceptor` configuración para que el cliente solo pueda leer y escribir los elementos cifrados y firmados. Tras implementar el siguiente cambio, el cliente cifrará y firmará los nuevos elementos en función de las acciones de atributos que configuró en el **paso 1**. El cliente solo podrá leer los elementos cifrados y firmados.
El siguiente ejemplo actualiza la configuración de cifrado de la tabla desde el **paso 2**. Puede actualizar la anulación de texto no cifrado con `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` o eliminar la política de texto no cifrado de su configuración. De forma predeterminada, el cliente solo lee y escribe los elementos cifrados y firmados. Cree una nueva `DynamoDbEncryptionInterceptor` con la actualización`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);
```
# Migre a la versión 3.x de la biblioteca de cifrado del cliente de Java para DynamoDB
****
| |
| --- |
| Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de AWS bases de datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). |
Versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB es una importante reescritura de la base de código 2.*x*. Incluye numerosas actualizaciones, como un nuevo formato de datos estructurados, una compatibilidad mejorada de multitenencia, cambios de esquema fluidos y compatibilidad con el cifrado para búsquedas. En este tema se proporciona orientación sobre cómo migrar el código a la versión 3.*x*.
## Migración de la versión 1.x a la versión 2.x
Migre a la versión 2.*x* antes de migrar a la versión 3.*x*. Versión 2. *x* cambió el símbolo del proveedor más reciente de `MostRecentProvider` a`CachingMostRecentProvider`. Si actualmente usa la versión 1. *x* de la biblioteca de cifrado del cliente de Java para DynamoDB con el `MostRecentProvider` símbolo, debe actualizar el nombre del símbolo en el código a. `CachingMostRecentProvider` Para obtener más información, consulte [Actualizaciones del proveedor más reciente](most-recent-provider.md#mrp-versions).
## Migración de la versión 2.x a la versión 3.x
En los siguientes procedimientos se describe cómo migrar el código desde la versión 2.*x* a la versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB.
### Paso 1. Prepárese para leer los elementos en el nuevo formato
Complete los siguientes pasos para preparar su cliente del SDK AWS de cifrado de bases de datos para leer los elementos en el nuevo formato. Tras implementar los siguientes cambios, el cliente seguirá comportándose del mismo modo que en la versión 2. *x*. Su cliente seguirá leyendo y escribiendo los elementos de la versión 2. formato *x*, pero estos cambios preparan al cliente para [leer los elementos en el nuevo formato](#ddb-java-migrate-step2).
**Actualice su versión AWS SDK para Java a la 2.x**
Versión 3.*x* de la biblioteca de cifrado del cliente de Java para DynamoDB requiere el [cliente mejorado de DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). El cliente mejorado de DynamoDB reemplaza al DBMapper Dynamo utilizado [en](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) versiones anteriores. Para usar el cliente mejorado, debe usar el. AWS SDK for Java 2.x
Siga las instrucciones para [migrar de la versión 1.x a la 2.x de AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html).
Para obtener más información sobre los AWS SDK for Java 2.x módulos necesarios, consulte. [Requisitos previos](ddb-java.md#ddb-java-prerequisites)
**Configure su cliente para que lea los elementos cifrados por las versiones antiguas**
Los siguientes procedimientos proporcionan una descripción general de los pasos que se muestran en el siguiente ejemplo de código.
1. Cree un [conjunto de claves](keyrings.md).
Los [administradores de conjunto de claves y materiales criptográficos](concepts.md#crypt-materials-manager) sustituyen a los proveedores de materiales criptográficos utilizados en las versiones anteriores de la biblioteca de cifrado del cliente de Java para DynamoDB.
**importante**
Las claves de encapsulación que especifique al crear un conjunto de claves deben ser las mismas claves de encapsulación que utilizó con su proveedor de materiales criptográficos en la versión 2. *x*.
1. Crea un esquema de tabla sobre tu clase anotada.
En este paso se definen las acciones de atributos que se utilizarán cuando comience a escribir elementos en el nuevo formato.
Para obtener instrucciones sobre el uso del nuevo cliente mejorado de DynamoDB, consulte [Generar un `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) en la * Guía para desarrolladores de AWS SDK para Java *.
En el siguiente ejemplo, se supone que actualizó la clase anotada a partir de la versión 2.*x* utilizando las nuevas anotaciones de acciones de atributos. Para obtener más información sobre cómo anotar las acciones de los atributos, consulte [Utilice una clase de datos anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**nota**
Si especifica algún `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, los atributos de partición y ordenación también deben serlo`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Para ver un ejemplo que muestre las anotaciones utilizadas para definir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consulte [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. Defina qué [atributos se excluyen de la firma](ddb-java-using.md#allowed-unauth).
1. Configure un mapa explícito de las acciones de los atributos configuradas en su clase modelada de la versión 2.x.
En este paso, se definen las acciones de atributo utilizadas para escribir los elementos en el formato anterior.
1. Configure el `DynamoDBEncryptor` que utilizó en la versión 2. *x* de la biblioteca de cifrado del cliente de Java para DynamoDB.
1. Configure el comportamiento heredado.
1. Crear una `DynamoDbEncryptionInterceptor`.
1. Cree un nuevo cliente AWS SDK de DynamoDB.
1. Cree el `DynamoDBEnhancedClient` y cree una tabla con su clase modelada.
Para obtener más información sobre el cliente mejorado de DynamoDB, [consulte crear 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) cliente mejorado.
```
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);
}
}
```
### Paso 2. Escriba los elementos en el nuevo formato
Una vez implementados los cambios del paso 1 en todos los lectores, complete los siguientes pasos para configurar su cliente del SDK de cifrado de AWS bases de datos para escribir elementos en el nuevo formato. Tras implementar los siguientes cambios, el cliente seguirá leyendo los elementos en el formato anterior y empezará a escribir y leer los elementos en el nuevo formato.
Los siguientes procedimientos proporcionan una descripción general de los pasos que se muestran en el siguiente ejemplo de código.
1. Siga configurando el conjunto de claves, el esquema de la tabla, las acciones de los atributos heredados, `allowedUnsignedAttributes` y `DynamoDBEncryptor` tal y como hizo en el [**Paso 1**](#ddb-java-migrate-step1).
1. Actualice su comportamiento anterior para escribir solo elementos nuevos con el nuevo formato.
1. Crear una `DynamoDbEncryptionInterceptor `
1. Cree un nuevo cliente AWS SDK de DynamoDB.
1. Cree el `DynamoDBEnhancedClient` y cree una tabla con su clase modelada.
Para obtener más información sobre el cliente mejorado de DynamoDB, consulte [Create an enhanced client](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).
```
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);
}
}
```
Tras implementar los cambios del paso 2, debe volver a cifrar todos los elementos antiguos de la tabla con el nuevo formato para poder continuar con el [Paso 3](#ddb-java-migrate-step3). No hay una única métrica o consulta que puedas ejecutar para cifrar rápidamente los elementos existentes. Utilice el proceso que mejor se adapte a su sistema. Por ejemplo, podría utilizar un proceso asíncrono que escanee lentamente la tabla y reescriba los elementos utilizando las nuevas acciones de atributo y la nueva configuración de cifrado que haya definido.
### Paso 3. Lea y escriba únicamente los elementos en el nuevo formato
Tras volver a cifrar todos los elementos de la tabla con el nuevo formato, puede eliminar el comportamiento anterior de la configuración. Siga los pasos que se indican a continuación para configurar el cliente para que solo lea y escriba los elementos en el nuevo formato.
Los siguientes procedimientos proporcionan una descripción general de los pasos que se muestran en el siguiente ejemplo de código.
1. Continúe configurando el conjunto de claves, el esquema de la tabla y `allowedUnsignedAttributes` tal como lo hizo en el [**Paso 1**](#ddb-java-migrate-step1). Elimine las acciones y acciones de los atributos heredados `DynamoDBEncryptor` de su configuración.
1. Creación de una `DynamoDbEncryptionInterceptor`.
1. Cree un nuevo cliente AWS SDK de DynamoDB.
1. Cree el `DynamoDBEnhancedClient` y cree una tabla con su clase modelada.
Para obtener más información sobre el cliente mejorado de DynamoDB, consulte [Create an enhanced client](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).
```
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);
}
}
```