Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Client di crittografia 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)