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á.
# Código de exemplo para o DynamoDB Encryption Client para Java
**nota**
Nossa biblioteca de criptografia do lado do cliente foi [renomeada como SDK de criptografia de banco de dados da AWS](DDBEC-rename.md). O tópico a seguir fornece informações sobre as versões 1.*x*—2.*x* do DynamoDB Encryption Client para Java e versões 1.*x*—3*x* do DynamoDB Encryption Client para Python. Para obter mais informações, consulte [SDK de criptografia de banco de dados da AWS para obter suporte à versão do DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Os exemplos a seguir mostram como usar o DynamoDB Encryption Client para Java para proteger a tabela do DynamoDB no aplicativo. Você pode encontrar mais exemplos (e contribuir com os seus) no diretório de [exemplos](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/Examples/runtimes/java/DDBECwithSDKV2/src/main/java/) do repositório [aws-database-encryption-sdk-dynamodb](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) em. GitHub
**Topics**
+ [Uso do DynamoDBEncryptor](#java-example-ddb-encryptor)
## Uso do DynamoDBEncryptor
Este exemplo mostra como usar o [DynamoDBEncryptor](https://aws.github.io/aws-database-encryption-sdk-dynamodb/com/amazonaws/services/dynamodbv2/datamodeling/sdkv2/encryption/DynamoDBEncryptor.html) de nível inferior com o [Direct KMS Provider](direct-kms-provider.md). O Direct KMS Provider gera e protege seus materiais criptográficos sob um [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS) especificado por você.
Você pode usar qualquer [provedor de materiais criptográficos](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatível com o. `DynamoDBEncryptor`
**Veja a amostra de código completa**: [AwsKmsEncryptedItem.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/Examples/runtimes/java/DDBECwithSDKV2/src/main/java/AwsKmsEncryptedItem.java)
Etapa 1: crie um Direct KMS Provider
Crie uma instância do AWS KMS cliente com a região especificada. Em seguida, use a instância do cliente para criar uma instância de Direct KMS Provider com o AWS KMS key de sua preferência.
Este exemplo usa o Amazon Resource Name (ARN) para identificar o AWS KMS key, mas você pode usar [qualquer identificador de chave 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 KmsClient kms = KmsClient.builder().region(Region.of({{region}})).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, {{keyArn}});
```
Etapa 2: crie um item
Este exemplo define um `record` HashMap que representa um item de tabela de amostra.
```
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"));
```
Etapa 3: crie um DynamoDBEncryptor
Crie uma instância do `DynamoDBEncryptor` com o Direct KMS Provider.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Etapa 4: crie um contexto de criptografia do DynamoDB
O [Contexto de criptografia do DynamoDB](concepts.md#encryption-context) contém informações sobre a estrutura da tabela e de como ela é criptografada e assinada.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Etapa 5: crie o objeto de ações de atributo
As [Ações de atributos](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinam os atributos do item que são criptografados e assinados, que são somente assinados e que não são criptografados nem assinados.
Em Java, para especificar ações de atributos, você cria pares HashMap de nome e `EncryptionFlags` valor do atributo.
Por exemplo, o código Java a seguir cria um `actions` HashMap que criptografa e assina todos os atributos no `record` item, exceto os atributos da chave de partição e da chave de classificação, que são assinados, mas não criptografados, e o `test` atributo, que não está assinado ou criptografado.
```
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;
}
}
```
Etapa 6: criptografe e assine o item
Para criptografar e assinar o item da tabela, chame o método `encryptRecord` na instância do `DynamoDBEncryptor`. Especifique o item da tabela (`record`), as ações de atributo (`actions`) e o contexto de criptografia (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Etapa 7: coloque o item na tabela do DynamoDB
Finalmente, coloque o item criptografado e assinado na tabela do DynamoDB.
```
final DynamoDbClient ddb = DynamoDbClient.builder().region(Region.of(region)).build();
ddb.putItem(tableName, encrypted_record);
```