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à.
# Linguaggi di programmazione disponibili per Amazon DynamoDB Encryption Client
**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).
Il client di crittografia Amazon DynamoDB è disponibile per i seguenti linguaggi di programmazione. Anche se ogni linguaggio ha delle librerie specifiche, le implementazioni risultanti sono interoperabili. Ad esempio, puoi crittografare (e firmare) un item con il client Java e decrittografarlo con il client Python.
Per maggiori informazioni, consulta l'argomento corrispondente.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# 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);
```
# Client di crittografia DynamoDB per Python
**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 DynamoDB per Python. Puoi trovare il codice nel [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repository su GitHub, incluso [codice di esempio](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) completo e testato per aiutarti a iniziare.
**Nota**
Versioni 1. *x*. *x* e 2. *x*. *x* [del DynamoDB Encryption Client for Python entreranno in vigore a luglio 2022. end-of-support ](what-is-database-encryption-sdk.md#support) Effettua l'upgrade a una versione più recente il prima possibile.
**Topics**
+ [Prerequisiti](#python-prerequisites)
+ [Installazione](#python-installation)
+ [Utilizzo del client di crittografia DynamoDB per Python](python-using.md)
+ [Esempi di Python](python-examples.md)
## Prerequisiti
Prima di installare il client di crittografia Amazon DynamoDB per Python, assicurati di avere i seguenti prerequisiti.
**Una versione supportata di Python**
Python 3.8 o versioni successive è richiesto dalle versioni 3.3.0 e successive di Amazon DynamoDB Encryption Client for Python. Per scaricare Python, consulta la pagina relativa ai [download di Python](https://www.python.org/downloads/).
Le versioni precedenti di Amazon DynamoDB Encryption Client for Python supportano Python 2.7 e Python 3.4 e versioni successive, ma consigliamo di utilizzare la versione più recente di DynamoDB Encryption Client.
**Lo strumento di installazione pip per Python**
Python 3.6 e versioni successive includono **pip**, anche se potresti volerlo aggiornare. Per ulteriori informazioni sull'aggiornamento o sull'installazione di pip, consulta la sezione relativa all'[installazione](https://pip.pypa.io/en/latest/installation/) nella documentazione su **pip**.
## Installazione
Usa **pip** per installare il client di crittografia Amazon DynamoDB per Python, come mostrato negli esempi seguenti.
**Per installare la versione più recente**
```
pip install dynamodb-encryption-sdk
```
Per ulteriori dettagli sull'utilizzo di **pip** per installare e aggiornare pacchetti, consulta la sezione relativa all'[installazione dei pacchetti](https://packaging.python.org/tutorials/installing-packages/).
Il DynamoDB Encryption Client richiede la libreria di crittografia su [tutte le piattaforme](https://cryptography.io/en/latest/). Tutte le versioni di **pip** installano e creano la libreria di **crittografia** su Windows. **pip** 8.1 e le versioni successive installano e creano la libreria di **crittografia** su Linux. Se utilizzi una versione precedente di **pip** e il tuo ambiente Linux non possiede gli strumenti necessari per creare la libreria di **crittografia**, devi installarli. Per ulteriori informazioni, consulta la sezione relativa alla [creazione di una crittografia in Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
È possibile scaricare l'ultima versione di sviluppo del DynamoDB Encryption Client dal [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repository in poi. GitHub
Dopo aver installato il DynamoDB Encryption Client, inizia a guardare l'esempio di codice Python in questa guida.
# Utilizzo del client di crittografia DynamoDB per Python
**Nota**
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) 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 for Python che potrebbero non essere presenti in altre implementazioni del linguaggio di programmazione. Queste funzionalità sono progettate per semplificare l'utilizzo del DynamoDB Encryption Client nel modo più sicuro. Ti consigliamo di utilizzarle a meno che il tuo caso d'uso non sia insolito.
Per i dettagli sulla programmazione con il DynamoDB Encryption Client, consulta gli esempi in [Python](python-examples.md) in questa guida, gli esempi nel repository GitHub su e [la documentazione](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) [Python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) per aws-dynamodb-encryption-python il DynamoDB Encryption Client.
**Topics**
+ [Classi helper del client](#python-helpers)
+ [TableInfo classe](#table-info)
+ [Operazioni di attributo in Python](#python-attribute-actions)
## Classi helper del client
Il client di crittografia DynamoDB per Python include diverse classi di supporto client che rispecchiano le classi Boto 3 per DynamoDB. Queste classi di supporto sono progettate per semplificare l'aggiunta di crittografia e firma all'applicazione DynamoDB esistente ed evitare i problemi più comuni, come segue:
+ Impedite di crittografare la chiave primaria del vostro elemento, aggiungendo un'azione di override per la chiave primaria all'oggetto o generando un'eccezione se l'[AttributeActions](#python-attribute-actions)oggetto dice esplicitamente al client di crittografare `AttributeActions` la chiave primaria. Se l'azione predefinita nell'oggetto `AttributeActions` è `DO_NOTHING`, le classi helper del client utilizzano tale azione per la chiave primaria. Altrimenti, utilizzano `SIGN_ONLY`.
+ Crea un [TableInfo oggetto](#python-helpers) e popola il contesto di [crittografia DynamoDB in base a una chiamata a DynamoDB](concepts.md#encryption-context). Questo aiuta a garantire che il contesto di crittografia DynamoDB sia accurato e che il client possa identificare la chiave primaria.
+ Supporta metodi, come `put_item` and`get_item`, che crittografano e decrittografano in modo trasparente gli elementi della tabella quando scrivi o leggi da una tabella DynamoDB. L'unico metodo non supportato è `update_item`.
Puoi utilizzare le classi helper del client al posto dell'interazione diretta con il [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor) di livello inferiore. Utilizza queste classi a meno che non sia necessario impostare opzioni avanzate nel componente di crittografia dell'item.
Le classi helper del client includono:
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)per le applicazioni che utilizzano la risorsa [Table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) in DynamoDB per elaborare una tabella alla volta.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)per le applicazioni che utilizzano la classe [Service Resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) in DynamoDB per l'elaborazione in batch.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)per applicazioni che utilizzano il [client di livello inferiore](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client) in DynamoDB.
Per utilizzare le classi client helper, il chiamante deve avere l'autorizzazione a chiamare l'operazione DynamoDB sulla tabella di destinazione [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html).
## TableInfo classe
La [TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)classe è una classe di supporto che rappresenta una tabella DynamoDB, completa di campi per la chiave primaria e gli indici secondari. Ti consente di ottenere informazioni precise e in tempo reale sulla tabella.
Se utilizzi una [classe helper del client](#python-helpers), questa crea e utilizza un oggetto `TableInfo` per tuo conto. Altrimenti, puoi crearne uno esplicitamente. Per vedere un esempio, consulta [Utilizzo del componente di crittografia dell'item](python-examples.md#python-example-item-encryptor).
Quando si chiama il `refresh_indexed_attributes` metodo su un `TableInfo` oggetto, popola i valori delle proprietà dell'oggetto chiamando l'operazione DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). L'esecuzione di query sulla tabella è molto più affidabile rispetto all'impostazione come hardcoded dei nomi di indice. La `TableInfo` classe include anche una `encryption_context_values` proprietà che fornisce i valori richiesti per il contesto di crittografia [DynamoDB](concepts.md#encryption-context).
Per utilizzare il `refresh_indexed_attributes` metodo, il chiamante deve avere il permesso di chiamare l'operazione [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB sulla tabella di destinazione.
## Operazioni di attributo in Python
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item. Per specificare le operazioni di attributo in Python, creare un oggetto `AttributeActions` con un'operazione predefinita ed eventuali eccezioni per determinati attributi. I valori validi vengono definiti nel tipo enumerato `CryptoAction`.
**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).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Ad esempio, questo oggetto `AttributeActions` stabilisce l'operazione `ENCRYPT_AND_SIGN` come predefinita per tutti gli attributi e specifica le eccezioni per gli attributi `ISBN` e `PublicationYear`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Se utilizzi una [classe helper del client](#python-helpers), non è necessario specificare un'operazione di attributo per gli attributi della chiave primaria. Le classi helper del client impediscono la crittografia della chiave primaria.
Se non utilizzi una classe helper del client e l'operazione predefinita è `ENCRYPT_AND_SIGN`, devi specificare un'operazione per la chiave primaria. L'operazione consigliata per le chiavi primarie è `SIGN_ONLY`. Per semplificare la procedura, utilizza il metodo `set_index_keys`, che utilizza l'operazione SIGN\$1ONLY per le chiavi primarie o l'operazione DO\$1NOTHING quando questa è impostata come operazione predefinita.
**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.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Codice di esempio per il client di crittografia DynamoDB per Python
**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 Python per proteggere i dati DynamoDB nella tua applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) nella directory [examples](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) del repository su. [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/) GitHub
**Topics**
+ [Usa la classe EncryptedTable client helper](#python-example-table)
+ [Utilizzo del componente di crittografia dell'item](#python-example-item-encryptor)
## Usa la classe EncryptedTable client helper
L'esempio seguente mostra come utilizzare il [provider KMS diretto](direct-kms-provider.md) con la `EncryptedTable` [classe helper del client](python-using.md#python-helpers). Questo esempio utilizza lo stesso [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) dell'esempio [Utilizzo del componente di crittografia dell'item](#python-example-item-encryptor) seguente. Tuttavia, utilizza la classe `EncryptedTable` invece di interagire direttamente con il [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor) di livello inferiore.
Confrontando questi esempi, puoi visualizzare il lavoro che la classe helper del client esegue per tuo conto. Ciò include la creazione del contesto di [crittografia DynamoDB](concepts.md#encryption-context) e la verifica che gli attributi della chiave primaria siano sempre firmati, ma mai crittografati. Per creare il contesto di crittografia e scoprire la chiave primaria, le classi client helper chiamano l'operazione DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Per eseguire questo codice, devi disporre dell'autorizzazione per chiamare questa operazione.
**Consulta l'esempio di codice completo**: [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
Fase 1: creazione della tabella
Inizia creando un'istanza di una tabella DynamoDB standard con il nome della tabella.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Fase 2: creazione di un provider di materiali crittografici
Crea un'istanza del [provider di materiali crittografici](crypto-materials-providers.md) (cryptographic materials provider, CMP) selezionato.
Questo esempio utilizza il [provider KMS diretto](direct-kms-provider.md), ma puoi utilizzare qualunque CMP compatibile. Per creare un provider Direct KMS, specifica un. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) Questo esempio utilizza l'Amazon Resource Name (ARN) di AWS KMS key, ma puoi utilizzare qualsiasi identificatore di chiave valido.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Fase 3: creazione dell'oggetto delle operazioni di attributo.
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item. L'oggetto `AttributeActions` in questo esempio crittografa e firma tutti gli item tranne l'attributo `test`, che viene ignorato.
Non devi specificare operazioni di attributo per gli attributi della chiave primaria quando utilizzi una classe helper del client. La classe `EncryptedTable` firma gli attributi della chiave primaria, ma non li crittografa mai.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Fase 4: creazione della tabella crittografata
Crea la tabella criptata utilizzando la tabella standard, il provider KMS diretto e le operazioni di attributo. Questa fase completa la configurazione.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Fase 5: inserimento dell'item non crittografato nella tabella
Quando si chiama il `put_item` metodo su`encrypted_table`, gli elementi della tabella vengono crittografati, firmati e aggiunti in modo trasparente alla tabella DynamoDB.
Come prima cosa, definisci l'item della tabella.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Inseriscilo quindi nella tabella.
```
encrypted_table.put_item(Item=plaintext_item)
```
Per ottenere l'elemento dalla tabella DynamoDB nella sua forma crittografata, chiamate `get_item` il metodo sull'oggetto. `table` Per ottenere l'item decrittografato, chiama il metodo `get_item` nell'oggetto `encrypted_table`.
## Utilizzo del componente di crittografia dell'item
Questo esempio mostra come interagire direttamente con l'[elemento encryptor nel DynamoDB Encryptor](DDBEC-legacy-concepts.md#item-encryptor) Client durante la crittografia degli elementi della tabella, invece di utilizzare le [classi client helper che interagiscono con l'crittografo degli elementi per](python-using.md#python-helpers) te.
Quando si utilizza questa tecnica, si creano manualmente il contesto di crittografia DynamoDB e l'oggetto `CryptoConfig` di configurazione (). Inoltre, si crittografano gli elementi in una chiamata e li si inserisce nella tabella DynamoDB in una chiamata separata. Ciò consente di personalizzare `put_item` le chiamate e utilizzare il DynamoDB Encryption Client per crittografare e firmare dati strutturati che non vengono mai inviati a DynamoDB.
Questo esempio utilizza il [provider KMS diretto](direct-kms-provider.md), ma puoi utilizzare qualunque CMP compatibile.
**Consulta l'esempio di codice completo**: [aws\$1kms\$1encrypted\$1item.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
Fase 1: creazione della tabella
Inizia creando un'istanza di una risorsa di tabella DynamoDB standard con il nome della tabella.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Fase 2: creazione di un provider di materiali crittografici
Crea un'istanza del [provider di materiali crittografici](crypto-materials-providers.md) (cryptographic materials provider, CMP) selezionato.
Questo esempio utilizza il [provider KMS diretto](direct-kms-provider.md), ma puoi utilizzare qualunque CMP compatibile. Per creare un provider Direct KMS, specifica un. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) Questo esempio utilizza l'Amazon Resource Name (ARN) di AWS KMS key, ma puoi utilizzare qualsiasi identificatore di chiave valido.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Passaggio 3: usa la classe helper TableInfo
Per ottenere informazioni sulla tabella da DynamoDB, create un'istanza della [TableInfo](python-using.md#python-helpers)classe helper. Quando lavori direttamente con il componente di crittografia dell'item, devi creare un'istanza `TableInfo` e chiamarne i metodi. Le [classi helper del client](python-using.md#python-helpers) eseguono questa operazione per tuo conto.
Il `refresh_indexed_attributes` metodo `TableInfo` utilizza l'operazione [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB per ottenere informazioni accurate e in tempo reale sulla tabella. Queste comprendono la chiave primaria e gli indici secondari locali e globali. L'intermediario deve disporre dell'autorizzazione a chiamare `DescribeTable`.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Fase 4: Creare il 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. Questo esempio crea un contesto di crittografia DynamoDB in modo esplicito, poiché interagisce con l'elemento encryptor. Le [classi client helper creano automaticamente](python-using.md#python-helpers) il contesto di crittografia DynamoDB.
Per ottenere la chiave di partizione e la chiave di ordinamento, puoi utilizzare le proprietà della classe helper. [TableInfo](python-using.md#python-helpers)
```
index_key = {
'partition_attribute': 'value1',
'sort_attribute': 55
}
encryption_context = EncryptionContext(
table_name=table_name,
partition_key_name=table_info.primary_index.partition,
sort_key_name=table_info.primary_index.sort,
attributes=dict_to_ddb(index_key)
)
```
Fase 5: creazione dell'oggetto delle operazioni di attributo.
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item. L'oggetto `AttributeActions` in questo esempio crittografa e firma tutti gli item tranne gli attributi della chiave primaria, che vengono firmati ma non crittografati, e l'attributo `test`, che viene ignorato.
Quando interagisci direttamente con il componente di crittografia dell'item e l'operazione predefinita è `ENCRYPT_AND_SIGN`, devi specificare un'operazione alternativa per la chiave primaria. Puoi utilizzare il metodo `set_index_keys`, che utilizza `SIGN_ONLY` per la chiave primaria o `DO_NOTHING` se questa è l'operazione predefinita.
Per specificare la chiave primaria, questo esempio utilizza le chiavi di indice nell'[TableInfo](python-using.md#python-helpers)oggetto, che viene popolato da una chiamata a DynamoDB. Questa tecnica è più sicura rispetto all'impostazione come hardcoded dei nomi della chiave primaria.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Fase 6: creazione della configurazione dell'item
Per configurare il client di crittografia DynamoDB, utilizza gli oggetti appena creati in [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)una configurazione per l'elemento della tabella. Le classi client helper lo creano per te. CryptoConfig
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Fase 7: crittografia dell'item
Questo passaggio crittografa e firma l'elemento, ma non lo inserisce nella tabella DynamoDB.
Quando si utilizza una classe client helper, gli elementi vengono crittografati e firmati in modo trasparente e quindi aggiunti alla tabella DynamoDB quando si chiama il `put_item` metodo della classe helper. Quando utilizzi direttamente il componente di crittografia dell'item, le operazioni di crittografia e di inserimento sono indipendenti.
Crea prima un item non crittografato.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Poi, crittografalo e firmalo. Il metodo `encrypt_python_item` richiede l'oggetto di configurazione `CryptoConfig`.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Fase 8: inserimento dell'item nella tabella
Questo passaggio inserisce l'elemento crittografato e firmato nella tabella DynamoDB.
```
table.put_item(Item=encrypted_item)
```
Per visualizzare l'item crittografato, chiama il metodo `get_item` nell'oggetto `table` originale, invece che nell'oggetto `encrypted_table`. Il metodo ottiene l'item dalla tabella DynamoDB senza verificarlo né decrittografarlo.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
L'immagine seguente mostra parte di un esempio di item della tabella crittografato e firmato.
I valori dell'attributo crittografato sono dati binari. I nomi e i valori degli attributi della chiave primaria (`partition_attribute` e `sort_attribute`) e l'attributo `test` restano non crittografati. L'output mostra anche l'attributo che contiene la firma (`*amzn-ddb-map-sig*`) e l'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`).
![\[Un estratto di un item crittografato e firmato\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)