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à.
# 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)