As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplos de Java
<a name="ddb-java-examples"></a>


****  

|  | 
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). | 

Os exemplos a seguir mostram como usar a biblioteca de criptografia do lado do cliente para o DynamoDB para proteger os itens da tabela no aplicativo. Você pode encontrar mais exemplos (e contribuir com os seus) nos [exemplos de Java no repositório](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 em. GitHub

Os exemplos a seguir demonstram como configurar a biblioteca Java de criptografia do lado do cliente para o DynamoDB em uma nova tabela não preenchida do Amazon DynamoDB. Se você quiser configurar suas tabelas existentes do Amazon DynamoDB para criptografia do lado do cliente, consulte [Adicionar versão 3.x a uma tabela existente](ddb-java-config-existing-table.md).

**Topics**
+ [Uso do cliente aprimorado do DynamoDB](#ddb-java-enhanced-client-example)
+ [Uso da API de nível inferior do DynamoDB](#ddb-java-lowlevel-API-example)
+ [Usando o nível inferior DynamoDbItemEncryptor](#ddb-java-itemencryptor)

## Uso do cliente aprimorado do DynamoDB
<a name="ddb-java-enhanced-client-example"></a>

O exemplo a seguir mostra como usar o DynamoDB Enhanced Client e o `DynamoDbEncryptionInterceptor` com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar itens da tabela do DynamoDB como parte de suas chamadas de API do DynamoDB.

Você pode usar qualquer [chaveiro](keyrings.md) compatível com o DynamoDB Enhanced Client, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.

**nota**  
O DynamoDB Enhanced Client [não oferece suporte à criptografia pesquisável](searchable-encryption.md). Use o `DynamoDbEncryptionInterceptor` com a API de nível inferior do DynamoDB para usar criptografia pesquisável.

**Veja a amostra de código completa**: [EnhancedPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)

**Etapa 1: criar o AWS KMS chaveiro**  
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.  

```
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
        .generator(kmsKeyId)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```

**Etapa 2: criar um esquema de tabela a partir da classe de dados anotada**  
O exemplo a seguir usa a classe de dados anotada para criar o `TableSchema`.  
[Este exemplo pressupõe que as ações de classe e atributo de dados anotadas foram definidas usando o .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 obter mais orientações sobre como anotar suas ações de atributos, consulte [Uso de uma classe de dados anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).  
[O SDK AWS de criptografia de banco de dados não oferece suporte a anotações em atributos aninhados.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)

```
final TableSchema<SimpleClass> schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```

**Etapa 3: definir quais atributos são excluídos das assinaturas**  
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).  

```
final String unsignedAttrPrefix = ":";
```

**Etapa 4: criar a configuração de criptografia**  
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.   
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).  
Para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons), você também deve incluir [`SearchConfig`](ddb-java-using.md#ddb-search-config) na configuração de criptografia.

```
final Map<String, DynamoDbEnhancedTableEncryptionConfig> tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
    DynamoDbEnhancedTableEncryptionConfig.builder()
        .logicalTableName(ddbTableName)
        .keyring(kmsKeyring)
        .allowedUnsignedAttributePrefix(unsignedAttrPrefix)
        .schemaOnEncrypt(tableSchema)
        .build());
```

**Etapa 5: cria o `DynamoDbEncryptionInterceptor`**  
O exemplo a seguir cria o `DynamoDbEncryptionInterceptor` usando `tableConfigs` da **Etapa 4**.  

```
final DynamoDbEncryptionInterceptor interceptor =
    DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
        CreateDynamoDbEncryptionInterceptorInput.builder()
            .tableEncryptionConfigs(tableConfigs)
            .build()
    );
```

**Etapa 6: criar um novo cliente AWS SDK do DynamoDB**  
**O exemplo a seguir cria um novo cliente AWS SDK do DynamoDB usando `interceptor` o da Etapa 5.**  

```
final DynamoDbClient ddb = DynamoDbClient.builder()
        .overrideConfiguration(
                ClientOverrideConfiguration.builder()
                       .addExecutionInterceptor(interceptor)
                       .build())
        .build();
```

**Etapa 7: criar o DynamoDB Enhanced Client e criar uma tabela**  
O exemplo a seguir cria o DynamoDB Enhanced Client usando o cliente AWS SDK DynamoDB criado na **Etapa 6** e cria uma tabela usando a classe de dados anotada.  

```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
        .dynamoDbClient(ddb)
        .build();
final DynamoDbTable<SimpleClass> table = enhancedClient.table(ddbTableName, tableSchema);
```

**Etapa 8: criptografar e salvar um item da tabela**  
O exemplo a seguir coloca um item na tabela do DynamoDB usando o DynamoDB Enhanced Client. O item é criptografado e assinado no lado do cliente antes de ser enviado ao 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);
```

## Uso da API de nível inferior do DynamoDB
<a name="ddb-java-lowlevel-API-example"></a>

O exemplo a seguir mostra como usar a API de nível inferior do DynamoDB com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar e assinar automaticamente itens no lado do cliente com suas solicitações `PutItem` do DynamoDB.

Você pode usar qualquer [chaveiro](keyrings.md) compatível, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.

**Veja a amostra de código completa**: [BasicPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)

**Etapa 1: criar o AWS KMS chaveiro**  
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.  

```
final MaterialProviders matProv = MaterialProviders.builder()
         .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
         .build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
        .generator(kmsKeyId)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```

**Etapa 2: Configurar ações de atributos**  
O exemplo a seguir define um mapa `attributeActionsOnEncrypt` que representa exemplos de [ações de atributos](concepts.md#crypt-actions) para um item da tabela.  
O exemplo a seguir não define nenhum atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.

```
final Map<String, CryptoAction> 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);
```

**Etapa 3: definir quais atributos são excluídos das assinaturas**  
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).  

```
final String unsignedAttrPrefix = ":";
```

**Etapa 4: definir a configuração de criptografia de tabelas do DynamoDB**  
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.  
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).  
Para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons), você também deve incluir [`SearchConfig`](ddb-java-using.md#ddb-search-config) na configuração de criptografia.

```
final Map<String, DynamoDbTableEncryptionConfig> 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);
```

**Etapa 5: criar o perfil do `DynamoDbEncryptionInterceptor`**  
O exemplo a seguir cria o `DynamoDbEncryptionInterceptor` usando `tableConfigs` da **Etapa 4**.  

```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
        .config(DynamoDbTablesEncryptionConfig.builder()
                .tableEncryptionConfigs(tableConfigs)
                .build())
        .build();
