Esempi per DynamoDB con AWS CLI - AWS Command Line Interface
Operazioni

Esempi per DynamoDB con AWS CLI

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

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

Ogni esempio include un link al codice sorgente completo, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.

Argomenti

Operazioni

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulle API, consulta BatchGetItem nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulle API, consulta BatchWriteItem nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta CreateBackup in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare create-global-table.

AWS CLI

Come creare una tabella globale

L’esempio create-global-table seguente crea una tabella globale da due tabelle identiche nelle Regioni AWS 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta CreateGlobalTable in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare create-table.

AWS CLI

Esempio 1: 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 il throughput allocato e la crittografia dei dati a riposo utilizzando la chiave gestita dal cliente (CMK) predefinita di proprietà di AWS. 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: creare una tabella e crittografarla con una CMK

L’esempio seguente crea una tabella denominata MusicCollection e la crittografa utilizzando una 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 4: creare una tabella con un indice secondario locale

L’esempio seguente utilizza 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 5: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 6: creare una tabella con più indici secondari globali contemporaneamente

L’esempio seguente crea una tabella denominata GameScores con due indici secondari globali. Gli schemi dei 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 7: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 8: creare una tabella con il flusso KEYS_ONLY abilitato

L’esempio seguente crea una tabella denominata GameScores con i flussi DynamoDB abilitati. Nel flusso vengono scritti solo gli attributi chiave degli elementi modificati.

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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 9: creare una tabella con la classe Standard-Accesso infrequente

L’esempio seguente crea una tabella denominata GameScores e assegna la classe di tabella Standard-Accesso Infrequente (DynamoDB Standard-IA). Questa classe di tabella è 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 10: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per ulteriori informazioni sulla API, consulta CreateTable nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta DeleteBackup in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare delete-item.

AWS CLI

Esempio 1: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulla API, consulta DeleteItem nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulla API, consulta DeleteTable nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta DescribeBackup in AWS CLI Command Reference.

L’esempio di codice seguente 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 Ripristino point-in-time per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 Analisi dell’accesso ai dati utilizzando CloudWatch Contributor Insights per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente mostra come utilizzare describe-endpoints.

AWS CLI

Come visualizzare le informazioni sugli endpoint regionali

L’esempio describe-endpoints seguente mostra i dettagli relativi agli endpoint per la Regione AWS 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 nella Guida di riferimento generale AWS.

  • Per informazioni dettagliate sull’API, consulta DescribeEndpoints in AWS CLI Command Reference.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta DescribeGlobalTable in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare describe-limits.

AWS CLI

Come visualizzare i limiti di capacità con provisioning

L’esempio describe-limits seguente mostra i limiti di capacità con provisioning per il tuo account nella Regione AWS corrente.

aws dynamodb describe-limits

Output:

{
    "AccountMaxReadCapacityUnits": 80000,
    "AccountMaxWriteCapacityUnits": 80000,
    "TableMaxReadCapacityUnits": 40000,
    "TableMaxWriteCapacityUnits": 40000
}

Per ulteriori informazioni, consulta Limiti in DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta DescribeLimits in AWS CLI Command Reference.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulle API, consulta DescribeTable nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente mostra come utilizzare describe-time-to-live.

AWS CLI

Come visualizzare le impostazioni del Time-to-Live per una tabella

L’esempio describe-time-to-live seguente mostra le impostazioni del 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta DescribeTimeToLive in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare get-item.

AWS CLI

Esempio 1: leggere un elemento in una tabella

L’esempio get-item seguente recupera un elemento dalla tabella MusicCollection. La tabella ha una chiave primaria hash e di intervallo (Artist e SongTitle). Sarà pertanto 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: leggere un elemento utilizzando una lettura coerente

L’esempio seguente recupera un elemento dalla tabella MusicCollection tramite 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: recuperare gli 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta GetItem nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente mostra come utilizzare list-backups.

AWS CLI

Esempio 1: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 4: limitare il numero di elementi restituiti

L’esempio seguente limita a 1 il numero di elementi restituiti. 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 5: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta ListBackups in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare list-contributor-insights.

AWS CLI

Esempio 1: 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 Analisi dell’accesso ai dati utilizzando CloudWatch Contributor Insights per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: limitare il numero di elementi restituiti

L’esempio seguente limita a 4 il numero di elementi restituiti. 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 Analisi dell’accesso ai dati utilizzando CloudWatch Contributor Insights per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: 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 Analisi dell’accesso ai dati utilizzando CloudWatch Contributor Insights per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta ListGlobalTables in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare list-tables.

