

Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub 

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

# Esempi di utilizzo di DynamoDB AWS CLI
<a name="cli_2_dynamodb_code_examples"></a>

I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS Command Line Interface con DynamoDB.

Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.

Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.

**Topics**
+ [Azioni](#actions)

## Azioni
<a name="actions"></a>

### `batch-get-item`
<a name="dynamodb_BatchGetItem_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare. `batch-get-item`

**AWS CLI**  
**Come recuperare più elementi da una tabella**  
L’esempio `batch-get-items` seguente legge più elementi dalla tabella `MusicCollection` utilizzando un batch di tre richieste `GetItem` e richiede il numero di unità di capacità di lettura utilizzate dall’operazione. Il comando restituisce solo l’attributo `AlbumTitle`.  

```
aws dynamodb batch-get-item \
    --request-items file://request-items.json \
    --return-consumed-capacity TOTAL
```
Contenuto di `request-items.json`:  

```
{
    "MusicCollection": {
        "Keys": [
            {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Scared of My Shadow"}
            }
        ],
        "ProjectionExpression":"AlbumTitle"
    }
}
```
Output:  

```
{
    "Responses": {
        "MusicCollection": [
            {
                "AlbumTitle": {
                    "S": "Somewhat Famous"
                }
            },
            {
                "AlbumTitle": {
                    "S": "Blue Sky Blues"
                }
            },
            {
                "AlbumTitle": {
                    "S": "Louder Than Ever"
                }
            }
        ]
    },
    "UnprocessedKeys": {},
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 1.5
        }
    ]
}
```
Per ulteriori informazioni, consulta [Operazioni batch](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.BatchOperations) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [BatchGetItem AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/batch-get-item.html)*Command Reference*. 

### `batch-write-item`
<a name="dynamodb_BatchWriteItem_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`batch-write-item`.

**AWS CLI**  
**Come aggiungere più elementi a una tabella**  
L’esempio `batch-write-item` seguente aggiunge tre nuovi elementi alla tabella `MusicCollection` utilizzando un batch di tre richieste `PutItem`. Richiede inoltre informazioni sul numero di unità di capacità di scrittura utilizzate dall’operazione e su eventuali raccolte di elementi modificate dall’operazione.  

```
aws dynamodb batch-write-item \
    --request-items file://request-items.json \
    --return-consumed-capacity INDEXES \
    --return-item-collection-metrics SIZE
```
Contenuto di `request-items.json`:  

```
{
    "MusicCollection": [
        {
            "PutRequest": {
                "Item": {
                    "Artist": {"S": "No One You Know"},
                    "SongTitle": {"S": "Call Me Today"},
                    "AlbumTitle": {"S": "Somewhat Famous"}
                }
            }
        },
        {
            "PutRequest": {
                "Item": {
                    "Artist": {"S": "Acme Band"},
                    "SongTitle": {"S": "Happy Day"},
                    "AlbumTitle": {"S": "Songs About Life"}
                }
            }
        },
        {
            "PutRequest": {
                "Item": {
                    "Artist": {"S": "No One You Know"},
                    "SongTitle": {"S": "Scared of My Shadow"},
                    "AlbumTitle": {"S": "Blue Sky Blues"}
                }
            }
        }
    ]
}
```
Output:  

```
{
    "UnprocessedItems": {},
    "ItemCollectionMetrics": {
        "MusicCollection": [
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "No One You Know"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            },
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "Acme Band"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            }
        ]
    },
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 6.0,
            "Table": {
                "CapacityUnits": 3.0
            },
            "LocalSecondaryIndexes": {
                "AlbumTitleIndex": {
                    "CapacityUnits": 3.0
                }
            }
        }
    ]
}
```
Per ulteriori informazioni, consulta [Operazioni batch](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.BatchOperations) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [BatchWriteItem AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/batch-write-item.html)*Command Reference*. 

### `create-backup`
<a name="dynamodb_CreateBackup_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`create-backup`.

**AWS CLI**  
**Come creare un backup per una tabella DynamoDB esistente**  
L’esempio `create-backup` seguente crea un backup della tabella `MusicCollection`.  

```
aws dynamodb create-backup \
    --table-name MusicCollection \
    --backup-name MusicCollectionBackup
```
Output:  

```
{
    "BackupDetails": {
        "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
        "BackupName": "MusicCollectionBackup",
        "BackupSizeBytes": 0,
        "BackupStatus": "CREATING",
        "BackupType": "USER",
        "BackupCreationDateTime": 1576616366.715
    }
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [CreateBackup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-backup.html)*Command Reference*. 

### `create-global-table`
<a name="dynamodb_CreateGlobalTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`create-global-table`.

**AWS CLI**  
**Come creare una tabella globale**  
L'`create-global-table`esempio seguente crea una tabella globale da due tabelle identiche nelle AWS regioni separate specificate.  

```
aws dynamodb create-global-table \
    --global-table-name MusicCollection \
    --replication-group RegionName=us-east-2 RegionName=us-east-1 \
    --region us-east-2
```
Output:  

```
{
    "GlobalTableDescription": {
        "ReplicationGroup": [
            {
                "RegionName": "us-east-2"
            },
            {
                "RegionName": "us-east-1"
            }
        ],
        "GlobalTableArn": "arn:aws:dynamodb::123456789012:global-table/MusicCollection",
        "CreationDateTime": 1576625818.532,
        "GlobalTableStatus": "CREATING",
        "GlobalTableName": "MusicCollection"
    }
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, vedere [CreateGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-global-table.html)in *AWS CLI Command Reference*. 

### `create-table`
<a name="dynamodb_CreateTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`create-table`.

**AWS CLI**  
**Esempio 1: come creare una tabella con tag**  
L’esempio `create-table` seguente utilizza gli attributi e lo schema di chiavi specificati per creare una tabella denominata `MusicCollection`. Questa tabella utilizza la velocità effettiva assegnata ed è crittografata a riposo utilizzando la CMK di AWS proprietà predefinita. Il comando applica inoltre un tag alla tabella, con una chiave `Owner` e un valore `blueTeam`.  

```
aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
    --tags Key=Owner,Value=blueTeam
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "TableName": "MusicCollection",
        "TableStatus": "CREATING",
        "KeySchema": [
            {
                "KeyType": "HASH",
                "AttributeName": "Artist"
            },
            {
                "KeyType": "RANGE",
                "AttributeName": "SongTitle"
            }
        ],
        "ItemCount": 0,
        "CreationDateTime": "2020-05-26T16:04:41.627000-07:00",
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come creare una tabella in modalità on demand**  
L’esempio seguente crea una tabella denominata `MusicCollection` utilizzando la modalità on demand, anziché la modalità basata su throughput allocato. Ciò risulta utile per le tabelle con carichi di lavoro imprevedibili.  

```
aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --billing-mode PAY_PER_REQUEST
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-27T11:44:10.807000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 0,
            "WriteCapacityUnits": 0
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "BillingModeSummary": {
            "BillingMode": "PAY_PER_REQUEST"
        }
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come creare una tabella e crittografarla con una chiave gestita dal cliente (CMK).**  
L’esempio seguente crea una tabella denominata `MusicCollection` e la crittografa utilizzando una chiave gestita dal cliente (CMK).  

```
aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
    --sse-specification Enabled=true,SSEType=KMS,KMSMasterKeyId=abcd1234-abcd-1234-a123-ab1234a1b234
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-27T11:12:16.431000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "SSEDescription": {
            "Status": "ENABLED",
            "SSEType": "KMS",
            "KMSMasterKeyArn": "arn:aws:kms:us-west-2:123456789012:key/abcd1234-abcd-1234-a123-ab1234a1b234"
        }
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 4: come creare una tabella con un indice secondario locale**  
Nell’esempio seguente vengono utilizzati gli attributi e lo schema di chiavi specificati per creare una tabella denominata `MusicCollection` con un indice secondario locale denominato `AlbumTitleIndex`.  

```
aws dynamodb create-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S AttributeName=AlbumTitle,AttributeType=S \
    --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --local-secondary-indexes \
        "[
            {
                \"IndexName\": \"AlbumTitleIndex\",
                \"KeySchema\": [
                    {\"AttributeName\": \"Artist\",\"KeyType\":\"HASH\"},
                    {\"AttributeName\": \"AlbumTitle\",\"KeyType\":\"RANGE\"}
                ],
                \"Projection\": {
                    \"ProjectionType\": \"INCLUDE\",
                    \"NonKeyAttributes\": [\"Genre\", \"Year\"]
                }
            }
        ]"
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "LocalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "Artist",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "Genre",
                        "Year"
                    ]
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 5: come creare una tabella con un indice secondario globale**  
L’esempio seguente crea una tabella denominata `GameScores` con un indice secondario globale denominato `GameTitleIndex`. La tabella di base ha una chiave di partizione di `UserId` e una chiave di ordinamento di `GameTitle`, permettendo di trovare il miglior punteggio di un singolo utente per un gioco specifico in modo efficiente, mentre il GSI ha una chiave di partizione di `GameTitle` e una chiave di ordinamento di `TopScore`, permettendo di trovare rapidamente il punteggio più alto complessivo per un determinato gioco.  

