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.
# Lenguajes de programación disponibles para el Cliente de encriptación de Amazon DynamoDB
**nota**
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
El Cliente de encriptación de Amazon DynamoDB está disponible para los siguientes lenguajes de programación. Las bibliotecas específicas de lenguaje varían, pero las implementaciones resultantes son interoperables. Por ejemplo, puede cifrar (y firmar) un elemento con el cliente Java y descifrar el elemento con el cliente Python.
Para obtener más información, consulte el tema correspondiente.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# Cliente de encriptación de Amazon DynamoDB para Java
**nota**
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
En este tema, se explica cómo instalar y utilizar el Cliente de encriptación de Amazon DynamoDB para Java. Para obtener más información sobre la programación con el cliente de cifrado de DynamoDB, consulte [los ejemplos de Java](java-examples.md), [los ejemplos del](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) repositorio GitHub y aws-dynamodb-encryption-java el Javadoc [del](https://aws.github.io/aws-dynamodb-encryption-java/) cliente de cifrado de DynamoDB.
**nota**
Versiones 1. *x*. *x* del cliente de cifrado de DynamoDB para Java entrarán [end-of-support en](what-is-database-encryption-sdk.md#support) fase a partir de julio de 2022. Actualice a una versión más reciente tan pronto como sea posible.
**Topics**
+ [Requisitos previos](#java-prerequisites)
+ [Instalación](#java-installation)
+ [Uso del cliente de cifrado de DynamoDB para Java](java-using.md)
+ [Ejemplos de Java](java-examples.md)
## Requisitos previos
Antes de instalar el Cliente de encriptación de Amazon DynamoDB para Java, asegúrese de que cumple 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 para Java**
El cliente de cifrado de DynamoDB requiere el módulo DynamoDB incluso si la aplicación no interactúa con DynamoDB. AWS SDK para Java Puede instalar todo el SDK o solo este módulo. Si utiliza Maven, añada `aws-java-sdk-dynamodb` al archivo `pom.xml`.
Para obtener más información sobre la instalación y configuración del, consulte. AWS SDK para Java[AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html)
## Instalación
Puede instalar el Cliente de encriptación de Amazon DynamoDB para Java de las siguientes maneras.
**Manualmente**
Para instalar el cliente de cifrado Amazon DynamoDB para Java, clone o descargue el repositorio. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**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.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Tras instalar el SDK, comience consultando el código de ejemplo de esta guía y el Javadoc del cliente de [cifrado de DynamoDB](https://aws.github.io/aws-dynamodb-encryption-java/). GitHub
# Uso del cliente de cifrado de DynamoDB para Java
**nota**
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
En este tema, se explican algunas de las características del cliente de cifrado de DynamoDB en Java que podrían no encontrarse en otras implementaciones de lenguaje de programación.
[Para obtener más información sobre la programación con el cliente de cifrado de DynamoDB, consulte [los ejemplos de Java, los](java-examples.md) ejemplos de GitHub on y [el](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) Javadoc `aws-dynamodb-encryption-java repository` del cliente de cifrado de DynamoDB.](https://aws.github.io/aws-dynamodb-encryption-java/)
**Topics**
+ [Encriptadores de elementos](#attribute-encryptor)
+ [Configuración del comportamiento de almacenamiento](#save-behavior)
+ [Acciones de atributo en Java](#attribute-actions-java)
+ [Reemplazar nombres de tabla](#override-table-name)
## Encriptadores de elementos: y Dynamo AttributeEncryptor DBEncryptor
[El cliente de cifrado de DynamoDB en Java tiene [dos cifradores de elementos](DDBEC-legacy-concepts.md#item-encryptor): el Dynamo de nivel inferior y el. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
`AttributeEncryptor`Es una clase auxiliar que le ayuda a usar [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK para Java con DBMapper el cliente de cifrado `DynamoDB Encryptor` de DynamoDB. Cuando utiliza el `AttributeEncryptor` con el `DynamoDBMapper`, cifra y firma de forma transparente los elementos cuando los guarda. También verifica y descifra de forma transparente los elementos al cargarlos.
## Configuración del comportamiento de almacenamiento
Puede usar el `AttributeEncryptor` y `DynamoDBMapper` para agregar o editar elementos de la tabla con atributos que solo están firmados o que están cifrados y firmados. Para estas tareas, recomendamos que lo configure para que use el comportamiento de guardado `PUT`, tal como se muestra en el siguiente ejemplo. De lo contrario, es posible que no pueda descifrar los datos.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Si utiliza el comportamiento de almacenamiento predeterminado, que actualiza los atributos en el elemento de la tabla, solo se incluyen en la firma atributos que se hayan cambiado. Como resultado, en las lecturas posteriores de todos los atributos, la firma no se validará, porque no incluye los atributos no modelados.
También puede utilizar el comportamiento de guardado `CLOBBER`. Este comportamiento es idéntico al comportamiento de guardado `PUT`, pero deshabilita el bloqueo positivo y sobrescribe el elemento en la tabla.
Para evitar errores de firma, el cliente de cifrado de DynamoDB lanza una excepción de tiempo de ejecución si se utiliza un `AttributeEncryptor` con un `DynamoDBMapper` que no está configurado con un comportamiento seguro de `CLOBBER` o `PUT`.
Para ver este código utilizado en un ejemplo, consulte [Uso del Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) y el ejemplo de [AwsKmsEncryptedObject.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) en el repositorio de. `aws-dynamodb-encryption-java` GitHub
## Acciones de atributo en Java
Las [acciones de atributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinan qué valores de atributo se cifran y se firman, cuáles solo se firman y cuáles se omiten. [El método que utilice para especificar las acciones de los atributos depende de si utiliza el Dynamo de nivel inferior o el `DynamoDBMapper` Dynamo de nivel inferior. `AttributeEncryptor` DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**importante**
Después de utilizar las acciones de atributo para cifrar los elementos de la tabla, agregar o quitar atributos del modelo de datos puede provocar un error de validación de firma que le impide descifrar los datos. Para ver una explicación detallada, consulte [Cambiar el modelo de datos](data-model.md).
### Acciones de atributos para el Dynamo DBMapper
Cuando utilice `DynamoDBMapper` y `AttributeEncryptor`, utilice anotaciones para especificar las acciones de atributos. El cliente de cifrado de DynamoDB utiliza las [anotaciones de atributo estándar](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.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**
No cifre el valor de los atributos con la [anotación @Dynamo DBVersion Attribute](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), aunque puede (y debe) firmarlos. De lo contrario, las condiciones que utilizan su valor tendrán efectos no previstos.
```
// Attributes are encrypted and signed
@DynamoDBAttribute(attributeName="Description")
// Partition keys are signed but not encrypted
@DynamoDBHashKey(attributeName="Title")
// Sort keys are signed but not encrypted
@DynamoDBRangeKey(attributeName="Author")
```
Para especificar las excepciones, utilice las anotaciones de cifrado que se definen en el cliente de cifrado de DynamoDB para Java. Si las especifica en el nivel de clase, se convierten en el valor predeterminado para la clase.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Por ejemplo, estas anotaciones firman pero no cifran el atributo `PublicationYear` y no cifran o firman el valor del atributo `ISBN`.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Acciones de atributos para el Dynamo DBEncryptor
Para especificar las acciones de los atributos cuando utilice la [Dinamo DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) directamente, cree un `HashMap` objeto en el que los pares nombre-valor representen los nombres de los atributos y las acciones especificadas.
Los valores válidos para las acciones de atributo que se definen en el tipo enumerado `EncryptionFlags`. Puede utilizar `ENCRYPT` y `SIGN` juntos, usar `SIGN` solo u omitir ambos. Sin embargo, si usa `ENCRYPT` solo, el cliente de cifrado de DynamoDB generará un error. No puede cifrar un atributo que no firme.
```
ENCRYPT
SIGN
```
**aviso**
No cifre los atributos de clave principal. Deben permanecer en texto no cifrado para que DynamoDB pueda encontrar el elemento sin realizar un examen completo de la tabla.
Si especifica una clave principal en el contexto de cifrado y, a continuación, especifica `ENCRYPT` en la acción de atributo para alguno de los atributos de clave principal, el cliente de cifrado de DynamoDB genera una excepción.
Por ejemplo, el siguiente código Java crea un código `actions` HashMap que cifra y firma todos los atributos del elemento. `record` Las excepciones son la clave de partición y los atributos de clave de clasificación, que se firman pero no se cifran, y el atributo `test`, que ni se signa ni se cifra.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // no break; falls through to next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Don't encrypt or sign
break;
default:
// Encrypt and sign everything else
actions.put(attributeName, encryptAndSign);
break;
}
}
```
A continuación, cuando llama al método [encryptRecord](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html#encryptRecord-java.util.Map-java.util.Map-com.amazonaws.services.dynamodbv2.datamodeling.encryption.EncryptionContext-) del `DynamoDBEncryptor`, especifique el mapa como el valor del parámetro `attributeFlags`. Por ejemplo, esta llamada a `encryptRecord` utiliza el mapa `actions`.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Reemplazar nombres de tabla
En el cliente de cifrado de DynamoDB, el nombre de la tabla de DynamoDB es un elemento del [contexto de cifrado de DynamoDB](concepts.md#encryption-context) que se pasa a los métodos de cifrado y descifrado. Al cifrar o firmar elementos de la tabla, el contexto de cifrado de DynamoDB, incluido el nombre de la tabla, está enlazado criptográficamente al texto cifrado. Si el contexto de cifrado de DynamoDB que se pasa al método de descifrado no coincide con el contexto de cifrado de DynamoDB que se pasó al método de cifrado, se produce un error en la operación de descifrado.
En ocasiones, el nombre de una tabla cambia, por ejemplo, cuando se hace una copia de seguridad de una tabla o se realiza una [point-in-time recuperación](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html). Al descifrar o verificar la firma de estos elementos, debe pasar el mismo contexto de cifrado de DynamoDB que se utilizó para cifrar y firmar los elementos, incluido el nombre de la tabla original. El nombre de la tabla actual no es necesario.
Cuando se utiliza `DynamoDBEncryptor`, se ensambla el contexto de cifrado de DynamoDB manualmente. Sin embargo, si está utilizando `DynamoDBMapper`, el `AttributeEncryptor` crea el contexto de cifrado de DynamoDB para usted, incluido el nombre de la tabla actual. Para indicar a `AttributeEncryptor` que cree un contexto de cifrado con un nombre de tabla diferente, utilice el `EncryptionContextOverrideOperator`.
Por ejemplo, el código siguiente crea instancias del proveedor de materiales criptográficos (CMP) y el `DynamoDBEncryptor`. Luego llama al método `setEncryptionContextOverrideOperator` de `DynamoDBEncryptor`. Utiliza el operador `overrideEncryptionContextTableName`, que anula un nombre de tabla. Cuando se configura de esta manera, el `AttributeEncryptor` crea un contexto de cifrado de DynamoDB que incluye `newTableName` en lugar de `oldTableName`. Para ver un ejemplo completo, consulte [EncryptionContextOverridesWithDynamoDBMapper.java.](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/EncryptionContextOverridesWithDynamoDBMapper.java)
```
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
encryptor.setEncryptionContextOverrideOperator(EncryptionContextOperators.overrideEncryptionContextTableName(
oldTableName, newTableName));
```
Cuando se llama al método de carga de `DynamoDBMapper`, que descifra y verifica el elemento, se especifica el nombre de la tabla original.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
También puede utilizar el operador `overrideEncryptionContextTableNameUsingMap`, que anula varios nombres de tabla.
Normalmente los operadores de reemplazo de nombres de tabla se utilizan al descifrar datos y verificar firmas. Sin embargo, puede usarlos para establecer el nombre de la tabla en el contexto de cifrado de DynamoDB en un valor diferente al cifrar y firmar.
No utilice los operadores de anulación de nombre de tabla si está utilizando `DynamoDBEncryptor`. En su lugar, cree un contexto de cifrado con el nombre de la tabla original y envíelo al método de descifrado.
# Ejemplo de código para el cliente de cifrado de DynamoDB para Java
**nota**
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Los siguientes ejemplos muestran cómo utilizar el cliente de cifrado de DynamoDB para Java para proteger los elementos de tabla de DynamoDB en su aplicación. Puedes encontrar más ejemplos (y aportar los tuyos) en el directorio de [ejemplos](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) del [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/)repositorio en GitHub.
**Topics**
+ [¿Usando el Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Uso del Dynamo DBMapper](#java-example-dynamodb-mapper)
## ¿Usando el Dynamo DBEncryptor
En este ejemplo, se muestra cómo utilizar el [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) de nivel inferior DBEncryptor con el proveedor de [Direct](direct-kms-provider.md) KMS. El proveedor de KMS directo genera y protege sus materiales criptográficos con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) que usted especifique.
Puede usar cualquier [proveedor de materiales criptográficos](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatible con`DynamoDBEncryptor`, y puede usar el proveedor de Direct KMS con y. `DynamoDBMapper` [AttributeEncryptor](java-using.md#attribute-encryptor)
**[Consulte el ejemplo de código completo: .java AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)**
Paso 1: crear el proveedor de KMS directo
Cree una instancia del AWS KMS cliente con la región especificada. A continuación, utilice la instancia de cliente para crear una instancia del proveedor de KMS directo con su AWS KMS key preferido.
En este ejemplo, se utiliza el nombre de recurso de Amazon (ARN) para identificar el AWS KMS key, pero se puede utilizar [cualquier identificador clave válido](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Paso 2: crear un elemento
En este ejemplo se define un elemento `record` HashMap que representa un ejemplo de una tabla.
```
final String partitionKeyName = "partition_attribute";
final String sortKeyName = "sort_attribute";
final Map record = new HashMap<>();
record.put(partitionKeyName, new AttributeValue().withS("value1"));
record.put(sortKeyName, new AttributeValue().withN("55"));
record.put("example", new AttributeValue().withS("data"));
record.put("numbers", new AttributeValue().withN("99"));
record.put("binary", new AttributeValue().withB(ByteBuffer.wrap(new byte[]{0x00, 0x01, 0x02})));
record.put("test", new AttributeValue().withS("test-value"));
```
Paso 3: Crear una dinamo DBEncryptor
Cree una instancia del `DynamoDBEncryptor` con el proveedor de KMS directo.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Paso 4: crear un contexto de cifrado de DynamoDB
El [contexto de cifrado de DynamoDB](concepts.md#encryption-context) contiene información acerca de la estructura de la tabla y cómo se cifra y se firma. Si utiliza el `DynamoDBMapper`, el `AttributeEncryptor` crea el contexto de cifrado automáticamente.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Paso 5: crear el objeto de acciones de atributo
Las [acciones de atributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinan qué atributos del elemento se cifran y se firman, cuáles solo se firman y cuáles no se cifran o firman.
En Java, para especificar las acciones de los atributos, se crea un par HashMap de pares de nombre y `EncryptionFlags` valor del atributo.
Por ejemplo, el siguiente código de Java crea un código `actions` HashMap que cifra y firma todos los atributos `record` del elemento, excepto los atributos de la clave de partición y la clave de clasificación, que están firmados, pero no cifrados, y el `test` atributo, que no está firmado ni cifrado.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // fall through to the next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Neither encrypted nor signed
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Paso 6: cifrar y firmar el elemento
Para cifrar y firmar el elemento de tabla, llame al método `encryptRecord` en la instancia del `DynamoDBEncryptor`. Especifique el elemento de tabla (`record`), las acciones de atributo (`actions`) y el contexto de cifrado (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Paso 7: colocar el elemento en la tabla de DynamoDB
Finalmente, coloque el elemento cifrado y firmado en la tabla de DynamoDB.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Uso del Dynamo DBMapper
El ejemplo siguiente le muestra cómo utilizar la clase auxiliar del DynamoDB Mapper con el [Proveedor de KMS directo](direct-kms-provider.md). El proveedor de KMS directo genera y protege sus materiales criptográficos con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) en AWS Key Management Service (AWS KMS) que usted especifique.
Puede utilizar cualquier [proveedor de materiales criptográficos](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatible con el `DynamoDBMapper` y puede utilizar el proveedor de KMS directo con el `DynamoDBEncryptor` de nivel inferior.
**[Consulte el ejemplo de código completo: .java AwsKmsEncryptedObject](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)**
Paso 1: crear el proveedor de KMS directo
Cree una instancia del AWS KMS cliente con la región especificada. A continuación, utilice la instancia de cliente para crear una instancia del proveedor de KMS directo con su AWS KMS key preferido.
En este ejemplo, se utiliza el nombre de recurso de Amazon (ARN) para identificar el AWS KMS key, pero se puede utilizar [cualquier identificador clave válido](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Paso 2: Crear DynamoDB Encryptor y Dynamo DBMapper
Utilice el Proveedor de KMS directo que creó en el paso anterior para crear una instancia del [Encriptador de DynamoDB](java-using.md#attribute-encryptor). Debe crear instancias en el Encriptador de DynamoDB de nivel inferior para utilizar DynamoDB Mapper.
A continuación, cree una instancia de base de datos de DynamoDB y una configuración de mapeador, y úselas para crear una instancia de DynamoDB Mapper.
Al utilizar el `DynamoDBMapper` para añadir o editar elementos firmados (o cifrados y firmados), configúrelo para [usar un comportamiento de almacenamiento](java-using.md#save-behavior), como `PUT`, que incluye todos los atributos, como se muestra en el ejemplo siguiente. De lo contrario, es posible que no pueda descifrar los datos.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp)
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Paso 3: Definir la tabla de DynamoDB
A continuación, defina la tabla de DynamoDB. Utilice anotaciones para especificar las [acciones del atributo](java-using.md#attribute-actions-java). En este ejemplo, se crea una tabla de DynamoDB, `ExampleTable`, y una clase `DataPoJo` que representa elementos de la tabla.
En este ejemplo de tabla, los atributos de clave principal se firmarán, pero no se cifrarán. Esto se aplica al `partition_attribute`, que se ha anotado con `@DynamoDBHashKey`, y el `sort_attribute`, que se ha anotado con `@DynamoDBRangeKey`.
Los atributos que son anotados con `@DynamoDBAttribute`, como `some numbers`, se cifrarán y firmarán. Las excepciones son atributos que utilizan las anotaciones de cifrado `@DoNotEncrypt` (solo firmar) o `@DoNotTouch` (no cifrar ni firmar) definidas por el cliente de cifrado de DynamoDB. Por ejemplo, ya que el atributo `leave me` tiene una anotación `@DoNotTouch`, no se cifrará ni se firmará.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String example;
private long someNumbers;
private byte[] someBinary;
private String leaveMe;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "example")
public String getExample() {
return example;
}
public void setExample(String example) {
this.example = example;
}
@DynamoDBAttribute(attributeName = "some numbers")
public long getSomeNumbers() {
return someNumbers;
}
public void setSomeNumbers(long someNumbers) {
this.someNumbers = someNumbers;
}
@DynamoDBAttribute(attributeName = "and some binary")
public byte[] getSomeBinary() {
return someBinary;
}
public void setSomeBinary(byte[] someBinary) {
this.someBinary = someBinary;
}
@DynamoDBAttribute(attributeName = "leave me")
@DoNotTouch
public String getLeaveMe() {
return leaveMe;
}
public void setLeaveMe(String leaveMe) {
this.leaveMe = leaveMe;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ", sortAttribute="
+ sortAttribute + ", example=" + example + ", someNumbers=" + someNumbers
+ ", someBinary=" + Arrays.toString(someBinary) + ", leaveMe=" + leaveMe + "]";
}
}
```
Paso 4: Cifrar y guardar un elemento de la tabla
Ahora, al crear un elemento de tabla y utilizar DynamoDB Mapper para guardarlo, el elemento se cifra automáticamente y firma antes de que se agregue a la tabla.
Este ejemplo define un elemento de tabla llamado `record`. Antes de que se guarde en la tabla, sus atributos se cifran y firman en función de las anotaciones de la clase `DataPoJo`. En este caso, todos los atributos salvo `PartitionAttribute`, `SortAttribute` y `LeaveMe` se cifran y se firman. `PartitionAttribute` y `SortAttributes` solo se firman. El atributo `LeaveMe` no está cifrado o firmado.
Para cifrar y firmar el elemento `record`y, a continuación, añadirlo a `ExampleTable`, llame al método `save` de la clase `DynamoDBMapper`. Dado que el DynamoDB mapper está configurado para utilizar el `PUT` comportamiento de almacenamiento, el elemento sustituye a cualquier elemento con las mismas claves principales, en lugar de actualizarla. De este modo, se garantiza que las firmas coincidan y puede descifrar el elemento cuando se obtiene de la tabla.
```
DataPoJo record = new DataPoJo();
record.setPartitionAttribute("is this");
record.setSortAttribute(55);
record.setExample("data");
record.setSomeNumbers(99);
record.setSomeBinary(new byte[]{0x00, 0x01, 0x02});
record.setLeaveMe("alone");
mapper.save(record);
```
# Cliente de cifrado de DynamoDB para Python
**nota**
Nuestra biblioteca de cifrado del cliente [pasó a llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
En este tema, se explica cómo instalar y utilizar el cliente de cifrado de DynamoDB para en Python. Puede encontrar el código en el [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repositorio de GitHub, incluido un [código de muestra](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) completo y probado que le ayudará a empezar.
**nota**
Versiones 1. *x*. *x* y 2. *x*. *x* del cliente de cifrado de DynamoDB para Python entrarán en vigor [end-of-support en](what-is-database-encryption-sdk.md#support) julio de 2022. Actualice a una versión más reciente tan pronto como sea posible.
**Topics**
+ [Requisitos previos](#python-prerequisites)
+ [Instalación](#python-installation)
+ [Uso del cliente de cifrado de DynamoDB para Python](python-using.md)
+ [Ejemplos de Python](python-examples.md)
## Requisitos previos
Antes de instalar el Cliente de encriptación de Amazon DynamoDB para Python, asegúrese de que cumple los siguientes requisitos previos.
**Una versión compatible de Python**
El cliente de cifrado de Amazon DynamoDB para las versiones 3.3.0 y posteriores de Python requiere Python 3.8 o posterior. Para descargar Python, visite el sitio de [descargas de Python](https://www.python.org/downloads/).
Las versiones anteriores del Cliente de encriptación de Amazon DynamoDB para Python admiten Python 2.7 y Python 3.4 y versiones posteriores, pero le recomendamos que utilice la versión más reciente del cliente de cifrado de DynamoDB.
**La herramienta de instalación pip para Python**
Python 3.6 y versiones posteriores incluyen **pip**, aunque es posible que desee actualizarlo. Para obtener más información acerca de la actualización o la instalación de pip, consulte la sección sobre la [instalación](https://pip.pypa.io/en/latest/installation/) en la documentación de **pip**.
## Instalación
Utilice **pip** para instalar el Cliente de encriptación de Amazon DynamoDB para Python, como se muestra en los siguientes ejemplos.
**Para instalar la versión más reciente**
```
pip install dynamodb-encryption-sdk
```
Para obtener más información acerca de cómo utilizar **pip** para instalar y actualizar paquetes, consulte la página sobre la [instalación de paquetes](https://packaging.python.org/tutorials/installing-packages/).
El cliente de cifrado de DynamoDB requiere la [biblioteca de criptografía](https://cryptography.io/en/latest/) en todas las plataformas. Todas las versiones de **pip** instalan y compilan la biblioteca **cryptography** en Windows. **pip** 8.1 y las versiones posteriores instalan y compilan la biblioteca **cryptography** en Linux. Si utiliza una versión anterior de **pip** y su entorno Linux no dispone de las herramientas necesarias para compilar la biblioteca **cryptography**, tiene que instalarlas. Para obtener más información, consulte [Building cryptography on Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
Puede obtener la última versión de desarrollo del cliente de cifrado de DynamoDB desde [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)el repositorio en adelante. GitHub
Después de instalar el cliente de cifrado de DynamoDB, comience examinando el código de Python de ejemplo de esta guía.
# Uso del cliente de cifrado de DynamoDB para Python
**nota**
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
En este tema, se explican algunas de las características del cliente de cifrado de DynamoDB para Python que podrían no encontrarse en otras implementaciones de lenguaje de programación. Estas características se han diseñado para facilitar el uso del cliente de cifrado de DynamoDB de la forma más segura. A menos que tenga un caso de uso inusual, le recomendamos que las utilice.
Para obtener más información sobre la programación con el cliente de cifrado de DynamoDB, consulte los ejemplos de [Python](python-examples.md) de esta guía, [los ejemplos del](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) repositorio GitHub y aws-dynamodb-encryption-python la documentación de [Python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) del cliente de cifrado de DynamoDB.
**Topics**
+ [Clases auxiliares de cliente](#python-helpers)
+ [TableInfo clase](#table-info)
+ [Acciones de atributo en Python](#python-attribute-actions)
## Clases auxiliares de cliente
El cliente de cifrado de DynamoDB para Python incluye varias clases auxiliares de cliente, que interactúan con las clases de Boto 3 para DynamoDB. Estas clases auxiliares se han diseñado para facilitar agregar cifrado y firma a su aplicación de DynamoDB existente y evitar los problemas más habituales del siguiente modo:
+ Evite cifrar la clave principal del elemento, ya sea añadiendo una acción de anulación de la clave principal del objeto o lanzando una excepción si el [AttributeActions](#python-attribute-actions)objeto indica explícitamente al cliente que cifre la clave principal. `AttributeActions` Si la acción predeterminada en su objeto `AttributeActions` es `DO_NOTHING`, las clases auxiliares de cliente utilizan dicha acción para la clave principal. De lo contrario, utilizan `SIGN_ONLY`.
+ Cree un [TableInfo objeto y complete](#python-helpers) el contexto de [cifrado de DynamoDB en función de una llamada a DynamoDB](concepts.md#encryption-context). Esto ayuda a garantizar que el contexto de cifrado de DynamoDB sea exacto y el cliente pueda identificar la clave principal.
+ Admite métodos, tales como `put_item` y `get_item`, que cifran y descifran de modo transparente los elementos de tabla al escribir o leer desde una tabla de DynamoDB. Solo el método `update_item` no se admite.
Puede utilizar las clases auxiliares de cliente en lugar de interactuar directamente con el [encriptador de elementos](DDBEC-legacy-concepts.md#item-encryptor) de nivel inferior. Utilice estas clases a menos que tenga que establecer opciones avanzadas en el encriptador de elementos.
Las clases auxiliares de cliente incluyen:
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)para las aplicaciones que utilizan el recurso [Tabla](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) de DynamoDB para procesar una tabla a la vez.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)para aplicaciones que utilizan la clase [Service Resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) de DynamoDB para el procesamiento por lotes.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)para aplicaciones que utilizan el [cliente de nivel inferior de DynamoDB](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client).
Para usar las clases auxiliares del cliente, la persona que llama debe tener permiso para llamar a la operación de DynamoDB en la tabla de destino [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html).
## TableInfo clase
La [TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)clase es una clase auxiliar que representa una tabla de DynamoDB, completa con campos para su clave principal e índices secundarios. Le ayuda a obtener información precisa y en tiempo real sobre la tabla.
Si utiliza una [clase auxiliar de cliente](#python-helpers), crea y utiliza un objeto `TableInfo` automáticamente. De lo contrario, puede crear una explícitamente. Para ver un ejemplo, consulta [Utilice el encriptador de elementos](python-examples.md#python-example-item-encryptor).
Cuando se llama al `refresh_indexed_attributes` método en un `TableInfo` objeto, se rellenan los valores de las propiedades del objeto mediante una llamada a la operación DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Consultar la tabla ofrece mucha más confianza que codificar de forma rígida los nombres de índice. La clase `TableInfo` incluye además una `encryption_context_values` propiedad que proporciona los valores requeridos para el [contexto de cifrado de DynamoDB](concepts.md#encryption-context).
Para usar el `refresh_indexed_attributes` método, la persona que llama debe tener permiso para llamar a la operación de [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB en la tabla de destino.
## Acciones de atributo en Python
Las [acciones de atributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) indican al encriptador de elementos qué acciones hay que realizar en cada atributo del elemento. Para especificar acciones de atributo en Python, cree un objeto `AttributeActions` con una acción predeterminada y cualquier excepción para atributos particulares. Los valores válidos se definen en el tipo enumerado `CryptoAction`.
**importante**
Después de utilizar las acciones de atributo para cifrar los elementos de la tabla, agregar o quitar atributos del modelo de datos puede provocar un error de validación de firma que le impide descifrar los datos. Para ver una explicación detallada, consulte [Cambiar el modelo de datos](data-model.md).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Por ejemplo, este objeto `AttributeActions` establece `ENCRYPT_AND_SIGN` como predeterminado para todos los atributos y especifica excepciones para los atributos `ISBN` y `PublicationYear`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Si utiliza una [clase auxiliar de cliente](#python-helpers), no tiene que especificar una acción de atributo para los atributos de clave principal. Las clases auxiliares de cliente impiden que cifre su clave principal.
Si no utiliza una clase auxiliar de cliente y la acción predeterminada es `ENCRYPT_AND_SIGN`, debe especificar una acción para la clave principal. La acción recomendada para las claves principales es `SIGN_ONLY`. Para facilitarlo, utilice el método `set_index_keys`, que utiliza SIGN\$1ONLY para claves principales o DO\$1NOTHING, cuando esa es la acción predeterminada.
**aviso**
No cifre los atributos de clave principal. Deben permanecer en texto no cifrado para que DynamoDB pueda encontrar el elemento sin realizar un examen completo de la tabla.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Código de ejemplo para el cliente de cifrado de DynamoDB para Python
**nota**
Nuestra biblioteca de cifrado del cliente pasó a [llamarse SDK de cifrado de bases de datos de AWS](DDBEC-rename.md). En el siguiente tema, se presenta información sobre las versiones 1.*x*—2.*x* del cliente de cifrado de DynamoDB para Java y versiones 1.*x*—3.*x* del cliente de cifrado de DynamoDB para Python. Para obtener más información, consulte el [SDK de cifrado de bases de datos de AWS para la compatibilidad de la versión de DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
En los siguientes ejemplos, se muestra cómo utilizar el cliente de cifrado de DynamoDB para Python para proteger los datos de DynamoDB en su aplicación. Puedes encontrar más ejemplos (y aportar los tuyos propios) en el directorio de [ejemplos](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) del [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repositorio de. GitHub
**Topics**
+ [Usa la clase de ayuda al EncryptedTable cliente](#python-example-table)
+ [Utilice el encriptador de elementos](#python-example-item-encryptor)
## Usa la clase de ayuda al EncryptedTable cliente
El ejemplo siguiente le muestra cómo utilizar el [proveedor de KMS directo](direct-kms-provider.md) con la `EncryptedTable` [clase auxiliar cliente](python-using.md#python-helpers). Este ejemplo utiliza el mismo [proveedor de materiales criptográficos](DDBEC-legacy-concepts.md#concept-material-provider) que el ejemplo [Utilice el encriptador de elementos](#python-example-item-encryptor) siguiente. Sin embargo, utiliza la clase `EncryptedTable` en lugar de interactuar directamente con el [encriptador de elementos](DDBEC-legacy-concepts.md#item-encryptor) de nivel inferior.
Comparando estos ejemplos, puede ver el trabajo que realiza la clase auxiliar cliente automáticamente. Esto incluye la creación del [contexto de cifrado de DynamoDB](concepts.md#encryption-context) y asegurarse de que los atributos de clave principal estén siempre firmados, pero nunca cifrados. Para crear el contexto de cifrado y descubrir la clave principal, las clases auxiliares del cliente llaman a la operación DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Para ejecutar este código, debe tener permiso para llamar a esta operación.
**Vea la muestra de código completa**: [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
Paso 1: crear la tabla
Empiece creando una instancia de una tabla de DynamoDB estándar con el nombre de la tabla.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Paso 2: crear un proveedor de materiales criptográficos
Cree una instancia del [proveedor de materiales criptográficos](crypto-materials-providers.md) (CMP) que ha seleccionado.
Este ejemplo utiliza el [proveedor de KMS directo](direct-kms-provider.md), pero puede utilizar cualquier CMP compatible. Para crear un proveedor de KMS directo, especifique un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys). En este ejemplo se utiliza el nombre de recurso de Amazon (ARN) del AWS KMS key, pero se puede utilizar cualquier identificador clave válido.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Paso 3: crear el objeto de acciones de atributo
Las [acciones de atributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) indican al encriptador de elementos qué acciones hay que realizar en cada atributo del elemento. El objeto `AttributeActions` de este ejemplo cifra y firma todos los elementos, excepto el atributo `test`, que se pasa por alto.
No especifique acciones de atributo para los atributos de clave principal cuando utilice una clase auxiliar cliente. La clase `EncryptedTable` firma, pero no cifra nunca, los atributos de clave principal.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Paso 4: crear la tabla cifrada
Cree la tabla cifrada utilizando la tabla estándar, el proveedor de KMS directo y las acciones de atributo. Este paso completa la configuración.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Paso 5: colocar el elemento de texto no cifrado en la tabla
Cuando se llama al método `put_item` en la `encrypted_table`, los elementos de la tabla se cifran de modo transparente, se firman y se agrega a su tabla de DynamoDB.
Primero, defina el elemento de tabla.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
A continuación, colóquelo en la tabla.
```
encrypted_table.put_item(Item=plaintext_item)
```
Para obtener el elemento desde la tabla de DynamoDB en su forma cifrada, llame al método `get_item` en el objeto `table`. Para obtener el objeto descifrado, llame al método `get_item` en el objeto `encrypted_table`.
## Utilice el encriptador de elementos
En este ejemplo, se muestra cómo interactuar directamente con el [encriptador de elementos](DDBEC-legacy-concepts.md#item-encryptor) en la al cifrar elementos de tabla, en lugar de utilizar las [clases auxiliares de cliente](python-using.md#python-helpers) que interactúan con el encriptador de elementos.
Cuando se utiliza esta técnica, crea el contexto de cifrado de DynamoDB y el objeto de configuración (`CryptoConfig`) manualmente. Además, cifra los elementos en una llamada y los coloca en su tabla de DynamoDB en una llamada independiente. Esto le permite personalizar sus `put_item` llamadas y utilizar el cliente de cifrado de DynamoDB para cifrar y firmar datos estructurados que nunca se envían a DynamoDB.
Este ejemplo utiliza el [proveedor de KMS directo](direct-kms-provider.md), pero puede utilizar cualquier CMP compatible.
**Vea la muestra de código completa**: [aws\$1kms\$1encrypted\$1item.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
Paso 1: crear la tabla
Empiece creando una instancia de un recurso de tabla de DynamoDB estándar con el nombre de la tabla.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Paso 2: crear un proveedor de materiales criptográficos
Cree una instancia del [proveedor de materiales criptográficos](crypto-materials-providers.md) (CMP) que ha seleccionado.
Este ejemplo utiliza el [proveedor de KMS directo](direct-kms-provider.md), pero puede utilizar cualquier CMP compatible. Para crear un proveedor de KMS directo, especifique un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys). En este ejemplo se utiliza el nombre de recurso de Amazon (ARN) del AWS KMS key, pero se puede utilizar cualquier identificador clave válido.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Paso 3: Usa la clase TableInfo auxiliar
Para obtener información sobre la tabla de DynamoDB, cree una instancia de [TableInfo](python-using.md#python-helpers)la clase auxiliar. Cuando trabaja directamente con el encriptador de elementos, tiene que crear una instancia `TableInfo` y llamar a sus métodos. Las [clases auxiliares de cliente](python-using.md#python-helpers) lo hacen automáticamente.
El `refresh_indexed_attributes` método `TableInfo` utiliza la operación [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB para obtener información precisa y en tiempo real sobre la tabla. Incluye su clave principal y sus índices secundarios locales y globales. El intermediario tiene que tener permiso para llamar a `DescribeTable`.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Paso 4: crear el contexto de cifrado de DynamoDB
El [contexto de cifrado de DynamoDB](concepts.md#encryption-context) contiene información acerca de la estructura de la tabla y cómo se cifra y se firma. En este ejemplo, se crea un contexto de cifrado de DynamoDB explícitamente, porque interactúa con el encriptador de elementos. Las [clases auxiliares de cliente](python-using.md#python-helpers) crean el contexto de cifrado de DynamoDB para usted.
Para obtener la clave de partición y la clave de clasificación, puede usar las propiedades de la clase [TableInfo](python-using.md#python-helpers)auxiliar.
```
index_key = {
'partition_attribute': 'value1',
'sort_attribute': 55
}
encryption_context = EncryptionContext(
table_name=table_name,
partition_key_name=table_info.primary_index.partition,
sort_key_name=table_info.primary_index.sort,
attributes=dict_to_ddb(index_key)
)
```
Paso 5: crear el objeto de acciones de atributo
Las [acciones de atributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) indican al encriptador de elementos qué acciones hay que realizar en cada atributo del elemento. El objeto `AttributeActions` en este ejemplo cifra y firma todos los elementos, excepto los atributos de clave principal, que se firman, pero no se cifran y el atributo `test`, que se pasa por alto.
Cuando se interactúa directamente con el encriptador de elementos y la acción predeterminada es `ENCRYPT_AND_SIGN`, debe especificar una acción alternativa para la clave principal. Puede utilizar el método `set_index_keys`, que usa `SIGN_ONLY` para la clave principal o utiliza `DO_NOTHING` si es la acción predeterminada.
Para especificar la clave principal, en este ejemplo se utilizan las claves de índice del [TableInfo](python-using.md#python-helpers)objeto, que se rellenan con una llamada a DynamoDB. Esta técnica es más segura que los nombres de clave principal de codificación rígida.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Paso 6: crear la configuración para el elemento
Para configurar el cliente de cifrado de DynamoDB, utilice los objetos que acaba de crear en [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)una configuración para el elemento de la tabla. Las clases auxiliares del cliente las crean por usted. CryptoConfig
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Paso 7: cifrar el elemento
En este paso, se cifra y firma el elemento, pero no lo coloca en la tabla de DynamoDB.
Cuando utiliza una clase auxiliar de cliente, sus elementos se cifran y se firman de modo transparente y, a continuación, se agregan a su tabla de DynamoDB cuando llama al `put_item` método de la clase auxiliar. Cuando utiliza el encriptador de elementos directamente, las acciones de cifrado y colocación son independientes.
En primer lugar, cree un elemento de texto no cifrado.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
A continuación, cífrelo y fírmelo. El método `encrypt_python_item` requiere el objeto de configuración `CryptoConfig`.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Paso 8: colocar el elemento en la tabla
En este paso, se coloca el elemento cifrado y firmado en la tabla de DynamoDB.
```
table.put_item(Item=encrypted_item)
```
Para ver el elemento cifrado, llame al método `get_item` en el objeto `table` original, en lugar del objeto `encrypted_table`. Obtiene el elemento de la tabla DynamoDB sin verificarlo y descifrarlo.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
En la imagen siguiente se muestra una parte de un elemento de tabla cifrado y firmado de ejemplo.
Los valores de atributo cifrados son datos binarios. Los nombres y los valores de los atributos de clave principal (`partition_attribute` y `sort_attribute`) y el atributo `test` permanecen en texto no cifrado. La salida muestra además el atributo que contiene la firma (`*amzn-ddb-map-sig*`) y el [atributo de descripción de materiales](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`).
![\[Un fragmento de un elemento cifrado y firmado\]](http://docs.aws.amazon.com/es_es/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)