AWS CLI

Esempio 1: elencare le tabelle

L’esempio list-tables seguente elenca le tabelle associate all’account e alla Regione AWS correnti.

aws dynamodb list-tables

Output:

{
    "TableNames": [
        "Forum",
        "ProductCatalog",
        "Reply",
        "Thread"
    ]
}

Per ulteriori informazioni, consulta Elencazione dei nomi delle tabelle nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 pari a 1.000.

aws dynamodb list-tables \
    --page-size 1

Output:

{
    "TableNames": [
        "Forum",
        "ProductCatalog",
        "Reply",
        "Thread"
    ]
}

Per ulteriori informazioni, consulta Elencazione dei nomi delle tabelle nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: limitare il numero di elementi restituiti

L’esempio seguente limita a 2 il numero di elementi restituiti. 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 Elencazione dei nomi delle tabelle nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 4: 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 Elencazione dei nomi delle tabelle nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta ListTables nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente mostra come utilizzare list-tags-of-resource.

AWS CLI

Esempio 1: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta ListTagsOfResource in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare put-item.

AWS CLI

Esempio 1: aggiungere un elemento a una tabella

L’esempio put-item seguente aggiunge un nuovo elemento alla tabella MusicCollection.

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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per ulteriori informazioni sulle API, consulta PutItem nella Documentazione di riferimento del comando AWS CLI.

L’esempio di codice seguente mostra come utilizzare query.

AWS CLI

Esempio 1: seguire una query su una tabella

Nel’esempio seguente query esegue query sulle voce della tabella MusicCollection. La tabella ha una chiave primaria hash e di intervallo (Artist e 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: eseguire una query su una tabella con elevata consistenza di lettura e attraversare l’indice in ordine decrescente

L’esempio seguente esegue la stessa query del primo, ma restituisce i risultati in ordine inverso e utilizza 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: filtrare risultati specifici

L’esempio seguente esegue una query su MusicCollection ma esclude i risultati con valori specifici nell’attributo AlbumTitle. Si noti 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 4: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 5: eseguire una query su un indice

L’esempio seguente esegue una query su un indice locale secondario AlbumTitleIndex. La query restituisce tutti gli attributi della tabella di base proiettati nell’indice secondario locale. Si noti 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulle API, consulta Query nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 Ripristino point-in-time per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente mostra come utilizzare scan.

AWS CLI

Come eseguire la scansione di una tabella

L’esempio scan seguente esegue la scansione dell’intera tabella MusicCollection e quindi restringe i risultati alle brani 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 della scansioni in DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulle API, consulta Scansione nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente mostra come utilizzare tag-resource.

AWS CLI

Come aggiungere tag a una risorsa DynamoDB

L’esempio tag-resource seguente aggiunge un tag con la coppia chiave-valore alla tabella MusicCollection.

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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta TagResource in AWS CLI Command Reference.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta TransactGetItems in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare transact-write-items.

AWS CLI

Esempio 1: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta TransactWriteItems in AWS CLI Command Reference.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta UntagResource in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare update-continuous-backups.

AWS CLI

Come aggiornare le impostazioni di backup continuo per una tabella DynamoDB

L’esempio update-continuous-backups seguente abilita il ripristino point-in-time per la tabella MusicCollection.

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 Ripristino point-in-time per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 Analisi dell’accesso ai dati utilizzando CloudWatch Contributor Insights per DynamoDB nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta UpdateGlobalTable in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare update-item.

AWS CLI

Esempio 1: aggiornare un elemento in una tabella

L’esempio update-item seguente aggiorna un elemento nella 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: aggiornare un elemento in base a una condizione

L’esempio seguente aggiorna un elemento nella tabella MusicCollection, ma solo se l’elemento esistente non ha già 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sulle API, consulta UpdateItem nella Documentazione di riferimento di AWS CLI.

L’esempio di codice seguente 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

L’esempio di codice seguente mostra come utilizzare update-table.

AWS CLI

Esempio 1: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 2: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 3: abilitare i flussi DynamoDB su una tabella

Il comando seguente abilita i flussi 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

Esempio 4: 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta UpdateTable in AWS CLI Command Reference.

L’esempio di codice seguente mostra come utilizzare update-time-to-live.

AWS CLI

Come aggiornare le impostazioni Time to Live per una tabella

L’esempio update-time-to-live seguente abilita le impostazioni del Time to Live per la 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 nella Guida per gli sviluppatori di Amazon DynamoDB.

  • Per informazioni dettagliate sull’API, consulta UpdateTimeToLive in AWS CLI Command Reference.