Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Client di crittografia Amazon DynamoDB per Java
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega come installare e utilizzare il client di crittografia Amazon DynamoDB per Java. [Per i dettagli sulla programmazione con il DynamoDB Encryption Client, consulta gli esempi [Java](java-examples.md), gli esempi nel repository GitHub su e [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) per aws-dynamodb-encryption-java il DynamoDB Encryption Client.](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)
**Nota**
Versioni 1. *x*. *x* del DynamoDB Encryption Client for Java entreranno in vigore gradualmente [end-of-support a luglio 2022](what-is-database-encryption-sdk.md#support). Effettua l'upgrade a una versione più recente il prima possibile.
**Topics**
+ [Prerequisiti](#java-prerequisites)
+ [Installazione](#java-installation)
+ [Utilizzo del client di crittografia DynamoDB per Java](java-using.md)
+ [Esempi di Java](java-examples.md)
## Prerequisiti
Prima di installare Amazon DynamoDB Encryption Client for Java, assicurati di avere i seguenti prerequisiti.
**Un ambiente di sviluppo Java**
È necessario Java 8 o versioni successive. Nel sito Web di Oracle, accedi alla pagina [Java SE Download](https://www.oracle.com/java/technologies/downloads/), quindi scarica e installa Java SE Development Kit (JDK).
Se utilizzi Oracle JDK, devi scaricare e installare anche [Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK per Java**
Il DynamoDB Encryption Client richiede il modulo DynamoDB di DynamoDB anche se AWS SDK per Java l'applicazione non interagisce con DynamoDB. Puoi installare l'intero SDK o solo questo modulo. Se utilizzi Maven, aggiungi `aws-java-sdk-dynamodb` al file `pom.xml`.
Per ulteriori informazioni sull'installazione e la configurazione di, vedere. AWS SDK per Java[AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html)
## Installazione
Puoi installare Amazon DynamoDB Encryption Client for Java nei seguenti modi.
**Manualmente**
Per installare Amazon DynamoDB Encryption Client for Java, clona o scarica il repository. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Utilizzo di Apache Maven**
Il client di crittografia Amazon DynamoDB per Java è disponibile [tramite Apache](https://maven.apache.org/) Maven con la seguente definizione di dipendenza.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Dopo aver installato l'SDK, inizia esaminando il codice di esempio in questa guida e il client di crittografia [DynamoDB Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) attivo. GitHub
# Utilizzo del client di crittografia DynamoDB per Java
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega alcune funzionalità del DynamoDB Encryption Client in Java che potrebbero non essere presenti in altre implementazioni del linguaggio di programmazione.
[Per i dettagli sulla programmazione con il DynamoDB Encryption Client, consulta gli esempi [Java](java-examples.md), gli esempi in [the](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) GitHub on e Javadoc per `aws-dynamodb-encryption-java repository` il DynamoDB Encryption Client.](https://aws.github.io/aws-dynamodb-encryption-java/)
**Topics**
+ [Componenti di crittografia dell'item](#attribute-encryptor)
+ [Configurazione del comportamento di salvataggio](#save-behavior)
+ [Operazioni di attributo in Java](#attribute-actions-java)
+ [Sovrascrivere i nomi delle tabelle](#override-table-name)
## Item encryptors: e Dynamo AttributeEncryptor DBEncryptor
[Il DynamoDB Encryption Client in Java dispone di [due crittografi di elementi](DDBEC-legacy-concepts.md#item-encryptor): Dynamo di livello inferiore e. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
`AttributeEncryptor`È una classe di supporto che consente di utilizzare [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK per Java con il `DynamoDB Encryptor` client DBMapper di crittografia DynamoDB. Quando utilizzi `AttributeEncryptor` con `DynamoDBMapper`, crittografa e firma in modo trasparente gli item quando li salvi. Inoltre, verifica e decrittografa in modo trasparente gli item quando li carichi.
## Configurazione del comportamento di salvataggio
È possibile utilizzare `AttributeEncryptor` and `DynamoDBMapper` per aggiungere o sostituire gli elementi della tabella con attributi solo firmati o crittografati e firmati. Per queste attività, ti consigliamo di configurare il servizio per utilizzare il comportamento di salvataggio `PUT`, come illustrato nell'esempio seguente. In caso contrario, potresti non riuscire a decrittografare i dati.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Se si utilizza il comportamento di salvataggio predefinito, che aggiorna solo gli attributi modellati nell'elemento della tabella, gli attributi non modellati non vengono inclusi nella firma e non vengono modificati dalle scritture della tabella. Di conseguenza, nelle letture successive di tutti gli attributi, la firma non verrà convalidata, poiché non include attributi non modellati.
Puoi inoltre utilizzare il comportamento di salvataggio `CLOBBER`. Questo comportamento di salvataggio è identico al comportamento di salvataggio `PUT`, ma disabilita il blocco ottimistico e sovrascrive l'item nella tabella.
Per evitare errori di firma, il client di crittografia DynamoDB genera un'eccezione di runtime se una viene utilizzata con `AttributeEncryptor` un file che non è configurato con `DynamoDBMapper` un comportamento di salvataggio di o. `CLOBBER` `PUT`
Per vedere questo codice usato in un esempio, vedi [Usare Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) e l'[AwsKmsEncryptedObjectesempio.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) nel repository in. `aws-dynamodb-encryption-java` GitHub
## Operazioni di attributo in Java
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinano quali valori attributo sono crittografati e firmati, quali solo firmati e quali ignorati. [Il metodo utilizzato per specificare le azioni degli attributi dipende dal fatto che si utilizzi il comando `DynamoDBMapper` and o il `AttributeEncryptor` Dynamo di livello inferiore. DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**Importante**
Dopo aver utilizzato le azioni degli attributi per crittografare gli elementi della tabella, l'aggiunta o la rimozione di attributi dal modello di dati potrebbe causare un errore di convalida della firma che impedisce di decrittografare i dati. Per una spiegazione dettagliata, consulta [Modifica del modello di dati](data-model.md).
### Azioni relative agli attributi per la Dynamo DBMapper
Quando utilizzi `DynamoDBMapper` e `AttributeEncryptor`, devi utilizzare le annotazioni per specificare le operazioni di attributo. Il DynamoDB Encryption Client utilizza le annotazioni [standard degli attributi DynamoDB che definiscono il tipo di attributo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html) per determinare come proteggere un attributo. Per impostazione predefinita, tutti gli attributi sono crittografati e firmati, tranne le chiavi primarie, che sono firmate ma non crittografate.
**Nota**
Non crittografate il valore degli attributi con l'[annotazione @Dynamo DBVersion Attribute](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), anche se potete (e dovreste) firmarli. In caso contrario, le condizioni che utilizzano questo valore potrebbero avere effetti imprevisti.
```
// 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")
```
Per specificare le eccezioni, utilizzate le annotazioni di crittografia definite nel DynamoDB Encryption Client for Java. Se le specifichi a livello di classe, diventano il valore predefinito per la classe.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Ad esempio, queste annotazioni firmano ma non crittografano l'attributo `PublicationYear` e non crittografano né firmano il valore attributo `ISBN`.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Azioni relative agli attributi per Dynamo DBEncryptor
Per specificare le azioni degli attributi quando utilizzate DBEncryptor direttamente [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html), create un `HashMap` oggetto in cui le coppie nome-valore rappresentino i nomi degli attributi e le azioni specificate.
I valori sono validi per le operazioni di attributo definite nel tipo enumerato `EncryptionFlags`. Puoi utilizzare `ENCRYPT` e `SIGN` insieme o solo `SIGN` o ometterle entrambe. Tuttavia, se si utilizza `ENCRYPT` da solo, il client di crittografia DynamoDB genera un errore. Non puoi crittografare un attributo non firmato.
```
ENCRYPT
SIGN
```
**avvertimento**
Non crittografare gli attributi che vengono usati per la chiave primaria. Devono rimanere in testo semplice in modo che DynamoDB possa trovare l'elemento senza eseguire una scansione completa della tabella.
Se si specifica una chiave primaria nel contesto di crittografia e quindi si specifica `ENCRYPT` nell'azione di attributo per uno degli attributi della chiave primaria, il client di crittografia DynamoDB genera un'eccezione.
Ad esempio, il seguente codice Java crea un codice `actions` HashMap che crittografa e firma tutti gli attributi dell'elemento. `record` Le eccezioni sono la chiave di partizione e gli attributi della chiave di ordinamento, che sono firmati ma non crittografati, e l'attributo `test`, che non è firmato o crittografato.
```
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;
}
}
```
Successivamente, quando chiami il metodo [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 componente `DynamoDBEncryptor`, devi specificare la mappa come valore del parametro `attributeFlags`. Ad esempio, questa chiamata a `encryptRecord` utilizza la mappa `actions`.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Sovrascrivere i nomi delle tabelle
Nel DynamoDB Encryption Client, il nome della tabella DynamoDB è un elemento del contesto di crittografia [DynamoDB che viene passato ai metodi di crittografia e decrittografia](concepts.md#encryption-context). Quando si crittografano o si firmano gli elementi della tabella, il contesto di crittografia DynamoDB, incluso il nome della tabella, è associato crittograficamente al testo cifrato. Se il contesto di crittografia DynamoDB passato al metodo decrypt non corrisponde al contesto di crittografia DynamoDB passato al metodo encrypt, l'operazione di decrittografia ha esito negativo.
[Occasionalmente, il nome di una tabella cambia, ad esempio quando si esegue il backup di una tabella o si esegue un ripristino. point-in-time ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) Quando si decrittografa o si verifica la firma di questi elementi, è necessario passare nello stesso contesto di crittografia DynamoDB utilizzato per crittografare e firmare gli elementi, incluso il nome della tabella originale. Il nome della tabella corrente non è necessario.
Quando si utilizza`DynamoDBEncryptor`, si assembla manualmente il contesto di crittografia DynamoDB. Tuttavia, se si utilizza il`DynamoDBMapper`, `AttributeEncryptor` crea automaticamente il contesto di crittografia DynamoDB, incluso il nome della tabella corrente. Per comunicare a `AttributeEncryptor` di creare un contesto di crittografia con un nome di tabella diverso, utilizza `EncryptionContextOverrideOperator`.
Ad esempio, il codice seguente crea istanze del provider di materiali crittografici (CMP) e di `DynamoDBEncryptor`. Quindi chiama il metodo `setEncryptionContextOverrideOperator` di `DynamoDBEncryptor`. Utilizza l'operatore `overrideEncryptionContextTableName`, che sovrascrive il nome di una tabella. Quando è configurato in questo modo, `AttributeEncryptor` crea un contesto di crittografia DynamoDB che `newTableName` include al posto di. `oldTableName` [Per un esempio completo, consulta EncryptionContextOverridesWithDynamo DBMapper .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));
```
Quando chiami il metodo di caricamento di `DynamoDBMapper`, che esegue la decrittografia e la verifica dell'item, devi specificare il nome della tabella originale.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Puoi anche utilizzare l'operatore `overrideEncryptionContextTableNameUsingMap`, che sovrascrive più nomi di tabella.
Gli operatori che sovrascrivono i nomi di tabella vengono in genere utilizzati per la decrittografia dei dati e la verifica delle firme. Tuttavia, è possibile utilizzarli per impostare il nome della tabella nel contesto di crittografia DynamoDB su un valore diverso durante la crittografia e la firma.
Non utilizzare operatori che sovrascrivono i nomi di tabella se utilizzi `DynamoDBEncryptor`. Crea invece un contesto di crittografia con il nome della tabella originale e invialo al metodo di decrittografia.
# Codice di esempio per il client di crittografia DynamoDB per Java
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Gli esempi seguenti mostrano come utilizzare il DynamoDB Encryption Client for Java per proteggere gli elementi della tabella DynamoDB nell'applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) nella directory [examples](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) del repository su. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Topics**
+ [Usare la Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Usare Dynamo DBMapper](#java-example-dynamodb-mapper)
## Usare la Dynamo DBEncryptor
[Questo esempio mostra come utilizzare [Dynamo di livello inferiore con Direct KMS DBEncryptor Provider](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html).](direct-kms-provider.md) Il provider Direct KMS genera e protegge i suoi materiali crittografici con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in () specificato dall'utente. AWS Key Management Service AWS KMS
Puoi utilizzare qualsiasi [fornitore di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatibile con`DynamoDBEncryptor`, e puoi utilizzare Direct KMS Provider con and. `DynamoDBMapper` [AttributeEncryptor](java-using.md#attribute-encryptor)
**[Guarda l'esempio di codice completo: .java AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)**
Fase 1: creazione del provider KMS diretto
Crea un'istanza del AWS KMS client con la regione specificata. Quindi, usa l'istanza del client per creare un'istanza del Direct KMS Provider con la tua preferita AWS KMS key.
Questo esempio utilizza Amazon Resource Name (ARN) per identificare AWS KMS key, ma puoi utilizzare [qualsiasi identificatore di chiave valido](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);
```
Fase 2: creazione di un item
Questo esempio definisce un elemento `record` HashMap che rappresenta un elemento di tabella di esempio.
```
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"));
```
Fase 3: Creare una dinamo DBEncryptor
Crea un'istanza del componente `DynamoDBEncryptor` con il provider KMS diretto.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Fase 4: Creare un contesto di crittografia DynamoDB
Il contesto di [crittografia DynamoDB](concepts.md#encryption-context) contiene informazioni sulla struttura della tabella e su come viene crittografata e firmata. Se utilizzi il componente `DynamoDBMapper`, il componente `AttributeEncryptor` crea il contesto di crittografia per tuo conto.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Fase 5: creazione dell'oggetto delle operazioni di attributo.
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinano quali attributi dell'item sono crittografati e firmati, quali solo firmati e quali non sono né crittografati né firmati.
In Java, per specificare le azioni relative agli attributi, si crea una serie HashMap di coppie di nomi e `EncryptionFlags` valori degli attributi.
Ad esempio, il codice Java seguente crea un codice `actions` HashMap che crittografa e firma tutti gli attributi dell'`record`elemento, ad eccezione della chiave di partizione e degli attributi della chiave di ordinamento, che sono firmati ma non crittografati, e dell'`test`attributo, che non è firmato o crittografato.
```
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;
}
}
```
Fase 6: crittografia e firma dell'item
Per crittografare e firmare l'item della tabella, chiama il metodo `encryptRecord` nell'istanza del componente `DynamoDBEncryptor`. Specifica l'item della tabella (`record`), le operazioni di attributo (`actions`) e il contesto di crittografia (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Fase 7: Inserire l'elemento nella tabella DynamoDB
Infine, inserisci l'elemento crittografato e firmato nella tabella DynamoDB.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Usare Dynamo DBMapper
[L'esempio seguente mostra come utilizzare la classe helper DynamoDB mapper con il provider Direct KMS.](direct-kms-provider.md) Il provider Direct KMS genera e protegge i suoi materiali crittografici con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in () specificato dall'utente. AWS Key Management Service AWS KMS
Puoi usare qualunque [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatibile insieme al mappatore `DynamoDBMapper` e puoi utilizzare il provider KMS diretto con il componente `DynamoDBEncryptor` di livello inferiore.
**[Guarda l'esempio di codice completo: .java AwsKmsEncryptedObject](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)**
Fase 1: creazione del provider KMS diretto
Crea un'istanza del AWS KMS client con la regione specificata. Quindi, usa l'istanza del client per creare un'istanza del Direct KMS Provider con la tua preferita AWS KMS key.
Questo esempio utilizza Amazon Resource Name (ARN) per identificare AWS KMS key, ma puoi utilizzare [qualsiasi identificatore di chiave valido](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);
```
Fase 2: Creare DynamoDB Encryptor e Dynamo DBMapper
Utilizza il provider Direct KMS creato nel passaggio precedente per creare un'istanza di [DynamoDB](java-using.md#attribute-encryptor) Encryptor. È necessario creare un'istanza del DynamoDB Encryptor di livello inferiore per utilizzare DynamoDB Mapper.
Successivamente, crea un'istanza del database DynamoDB e una configurazione mapper e usale per creare un'istanza del DynamoDB Mapper.
Quando utilizzi `DynamoDBMapper` per aggiungere o modificare item firmati (oppure crittografati e firmati), configuralo per [utilizzare un comportamento di salvataggio](java-using.md#save-behavior), ad esempio `PUT`, che includa tutti gli attributi, come mostrato nel seguente esempio. In caso contrario, potresti non riuscire a decrittografare i dati.
```
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));
```
Fase 3: Definizione della tabella DynamoDB
Successivamente, definisci la tua tabella DynamoDB. Per specificare le [operazioni di attributo](java-using.md#attribute-actions-java), utilizza le annotazioni. Questo esempio crea una tabella DynamoDB e `DataPoJo` una classe che rappresenta gli elementi della tabella`ExampleTable`.
In questo esempio, gli attributi della chiave primaria saranno firmati ma non crittografati. Ciò vale per l'attributo `partition_attribute`, che viene annotato con `@DynamoDBHashKey`, e per l'attributo `sort_attribute`, che viene annotato con `@DynamoDBRangeKey`.
Gli attributi annotati con `@DynamoDBAttribute`, ad esempio `some numbers`, saranno crittografati e firmati. Le eccezioni sono gli attributi che utilizzano le annotazioni di crittografia `@DoNotEncrypt` (solo firma) o `@DoNotTouch` (non crittografare o firmare) definite dal DynamoDB Encryption Client. Ad esempio, poiché l'attributo `leave me` ha un'annotazione `@DoNotTouch`, non sarà crittografato né firmato.
```
@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 + "]";
}
}
```
Fase 4: crittografia e salvataggio di un item della tabella
Ora, quando si crea un elemento della tabella e si utilizza DynamoDB Mapper per salvarlo, l'elemento viene automaticamente crittografato e firmato prima di essere aggiunto alla tabella.
In questo esempio viene definito un item della tabella denominato `record`. Prima che venga salvato nella tabella, i suoi attributi vengono crittografati e firmati in base alle annotazioni nella classe `DataPoJo`. In questo caso, tutti gli attributi eccetto `PartitionAttribute`, `SortAttribute` e `LeaveMe` sono crittografati e firmati. `PartitionAttribute` e `SortAttributes` sono solo firmati. L'attributo `LeaveMe` non è crittografato né firmato.
Per crittografare e firmare l'item `record` e aggiungerlo alla tabella `ExampleTable`, chiama il metodo `save` della classe `DynamoDBMapper`. Poiché DynamoDB Mapper è configurato per utilizzare `PUT` il comportamento di salvataggio, l'elemento sostituisce qualsiasi elemento con le stesse chiavi primarie, anziché aggiornarlo. In questo modo le firme corrispondono ed è possibile decrittografare l'item quando si ottiene dalla tabella.
```
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);
```