```
aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S AttributeName=TopScore,AttributeType=N \
    --key-schema AttributeName=UserId,KeyType=HASH \
                AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --global-secondary-indexes \
        "[
            {
                \"IndexName\": \"GameTitleIndex\",
                \"KeySchema\": [
                    {\"AttributeName\":\"GameTitle\",\"KeyType\":\"HASH\"},
                    {\"AttributeName\":\"TopScore\",\"KeyType\":\"RANGE\"}
                ],
                \"Projection\": {
                    \"ProjectionType\":\"INCLUDE\",
                    \"NonKeyAttributes\":[\"UserId\"]
                },
                \"ProvisionedThroughput\": {
                    \"ReadCapacityUnits\": 10,
                    \"WriteCapacityUnits\": 5
                }
            }
        ]"
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "TopScore",
                "AttributeType": "N"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-26T17:28:15.602000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "GameTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "GameTitle",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "TopScore",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "UserId"
                    ]
                },
                "IndexStatus": "CREATING",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 5
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameTitleIndex"
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 6: come creare una tabella con più indici secondari globali contemporaneamente**  
Nell’esempio seguente viene creata una tabella denominata `GameScores` con due indici secondari globali. Gli schemi GSI vengono passati tramite un file, anziché nella riga di comando.  

```
aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S AttributeName=TopScore,AttributeType=N AttributeName=Date,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --global-secondary-indexes file://gsi.json
```
Contenuto di `gsi.json`:  

```
[
    {
        "IndexName": "GameTitleIndex",
        "KeySchema": [
            {
                "AttributeName": "GameTitle",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "TopScore",
                "KeyType": "RANGE"
            }
        ],
        "Projection": {
            "ProjectionType": "ALL"
        },
        "ProvisionedThroughput": {
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        }
    },
    {
        "IndexName": "GameDateIndex",
        "KeySchema": [
            {
                "AttributeName": "GameTitle",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "Date",
                "KeyType": "RANGE"
            }
        ],
        "Projection": {
            "ProjectionType": "ALL"
        },
        "ProvisionedThroughput": {
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        }
    }
]
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Date",
                "AttributeType": "S"
            },
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "TopScore",
                "AttributeType": "N"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-08-04T16:40:55.524000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "GameTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "GameTitle",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "TopScore",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "CREATING",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 5
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameTitleIndex"
            },
            {
                "IndexName": "GameDateIndex",
                "KeySchema": [
                    {
                        "AttributeName": "GameTitle",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "Date",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "CREATING",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 5
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/index/GameDateIndex"
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 7: come creare una tabella con i flussi abilitati**  
L’esempio seguente crea una tabella denominata `GameScores` con i flussi DynamoDB abilitati. Le immagini vecchie e nuove di ciascun elemento verranno scritte nel flusso.  

```
aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --stream-specification StreamEnabled=TRUE,StreamViewType=NEW_AND_OLD_IMAGES
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2020-05-27T10:49:34.056000-07:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "NEW_AND_OLD_IMAGES"
        },
        "LatestStreamLabel": "2020-05-27T17:49:34.056",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/2020-05-27T17:49:34.056"
    }
}
```
Per ulteriori informazioni, consulta [Operazioni di base per le tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 8: come creare una tabella con il flusso KEYS\$1ONLY abilitato**  
L’esempio seguente crea una tabella denominata `GameScores` con i flussi DynamoDB abilitati. Solo gli attributi chiave dell’elemento modificato vengono scritti nel flusso.  

```
aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --stream-specification StreamEnabled=TRUE,StreamViewType=KEYS_ONLY
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2023-05-25T18:45:34.140000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "KEYS_ONLY"
        },
        "LatestStreamLabel": "2023-05-25T18:45:34.140",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores/stream/2023-05-25T18:45:34.140",
        "DeletionProtectionEnabled": false
    }
}
```
Per ulteriori informazioni, consulta [Acquisizione dei dati di modifica per DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 9: come creare una tabella con la classe Accesso infrequente standard**  
L’esempio seguente crea una tabella denominata `GameScores` e assegna la classe di tabella Accesso Infrequente Amazon DynamoDB Standard (AI Amazon DynamoDB Standard). Questa classe di tabelle è ottimizzata a livello di archiviazione in quanto l’archiviazione rappresenta il costo principale.  

```
aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --table-class STANDARD_INFREQUENT_ACCESS
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2023-05-25T18:33:07.581000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "TableClassSummary": {
            "TableClass": "STANDARD_INFREQUENT_ACCESS"
        },
        "DeletionProtectionEnabled": false
    }
}
```
Per ulteriori informazioni, consulta [Classi di tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 10: come creare una tabella con l’opzione Protezione da eliminazione abilitata**  
L’esempio seguente crea una tabella denominata `GameScores` e abilita la protezione da eliminazione.  

```
aws dynamodb create-table \
    --table-name GameScores \
    --attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S \
    --key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
    --deletion-protection-enabled
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "GameTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "UserId",
                "AttributeType": "S"
            }
        ],
        "TableName": "GameScores",
        "KeySchema": [
            {
                "AttributeName": "UserId",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "GameTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": "2023-05-25T23:02:17.093000+00:00",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 10,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/GameScores",
        "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "DeletionProtectionEnabled": true
    }
}
```
Per ulteriori informazioni, consulta [Uso della protezione da eliminazione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeletionProtection) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  *Per i dettagli sull'API, consulta Command [CreateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-table.html)Reference AWS CLI .* 

### `delete-backup`
<a name="dynamodb_DeleteBackup_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`delete-backup`.

**AWS CLI**  
**Come eliminare un backup DynamoDB esistente**  
L’esempio `delete-backup` seguente elimina il backup esistente specificato.  

```
aws dynamodb delete-backup \
    --backup-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a
```
Output:  

```
{
    "BackupDescription": {
        "BackupDetails": {
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
            "BackupName": "MusicCollectionBackup",
            "BackupSizeBytes": 0,
            "BackupStatus": "DELETED",
            "BackupType": "USER",
            "BackupCreationDateTime": 1576616366.715
        },
        "SourceTableDetails": {
            "TableName": "MusicCollection",
            "TableId": "b0c04bcc-309b-4352-b2ae-9088af169fe2",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "TableSizeBytes": 0,
            "KeySchema": [
                {
                    "AttributeName": "Artist",
                    "KeyType": "HASH"
                },
                {
                    "AttributeName": "SongTitle",
                    "KeyType": "RANGE"
                }
            ],
            "TableCreationDateTime": 1576615228.571,
            "ProvisionedThroughput": {
                "ReadCapacityUnits": 5,
                "WriteCapacityUnits": 5
            },
            "ItemCount": 0,
            "BillingMode": "PROVISIONED"
        },
        "SourceTableFeatureDetails": {}
    }
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DeleteBackup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-backup.html)*Command Reference*. 

### `delete-item`
<a name="dynamodb_DeleteItem_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`delete-item`.

**AWS CLI**  
**Esempio 1: come eliminare un elemento**  
L’esempio `delete-item` seguente elimina un elemento dalla tabella `MusicCollection` e richiede i dettagli sull’elemento eliminato e sulla capacità utilizzata dalla richiesta.  

```
aws dynamodb delete-item \
    --table-name MusicCollection \
    --key file://key.json \
    --return-values ALL_OLD \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE
```
Contenuto di `key.json`:  

```
{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Scared of My Shadow"}
}
```
Output:  

```
{
    "Attributes": {
        "AlbumTitle": {
            "S": "Blue Sky Blues"
        },
        "Artist": {
            "S": "No One You Know"
        },
        "SongTitle": {
            "S": "Scared of My Shadow"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 2.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "No One You Know"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}
```
Per ulteriori informazioni, consulta [Scrittura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come eliminare un elemento in base a una condizione**  
L’esempio seguente elimina un elemento dalla tabella `ProductCatalog` solo se `ProductCategory` è `Sporting Goods` o `Gardening Supplies` e se il relativo prezzo è compreso tra 500 e 600. Restituisce i dettagli sull’elemento eliminato.  

```
aws dynamodb delete-item \
    --table-name ProductCatalog \
    --key '{"Id":{"N":"456"}}' \
    --condition-expression "(ProductCategory IN (:cat1, :cat2)) and (#P between :lo and :hi)" \
    --expression-attribute-names file://names.json \
    --expression-attribute-values file://values.json \
    --return-values ALL_OLD
```
Contenuto di `names.json`:  

```
{
    "#P": "Price"
}
```
Contenuto di `values.json`:  

```
{
    ":cat1": {"S": "Sporting Goods"},
    ":cat2": {"S": "Gardening Supplies"},
    ":lo": {"N": "500"},
    ":hi": {"N": "600"}
}
```
Output:  

```
{
    "Attributes": {
        "Id": {
            "N": "456"
        },
        "Price": {
            "N": "550"
        },
        "ProductCategory": {
            "S": "Sporting Goods"
        }
    }
}
```
Per ulteriori informazioni, consulta [Scrittura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DeleteItem AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-item.html)*Command Reference*. 

### `delete-table`
<a name="dynamodb_DeleteTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`delete-table`.

**AWS CLI**  
**Come eliminare una tabella**  
L’esempio `delete-table` seguente elimina la tabella `MusicCollection`.  

```
aws dynamodb delete-table \
    --table-name MusicCollection
```
Output:  

```
{
    "TableDescription": {
        "TableStatus": "DELETING",
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableName": "MusicCollection",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        }
    }
}
```
Per ulteriori informazioni, consulta [Eliminazione di una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeleteTable) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DeleteTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-table.html)*Command Reference*. 

### `describe-backup`
<a name="dynamodb_DescribeBackup_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-backup`.

**AWS CLI**  
**Come ottenere informazioni su un backup esistente di una tabella**  
L’esempio `describe-backup` seguente mostra le informazioni relative al backup esistente specificato.  

```
aws dynamodb describe-backup \
    --backup-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a
```
Output:  

```
{
    "BackupDescription": {
        "BackupDetails": {
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
            "BackupName": "MusicCollectionBackup",
            "BackupSizeBytes": 0,
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupCreationDateTime": 1576616366.715
        },
        "SourceTableDetails": {
            "TableName": "MusicCollection",
            "TableId": "b0c04bcc-309b-4352-b2ae-9088af169fe2",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "TableSizeBytes": 0,
            "KeySchema": [
                {
                    "AttributeName": "Artist",
                    "KeyType": "HASH"
                },
                {
                    "AttributeName": "SongTitle",
                    "KeyType": "RANGE"
                }
            ],
            "TableCreationDateTime": 1576615228.571,
            "ProvisionedThroughput": {
                "ReadCapacityUnits": 5,
                "WriteCapacityUnits": 5
            },
            "ItemCount": 0,
            "BillingMode": "PROVISIONED"
        },
        "SourceTableFeatureDetails": {}
    }
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DescribeBackup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-backup.html)*Command Reference*. 

### `describe-continuous-backups`
<a name="dynamodb_DescribeContinuousBackups_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-continuous-backups`.

**AWS CLI**  
**Come ottenere informazioni sui backup continui per una tabella DynamoDB**  
L’esempio `describe-continuous-backups` seguente mostra i dettagli sulle impostazioni dei backup continui per la tabella `MusicCollection`.  

```
aws dynamodb describe-continuous-backups \
    --table-name MusicCollection
```
Output:  

```
{
    "ContinuousBackupsDescription": {
        "ContinuousBackupsStatus": "ENABLED",
        "PointInTimeRecoveryDescription": {
            "PointInTimeRecoveryStatus": "DISABLED"
        }
    }
}
```
Per ulteriori informazioni, consulta [Point-in-Time Recovery for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) nella Amazon DynamoDB Developer *Guide*.  
+  *Per i dettagli sull'API, consulta [DescribeContinuousBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-continuous-backups.html)Command Reference.AWS CLI * 

### `describe-contributor-insights`
<a name="dynamodb_DescribeContributorInsights_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-contributor-insights`.

**AWS CLI**  
**Come visualizzare le impostazioni di Contributor Insights per una tabella DynamoDB**  
L’esempio `describe-contributor-insights` seguente mostra le impostazioni di Contributor Insights per la tabella `MusicCollection` e l’indice secondario globale `AlbumTitle-index`.  

```
aws dynamodb describe-contributor-insights \
    --table-name MusicCollection \
    --index-name AlbumTitle-index
```
Output:  

```
{
    "TableName": "MusicCollection",
    "IndexName": "AlbumTitle-index",
    "ContributorInsightsRuleList": [
        "DynamoDBContributorInsights-PKC-MusicCollection-1576629651520",
        "DynamoDBContributorInsights-SKC-MusicCollection-1576629651520",
        "DynamoDBContributorInsights-PKT-MusicCollection-1576629651520",
        "DynamoDBContributorInsights-SKT-MusicCollection-1576629651520"
    ],
    "ContributorInsightsStatus": "ENABLED",
    "LastUpdateDateTime": 1576629654.78
}
```
*Per ulteriori informazioni, consulta [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB nella Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) Developer Guide.*  
+  *Per i dettagli sull'API, consulta Command Reference. [DescribeContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-contributor-insights.html)AWS CLI * 

### `describe-endpoints`
<a name="dynamodb_DescribeEndpoints_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-endpoints`.

**AWS CLI**  
**Come visualizzare le informazioni sugli endpoint regionali**  
L'`describe-endpoints`esempio seguente mostra i dettagli sugli endpoint per la AWS regione corrente.  

```
aws dynamodb describe-endpoints
```
Output:  

```
{
    "Endpoints": [
        {
            "Address": "dynamodb.us-west-2.amazonaws.com",
            "CachePeriodInMinutes": 1440
        }
    ]
}
```
Per ulteriori informazioni, consulta [Endpoint e quote di Amazon DynamoDB](https://docs.aws.amazon.com/general/latest/gr/ddb.html) nella *documentazione generale di riferimento di AWS *.  
+  Per i dettagli sull'API, vedere [DescribeEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-endpoints.html)in *AWS CLI Command Reference.* 

### `describe-global-table-settings`
<a name="dynamodb_DescribeGlobalTableSettings_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-global-table-settings`.

**AWS CLI**  
**Come ottenere informazioni sulle impostazioni di una tabella globale DynamoDB**  
L’esempio `describe-global-table-settings` seguente mostra le impostazioni per la tabella globale `MusicCollection`.  

```
aws dynamodb describe-global-table-settings \
    --global-table-name MusicCollection
```
Output:  

```
{
    "GlobalTableName": "MusicCollection",
    "ReplicaSettings": [
        {
            "RegionName": "us-east-1",
            "ReplicaStatus": "ACTIVE",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 5,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        },
        {
            "RegionName": "us-east-2",
            "ReplicaStatus": "ACTIVE",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 5,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        }
    ]
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DescribeGlobalTableSettings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-global-table-settings.html)*Command Reference*. 

### `describe-global-table`
<a name="dynamodb_DescribeGlobalTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-global-table`.

**AWS CLI**  
**Come visualizzare le informazioni su una tabella globale DynamoDB**  
L’esempio `describe-global-table` seguente mostra i dettagli relativi alla tabella globale `MusicCollection`.  

```
aws dynamodb describe-global-table \
    --global-table-name MusicCollection
```
Output:  

```
{
    "GlobalTableDescription": {
        "ReplicationGroup": [
            {
                "RegionName": "us-east-2"
            },
            {
                "RegionName": "us-east-1"
            }
        ],
        "GlobalTableArn": "arn:aws:dynamodb::123456789012:global-table/MusicCollection",
        "CreationDateTime": 1576625818.532,
        "GlobalTableStatus": "ACTIVE",
        "GlobalTableName": "MusicCollection"
    }
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DescribeGlobalTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-global-table.html)*Command Reference*. 

### `describe-limits`
<a name="dynamodb_DescribeLimits_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-limits`.

**AWS CLI**  
**Come visualizzare i limiti di capacità con provisioning**  
L'`describe-limits`esempio seguente mostra i limiti di capacità prevista per il tuo account nella regione corrente. AWS   

```
aws dynamodb describe-limits
```
Output:  

```
{
    "AccountMaxReadCapacityUnits": 80000,
    "AccountMaxWriteCapacityUnits": 80000,
    "TableMaxReadCapacityUnits": 40000,
    "TableMaxWriteCapacityUnits": 40000
}
```
Per ulteriori informazioni, consulta [Limiti in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  *Per i dettagli sull'API, consulta Command [DescribeLimits](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-limits.html)Reference AWS CLI .* 

### `describe-table-replica-auto-scaling`
<a name="dynamodb_DescribeTableReplicaAutoScaling_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-table-replica-auto-scaling`.

**AWS CLI**  
**Come visualizzare le impostazioni di dimensionamento automatico tra le repliche di una tabella globale**  
L’esempio `describe-table-replica-auto-scaling` seguente mostra le impostazioni di dimensionamento automatico tra le repliche della tabella globale `MusicCollection`.  

```
aws dynamodb describe-table-replica-auto-scaling \
    --table-name MusicCollection
```
Output:  

```
{
    "TableAutoScalingDescription": {
        "TableName": "MusicCollection",
        "TableStatus": "ACTIVE",
        "Replicas": [
            {
                "RegionName": "us-east-1",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            },
            {
                "RegionName": "us-east-2",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DescribeTableReplicaAutoScaling AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-table-replica-auto-scaling.html)*Command Reference*. 

### `describe-table`
<a name="dynamodb_DescribeTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-table`.

**AWS CLI**  
**Come descrivere una tabella**  
L’esempio `describe-table` seguente descrive la tabella `MusicCollection`.  

```
aws dynamodb describe-table \
    --table-name MusicCollection
```
Output:  

```
{
    "Table": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "TableName": "MusicCollection",
        "TableStatus": "ACTIVE",
        "KeySchema": [
            {
                "KeyType": "HASH",
                "AttributeName": "Artist"
            },
            {
                "KeyType": "RANGE",
                "AttributeName": "SongTitle"
            }
        ],
        "ItemCount": 0,
        "CreationDateTime": 1421866952.062
    }
}
```
Per ulteriori informazioni, consulta [Descrizione di una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DescribeTable) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DescribeTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-table.html)*Command Reference*. 

### `describe-time-to-live`
<a name="dynamodb_DescribeTimeToLive_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`describe-time-to-live`.

**AWS CLI**  
**Come visualizzare le impostazioni Time to Live per una tabella**  
L’esempio `describe-time-to-live` seguente visualizza le impostazioni Time to Live per la tabella `MusicCollection`.  

```
aws dynamodb describe-time-to-live \
    --table-name MusicCollection
```
Output:  

```
{
    "TimeToLiveDescription": {
        "TimeToLiveStatus": "ENABLED",
        "AttributeName": "ttl"
    }
}
```
Per ulteriori informazioni, consulta [Time to Live](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [DescribeTimeToLive AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-time-to-live.html)*Command Reference*. 

### `get-item`
<a name="dynamodb_GetItem_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`get-item`.

**AWS CLI**  
**Esempio 1: come leggere un elemento in una tabella**  
L’esempio `get-item` seguente recupera un elemento dalla tabella `MusicCollection`. La tabella ha una chiave hash-and-range primaria (`Artist`e`SongTitle`), quindi è necessario specificare entrambi questi attributi. Il comando richiede anche informazioni sulla capacità di scrittura utilizzata dall’operazione.  

```
aws dynamodb get-item \
    --table-name MusicCollection \
    --key file://key.json \
    --return-consumed-capacity TOTAL
```
Contenuto di `key.json`:  

```
{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}
```
Output:  

```
{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}
```
Per ulteriori informazioni, consulta [Lettura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come leggere un elemento utilizzando una lettura consistente**  
L’esempio seguente recupera un elemento dalla tabella `MusicCollection` tramite operazioni a elevata consistenza di lettura.  

```
aws dynamodb get-item \
    --table-name MusicCollection \
    --key file://key.json \
    --consistent-read \
    --return-consumed-capacity TOTAL
```
Contenuto di `key.json`:  

```
{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}
```
Output:  

```
{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    }
}
```
Per ulteriori informazioni, consulta [Lettura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come recuperare attributi specifici di un elemento**  
L’esempio seguente utilizza un’espressione di proiezione per recuperare solo tre attributi dell’elemento desiderato.  

```
aws dynamodb get-item \
    --table-name ProductCatalog \
    --key '{"Id": {"N": "102"}}' \
    --projection-expression "#T, #C, #P" \
    --expression-attribute-names file://names.json
```
Contenuto di `names.json`:  

```
{
    "#T": "Title",
    "#C": "ProductCategory",
    "#P": "Price"
}
```
Output:  

```
{
    "Item": {
        "Price": {
            "N": "20"
        },
        "Title": {
            "S": "Book 102 Title"
        },
        "ProductCategory": {
            "S": "Book"
        }
    }
}
```
Per ulteriori informazioni, consulta [Lettura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [GetItem AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/get-item.html)*Command Reference*. 

### `list-backups`
<a name="dynamodb_ListBackups_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`list-backups`.

**AWS CLI**  
**Esempio 1: come elencare tutti i backup DynamoDB esistenti**  
L’esempio `list-backups` seguente elenca tutti i backup esistenti.  

```
aws dynamodb list-backups
```
Output:  

```
{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        },
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-b2abc345",
            "BackupName": "MusicCollectionBackup2",
            "BackupCreationDateTime": "2020-06-26T11:08:35.431000-07:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 400
        }
    ]
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come elencare i backup creati dall’utente in un intervallo di tempo specifico**  
L’esempio seguente elenca solo i backup della tabella `MusicCollection` creati dall’utente (non quelli creati automaticamente da DynamoDB) con una data di creazione compresa tra il 1° gennaio 2020 e il 1° marzo 2020.  

```
aws dynamodb list-backups \
    --table-name MusicCollection \
    --time-range-lower-bound 1577836800 \
    --time-range-upper-bound 1583020800 \
    --backup-type USER
```
Output:  

```
{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        }
    ]
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come limitare le dimensioni della pagina**  
L’esempio seguente restituisce un elenco di tutti i backup esistenti, ma recupera solo un elemento in ogni chiamata, eseguendo più chiamate, se necessario, per ottenere l’intero elenco. La limitazione delle dimensioni della pagina è utile quando si eseguono comandi di tipo elenco su un numero elevato di risorse, il che può causare un errore di “timeout” quando si utilizza la dimensione di pagina predefinita pari a 1.000.  

```
aws dynamodb list-backups \
    --page-size 1
```
Output:  

```
{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        },
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-b2abc345",
            "BackupName": "MusicCollectionBackup2",
            "BackupCreationDateTime": "2020-06-26T11:08:35.431000-07:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 400
        }
    ]
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 4: come limitare il numero di elementi restituiti**  
L’esempio seguente limita il numero di righe restituite a 1. La risposta include un valore `NextToken` con cui recuperare la pagina di risultati successiva.  

```
aws dynamodb list-backups \
    --max-items 1
```
Output:  

```
{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-a1bcd234",
            "BackupName": "MusicCollectionBackup1",
            "BackupCreationDateTime": "2020-02-12T14:41:51.617000-08:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 170
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 5: come recuperare la pagina di risultati successiva**  
Il comando seguente utilizza il valore `NextToken` di una precedente chiamata al comando `list-backups` per recuperare un’altra pagina di risultati. Poiché la risposta in questo caso non include un valore `NextToken`, ciò significa che è stata raggiunta la fine dei risultati.  

```
aws dynamodb list-backups \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Output  

```
{
    "BackupSummaries": [
        {
            "TableName": "MusicCollection",
            "TableId": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
            "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "BackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01234567890123-b2abc345",
            "BackupName": "MusicCollectionBackup2",
            "BackupCreationDateTime": "2020-06-26T11:08:35.431000-07:00",
            "BackupStatus": "AVAILABLE",
            "BackupType": "USER",
            "BackupSizeBytes": 400
        }
    ]
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [ListBackups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-backups.html)*Command Reference*. 

### `list-contributor-insights`
<a name="dynamodb_ListContributorInsights_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`list-contributor-insights`.

**AWS CLI**  
**Esempio 1: come visualizzare un elenco di riepiloghi di Contributor Insights**  
L’esempio `list-contributor-insights` seguente mostra un elenco di riepiloghi di Contributor Insights.  

```
aws dynamodb list-contributor-insights
```
Output:  

```
{
    "ContributorInsightsSummaries": [
        {
            "TableName": "MusicCollection",
            "IndexName": "AlbumTitle-index",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "ProductCatalog",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Forum",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Reply",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Thread",
            "ContributorInsightsStatus": "ENABLED"
        }
    ]
}
```
*Per ulteriori informazioni, consulta [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB nella Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) Developer Guide.*  
**Esempio 2: come limitare il numero di elementi restituiti**  
L’esempio seguente limita il numero di righe restituite a 4. La risposta include un valore `NextToken` con cui recuperare la pagina di risultati successiva.  

```
aws dynamodb list-contributor-insights \
    --max-results 4
```
Output:  

```
{
    "ContributorInsightsSummaries": [
        {
            "TableName": "MusicCollection",
            "IndexName": "AlbumTitle-index",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "ProductCatalog",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Forum",
            "ContributorInsightsStatus": "ENABLED"
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
*Per ulteriori informazioni, consulta [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB nella Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) Developer Guide.*  
**Esempio 3: come recuperare la pagina di risultati successiva**  
Il comando seguente utilizza il valore `NextToken` di una precedente chiamata al comando `list-contributor-insights` per recuperare un’altra pagina di risultati. Poiché la risposta in questo caso non include un valore `NextToken`, ciò significa che è stata raggiunta la fine dei risultati.  

```
aws dynamodb list-contributor-insights \
    --max-results 4 \
    --next-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Output:  

```
{
    "ContributorInsightsSummaries": [
        {
            "TableName": "Reply",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Thread",
            "ContributorInsightsStatus": "ENABLED"
        }
    ]
}
```
*Per ulteriori informazioni, consulta [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB nella Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) Developer Guide.*  
+  *Per i dettagli sull'API, consulta Command Reference. [ListContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-contributor-insights.html)AWS CLI * 

### `list-global-tables`
<a name="dynamodb_ListGlobalTables_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`list-global-tables`.

**AWS CLI**  
**Come elencare le tabelle globali DynamoDB esistenti**  
L’esempio `list-global-tables` seguente elenca tutte le tabelle globali esistenti.  

```
aws dynamodb list-global-tables
```
Output:  

```
{
    "GlobalTables": [
        {
            "GlobalTableName": "MusicCollection",
            "ReplicationGroup": [
                {
                    "RegionName": "us-east-2"
                },
                {
                    "RegionName": "us-east-1"
                }
            ]
        }
    ]
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [ListGlobalTables AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-global-tables.html)*Command Reference*. 

### `list-tables`
<a name="dynamodb_ListTables_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`list-tables`.

**AWS CLI**  
**Esempio 1: come elencare le tabelle**  
L'`list-tables`esempio seguente elenca tutte le tabelle associate all' AWS account corrente e alla regione.  

```
aws dynamodb list-tables
```
Output:  

```
{
    "TableNames": [
        "Forum",
        "ProductCatalog",
        "Reply",
        "Thread"
    ]
}
```
Per ulteriori informazioni, consulta [Elenco dei nomi delle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come limitare le dimensioni della pagina**  
L’esempio seguente restituisce un elenco di tutte le tabelle esistenti, ma recupera solo un elemento in ogni chiamata, eseguendo più chiamate se necessario per ottenere l’intero elenco. La limitazione delle dimensioni della pagina è utile quando si eseguono comandi di tipo elenco su un numero elevato di risorse, il che può causare un errore di “timeout” quando si utilizza la dimensione di pagina predefinita di 1000.  

```
aws dynamodb list-tables \
    --page-size 1
```
Output:  

```
{
    "TableNames": [
        "Forum",
        "ProductCatalog",
        "Reply",
        "Thread"
    ]
}
```
Per ulteriori informazioni, consulta [Elenco dei nomi delle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come limitare il numero di elementi restituiti**  
L’esempio seguente limita il numero di righe restituite a 2. La risposta include un valore `NextToken` con cui recuperare la pagina di risultati successiva.  

```
aws dynamodb list-tables \
    --max-items 2
```
Output:  

```
{
    "TableNames": [
        "Forum",
        "ProductCatalog"
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
Per ulteriori informazioni, consulta [Elenco dei nomi delle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 4: come recuperare la pagina di risultati successiva**  
Il comando seguente utilizza il valore `NextToken` di una precedente chiamata al comando `list-tables` per recuperare un’altra pagina di risultati. Poiché la risposta in questo caso non include un valore `NextToken`, ciò significa che è stata raggiunta la fine dei risultati.  

```
aws dynamodb list-tables \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Output:  

```
{
    "TableNames": [
        "Reply",
        "Thread"
    ]
}
```
Per ulteriori informazioni, consulta [Elenco dei nomi delle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [ListTables AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-tables.html)*Command Reference*. 

### `list-tags-of-resource`
<a name="dynamodb_ListTagsOfResource_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`list-tags-of-resource`.

**AWS CLI**  
**Esempio 1: come elencare i tag di una risorsa DynamoDB**  
L’esempio `list-tags-of-resource` seguente mostra i tag per la tabella `MusicCollection`.  

```
aws dynamodb list-tags-of-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection
```
Output:  

```
{
    "Tags": [
        {
            "Key": "Owner",
            "Value": "blueTeam"
        },
        {
            "Key": "Environment",
            "Value": "Production"
        }
    ]
}
```
Per ulteriori informazioni, consulta [Tagging per Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come limitare il numero di tag restituiti**  
L’esempio seguente limita a 1 il numero di tag restituiti. La risposta include un valore `NextToken` con cui recuperare la pagina di risultati successiva.  

```
aws dynamodb list-tags-of-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --max-items 1
```
Output:  

```
{
    "Tags": [
        {
            "Key": "Owner",
            "Value": "blueTeam"
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
Per ulteriori informazioni, consulta [Tagging per Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come recuperare la pagina di risultati successiva**  
Il comando seguente utilizza il valore `NextToken` di una precedente chiamata al comando `list-tags-of-resource` per recuperare un’altra pagina di risultati. Poiché la risposta in questo caso non include un valore `NextToken`, ciò significa che è stata raggiunta la fine dei risultati.  

```
aws dynamodb list-tags-of-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Output:  

```
{
    "Tags": [
        {
            "Key": "Environment",
            "Value": "Production"
        }
    ]
}
```
Per ulteriori informazioni, consulta [Tagging per Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [ListTagsOfResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-tags-of-resource.html)*Command Reference*. 

### `put-item`
<a name="dynamodb_PutItem_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`put-item`.

**AWS CLI**  
**Esempio 1: come aggiungere un elemento a una tabella**  
L'`put-item`esempio seguente aggiunge un nuovo elemento alla *MusicCollection*tabella.  

```
aws dynamodb put-item \
    --table-name MusicCollection \
    --item file://item.json \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE
```
Contenuto di `item.json`:  

```
{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Call Me Today"},
    "AlbumTitle": {"S": "Greatest Hits"}
}
```
Output:  

```
{
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "No One You Know"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}
```
Per ulteriori informazioni, consulta [Scrittura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come sovrascrivere in base a una condizione un elemento in una tabella**  
L’esempio `put-item` seguente sovrascrive un elemento esistente nella tabella `MusicCollection` solo se tale elemento include un attributo `AlbumTitle` con il valore `Greatest Hits`. Il comando restituisce il valore precedente dell’elemento.  

```
aws dynamodb put-item \
    --table-name MusicCollection \
    --item file://item.json \
    --condition-expression "#A = :A" \
    --expression-attribute-names file://names.json \
    --expression-attribute-values file://values.json \
    --return-values ALL_OLD
```
Contenuto di `item.json`:  

```
{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Call Me Today"},
    "AlbumTitle": {"S": "Somewhat Famous"}
}
```
Contenuto di `names.json`:  

```
{
    "#A": "AlbumTitle"
}
```
Contenuto di `values.json`:  

```
{
    ":A": {"S": "Greatest Hits"}
}
```
Output:  

```
{
    "Attributes": {
        "AlbumTitle": {
            "S": "Greatest Hits"
        },
        "Artist": {
            "S": "No One You Know"
        },
        "SongTitle": {
            "S": "Call Me Today"
        }
    }
}
```
Se la chiave esiste già, verrà visualizzato l’output seguente:  

```
A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.
```
Per ulteriori informazioni, consulta [Scrittura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, vedere [PutItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/put-item.html)in *AWS CLI Command Reference*. 

### `query`
<a name="dynamodb_Query_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`query`.

**AWS CLI**  
**Esempio 1: come eseguire una query su una tabella**  
L’esempio `query` seguente esegue query sulle voce della tabella `MusicCollection`. La tabella ha una chiave hash-and-range primaria (`Artist`and`SongTitle`), ma questa query specifica solo il valore della chiave hash. Restituisce i titoli dei brani dell’artista “No One You Know”.  

```
aws dynamodb query \
    --table-name MusicCollection \
    --projection-expression "SongTitle" \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json \
    --return-consumed-capacity TOTAL
```
Contenuto di `expression-attributes.json`:  

```
{
    ":v1": {"S": "No One You Know"}
}
```
Output:  

```
{
    "Items": [
        {
            "SongTitle": {
                "S": "Call Me Today"
            },
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}
```
Per ulteriori informazioni, consulta [Utilizzo delle query in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come eseguire una query su una tabella utilizzando l’elevata consistenza di lettura e attraversare l’indice in ordine decrescente**  
L’esempio seguente esegue la stessa query del primo esempio, ma restituisce i risultati in ordine inverso e utilizza operazioni a elevata consistenza di lettura.  

```
aws dynamodb query \
    --table-name MusicCollection \
    --projection-expression "SongTitle" \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json \
    --consistent-read \
    --no-scan-index-forward \
    --return-consumed-capacity TOTAL
```
Contenuto di `expression-attributes.json`:  

```
{
    ":v1": {"S": "No One You Know"}
}
```
Output:  

```
{
    "Items": [
        {
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        },
        {
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    }
}
```
Per ulteriori informazioni, consulta [Utilizzo delle query in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come filtrare risultati specifici**  
L’esempio seguente esegue una query su `MusicCollection` ma esclude i risultati con valori specifici nell’attributo `AlbumTitle`. Nota che ciò non influisce su `ScannedCount` o `ConsumedCapacity`, poiché il filtro viene applicato dopo la lettura degli elementi.  

```
aws dynamodb query \
    --table-name MusicCollection \
    --key-condition-expression "#n1 = :v1" \
    --filter-expression "NOT (#n2 IN (:v2, :v3))" \
    --expression-attribute-names file://names.json \
    --expression-attribute-values file://values.json \
    --return-consumed-capacity TOTAL
```
Contenuto di `values.json`:  

```
{
    ":v1": {"S": "No One You Know"},
    ":v2": {"S": "Blue Sky Blues"},
    ":v3": {"S": "Greatest Hits"}
}
```
Contenuto di `names.json`:  

```
{
    "#n1": "Artist",
    "#n2": "AlbumTitle"
}
```
Output:  

```
{
    "Items": [
        {
            "AlbumTitle": {
                "S": "Somewhat Famous"
            },
            "Artist": {
                "S": "No One You Know"
            },
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 1,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}
```
Per ulteriori informazioni, consulta [Utilizzo delle query in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 4: come recuperare solo il conteggio degli elementi**  
L’esempio seguente recupera il conteggio degli elementi corrispondenti alla query, ma non recupera nessuno degli elementi stessi.  

```
aws dynamodb query \
    --table-name MusicCollection \
    --select COUNT \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json
```
Contenuto di `expression-attributes.json`:  

```
{
    ":v1": {"S": "No One You Know"}
}
```
Output:  

```
{
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": null
}
```
Per ulteriori informazioni, consulta [Utilizzo delle query in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 5: come eseguire una query su un indice**  
L’esempio seguente esegue una query sull’indice globale secondario `AlbumTitleIndex`. La query restituisce tutti gli attributi della tabella di base proiettati nell’indice secondario locale. Nota che durante l’esecuzione di query su un indice secondario locale o su un indice secondario globale è necessario fornire anche il nome della tabella di base mediante il parametro `table-name`.  

```
aws dynamodb query \
    --table-name MusicCollection \
    --index-name AlbumTitleIndex \
    --key-condition-expression "Artist = :v1" \
    --expression-attribute-values file://expression-attributes.json \
    --select ALL_PROJECTED_ATTRIBUTES \
    --return-consumed-capacity INDEXES
```
Contenuto di `expression-attributes.json`:  

```
{
    ":v1": {"S": "No One You Know"}
}
```
Output:  

```
{
    "Items": [
        {
            "AlbumTitle": {
                "S": "Blue Sky Blues"
            },
            "Artist": {
                "S": "No One You Know"
            },
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        },
        {
            "AlbumTitle": {
                "S": "Somewhat Famous"
            },
            "Artist": {
                "S": "No One You Know"
            },
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5,
        "Table": {
            "CapacityUnits": 0.0
        },
        "LocalSecondaryIndexes": {
            "AlbumTitleIndex": {
                "CapacityUnits": 0.5
            }
        }
    }
}
```
Per ulteriori informazioni, consulta [Utilizzo delle query in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per informazioni dettagliate sull’API, consulta [Query](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/query.html) nella *documentazione di riferimento di AWS CLI *. 

### `restore-table-from-backup`
<a name="dynamodb_RestoreTableFromBackup_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare. `restore-table-from-backup`

**AWS CLI**  
**Come ripristinare una tabella DynamoDB da un backup esistente**  
L’esempio `restore-table-from-backup` seguente ripristina la tabella specificata da un backup esistente.  

```
aws dynamodb restore-table-from-backup \
    --target-table-name MusicCollection \
    --backup-arnarn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection2",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": 1576618274.326,
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection2",
        "TableId": "114865c9-5ef3-496c-b4d1-c4cbdd2d44fb",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED"
        },
        "RestoreSummary": {
            "SourceBackupArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a",
            "SourceTableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "RestoreDateTime": 1576616366.715,
            "RestoreInProgress": true
        }
    }
}
```
Per ulteriori informazioni, consulta [Backup e ripristino on demand per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [RestoreTableFromBackup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/restore-table-from-backup.html)*Command Reference*. 

### `restore-table-to-point-in-time`
<a name="dynamodb_RestoreTableToPointInTime_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`restore-table-to-point-in-time`.

**AWS CLI**  
**Come ripristinare una tabella DynamoDB a un determinato momento**  
L’esempio `restore-table-to-point-in-time` seguente ripristina la tabella `MusicCollection` al momento specificato.  

```
aws dynamodb restore-table-to-point-in-time \
    --source-table-name MusicCollection \
    --target-table-name MusicCollectionRestore \
    --restore-date-time 1576622404.0
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollectionRestore",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "CREATING",
        "CreationDateTime": 1576623311.86,
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 5,
            "WriteCapacityUnits": 5
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollectionRestore",
        "TableId": "befd9e0e-1843-4dc6-a147-d6d00e85cb1f",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED"
        },
        "RestoreSummary": {
            "SourceTableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
            "RestoreDateTime": 1576622404.0,
            "RestoreInProgress": true
        }
    }
}
```
Per ulteriori informazioni, consulta [Point-in-Time Recovery for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) nella Amazon DynamoDB Developer *Guide*.  
+  *Per i dettagli sull'API, consulta [RestoreTableToPointInTime](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/restore-table-to-point-in-time.html)Command Reference.AWS CLI * 

### `scan`
<a name="dynamodb_Scan_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`scan`.

**AWS CLI**  
**Come eseguire la scansione di una tabella**  
L’esempio `scan` seguente analizza l’intera tabella `MusicCollection`, quindi restringe i risultati alle canzoni dell’artista “No One You Know”. Per ogni elemento, vengono restituiti solo il titolo dell’album e il titolo del brano.  

```
aws dynamodb scan \
    --table-name MusicCollection \
    --filter-expression "Artist = :a" \
    --projection-expression "#ST, #AT" \
    --expression-attribute-names file://expression-attribute-names.json \
    --expression-attribute-values file://expression-attribute-values.json
```
Contenuto di `expression-attribute-names.json`:  

```
{
    "#ST": "SongTitle",
    "#AT":"AlbumTitle"
}
```
Contenuto di `expression-attribute-values.json`:  

```
{
    ":a": {"S": "No One You Know"}
}
```
Output:  

```
{
    "Count": 2,
    "Items": [
        {
            "SongTitle": {
                "S": "Call Me Today"
            },
            "AlbumTitle": {
                "S": "Somewhat Famous"
            }
        },
        {
            "SongTitle": {
                "S": "Scared of My Shadow"
            },
            "AlbumTitle": {
                "S": "Blue Sky Blues"
            }
        }
    ],
    "ScannedCount": 3,
    "ConsumedCapacity": null
}
```
Per ulteriori informazioni, consulta [Utilizzo delle scansioni in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per informazioni dettagliate sull’API, consulta [Scansione](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/scan.html) nella *documentazione di riferimento di AWS CLI *. 

### `tag-resource`
<a name="dynamodb_TagResource_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`tag-resource`.

**AWS CLI**  
**Come aggiungere tag a una risorsa DynamoDB**  
L'`tag-resource`esempio seguente aggiunge una key/value coppia di tag alla `MusicCollection` tabella.  

```
aws dynamodb tag-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --tags Key=Owner,Value=blueTeam
```
Questo comando non produce alcun output.  
Per ulteriori informazioni, consulta [Tagging per Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, vedere [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/tag-resource.html)in *AWS CLI Command Reference*. 

### `transact-get-items`
<a name="dynamodb_TransactGetItems_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`transact-get-items`.

**AWS CLI**  
**Come recuperare più elementi in modo atomico da una o più tabelle**  
L’esempio `transact-get-items` seguente recupera più elementi in modo atomico.  

```
aws dynamodb transact-get-items \
    --transact-items file://transact-items.json \
    --return-consumed-capacity TOTAL
```
Contenuto di `transact-items.json`:  

```
[
    {
        "Get": {
            "Key": {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            "TableName": "MusicCollection"
        }
    },
    {
        "Get": {
            "Key": {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            "TableName": "MusicCollection"
        }
    }
]
```
Output:  

```
{
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 4.0,
            "ReadCapacityUnits": 4.0
        }
    ],
    "Responses": [
        {
            "Item": {
                "AlbumTitle": {
                    "S": "Songs About Life"
                },
                "Artist": {
                    "S": "Acme Band"
                },
                "SongTitle": {
                    "S": "Happy Day"
                }
            }
        },
        {
            "Item": {
                "AlbumTitle": {
                    "S": "Somewhat Famous"
                },
                "Artist": {
                    "S": "No One You Know"
                },
                "SongTitle": {
                    "S": "Call Me Today"
                }
            }
        }
    ]
}
```
Per ulteriori informazioni, consulta [Gestione di flussi di lavoro complessi con transazioni DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [TransactGetItems AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/transact-get-items.html)*Command Reference*. 

### `transact-write-items`
<a name="dynamodb_TransactWriteItems_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`transact-write-items`.

**AWS CLI**  
**Esempio 1: come scrivere elementi in modo atomico su una o più tabelle**  
L’esempio `transact-write-items` seguente aggiorna un elemento e ne elimina un altro. L’operazione ha esito negativo se una delle operazioni fallisce o se uno degli elementi contiene un attributo `Rating`.  

```
aws dynamodb transact-write-items \
    --transact-items file://transact-items.json \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE
```
Contenuto del file `transact-items.json`:  

```
[
    {
        "Update": {
            "Key": {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            "UpdateExpression": "SET AlbumTitle = :newval",
            "ExpressionAttributeValues": {
                ":newval": {"S": "Updated Album Title"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    },
    {
        "Delete": {
            "Key": {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    }
]
```
Output:  

```
{
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 10.0,
            "WriteCapacityUnits": 10.0
        }
    ],
    "ItemCollectionMetrics": {
        "MusicCollection": [
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "No One You Know"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            },
            {
                "ItemCollectionKey": {
                    "Artist": {
                        "S": "Acme Band"
                    }
                },
                "SizeEstimateRangeGB": [
                    0.0,
                    1.0
                ]
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Gestione di flussi di lavoro complessi con transazioni DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come scrivere elementi in modo atomico utilizzando un token di richiesta del client**  
Il comando seguente utilizza un token di richiesta del client per effettuare la chiamata a `transact-write-items` idempotente, il che significa che più chiamate hanno lo stesso effetto di una singola chiamata.  

```
aws dynamodb transact-write-items \
    --transact-items file://transact-items.json \
    --client-request-token abc123
```
Contenuto del file `transact-items.json`:  

```
[
    {
        "Update": {
            "Key": {
                "Artist": {"S": "Acme Band"},
                "SongTitle": {"S": "Happy Day"}
            },
            "UpdateExpression": "SET AlbumTitle = :newval",
            "ExpressionAttributeValues": {
                ":newval": {"S": "Updated Album Title"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    },
    {
        "Delete": {
            "Key": {
                "Artist": {"S": "No One You Know"},
                "SongTitle": {"S": "Call Me Today"}
            },
            "TableName": "MusicCollection",
            "ConditionExpression": "attribute_not_exists(Rating)"
        }
    }
]
```
Questo comando non produce alcun output.  
Per ulteriori informazioni, consulta [Gestione di flussi di lavoro complessi con transazioni DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [TransactWriteItems AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/transact-write-items.html)*Command Reference*. 

### `untag-resource`
<a name="dynamodb_UntagResource_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`untag-resource`.

**AWS CLI**  
**Come rimuovere un tag da una risorsa DynamoDB**  
L’esempio `untag-resource` seguente rimuove il tag con la chiave `Owner` dalla tabella `MusicCollection`.  

```
aws dynamodb untag-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --tag-keys Owner
```
Questo comando non produce alcun output.  
Per ulteriori informazioni, consulta [Tagging per Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UntagResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/untag-resource.html)*Command Reference*. 

### `update-continuous-backups`
<a name="dynamodb_UpdateContinuousBackups_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-continuous-backups`.

**AWS CLI**  
**Come aggiornare le impostazioni di backup continuo per una tabella DynamoDB**  
L'`update-continuous-backups`esempio seguente abilita il point-in-time ripristino della `MusicCollection` tabella.  

```
aws dynamodb update-continuous-backups \
    --table-name MusicCollection \
    --point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
```
Output:  

```
{
    "ContinuousBackupsDescription": {
        "ContinuousBackupsStatus": "ENABLED",
        "PointInTimeRecoveryDescription": {
            "PointInTimeRecoveryStatus": "ENABLED",
            "EarliestRestorableDateTime": 1576622404.0,
            "LatestRestorableDateTime": 1576622404.0
        }
    }
}
```
Per ulteriori informazioni, consulta [Point-in-Time Recovery for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) nella Amazon DynamoDB Developer *Guide*.  
+  *Per i dettagli sull'API, consulta [UpdateContinuousBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-continuous-backups.html)Command Reference.AWS CLI * 

### `update-contributor-insights`
<a name="dynamodb_UpdateContributorInsights_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-contributor-insights`.

**AWS CLI**  
**Come abilitare Contributor Insights su una tabella**  
L’esempio `update-contributor-insights` seguente abilita Contributor Insights sulla tabella `MusicCollection` e l’indice secondario globale `AlbumTitle-index`.  

```
aws dynamodb update-contributor-insights \
    --table-name MusicCollection \
    --index-name AlbumTitle-index \
    --contributor-insights-action ENABLE
```
Output:  

```
{
    "TableName": "MusicCollection",
    "IndexName": "AlbumTitle-index",
    "ContributorInsightsStatus": "ENABLING"
}
```
*Per ulteriori informazioni, consulta [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB nella Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) Developer Guide.*  
+  *Per i dettagli sull'API, consulta Command Reference. [UpdateContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-contributor-insights.html)AWS CLI * 

### `update-global-table-settings`
<a name="dynamodb_UpdateGlobalTableSettings_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-global-table-settings`.

**AWS CLI**  
**Come aggiornare le impostazioni della capacità di scrittura con provisioning su una tabella globale DynamoDB**  
L’esempio `update-global-table-settings` seguente imposta su 15 la capacità di scrittura con provisioning della tabella globale `MusicCollection`.  

```
aws dynamodb update-global-table-settings \
    --global-table-name MusicCollection \
    --global-table-provisioned-write-capacity-units 15
```
Output:  

```
{
    "GlobalTableName": "MusicCollection",
    "ReplicaSettings": [
        {
            "RegionName": "eu-west-1",
            "ReplicaStatus": "UPDATING",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 10,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        },
        {
            "RegionName": "us-east-1",
            "ReplicaStatus": "UPDATING",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 10,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        },
        {
            "RegionName": "us-east-2",
            "ReplicaStatus": "UPDATING",
            "ReplicaProvisionedReadCapacityUnits": 10,
            "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            },
            "ReplicaProvisionedWriteCapacityUnits": 10,
            "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                "AutoScalingDisabled": true
            }
        }
    ]
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UpdateGlobalTableSettings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-global-table-settings.html)*Command Reference*. 

### `update-global-table`
<a name="dynamodb_UpdateGlobalTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-global-table`.

**AWS CLI**  
**Come aggiornare una tabella globale DynamoDB**  
L’esempio `update-global-table` seguente aggiunge una replica nella Regione specificata alla tabella globale `MusicCollection`.  

```
aws dynamodb update-global-table \
    --global-table-name MusicCollection \
    --replica-updates Create={RegionName=eu-west-1}
```
Output:  

```
{
    "GlobalTableDescription": {
        "ReplicationGroup": [
            {
                "RegionName": "eu-west-1"
            },
            {
                "RegionName": "us-east-2"
            },
            {
                "RegionName": "us-east-1"
            }
        ],
        "GlobalTableArn": "arn:aws:dynamodb::123456789012:global-table/MusicCollection",
        "CreationDateTime": 1576625818.532,
        "GlobalTableStatus": "ACTIVE",
        "GlobalTableName": "MusicCollection"
    }
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UpdateGlobalTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-global-table.html)*Command Reference*. 

### `update-item`
<a name="dynamodb_UpdateItem_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-item`.

**AWS CLI**  
**Esempio 1: come aggiornare un elemento in una tabella**  
L’esempio `update-item` seguente legge una voce dalla tabella `MusicCollection`. Aggiunge un nuovo attributo (`Year`) e modifica l’attributo `AlbumTitle`. Tutti gli attributi dell’elemento come appaiono dopo l’aggiornamento vengono restituiti nella risposta.  

```
aws dynamodb update-item \
    --table-name MusicCollection \
    --key file://key.json \
    --update-expression "SET #Y = :y, #AT = :t" \
    --expression-attribute-names file://expression-attribute-names.json \
    --expression-attribute-values file://expression-attribute-values.json  \
    --return-values ALL_NEW \
    --return-consumed-capacity TOTAL \
    --return-item-collection-metrics SIZE
```
Contenuto di `key.json`:  

```
{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}
```
Contenuto di `expression-attribute-names.json`:  

```
{
    "#Y":"Year", "#AT":"AlbumTitle"
}
```
Contenuto di `expression-attribute-values.json`:  

```
{
    ":y":{"N": "2015"},
    ":t":{"S": "Louder Than Ever"}
}
```
Output:  

```
{
    "Attributes": {
        "AlbumTitle": {
            "S": "Louder Than Ever"
        },
        "Awards": {
            "N": "10"
        },
        "Artist": {
            "S": "Acme Band"
        },
        "Year": {
            "N": "2015"
        },
        "SongTitle": {
            "S": "Happy Day"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 3.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "Acme Band"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}
```
Per ulteriori informazioni, consulta [Scrittura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come aggiornare un elemento in base a una condizione**  
L’esempio seguente aggiorna un elemento nella tabella `MusicCollection`, ma solo se l’elemento esistente non dispone già di un attributo `Year`.  

```
aws dynamodb update-item \
    --table-name MusicCollection \
    --key file://key.json \
    --update-expression "SET #Y = :y, #AT = :t" \
    --expression-attribute-names file://expression-attribute-names.json \
    --expression-attribute-values file://expression-attribute-values.json  \
    --condition-expression "attribute_not_exists(#Y)"
```
Contenuto di `key.json`:  

```
{
    "Artist": {"S": "Acme Band"},
    "SongTitle": {"S": "Happy Day"}
}
```
Contenuto di `expression-attribute-names.json`:  

```
{
    "#Y":"Year",
    "#AT":"AlbumTitle"
}
```
Contenuto di `expression-attribute-values.json`:  

```
{
    ":y":{"N": "2015"},
    ":t":{"S": "Louder Than Ever"}
}
```
Se l’elemento include già un attributo `Year`, DynamoDB restituisce il seguente output.  

```
An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed
```
Per ulteriori informazioni, consulta [Scrittura di un elemento](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UpdateItem AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-item.html)*Command Reference*. 

### `update-table-replica-auto-scaling`
<a name="dynamodb_UpdateTableReplicaAutoScaling_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-table-replica-auto-scaling`.

**AWS CLI**  
**Come aggiornare le impostazioni di dimensionamento automatico tra le repliche di una tabella globale**  
L’esempio `update-table-replica-auto-scaling` seguente aggiorna le impostazioni di dimensionamento automatico della capacità di scrittura tra le repliche della tabella globale specificata.  

```
aws dynamodb update-table-replica-auto-scaling \
    --table-name MusicCollection \
    --provisioned-write-capacity-auto-scaling-update file://auto-scaling-policy.json
```
Contenuto di `auto-scaling-policy.json`:  

```
{
    "MinimumUnits": 10,
    "MaximumUnits": 100,
    "AutoScalingDisabled": false,
    "ScalingPolicyUpdate": {
        "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
        "TargetTrackingScalingPolicyConfiguration": {
            "TargetValue": 80
        }
    }
}
```
Output:  

```
{
    "TableAutoScalingDescription": {
        "TableName": "MusicCollection",
        "TableStatus": "ACTIVE",
        "Replicas": [
            {
                "RegionName": "eu-central-1",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 10,
                    "MaximumUnits": 100,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 80.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            },
            {
                "RegionName": "us-east-1",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 10,
                    "MaximumUnits": 100,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 80.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            },
            {
                "RegionName": "us-east-2",
                "GlobalSecondaryIndexes": [],
                "ReplicaProvisionedReadCapacityAutoScalingSettings": {
                    "MinimumUnits": 5,
                    "MaximumUnits": 40000,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBReadCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 70.0
                            }
                        }
                    ]
                },
                "ReplicaProvisionedWriteCapacityAutoScalingSettings": {
                    "MinimumUnits": 10,
                    "MaximumUnits": 100,
                    "AutoScalingRoleArn": "arn:aws:iam::123456789012:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
                    "ScalingPolicies": [
                        {
                            "PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
                            "TargetTrackingScalingPolicyConfiguration": {
                                "TargetValue": 80.0
                            }
                        }
                    ]
                },
                "ReplicaStatus": "ACTIVE"
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UpdateTableReplicaAutoScaling AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-table-replica-auto-scaling.html)*Command Reference*. 

### `update-table`
<a name="dynamodb_UpdateTable_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-table`.

**AWS CLI**  
**Esempio 1: come modificare la modalità di fatturazione di una tabella**  
L’esempio `update-table` seguente aumenta la capacità di lettura e scrittura allocata per la tabella `MusicCollection`.  

```
aws dynamodb update-table \
    --table-name MusicCollection \
    --billing-mode PROVISIONED \
    --provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "UPDATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T13:18:18.921000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        }
    }
}
```
Per ulteriori informazioni, consulta [Aggiornamento di una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 2: come creare un indice secondario globale**  
L’esempio seguente aggiunge un indice secondario globale alla tabella `MusicCollection`.  

```
aws dynamodb update-table \
    --table-name MusicCollection \
    --attribute-definitions AttributeName=AlbumTitle,AttributeType=S \
    --global-secondary-index-updates file://gsi-updates.json
```
Contenuto di `gsi-updates.json`:  

```
[
    {
        "Create": {
            "IndexName": "AlbumTitle-index",
            "KeySchema": [
                {
                    "AttributeName": "AlbumTitle",
                    "KeyType": "HASH"
                }
            ],
            "ProvisionedThroughput": {
                "ReadCapacityUnits": 10,
                "WriteCapacityUnits": 10
            },
            "Projection": {
                "ProjectionType": "ALL"
            }
        }
    }
]
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "UPDATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T12:59:17.537000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        },
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitle-index",
                "KeySchema": [
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "HASH"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "CREATING",
                "Backfilling": false,
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 10
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitle-index"
            }
        ]
    }
}
```
Per ulteriori informazioni, consulta [Aggiornamento di una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 3: come abilitare i flussi DynamoDB in una tabella**  
Il comando seguente abilita i flussi Amazon DynamoDB sulla tabella `MusicCollection`.  

```
aws dynamodb update-table \
    --table-name MusicCollection \
    --stream-specification StreamEnabled=true,StreamViewType=NEW_IMAGE
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "UPDATING",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T12:59:17.537000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        },
        "LocalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "Artist",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "Year",
                        "Genre"
                    ]
                },
                "IndexSizeBytes": 139,
                "ItemCount": 2,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
            }
        ],
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitle-index",
                "KeySchema": [
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "HASH"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "ACTIVE",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 10
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitle-index"
            }
        ],
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "NEW_IMAGE"
        },
        "LatestStreamLabel": "2020-07-28T21:53:39.112",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/stream/2020-07-28T21:53:39.112"
    }
}
```
Per ulteriori informazioni, consulta [Aggiornamento di una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
**Esempio 4: come abilitare la crittografia lato server**  
L’esempio seguente abilita la crittografia lato server sulla tabella `MusicCollection`.  

```
aws dynamodb update-table \
    --table-name MusicCollection \
    --sse-specification Enabled=true,SSEType=KMS
```
Output:  

```
{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "AlbumTitle",
                "AttributeType": "S"
            },
            {
                "AttributeName": "Artist",
                "AttributeType": "S"
            },
            {
                "AttributeName": "SongTitle",
                "AttributeType": "S"
            }
        ],
        "TableName": "MusicCollection",
        "KeySchema": [
            {
                "AttributeName": "Artist",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "SongTitle",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "ACTIVE",
        "CreationDateTime": "2020-05-26T15:59:49.473000-07:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "2020-07-28T12:59:17.537000-07:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 15,
            "WriteCapacityUnits": 10
        },
        "TableSizeBytes": 182,
        "ItemCount": 2,
        "TableArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection",
        "TableId": "abcd0123-01ab-23cd-0123-abcdef123456",
        "BillingModeSummary": {
            "BillingMode": "PROVISIONED",
            "LastUpdateToPayPerRequestDateTime": "2020-07-28T13:14:48.366000-07:00"
        },
        "LocalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitleIndex",
                "KeySchema": [
                    {
                        "AttributeName": "Artist",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "RANGE"
                    }
                ],
                "Projection": {
                    "ProjectionType": "INCLUDE",
                    "NonKeyAttributes": [
                        "Year",
                        "Genre"
                    ]
                },
                "IndexSizeBytes": 139,
                "ItemCount": 2,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitleIndex"
            }
        ],
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "AlbumTitle-index",
                "KeySchema": [
                    {
                        "AttributeName": "AlbumTitle",
                        "KeyType": "HASH"
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                },
                "IndexStatus": "ACTIVE",
                "ProvisionedThroughput": {
                    "NumberOfDecreasesToday": 0,
                    "ReadCapacityUnits": 10,
                    "WriteCapacityUnits": 10
                },
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/index/AlbumTitle-index"
            }
        ],
        "StreamSpecification": {
            "StreamEnabled": true,
            "StreamViewType": "NEW_IMAGE"
        },
        "LatestStreamLabel": "2020-07-28T21:53:39.112",
        "LatestStreamArn": "arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/stream/2020-07-28T21:53:39.112",
        "SSEDescription": {
            "Status": "UPDATING"
        }
    }
}
```
Per ulteriori informazioni, consulta [Aggiornamento di una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UpdateTable AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-table.html)*Command Reference*. 

### `update-time-to-live`
<a name="dynamodb_UpdateTimeToLive_cli_2_topic"></a>

Il seguente esempio di codice mostra come utilizzare`update-time-to-live`.

**AWS CLI**  
**Come aggiornare le impostazioni Time to Live in una tabella**  
L’esempio `update-time-to-live` seguente abilita le impostazioni Time to Live nella tabella specificata.  

```
aws dynamodb update-time-to-live \
    --table-name MusicCollection \
    --time-to-live-specification Enabled=true,AttributeName=ttl
```
Output:  

```
{
    "TimeToLiveSpecification": {
        "Enabled": true,
        "AttributeName": "ttl"
    }
}
```
Per ulteriori informazioni, consulta [Time to Live](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html) nella *Guida per gli sviluppatori di Amazon DynamoDB*.  
+  Per i dettagli sull'API, consulta [UpdateTimeToLive AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-time-to-live.html)*Command Reference*. 