```

**Etapa 6: criar um novo cliente AWS SDK do DynamoDB**  
**O exemplo a seguir cria um novo cliente AWS SDK do DynamoDB usando `interceptor` o da Etapa 5.**  

```
final DynamoDbClient ddb = DynamoDbClient.builder()
        .overrideConfiguration(
                ClientOverrideConfiguration.builder()
                       .addExecutionInterceptor(interceptor)
                       .build())
        .build();
```

**Etapa 7: criptografar e assinar um item da tabela do DynamoDB**  
O exemplo a seguir define um mapa `item` que representa um item da tabela de exemplo e coloca o item na tabela do DynamoDB. O item é criptografado e assinado no lado do cliente antes de ser enviado ao DynamoDB.  

```
final HashMap<String, AttributeValue> 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 o nível inferior DynamoDbItemEncryptor
<a name="ddb-java-itemencryptor"></a>

O exemplo a seguir mostra como usar o nível inferior de `DynamoDbItemEncryptor` com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar e assinar diretamente os itens da tabela. O `DynamoDbItemEncryptor` não coloca o item na tabela do DynamoDB.

Você pode usar qualquer [chaveiro](keyrings.md) compatível com o DynamoDB Enhanced Client, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.

**nota**  
O nível inferior do `DynamoDbItemEncryptor` não oferece suporte à [criptografia pesquisável](searchable-encryption.md). Use o `DynamoDbEncryptionInterceptor` com a API de nível inferior do DynamoDB para usar criptografia pesquisável.

**Veja a amostra de código completa**: [ItemEncryptDecryptExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)

**Etapa 1: criar o AWS KMS chaveiro**  
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.  

```
final MaterialProviders matProv = MaterialProviders.builder()
         .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
         .build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
        .generator(kmsKeyId)
        .build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```

**Etapa 2: Configurar ações de atributos**  
O exemplo a seguir define um mapa `attributeActionsOnEncrypt` que representa exemplos de [ações de atributos](concepts.md#crypt-actions) para um item da tabela.  
O exemplo a seguir não define nenhum atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.

```
final Map<String, CryptoAction> 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);
```

**Etapa 3: definir quais atributos são excluídos das assinaturas**  
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).  

```
final String unsignedAttrPrefix = ":";
```

**Etapa 4: definir a configuração de `DynamoDbItemEncryptor`**  
O exemplo a seguir define a configuração para `DynamoDbItemEncryptor`.  
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados 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();
```

**Etapa 5: criar o perfil do `DynamoDbItemEncryptor`**  
O exemplo a seguir cria um novo `DynamoDbItemEncryptor` usando `config` da **Etapa 4**.  

```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
        .DynamoDbItemEncryptorConfig(config)
        .build();
```

**Etapa 6: criptografar e assinar diretamente um item da tabela**  
O exemplo a seguir criptografa e assina diretamente um item usando o `DynamoDbItemEncryptor`. O `DynamoDbItemEncryptor` não coloca o item na tabela do DynamoDB.  

```
final Map<String, AttributeValue> 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<String, AttributeValue> encryptedItem = itemEncryptor.EncryptItem(
        EncryptItemInput.builder()
                .plaintextItem(originalItem)
                .build()
).encryptedItem();
```