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à.
# Java
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Questo argomento spiega come installare e utilizzare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB. Per i dettagli sulla programmazione con AWS Database Encryption SDK per DynamoDB, consulta gli esempi [Java nel](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 repository -dynamodb su. GitHub
**Nota**
I seguenti argomenti si concentrano sulla versione 3. *x* della libreria di crittografia lato client Java per DynamoDB.
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il AWS Database Encryption SDK continua a supportare le [versioni precedenti di DynamoDB](legacy-dynamodb-encryption-client.md) Encryption Client.
**Topics**
+ [Prerequisiti](#ddb-java-prerequisites)
+ [Installazione](#ddb-java-installation)
+ [Utilizzo del client Java](ddb-java-using.md)
+ [Esempi di Java](ddb-java-examples.md)
+ [Aggiungi la versione 3.x a una tabella esistente](ddb-java-config-existing-table.md)
+ [Migrare alla versione 3.x](ddb-java-migrate.md)
## Prerequisiti
Prima di installare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB, 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 for Java 2.x**
Il AWS Database Encryption SDK per DynamoDB richiede [il modulo DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) di. AWS SDK for Java 2.x Puoi installare l'intero SDK o solo questo modulo.
Per informazioni sull'aggiornamento della versione di AWS SDK per Java, consulta [Migrazione dalla versione](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) 1.x alla 2.x di. AWS SDK per Java
AWS SDK per Java È disponibile tramite Apache Maven. È possibile dichiarare una dipendenza per l'intero modulo o solo per il modulo AWS SDK per Java. `dynamodb-enhanced`
**Installa AWS SDK per Java utilizzando Apache Maven**
+ Per [importare l'intero AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) come dipendenza, dichiaralo nel file `pom.xml`.
+ Per creare una dipendenza solo per il modulo Amazon DynamoDB AWS SDK per Java in, segui le [istruzioni](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) per specificare moduli particolari. Imposta il `groupId` to e il to. `software.amazon.awssdk` `artifactID` `dynamodb-enhanced`
**Nota**
Se si utilizza il AWS KMS portachiavi o il portachiavi AWS KMS gerarchico, è inoltre necessario creare una dipendenza per il modulo. AWS KMS Imposta il to e il `groupId` to. `software.amazon.awssdk` `artifactID` `kms`
## Installazione
È possibile installare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB nei seguenti modi.
**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.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Usare Gradle Kotlin**
*Puoi usare [Gradle](https://gradle.org/) per dichiarare una dipendenza da Amazon DynamoDB Encryption Client for Java aggiungendo quanto segue alla sezione delle dipendenze del tuo progetto Gradle.*
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Manualmente**
[Per installare la libreria di crittografia lato client Java per DynamoDB, clona o scarica il repository -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
[Dopo aver installato l'SDK, inizia a guardare il codice di esempio in questa guida e gli esempi Java nel repository -dynamodb su.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk GitHub
# Utilizzo della libreria di crittografia lato client Java per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Questo argomento spiega alcune delle funzioni e delle classi di supporto della versione 3. *x* della libreria di crittografia lato client Java per DynamoDB.
[Per i dettagli sulla programmazione con la libreria di crittografia lato client Java per DynamoDB, consulta gli esempi Java, [gli esempi Java nel repository](java-examples.md) -dynamodb su.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk GitHub
**Topics**
+ [Componenti di crittografia dell'item](#ddb-item-encryptors)
+ [Operazioni di attributo](#ddb-attribute-actions)
+ [Configurazione della crittografia](#ddb-config-encrypt)
+ [Aggiornamento degli elementi](#ddb-update-items)
+ [Decrittografia dei set firmati](#ddb-java-signed-sets)
## Componenti di crittografia dell'item
Fondamentalmente, il AWS Database Encryption SDK per DynamoDB è un cifratore di elementi. È possibile utilizzare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB per crittografare, firmare, verificare e decrittografare gli elementi della tabella DynamoDB nei seguenti modi.
**Il client avanzato per DynamoDB**
È possibile configurare il [DynamoDB Enhanced Client per crittografare e firmare automaticamente `DynamoDbEncryptionInterceptor` gli elementi lato client con le richieste DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). `PutItem` Con DynamoDB Enhanced Client, puoi definire le azioni degli attributi utilizzando [una](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) classe di dati annotata. Consigliamo di utilizzare il DynamoDB Enhanced Client ogni volta che è possibile.
[Il DynamoDB Enhanced Client non supporta la crittografia ricercabile.](searchable-encryption.md)
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
**L'API DynamoDB di basso livello**
Puoi configurare l'API [DynamoDB di basso livello per crittografare e firmare](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) automaticamente gli elementi lato client con `DynamoDbEncryptionInterceptor` le tue richieste DynamoDB. `PutItem`
[È necessario utilizzare l'API DynamoDB di basso livello per utilizzare la crittografia ricercabile.](searchable-encryption.md)
**Il livello inferiore `DynamoDbItemEncryptor`**
Il livello inferiore crittografa e firma o decrittografa e verifica `DynamoDbItemEncryptor` direttamente gli elementi della tabella senza chiamare DynamoDB. Non crea DynamoDB o `PutItem` richieste`GetItem`. Ad esempio, puoi utilizzare il livello inferiore per `DynamoDbItemEncryptor` decrittografare e verificare direttamente un elemento DynamoDB che hai già recuperato.
[Il livello inferiore non supporta la crittografia ricercabile. `DynamoDbItemEncryptor`](searchable-encryption.md)
## Azioni relative agli attributi nel AWS Database Encryption SDK per DynamoDB
[Le azioni relative](concepts.md#crypt-actions) agli attributi determinano quali valori degli attributi sono crittografati e firmati, quali sono solo firmati, quali sono firmati e inclusi nel contesto di crittografia e quali vengono ignorati.
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva di AWS Database Encryption SDK. Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Se utilizzi l'API DynamoDB di basso livello o il `DynamoDbItemEncryptor` livello inferiore, devi definire manualmente le azioni degli attributi. [Se si utilizza il DynamoDB Enhanced Client, è possibile definire manualmente le azioni relative agli attributi oppure utilizzare una classe di dati annotata per generare un. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Per semplificare il processo di configurazione, consigliamo di utilizzare una classe di dati annotata. Quando utilizzate una classe di dati annotata, dovete modellare l'oggetto una sola volta.
**Nota**
Dopo aver definito le azioni relative agli attributi, è necessario definire quali attributi sono esclusi dalle firme. Per semplificare l'aggiunta di nuovi attributi non firmati in futuro, consigliamo di scegliere un prefisso distinto (ad esempio "`:`«) per identificare gli attributi non firmati. Includi questo prefisso nel nome dell'attributo per tutti gli attributi contrassegnati durante `DO_NOTHING` la definizione dello schema DynamoDB e delle azioni degli attributi.
### Utilizza una classe di dati annotata
Utilizza una [classe di dati annotata](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) per specificare le azioni degli attributi con DynamoDB Enhanced Client e. `DynamoDbEncryptionInterceptor` Il AWS Database Encryption SDK per DynamoDB utilizza le annotazioni [standard degli attributi DynamoDB che definiscono il tipo di attributo](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.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**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva del Database Encryption SDK. AWS Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
[SimpleClassConsulta.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) nel repository aws-database-encryption-sdk -dynamodb su GitHub per ulteriori indicazioni sulle annotazioni di DynamoDB Enhanced Client.
Per impostazione predefinita, gli attributi della chiave primaria sono firmati ma non crittografati (`SIGN_ONLY`) e tutti gli altri attributi sono crittografati e firmati (). `ENCRYPT_AND_SIGN` Se si definiscono gli attributi come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, allora anche gli attributi di partizione e ordinamento devono esserlo`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Per specificare le eccezioni, utilizzate le annotazioni di crittografia definite nella libreria di crittografia lato client Java per DynamoDB. Ad esempio, se desideri che un particolare attributo venga firmato, utilizza l'annotazione. `@DynamoDbEncryptionSignOnly` Se desideri che un particolare attributo venga firmato e incluso nel contesto di crittografia, usa il`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Se vuoi che un particolare attributo non sia né firmato né crittografato (`DO_NOTHING`), usa l'`@DynamoDbEncryptionDoNothing`annotazione.
**Nota**
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
L'esempio seguente mostra le annotazioni utilizzate per definire e attribuire `ENCRYPT_AND_SIGN` le `SIGN_ONLY` azioni. `DO_NOTHING` [Per un esempio che mostra le annotazioni utilizzate per definire`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vedete SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
```
@DynamoDbBean
public class SimpleClass {
private String partitionKey;
private int sortKey;
private String attribute1;
private String attribute2;
private String attribute3;
@DynamoDbPartitionKey
@DynamoDbAttribute(value = "partition_key")
public String getPartitionKey() {
return this.partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
@DynamoDbSortKey
@DynamoDbAttribute(value = "sort_key")
public int getSortKey() {
return this.sortKey;
}
public void setSortKey(int sortKey) {
this.sortKey = sortKey;
}
public String getAttribute1() {
return this.attribute1;
}
public void setAttribute1(String attribute1) {
this.attribute1 = attribute1;
}
@DynamoDbEncryptionSignOnly
public String getAttribute2() {
return this.attribute2;
}
public void setAttribute2(String attribute2) {
this.attribute2 = attribute2;
}
@DynamoDbEncryptionDoNothing
public String getAttribute3() {
return this.attribute3;
}
@DynamoDbAttribute(value = ":attribute3")
public void setAttribute3(String attribute3) {
this.attribute3 = attribute3;
}
}
```
Usa la tua classe di dati annotata per creare il file `TableSchema` come mostrato nel seguente frammento.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Definisci manualmente le azioni degli attributi
Per specificare manualmente le azioni degli attributi, create un `Map` oggetto in cui le coppie nome-valore rappresentino i nomi degli attributi e le azioni specificate.
Specificate `ENCRYPT_AND_SIGN` di crittografare e firmare un attributo. `SIGN_ONLY`Specificare di firmare, ma non crittografare, un attributo. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`Specificare di firmare un attributo e di includerlo nel contesto di crittografia. Non è possibile crittografare un attributo senza firmarlo. `DO_NOTHING`Specificare di ignorare un attributo.
Gli attributi di partizione e ordinamento devono essere `SIGN_ONLY` o`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si definiscono gli attributi come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, allora anche gli attributi di partizione e ordinamento devono essere uguali. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva del AWS Database Encryption SDK. Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be signed
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
// The sort attribute must be signed
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute3", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put(":attribute4", CryptoAction.DO_NOTHING);
```
## Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB
Quando si utilizza AWS Database Encryption SDK, è necessario definire in modo esplicito una configurazione di crittografia per la tabella DynamoDB. I valori richiesti nella configurazione di crittografia dipendono dal fatto che le azioni degli attributi siano state definite manualmente o con una classe di dati annotata.
Il seguente frammento definisce una configurazione di crittografia delle tabelle DynamoDB utilizzando il DynamoDB Enhanced Client e gli attributi non firmati consentiti definiti da un prefisso [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html)distinto.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
// Optional: only required if you use beacons
.search(SearchConfig.builder()
.writeVersion(1) // MUST be 1
.versions(beaconVersions)
.build())
.build());
```
**Nome della tabella logica**
Un nome di tabella logica per la tabella DynamoDB.
Il nome della tabella logica è associato crittograficamente a tutti i dati memorizzati nella tabella per semplificare le operazioni di ripristino di DynamoDB. Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. È necessario specificare sempre lo stesso nome di tabella logica. Affinché la decrittografia abbia esito positivo, il nome della tabella logica deve corrispondere al nome specificato nella crittografia. Nel caso in cui il nome della tabella DynamoDB cambi dopo il [ripristino della tabella DynamoDB da un backup, il nome della tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) logica assicura che l'operazione di decrittografia riconosca ancora la tabella.
**Attributi non firmati consentiti**
Gli attributi contrassegnati `DO_NOTHING` nelle azioni relative agli attributi.
Gli attributi non firmati consentiti indicano al client quali attributi sono esclusi dalle firme. Il client presume che tutti gli altri attributi siano inclusi nella firma. Quindi, durante la decrittografia di un record, il client determina quali attributi deve verificare e quali ignorare tra gli attributi non firmati consentiti specificati. Non è possibile rimuovere un attributo dagli attributi non firmati consentiti.
È possibile definire gli attributi non firmati consentiti in modo esplicito creando un array che elenca tutti gli attributi. `DO_NOTHING` È inoltre possibile specificare un prefisso distinto quando si assegnano nomi `DO_NOTHING` agli attributi e utilizzare il prefisso per indicare al client quali attributi non sono firmati. Consigliamo vivamente di specificare un prefisso distinto perché semplifica il processo di aggiunta di un nuovo `DO_NOTHING` attributo in futuro. Per ulteriori informazioni, consulta [Aggiornamento del modello di dati](ddb-update-data-model.md).
Se non si specifica un prefisso per tutti gli `DO_NOTHING` attributi, è possibile configurare un `allowedUnsignedAttributes` array che elenchi in modo esplicito tutti gli attributi che il client dovrebbe aspettarsi che non siano firmati quando li incontra durante la decrittografia. È necessario definire in modo esplicito gli attributi non firmati consentiti solo se assolutamente necessario.
**Configurazione della ricerca (opzionale)**
`SearchConfig`definisce la versione del [beacon](using-beacons.md#beacon-version).
[È `SearchConfig` necessario specificare il per utilizzare la [crittografia ricercabile](searchable-encryption.md) o i beacon firmati.](configure.md#signed-beacons)
**Algorithm Suite (opzionale)**
`algorithmSuiteId`Definisce la suite di algoritmi utilizzata da AWS Database Encryption SDK.
A meno che non si specifichi esplicitamente una suite di algoritmi alternativa, AWS Database Encryption SDK utilizza la suite di algoritmi [predefinita](supported-algorithms.md#recommended-algorithms). [La suite di algoritmi predefinita utilizza l'algoritmo AES-GCM con derivazione delle chiavi, firme [digitali](concepts.md#digital-sigs) e impegno delle chiavi.](concepts.md#key-commitment) Sebbene la suite di algoritmi predefinita sia probabilmente adatta alla maggior parte delle applicazioni, è possibile scegliere una suite di algoritmi alternativa. Ad esempio, alcuni modelli di fiducia sarebbero soddisfatti da una suite di algoritmi senza firme digitali. Per informazioni sulle suite di algoritmi supportate da AWS Database Encryption SDK, consulta. [Suite di algoritmi supportate nel AWS Database Encryption SDK](supported-algorithms.md)
Per selezionare la [suite di algoritmi AES-GCM senza firme digitali ECDSA](supported-algorithms.md#other-algorithms), includi il seguente frammento nella configurazione di crittografia delle tabelle.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Aggiornamento degli AWS elementi con Database Encryption SDK
Il AWS Database Encryption SDK non supporta [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) per gli elementi che sono stati crittografati o firmati. Per aggiornare un elemento crittografato o firmato, è necessario utilizzare [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html):. PutItem Quando specifichi la stessa chiave primaria di un elemento esistente nella tua `PutItem` richiesta, il nuovo elemento sostituisce completamente l'elemento esistente. Puoi anche usare [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) per cancellare e sostituire tutti gli attributi al momento del salvataggio dopo aver aggiornato i tuoi articoli.
## Decrittografia dei set firmati
Nelle versioni 3.0.0 e 3.1.0 di AWS Database Encryption SDK, se si definisce un attributo di [tipo set](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) come`SIGN_ONLY`, i valori del set vengono canonicalizzati nell'ordine in cui vengono forniti. DynamoDB non mantiene l'ordine dei set. Di conseguenza, c'è la possibilità che la convalida della firma dell'elemento che contiene il set abbia esito negativo. La convalida della firma ha esito negativo quando i valori del set vengono restituiti in un ordine diverso da quello fornito al AWS Database Encryption SDK, anche se gli attributi del set contengono gli stessi valori.
**Nota**
Le versioni 3.1.1 e successive del AWS Database Encryption SDK canonicalizzano i valori di tutti gli attributi dei tipi di set, in modo che i valori vengano letti nello stesso ordine in cui sono stati scritti in DynamoDB.
Se la convalida della firma fallisce, l'operazione di decrittografia fallisce e restituisce il seguente messaggio di errore.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Nessun tag del destinatario corrispondente. |
Se ricevete il messaggio di errore riportato sopra e ritenete che l'elemento che state cercando di decrittografare includa un set firmato utilizzando la versione 3.0.0 o 3.1.0, consultate la [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)directory del repository aws-database-encryption-sdk -dynamodb-java su per i dettagli su come convalidare correttamente il set. GitHub
# Esempi di Java
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Gli esempi seguenti mostrano come utilizzare la libreria di crittografia lato client Java per DynamoDB per proteggere gli elementi della tabella nell'applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) negli [esempi Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) nel repository -dynamodb su. aws-database-encryption-sdk GitHub
Gli esempi seguenti mostrano come configurare la libreria di crittografia lato client Java per DynamoDB in una nuova tabella Amazon DynamoDB non popolata. Se desideri configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client, consulta. [Aggiungi la versione 3.x a una tabella esistente](ddb-java-config-existing-table.md)
**Topics**
+ [Utilizzo del client avanzato DynamoDB](#ddb-java-enhanced-client-example)
+ [Utilizzo dell'API DynamoDB di basso livello](#ddb-java-lowlevel-API-example)
+ [Utilizzo del livello inferiore DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Utilizzo del client avanzato DynamoDB
L'esempio seguente mostra come utilizzare il DynamoDB Enhanced Client `DynamoDbEncryptionInterceptor` e [AWS KMS un](use-kms-keyring.md) portachiavi per crittografare gli elementi della tabella DynamoDB come parte delle chiamate API DynamoDB.
Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.
**Nota**
[Il DynamoDB Enhanced Client non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'`DynamoDbEncryptionInterceptor`API DynamoDB di basso livello per utilizzare la crittografia ricercabile.
**Guarda l'esempio di codice completo**[: .java EnhancedPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: creare uno schema tabellare dalla classe di dati annotata**
L'esempio seguente utilizza la classe di dati annotati per creare il. `TableSchema`
[Questo esempio presuppone che la classe di dati annotata e le azioni degli attributi siano state definite utilizzando .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) Per ulteriori informazioni sull'annotazione delle azioni relative agli attributi, consulta. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Fase 4: Creare la configurazione di crittografia**
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per la tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Fase 5: Crea il `DynamoDbEncryptionInterceptor`**
L'esempio seguente ne crea uno nuovo `DynamoDbEncryptionInterceptor` con il `tableConfigs` **passo 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Fase 6: Creare un nuovo client AWS SDK DynamoDB**
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `interceptor` lo Step 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Fase 7: Creare il DynamoDB Enhanced Client e creare una tabella**
L'esempio seguente crea il DynamoDB Enhanced Client utilizzando il client DynamoDB AWS SDK creato **nel passaggio** 6 e crea una tabella utilizzando la classe di dati annotati.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Fase 8: Crittografare e firmare un elemento della tabella**
L'esempio seguente inserisce un elemento nella tabella DynamoDB utilizzando il DynamoDB Enhanced Client. L'elemento viene crittografato e firmato lato client prima di essere inviato a DynamoDB.
```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");
table.putItem(item);
```
## Utilizzo dell'API DynamoDB di basso livello
L'esempio seguente mostra come utilizzare l'API DynamoDB di basso livello con [AWS KMS un](use-kms-keyring.md) portachiavi per crittografare e firmare automaticamente gli elementi lato client con le richieste DynamoDB. `PutItem`
Puoi utilizzare qualsiasi [portachiavi supportato, ma ti consigliamo di utilizzare uno dei portachiavi](keyrings.md) quando possibile. AWS KMS
**[Guarda l'esempio di codice completo: .java BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)**
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: configura le azioni relative agli attributi**
L'esempio seguente definisce una `attributeActionsOnEncrypt` mappa che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Fase 4: Definire la configurazione di crittografia delle tabelle DynamoDB**
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
tableConfigs.put(ddbTableName, config);
```
**Fase 5: Creare il `DynamoDbEncryptionInterceptor`**
L'esempio seguente crea l'`DynamoDbEncryptionInterceptor`utilizzo del `tableConfigs` dal **passaggio 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Fase 6: Creare un nuovo client AWS SDK DynamoDB**
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `interceptor` lo Step 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Fase 7: Crittografare e firmare un elemento della tabella DynamoDB**
L'esempio seguente definisce una `item` mappa che rappresenta un elemento della tabella di esempio e inserisce l'elemento nella tabella DynamoDB. L'elemento viene crittografato e firmato lato client prima di essere inviato a DynamoDB.
```
final HashMap item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final PutItemRequest putRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(item)
.build();
final PutItemResponse putResponse = ddb.putItem(putRequest);
```
## Utilizzo del livello inferiore DynamoDbItemEncryptor
L'esempio seguente mostra come utilizzare il livello inferiore `DynamoDbItemEncryptor` con un [AWS KMS portachiavi](use-kms-keyring.md) per crittografare e firmare direttamente gli elementi della tabella. Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella DynamoDB.
Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.
**Nota**
[Il livello inferiore `DynamoDbItemEncryptor` non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'`DynamoDbEncryptionInterceptor`API DynamoDB di basso livello per utilizzare la crittografia ricercabile.
**Guarda l'esempio di codice completo**[: .java ItemEncryptDecryptExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: configura le azioni relative agli attributi**
L'esempio seguente definisce una `attributeActionsOnEncrypt` mappa che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Fase 4: Definire la configurazione `DynamoDbItemEncryptor`**
L'esempio seguente definisce la configurazione per`DynamoDbItemEncryptor`.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per 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();
```
**Fase 5: Creare il `DynamoDbItemEncryptor`**
L'esempio seguente ne crea uno nuovo `DynamoDbItemEncryptor` utilizzando il `config` tratto dal **passaggio 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Fase 6: Crittografare e firmare direttamente un elemento della tabella**
L'esempio seguente crittografa e firma direttamente un elemento utilizzando il. `DynamoDbItemEncryptor` Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella DynamoDB.
```
final Map originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final Map encryptedItem = itemEncryptor.EncryptItem(
EncryptItemInput.builder()
.plaintextItem(originalItem)
.build()
).encryptedItem();
```
# Configurare una tabella DynamoDB esistente per utilizzare AWS il Database Encryption SDK per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Con la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB, puoi configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client. Questo argomento fornisce indicazioni sui tre passaggi da eseguire per aggiungere la versione 3. *x* su una tabella DynamoDB esistente e popolata.
**Prerequisiti**
Versione 3. *x* [della libreria di crittografia lato client Java per DynamoDB richiede il DynamoDB Enhanced Client fornito in.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) AWS SDK for Java 2.x Se usi ancora [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), devi migrare per utilizzare il DynamoDB AWS SDK for Java 2.x Enhanced Client.
Segui le istruzioni per la [migrazione dalla versione](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) 1.x alla 2.x di. AWS SDK per Java
Quindi, segui le istruzioni per [iniziare a utilizzare l'API DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Prima di configurare la tabella per utilizzare la libreria di crittografia lato client Java per DynamoDB, è necessario generare una classe di dati `TableSchema`[con annotazioni e creare un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) client avanzato.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient)
## Fase 1: Prepararsi a leggere e scrivere elementi crittografati
Completa i seguenti passaggi per preparare il client AWS Database Encryption SDK per leggere e scrivere elementi crittografati. Dopo aver implementato le seguenti modifiche, il client continuerà a leggere e scrivere elementi in testo non crittografato. Non crittograferà né firmerà i nuovi elementi scritti nella tabella, ma sarà in grado di decrittografare gli elementi crittografati non appena vengono visualizzati. Queste modifiche preparano il client a iniziare a [crittografare](#ddb-java-add-step2) nuovi elementi. Le seguenti modifiche devono essere implementate su ciascun lettore prima di procedere al passaggio successivo.
**1. Definite le azioni relative agli [attributi](concepts.md#crypt-actions)**
Aggiorna la tua classe di dati annotata per includere azioni di attributo che definiscono quali valori degli attributi saranno crittografati e firmati, quali saranno solo firmati e quali verranno ignorati.
Consulta il [SimpleClassfile.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) nel repository aws-database-encryption-sdk -dynamodb GitHub per ulteriori informazioni sulle annotazioni di DynamoDB Enhanced Client.
Per impostazione predefinita, gli attributi della chiave primaria sono firmati ma non crittografati (`SIGN_ONLY`) e tutti gli altri attributi sono crittografati e firmati (). `ENCRYPT_AND_SIGN` Per specificare le eccezioni, utilizzate le annotazioni di crittografia definite nella libreria di crittografia lato client Java per DynamoDB. Ad esempio, se vuoi che un particolare attributo sia solo segno, usa l'annotazione. `@DynamoDbEncryptionSignOnly` Se desideri che un particolare attributo sia firmato e incluso nel contesto di crittografia, usa l'`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`annotazione. Se vuoi che un particolare attributo non sia né firmato né crittografato (`DO_NOTHING`), usa l'`@DynamoDbEncryptionDoNothing`annotazione.
Se specificate degli `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributi, devono esserlo anche gli attributi di partizione e ordinamento. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` [Per un esempio che mostra le annotazioni utilizzate per definire`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vedete SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
Per esempio annotazioni, vedere. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**2. Definire quali attributi verranno esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presumerà che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. [Crea un portachiavi](keyrings.md)**
L'esempio seguente crea un [AWS KMS portachiavi](use-kms-keyring.md). Il AWS KMS portachiavi utilizza la crittografia simmetrica o RSA asimmetrica per generare, crittografare e AWS KMS keys decrittografare le chiavi di dati.
Questo esempio utilizza per creare un portachiavi con una chiave KMS di crittografia `CreateMrkMultiKeyring` simmetrica. AWS KMS Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Definire la configurazione di crittografia delle tabelle DynamoDB **
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).
È necessario specificare `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` come override in testo semplice. Questa politica continua a leggere e scrivere elementi in testo non crittografato, legge gli elementi crittografati e prepara il client alla scrittura di elementi crittografati.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
**5. Creazione del `DynamoDbEncryptionInterceptor`**
**L'esempio seguente crea l'`DynamoDbEncryptionInterceptor`utilizzo del dal passaggio 3. `tableConfigs`**
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Fase 2: Scrivere elementi crittografati e firmati
Aggiorna la politica del testo in chiaro nella tua `DynamoDbEncryptionInterceptor` configurazione per consentire al client di scrivere elementi crittografati e firmati. **Dopo aver implementato la seguente modifica, il client crittograferà e firmerà i nuovi elementi in base alle azioni degli attributi configurate nel passaggio 1.** Il client sarà in grado di leggere elementi in testo semplice e elementi crittografati e firmati.
Prima di procedere alla [Fase 3](#ddb-java-add-step3), è necessario crittografare e firmare tutti gli elementi di testo in chiaro esistenti nella tabella. Non è possibile eseguire alcuna metrica o query per crittografare rapidamente gli elementi di testo in chiaro esistenti. Utilizzate il processo più adatto al vostro sistema. Ad esempio, è possibile utilizzare un processo asincrono che scansiona lentamente la tabella e quindi riscrive gli elementi utilizzando le azioni degli attributi e la configurazione di crittografia definite. Per identificare gli elementi di testo in chiaro nella tabella, consigliamo di cercare tutti gli elementi che non contengono gli `aws_dbe_foot` attributi `aws_dbe_head` e che AWS Database Encryption SDK aggiunge agli elementi quando sono crittografati e firmati.
**L'esempio seguente aggiorna la configurazione di crittografia della tabella dal passaggio 1.** È necessario aggiornare l'override del testo in chiaro con. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Questo criterio continua a leggere gli elementi di testo in chiaro, ma legge e scrive anche gli elementi crittografati. Creane uno nuovo `DynamoDbEncryptionInterceptor` utilizzando quello aggiornato. `tableConfigs`
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
## Passaggio 3: Leggi solo gli elementi crittografati e firmati
Dopo aver crittografato e firmato tutti gli articoli, aggiorna l'override del testo in chiaro nella `DynamoDbEncryptionInterceptor` configurazione per consentire al client di leggere e scrivere solo gli elementi crittografati e firmati. **Dopo aver implementato la seguente modifica, il client crittograferà e firmerà i nuovi elementi in base alle azioni degli attributi configurate nel passaggio 1.** Il client sarà in grado di leggere solo gli elementi crittografati e firmati.
L'esempio seguente aggiorna la configurazione di crittografia delle tabelle dal **passaggio 2**. È possibile aggiornare l'override del testo in chiaro con `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` o rimuovere la politica del testo in chiaro dalla configurazione. Per impostazione predefinita, il client legge e scrive solo elementi crittografati e firmati. Creane uno nuovo `DynamoDbEncryptionInterceptor` utilizzando quello aggiornato`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
// Optional: you can also remove the plaintext policy from your configuration
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
# Esegui la migrazione alla versione 3.x della libreria di crittografia lato client Java per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Versione 3. *x* della libreria di crittografia lato client Java per DynamoDB è una riscrittura importante della 2. *x* codice base. Include molti aggiornamenti, come un nuovo formato di dati strutturati, un supporto multitenancy migliorato, modifiche dello schema senza interruzioni e supporto per la crittografia ricercabile. Questo argomento fornisce indicazioni su come migrare il codice alla versione 3. *x.*
## Migrazione dalla versione 1.x alla 2.x
Migrare alla versione 2. *x* prima di migrare alla versione 3. *x.* Versione 2. *x* ha cambiato il simbolo del provider più recente da `MostRecentProvider` a`CachingMostRecentProvider`. Se attualmente utilizzi la versione 1. *x* della libreria di crittografia lato client Java per DynamoDB con il `MostRecentProvider` simbolo, è necessario aggiornare il nome del simbolo nel codice su. `CachingMostRecentProvider` Per ulteriori informazioni, consulta [Updates to the](most-recent-provider.md#mrp-versions) Most Recent Provider.
## Migrazione dalla versione 2.x alla 3.x
Le seguenti procedure descrivono come migrare il codice dalla versione 2. *x* alla versione 3. *x* della libreria di crittografia lato client Java per DynamoDB.
### Passaggio 1. Preparati a leggere gli articoli nel nuovo formato
Completa i seguenti passaggi per preparare il client AWS Database Encryption SDK alla lettura degli elementi nel nuovo formato. Dopo aver implementato le seguenti modifiche, il client continuerà a comportarsi nello stesso modo in cui si comportava nella versione 2. *x.* Il tuo client continuerà a leggere e scrivere elementi nella versione 2. formato *x*, ma queste modifiche preparano il client a [leggere gli elementi nel nuovo formato](#ddb-java-migrate-step2).
**Aggiorna il tuo AWS SDK per Java alla versione 2.x**
Versione 3. *x* [della libreria di crittografia lato client Java per DynamoDB richiede DynamoDB Enhanced Client.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Il DynamoDB Enhanced Client sostituisce il DBMapper Dynamo utilizzato [nelle versioni precedenti](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html). Per utilizzare il client avanzato, è necessario utilizzare il. AWS SDK for Java 2.x
Segui le istruzioni per la [migrazione dalla versione 1.x alla 2.x di](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK per Java
Per ulteriori informazioni sui AWS SDK for Java 2.x moduli richiesti, vedere. [Prerequisiti](ddb-java.md#ddb-java-prerequisites)
**Configura il tuo client per leggere gli elementi crittografati dalle versioni precedenti**
Le seguenti procedure forniscono una panoramica dei passaggi illustrati nell'esempio di codice riportato di seguito.
1. Crea un [portachiavi.](keyrings.md)
I portachiavi e [i gestori di materiali crittografici](concepts.md#crypt-materials-manager) sostituiscono i fornitori di materiali crittografici utilizzati nelle versioni precedenti della libreria di crittografia lato client Java per DynamoDB.
**Importante**
Le chiavi di wrapping specificate durante la creazione di un portachiavi devono essere le stesse chiavi di wrapping utilizzate con il fornitore di materiali crittografici nella versione 2. *x.*
1. Crea uno schema tabellare sulla tua classe annotata.
Questo passaggio definisce le azioni degli attributi che verranno utilizzate quando inizierai a scrivere elementi nel nuovo formato.
*Per indicazioni sull'uso del nuovo DynamoDB Enhanced Client, consulta [Generate a nella AWS SDK per Java Developer `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Guide.*
L'esempio seguente presuppone che tu abbia aggiornato la tua classe annotata dalla versione 2. *x* utilizzando le nuove annotazioni sulle azioni degli attributi. Per ulteriori indicazioni sull'annotazione delle azioni relative agli attributi, vedere. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**Nota**
Se si specificano degli `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributi, devono esserlo anche gli attributi di partizione e ordinamento. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` [Per un esempio che mostra le annotazioni utilizzate per definire`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vedete SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
1. Definire quali [attributi sono esclusi dalla firma](ddb-java-using.md#allowed-unauth).
1. Configura una mappa esplicita delle azioni degli attributi configurate nella classe modellata della versione 2.x.
Questo passaggio definisce le azioni degli attributi utilizzate per scrivere gli elementi nel vecchio formato.
1. Configura quello `DynamoDBEncryptor` che hai usato nella versione 2. *x* della libreria di crittografia lato client Java per DynamoDB.
1. Configura il comportamento precedente.
1. Creare un `DynamoDbEncryptionInterceptor`.
1. Crea un nuovo client AWS SDK DynamoDB.
1. Crea `DynamoDBEnhancedClient` e crea una tabella con la tua classe modellata.
Per ulteriori informazioni sul DynamoDB Enhanced Client, [consulta creare un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client avanzato.
```
public class MigrationExampleStep1 {
public static void MigrationStep1(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Create a Keyring.
// This example creates an AWS KMS Keyring that specifies the
// same kmsKeyId previously used in the version 2.x configuration.
// It uses the 'CreateMrkMultiKeyring' method to create the
// keyring, so that the keyring can correctly handle both single
// region and Multi-Region KMS Keys.
// Note that this example uses the AWS SDK for Java v2 KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
// 2. Create a Table Schema over your annotated class.
// For guidance on using the new attribute actions
// annotations, see SimpleClass.java in the
// aws-database-encryption-sdk-dynamodb GitHub repository.
// All primary key attributes must be signed but not encrypted
// and by default all non-primary key attributes
// are encrypted and signed (ENCRYPT_AND_SIGN).
// If you want a particular non-primary key attribute to be signed but
// not encrypted, use the 'DynamoDbEncryptionSignOnly' annotation.
// If you want a particular attribute to be neither signed nor encrypted
// (DO_NOTHING), use the 'DynamoDbEncryptionDoNothing' annotation.
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
// 3. Define which attributes the client should expect to be excluded
// from the signature when reading items.
// This value represents all unsigned attributes across the entire
// dataset.
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 4. Configure an explicit map of the attribute actions configured
// in your version 2.x modeled class.
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
// 5. Configure the DynamoDBEncryptor that you used in version 2.x.
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 6. Configure the legacy behavior.
// Input the DynamoDBEncryptor and attribute actions created in
// the previous steps. For Legacy Policy, use
// 'FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy continues to read
// and write items using the old format, but will be able to read
// items written in the new format as soon as they appear.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 7. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 8. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 7.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 9. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb client
// created in Step 8, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
### Passaggio 2. Scrivi gli elementi nel nuovo formato
Dopo aver distribuito le modifiche dal Passaggio 1 a tutti i lettori, completa i passaggi seguenti per configurare il client AWS Database Encryption SDK per scrivere elementi nel nuovo formato. Dopo aver implementato le seguenti modifiche, il client continuerà a leggere gli elementi nel vecchio formato e inizierà a scrivere e leggere gli elementi nel nuovo formato.
Le seguenti procedure forniscono una panoramica dei passaggi illustrati nell'esempio di codice riportato di seguito.
1. Continua a configurare il portachiavi, lo schema della tabella`allowedUnsignedAttributes`, le azioni degli attributi legacy e `DynamoDBEncryptor` come hai fatto nel [**passaggio**](#ddb-java-migrate-step1) 1.
1. Aggiorna il tuo comportamento precedente per scrivere solo nuovi elementi utilizzando il nuovo formato.
1. Creazione di una `DynamoDbEncryptionInterceptor `
1. Crea un nuovo client AWS SDK DynamoDB.
1. Crea `DynamoDBEnhancedClient` e crea una tabella con la tua classe modellata.
Per ulteriori informazioni sul DynamoDB Enhanced Client, [consulta creare un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client avanzato.
```
public class MigrationExampleStep2 {
public static void MigrationStep2(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema, legacy
// attribute actions, allowedUnsignedAttributes, and
// DynamoDBEncryptor as you did in Step 1.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 2. Update your legacy behavior to only write new items using the new
// format.
// For Legacy Policy, use 'FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy
// continues to read items in both formats, but will only write items
// using the new format.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb Client created
// in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
[Dopo aver implementato le modifiche della Fase 2, è necessario crittografare nuovamente tutti i vecchi elementi della tabella con il nuovo formato prima di poter continuare con la Fase 3.](#ddb-java-migrate-step3) Non è possibile eseguire alcuna metrica o query per crittografare rapidamente gli elementi esistenti. Utilizzate il processo più adatto al vostro sistema. Ad esempio, è possibile utilizzare un processo asincrono che scansiona lentamente la tabella e quindi riscrive gli elementi utilizzando le nuove azioni degli attributi e la configurazione di crittografia definite.
### Fase 3. Leggi e scrivi solo elementi nel nuovo formato
Dopo aver ricrittografato tutti gli elementi della tabella con il nuovo formato, puoi rimuovere il comportamento precedente dalla tua configurazione. Completa i seguenti passaggi per configurare il client in modo che legga e scriva solo elementi nel nuovo formato.
Le seguenti procedure forniscono una panoramica dei passaggi illustrati nell'esempio di codice riportato di seguito.
1. Continua a configurare il portachiavi, lo schema della tabella e `allowedUnsignedAttributes` come hai fatto nel [**passaggio**](#ddb-java-migrate-step1) 1. Rimuovi le azioni degli attributi precedenti `DynamoDBEncryptor` dalla tua configurazione.
1. Creare un `DynamoDbEncryptionInterceptor`.
1. Crea un nuovo client AWS SDK DynamoDB.
1. Crea `DynamoDBEnhancedClient` e crea una tabella con la tua classe modellata.
Per ulteriori informazioni sul DynamoDB Enhanced Client, [consulta creare un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient) client avanzato.
```
public class MigrationExampleStep3 {
public static void MigrationStep3(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema,
// and allowedUnsignedAttributes as you did in Step 1.
// Do not include the configurations for the DynamoDBEncryptor or
// the legacy attribute actions.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
// Do not configure any legacy behavior.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK Client
// created in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```