# DynamoDB examples using AWS CLI
The following code examples show you how to perform actions and implement common scenarios by using the AWS Command Line Interface with DynamoDB.
*Actions* are code excerpts from larger programs and must be run in context. While actions show you how to call individual service functions, you can see actions in context in their related scenarios.
Each example includes a link to the complete source code, where you can find instructions on how to set up and run the code in context.
**Topics**
+ [Actions](#actions)
## Actions
### `batch-get-item`
The following code example shows how to use `batch-get-item`.
**AWS CLI**
**To retrieve multiple items from a table**
The following `batch-get-items` example reads multiple items from the `MusicCollection` table using a batch of three `GetItem` requests, and requests the number of read capacity units consumed by the operation. The command returns only the `AlbumTitle` attribute.
```
aws dynamodb batch-get-item \
--request-items file://request-items.json \
--return-consumed-capacity TOTAL
```
Contents of `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
}
]
}
```
For more information, see [Batch Operations](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.BatchOperations) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [BatchGetItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/batch-get-item.html) in *AWS CLI Command Reference*.
### `batch-write-item`
The following code example shows how to use `batch-write-item`.
**AWS CLI**
**To add multiple items to a table**
The following `batch-write-item` example adds three new items to the `MusicCollection` table using a batch of three `PutItem` requests. It also requests information about the number of write capacity units consumed by the operation and any item collections modified by the operation.
```
aws dynamodb batch-write-item \
--request-items file://request-items.json \
--return-consumed-capacity INDEXES \
--return-item-collection-metrics SIZE
```
Contents of `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
}
}
}
]
}
```
For more information, see [Batch Operations](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.BatchOperations) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [BatchWriteItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/batch-write-item.html) in *AWS CLI Command Reference*.
### `create-backup`
The following code example shows how to use `create-backup`.
**AWS CLI**
**To create a backup for an existing DynamoDB table**
The following `create-backup` example creates a backup of the `MusicCollection` table.
```
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
}
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [CreateBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-backup.html) in *AWS CLI Command Reference*.
### `create-global-table`
The following code example shows how to use `create-global-table`.
**AWS CLI**
**To create a global table**
The following `create-global-table` example creates a global table from two identical tables in the specified, separate AWS Regions.
```
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"
}
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [CreateGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-global-table.html) in *AWS CLI Command Reference*.
### `create-table`
The following code example shows how to use `create-table`.
**AWS CLI**
**Example 1: To create a table with tags**
The following `create-table` example uses the specified attributes and key schema to create a table named `MusicCollection`. This table uses provisioned throughput and is encrypted at rest using the default AWS owned CMK. The command also applies a tag to the table, with a key of `Owner` and a value of `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"
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To create a table in On-Demand Mode**
The following example creates a table called `MusicCollection` using on-demand mode, rather than provisioned throughput mode. This is useful for tables with unpredictable workloads.
```
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"
}
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To create a table and encrypt it with a Customer Managed CMK**
The following example creates a table named `MusicCollection` and encrypts it using a customer managed 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"
}
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 4: To create a table with a Local Secondary Index**
The following example uses the specified attributes and key schema to create a table named `MusicCollection` with a Local Secondary Index named `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"
}
]
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 5: To create a table with a Global Secondary Index**
The following example creates a table named `GameScores` with a Global Secondary Index called `GameTitleIndex`. The base table has a partition key of `UserId` and a sort key of `GameTitle`, allowing you to find an individual user's best score for a specific game efficiently, whereas the GSI has a partition key of `GameTitle` and a sort key of `TopScore`, allowing you to quickly find the overall highest score for a particular game.
```
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"
}
]
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 6: To create a table with multiple Global Secondary Indexes at once**
The following example creates a table named `GameScores` with two Global Secondary Indexes. The GSI schemas are passed via a file, rather than on the command line.
```
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
```
Contents of `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"
}
]
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 7: To create a table with Streams enabled**
The following example creates a table called `GameScores` with DynamoDB Streams enabled. Both new and old images of each item will be written to the stream.
```
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"
}
}
```
For more information, see [Basic Operations for Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) in the *Amazon DynamoDB Developer Guide*.
**Example 8: To create a table with Keys-Only Stream enabled**
The following example creates a table called `GameScores` with DynamoDB Streams enabled. Only the key attributes of modified items are written to the stream.
```
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
}
}
```
For more information, see [Change data capture for DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) in the *Amazon DynamoDB Developer Guide*.
**Example 9: To create a table with the Standard Infrequent Access class**
The following example creates a table called `GameScores` and assigns the Standard-Infrequent Access (DynamoDB Standard-IA) table class. This table class is optimized for storage being the dominant cost.
```
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
}
}
```
For more information, see [Table classes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html) in the *Amazon DynamoDB Developer Guide*.
**Example 10: To Create a table with Delete Protection enabled**
The following example creates a table called `GameScores` and enables deletion protection.
```
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
}
}
```
For more information, see [Using deletion protection](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeletionProtection) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [CreateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-table.html) in *AWS CLI Command Reference*.
### `delete-backup`
The following code example shows how to use `delete-backup`.
**AWS CLI**
**To delete an existing DynamoDB backup**
The following `delete-backup` example deletes the specified existing backup.
```
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": {}
}
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DeleteBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-backup.html) in *AWS CLI Command Reference*.
### `delete-item`
The following code example shows how to use `delete-item`.
**AWS CLI**
**Example 1: To delete an item**
The following `delete-item` example deletes an item from the `MusicCollection` table and requests details about the item that was deleted and the capacity used by the request.
```
aws dynamodb delete-item \
--table-name MusicCollection \
--key file://key.json \
--return-values ALL_OLD \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Contents of `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
]
}
}
```
For more information, see [Writing an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To delete an item conditionally**
The following example deletes an item from the `ProductCatalog` table only if its `ProductCategory` is either `Sporting Goods` or `Gardening Supplies` and its price is between 500 and 600. It returns details about the item that was deleted.
```
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
```
Contents of `names.json`:
```
{
"#P": "Price"
}
```
Contents of `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"
}
}
}
```
For more information, see [Writing an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DeleteItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-item.html) in *AWS CLI Command Reference*.
### `delete-table`
The following code example shows how to use `delete-table`.
**AWS CLI**
**To delete a table**
The following `delete-table` example deletes the `MusicCollection` table.
```
aws dynamodb delete-table \
--table-name MusicCollection
```
Output:
```
{
"TableDescription": {
"TableStatus": "DELETING",
"TableSizeBytes": 0,
"ItemCount": 0,
"TableName": "MusicCollection",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 5
}
}
}
```
For more information, see [Deleting a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeleteTable) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DeleteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-table.html) in *AWS CLI Command Reference*.
### `describe-backup`
The following code example shows how to use `describe-backup`.
**AWS CLI**
**To get information about an existing backup of a table**
The following `describe-backup` example displays information about the specified existing backup.
```
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": {}
}
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-backup.html) in *AWS CLI Command Reference*.
### `describe-continuous-backups`
The following code example shows how to use `describe-continuous-backups`.
**AWS CLI**
**To get information about continuous backups for a DynamoDB table**
The following `describe-continuous-backups` example displays details about the continuous backup settings for the `MusicCollection` table.
```
aws dynamodb describe-continuous-backups \
--table-name MusicCollection
```
Output:
```
{
"ContinuousBackupsDescription": {
"ContinuousBackupsStatus": "ENABLED",
"PointInTimeRecoveryDescription": {
"PointInTimeRecoveryStatus": "DISABLED"
}
}
}
```
For more information, see [Point-in-Time Recovery for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeContinuousBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-continuous-backups.html) in *AWS CLI Command Reference*.
### `describe-contributor-insights`
The following code example shows how to use `describe-contributor-insights`.
**AWS CLI**
**To view Contributor Insights settings for a DynamoDB table**
The following `describe-contributor-insights` example displays the Contributor Insights settings for the `MusicCollection` table and the `AlbumTitle-index` global secondary 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
}
```
For more information, see [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-contributor-insights.html) in *AWS CLI Command Reference*.
### `describe-endpoints`
The following code example shows how to use `describe-endpoints`.
**AWS CLI**
**To view regional endpoint information**
The following `describe-endpoints` example displays details about the endpoints for the current AWS Region.
```
aws dynamodb describe-endpoints
```
Output:
```
{
"Endpoints": [
{
"Address": "dynamodb.us-west-2.amazonaws.com",
"CachePeriodInMinutes": 1440
}
]
}
```
For more information, see [Amazon DynamoDB Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/ddb.html) in the *AWS General Reference*.
+ For API details, see [DescribeEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-endpoints.html) in *AWS CLI Command Reference*.
### `describe-global-table-settings`
The following code example shows how to use `describe-global-table-settings`.
**AWS CLI**
**To get information about a DynamoDB global table's settings**
The following `describe-global-table-settings` example displays the settings for the `MusicCollection` global table.
```
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
}
}
]
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeGlobalTableSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-global-table-settings.html) in *AWS CLI Command Reference*.
### `describe-global-table`
The following code example shows how to use `describe-global-table`.
**AWS CLI**
**To display information about a DynamoDB global table**
The following `describe-global-table` example displays details about the `MusicCollection` global table.
```
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"
}
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-global-table.html) in *AWS CLI Command Reference*.
### `describe-limits`
The following code example shows how to use `describe-limits`.
**AWS CLI**
**To view provisioned-capacity limits**
The following `describe-limits` example displays provisioned-capacity limits for your account in the current AWS Region.
```
aws dynamodb describe-limits
```
Output:
```
{
"AccountMaxReadCapacityUnits": 80000,
"AccountMaxWriteCapacityUnits": 80000,
"TableMaxReadCapacityUnits": 40000,
"TableMaxWriteCapacityUnits": 40000
}
```
For more information, see [Limits in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeLimits](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-limits.html) in *AWS CLI Command Reference*.
### `describe-table-replica-auto-scaling`
The following code example shows how to use `describe-table-replica-auto-scaling`.
**AWS CLI**
**To view auto scaling settings across replicas of a global table**
The following `describe-table-replica-auto-scaling` example displays auto scaling settings across replicas of the `MusicCollection` global table.
```
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"
}
]
}
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeTableReplicaAutoScaling](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-table-replica-auto-scaling.html) in *AWS CLI Command Reference*.
### `describe-table`
The following code example shows how to use `describe-table`.
**AWS CLI**
**To describe a table**
The following `describe-table` example describes the `MusicCollection` table.
```
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
}
}
```
For more information, see [Describing a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DescribeTable) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-table.html) in *AWS CLI Command Reference*.
### `describe-time-to-live`
The following code example shows how to use `describe-time-to-live`.
**AWS CLI**
**To view Time to Live settings for a table**
The following `describe-time-to-live` example displays Time to Live settings for the `MusicCollection` table.
```
aws dynamodb describe-time-to-live \
--table-name MusicCollection
```
Output:
```
{
"TimeToLiveDescription": {
"TimeToLiveStatus": "ENABLED",
"AttributeName": "ttl"
}
}
```
For more information, see [Time to Live](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [DescribeTimeToLive](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-time-to-live.html) in *AWS CLI Command Reference*.
### `get-item`
The following code example shows how to use `get-item`.
**AWS CLI**
**Example 1: To read an item in a table**
The following `get-item` example retrieves an item from the `MusicCollection` table. The table has a hash-and-range primary key (`Artist` and `SongTitle`), so you must specify both of these attributes. The command also requests information about the read capacity consumed by the operation.
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--return-consumed-capacity TOTAL
```
Contents of `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
}
}
```
For more information, see [Reading an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To read an item using a consistent read**
The following example retrieves an item from the `MusicCollection` table using strongly consistent reads.
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--consistent-read \
--return-consumed-capacity TOTAL
```
Contents of `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
}
}
```
For more information, see [Reading an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To retrieve specific attributes of an item**
The following example uses a projection expression to retrieve only three attributes of the desired item.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "102"}}' \
--projection-expression "#T, #C, #P" \
--expression-attribute-names file://names.json
```
Contents of `names.json`:
```
{
"#T": "Title",
"#C": "ProductCategory",
"#P": "Price"
}
```
Output:
```
{
"Item": {
"Price": {
"N": "20"
},
"Title": {
"S": "Book 102 Title"
},
"ProductCategory": {
"S": "Book"
}
}
}
```
For more information, see [Reading an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [GetItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/get-item.html) in *AWS CLI Command Reference*.
### `list-backups`
The following code example shows how to use `list-backups`.
**AWS CLI**
**Example 1: To list all existing DynamoDB backups**
The following `list-backups` example lists all of your existing backups.
```
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
}
]
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To list user-created backups in a specific time range**
The following example lists only backups of the `MusicCollection` table that were created by the user (not those automatically created by DynamoDB) with a creation date between January 1, 2020 and March 1, 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
}
]
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To limit page size**
The following example returns a list of all existing backups, but retrieves only one item in each call, performing multiple calls if necessary to get the entire list. Limiting the page size is useful when running list commands on a large number of resources, which can result in a "timed out" error when using the default page size of 1000.
```
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
}
]
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
**Example 4: To limit the number of items returned**
The following example limits the number of items returned to 1. The response includes a `NextToken` value with which to retrieve the next page of results.
```
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"
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
**Example 5: To retrieve the next page of results**
The following command uses the `NextToken` value from a previous call to the `list-backups` command to retrieve another page of results. Since the response in this case does not include a `NextToken` value, we know that we have reached the end of the results.
```
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
}
]
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [ListBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-backups.html) in *AWS CLI Command Reference*.
### `list-contributor-insights`
The following code example shows how to use `list-contributor-insights`.
**AWS CLI**
**Example 1: To view a list of Contributor Insights summaries**
The following `list-contributor-insights` example displays a list of Contributor Insights summaries.
```
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"
}
]
}
```
For more information, see [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To limit the number of items returned**
The following example limits the number of items returned to 4. The response includes a `NextToken` value with which to retrieve the next page of results.
```
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"
}
```
For more information, see [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To retrieve the next page of results**
The following command uses the `NextToken` value from a previous call to the `list-contributor-insights` command to retrieve another page of results. Since the response in this case does not include a `NextToken` value, we know that we have reached the end of the results.
```
aws dynamodb list-contributor-insights \
--max-results 4 \
--next-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Output:
```
{
"ContributorInsightsSummaries": [
{
"TableName": "Reply",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "Thread",
"ContributorInsightsStatus": "ENABLED"
}
]
}
```
For more information, see [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [ListContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-contributor-insights.html) in *AWS CLI Command Reference*.
### `list-global-tables`
The following code example shows how to use `list-global-tables`.
**AWS CLI**
**To list existing DynamoDB global tables**
The following `list-global-tables` example lists all of your existing global tables.
```
aws dynamodb list-global-tables
```
Output:
```
{
"GlobalTables": [
{
"GlobalTableName": "MusicCollection",
"ReplicationGroup": [
{
"RegionName": "us-east-2"
},
{
"RegionName": "us-east-1"
}
]
}
]
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [ListGlobalTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-global-tables.html) in *AWS CLI Command Reference*.
### `list-tables`
The following code example shows how to use `list-tables`.
**AWS CLI**
**Example 1: To list tables**
The following `list-tables` example lists all of the tables associated with the current AWS account and Region.
```
aws dynamodb list-tables
```
Output:
```
{
"TableNames": [
"Forum",
"ProductCatalog",
"Reply",
"Thread"
]
}
```
For more information, see [Listing Table Names](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To limit page size**
The following example returns a list of all existing tables, but retrieves only one item in each call, performing multiple calls if necessary to get the entire list. Limiting the page size is useful when running list commands on a large number of resources, which can result in a "timed out" error when using the default page size of 1000.
```
aws dynamodb list-tables \
--page-size 1
```
Output:
```
{
"TableNames": [
"Forum",
"ProductCatalog",
"Reply",
"Thread"
]
}
```
For more information, see [Listing Table Names](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To limit the number of items returned**
The following example limits the number of items returned to 2. The response includes a `NextToken` value with which to retrieve the next page of results.
```
aws dynamodb list-tables \
--max-items 2
```
Output:
```
{
"TableNames": [
"Forum",
"ProductCatalog"
],
"NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
For more information, see [Listing Table Names](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) in the *Amazon DynamoDB Developer Guide*.
**Example 4: To retrieve the next page of results**
The following command uses the `NextToken` value from a previous call to the `list-tables` command to retrieve another page of results. Since the response in this case does not include a `NextToken` value, we know that we have reached the end of the results.
```
aws dynamodb list-tables \
--starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Output:
```
{
"TableNames": [
"Reply",
"Thread"
]
}
```
For more information, see [Listing Table Names](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [ListTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-tables.html) in *AWS CLI Command Reference*.
### `list-tags-of-resource`
The following code example shows how to use `list-tags-of-resource`.
**AWS CLI**
**Example 1: To list tags of a DynamoDB resource**
The following `list-tags-of-resource` example displays tags for the `MusicCollection` table.
```
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"
}
]
}
```
For more information, see [Tagging for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To limit the number of tags returned**
The following example limits the number of tags returned to 1. The response includes a `NextToken` value with which to retrieve the next page of results.
```
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"
}
```
For more information, see [Tagging for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To retrieve the next page of results**
The following command uses the `NextToken` value from a previous call to the `list-tags-of-resource` command to retrieve another page of results. Since the response in this case does not include a `NextToken` value, we know that we have reached the end of the results.
```
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"
}
]
}
```
For more information, see [Tagging for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [ListTagsOfResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-tags-of-resource.html) in *AWS CLI Command Reference*.
### `put-item`
The following code example shows how to use `put-item`.
**AWS CLI**
**Example 1: To add an item to a table**
The following `put-item` example adds a new item to the *MusicCollection* table.
```
aws dynamodb put-item \
--table-name MusicCollection \
--item file://item.json \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Contents of `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
]
}
}
```
For more information, see [Writing an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To conditionally overwrite an item in a table**
The following `put-item` example overwrites an existing item in the `MusicCollection` table only if that existing item has an `AlbumTitle` attribute with a value of `Greatest Hits`. The command returns the previous value of the item.
```
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
```
Contents of `item.json`:
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}
}
```
Contents of `names.json`:
```
{
"#A": "AlbumTitle"
}
```
Contents of `values.json`:
```
{
":A": {"S": "Greatest Hits"}
}
```
Output:
```
{
"Attributes": {
"AlbumTitle": {
"S": "Greatest Hits"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Call Me Today"
}
}
}
```
If the key already exists, you should see the following output:
```
A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.
```
For more information, see [Writing an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [PutItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/put-item.html) in *AWS CLI Command Reference*.
### `query`
The following code example shows how to use `query`.
**AWS CLI**
**Example 1: To query a table**
The following `query` example queries items in the `MusicCollection` table. The table has a hash-and-range primary key (`Artist` and `SongTitle`), but this query only specifies the hash key value. It returns song titles by the artist named "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
```
Contents of `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
}
}
```
For more information, see [Working with Queries in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To query a table using strongly consistent reads and traverse the index in descending order**
The following example performs the same query as the first example, but returns results in reverse order and uses strongly consistent reads.
```
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
```
Contents of `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
}
}
```
For more information, see [Working with Queries in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To filter out specific results**
The following example queries the `MusicCollection` but excludes results with specific values in the `AlbumTitle` attribute. Note that this does not affect the `ScannedCount` or `ConsumedCapacity`, because the filter is applied after the items have been read.
```
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
```
Contents of `values.json`:
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Blue Sky Blues"},
":v3": {"S": "Greatest Hits"}
}
```
Contents of `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
}
}
```
For more information, see [Working with Queries in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) in the *Amazon DynamoDB Developer Guide*.
**Example 4: To retrieve only an item count**
The following example retrieves a count of items matching the query, but does not retrieve any of the items themselves.
```
aws dynamodb query \
--table-name MusicCollection \
--select COUNT \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json
```
Contents of `expression-attributes.json`:
```
{
":v1": {"S": "No One You Know"}
}
```
Output:
```
{
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": null
}
```
For more information, see [Working with Queries in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) in the *Amazon DynamoDB Developer Guide*.
**Example 5: To query an index**
The following example queries the local secondary index `AlbumTitleIndex`. The query returns all attributes from the base table that have been projected into the local secondary index. Note that when querying a local secondary index or global secondary index, you must also provide the name of the base table using the `table-name` parameter.
```
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
```
Contents of `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
}
}
}
}
```
For more information, see [Working with Queries in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [Query](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/query.html) in *AWS CLI Command Reference*.
### `restore-table-from-backup`
The following code example shows how to use `restore-table-from-backup`.
**AWS CLI**
**To restore a DynamoDB table from an existing backup**
The following `restore-table-from-backup` example restores the specified table from an existing backup.
```
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
}
}
}
```
For more information, see [On-Demand Backup and Restore for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [RestoreTableFromBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/restore-table-from-backup.html) in *AWS CLI Command Reference*.
### `restore-table-to-point-in-time`
The following code example shows how to use `restore-table-to-point-in-time`.
**AWS CLI**
**To restore a DynamoDB table to a point in time**
The following `restore-table-to-point-in-time` example restores the `MusicCollection` table to the specified point in time.
```
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
}
}
}
```
For more information, see [Point-in-Time Recovery for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [RestoreTableToPointInTime](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/restore-table-to-point-in-time.html) in *AWS CLI Command Reference*.
### `scan`
The following code example shows how to use `scan`.
**AWS CLI**
**To scan a table**
The following `scan` example scans the entire `MusicCollection` table, and then narrows the results to songs by the artist "No One You Know". For each item, only the album title and song title are returned.
```
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
```
Contents of `expression-attribute-names.json`:
```
{
"#ST": "SongTitle",
"#AT":"AlbumTitle"
}
```
Contents of `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
}
```
For more information, see [Working with Scans in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [Scan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/scan.html) in *AWS CLI Command Reference*.
### `tag-resource`
The following code example shows how to use `tag-resource`.
**AWS CLI**
**To add tags to a DynamoDB resource**
The following `tag-resource` example adds a tag key/value pair to the `MusicCollection` table.
```
aws dynamodb tag-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--tags Key=Owner,Value=blueTeam
```
This command produces no output.
For more information, see [Tagging for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/tag-resource.html) in *AWS CLI Command Reference*.
### `transact-get-items`
The following code example shows how to use `transact-get-items`.
**AWS CLI**
**To retrieve multiple items atomically from one or more tables**
The following `transact-get-items` example retrieves multiple items atomically.
```
aws dynamodb transact-get-items \
--transact-items file://transact-items.json \
--return-consumed-capacity TOTAL
```
Contents of `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"
}
}
}
]
}
```
For more information, see [Managing Complex Workflows with DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [TransactGetItems](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/transact-get-items.html) in *AWS CLI Command Reference*.
### `transact-write-items`
The following code example shows how to use `transact-write-items`.
**AWS CLI**
**Example 1: To write items atomically to one or more tables**
The following `transact-write-items` example updates one item and deletes another. The operation fails if either operation fails, or if either item contains a `Rating` attribute.
```
aws dynamodb transact-write-items \
--transact-items file://transact-items.json \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Contents of the `transact-items.json` file:
```
[
{
"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
]
}
]
}
}
```
For more information, see [Managing Complex Workflows with DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To write items atomically using a client request token**
The following command uses a client request token to make the call to `transact-write-items` idempotent, meaning that multiple calls have the same effect as one single call.
```
aws dynamodb transact-write-items \
--transact-items file://transact-items.json \
--client-request-token abc123
```
Contents of the `transact-items.json` file:
```
[
{
"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)"
}
}
]
```
This command produces no output.
For more information, see [Managing Complex Workflows with DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [TransactWriteItems](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/transact-write-items.html) in *AWS CLI Command Reference*.
### `untag-resource`
The following code example shows how to use `untag-resource`.
**AWS CLI**
**To remove a tag from a DynamoDB resource**
The following `untag-resource` example removes the tag with the key `Owner` from the `MusicCollection` table.
```
aws dynamodb untag-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--tag-keys Owner
```
This command produces no output.
For more information, see [Tagging for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/untag-resource.html) in *AWS CLI Command Reference*.
### `update-continuous-backups`
The following code example shows how to use `update-continuous-backups`.
**AWS CLI**
**To update continuous backup settings for a DynamoDB table**
The following `update-continuous-backups` example enables point-in-time recovery for the `MusicCollection` table.
```
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
}
}
}
```
For more information, see [Point-in-Time Recovery for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateContinuousBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-continuous-backups.html) in *AWS CLI Command Reference*.
### `update-contributor-insights`
The following code example shows how to use `update-contributor-insights`.
**AWS CLI**
**To enable Contributor Insights on a table**
The following `update-contributor-insights` example enables Contributor Insights on the `MusicCollection` table and the `AlbumTitle-index` global secondary 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"
}
```
For more information, see [Analyzing Data Access Using CloudWatch Contributor Insights for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-contributor-insights.html) in *AWS CLI Command Reference*.
### `update-global-table-settings`
The following code example shows how to use `update-global-table-settings`.
**AWS CLI**
**To update provisioned write capacity settings on a DynamoDB global table**
The following `update-global-table-settings` example sets the provisioned write capacity of the `MusicCollection` global table to 15.
```
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
}
}
]
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateGlobalTableSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-global-table-settings.html) in *AWS CLI Command Reference*.
### `update-global-table`
The following code example shows how to use `update-global-table`.
**AWS CLI**
**To update a DynamoDB global table**
The following `update-global-table` example adds a replica in the specified Region to the `MusicCollection` global table.
```
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"
}
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-global-table.html) in *AWS CLI Command Reference*.
### `update-item`
The following code example shows how to use `update-item`.
**AWS CLI**
**Example 1: To update an item in a table**
The following `update-item` example updates an item in the `MusicCollection` table. It adds a new attribute (`Year`) and modifies the `AlbumTitle` attribute. All of the attributes in the item, as they appear after the update, are returned in the response.
```
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
```
Contents of `key.json`:
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Contents of `expression-attribute-names.json`:
```
{
"#Y":"Year", "#AT":"AlbumTitle"
}
```
Contents of `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
]
}
}
```
For more information, see [Writing an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To update an item conditionally**
The following example updates an item in the `MusicCollection` table, but only if the existing item does not already have a `Year` attribute.
```
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)"
```
Contents of `key.json`:
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Contents of `expression-attribute-names.json`:
```
{
"#Y":"Year",
"#AT":"AlbumTitle"
}
```
Contents of `expression-attribute-values.json`:
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
If the item already has a `Year` attribute, DynamoDB returns the following output.
```
An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed
```
For more information, see [Writing an Item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-item.html) in *AWS CLI Command Reference*.
### `update-table-replica-auto-scaling`
The following code example shows how to use `update-table-replica-auto-scaling`.
**AWS CLI**
**To update auto scaling settings across replicas of a global table**
The following `update-table-replica-auto-scaling` example updates write capacity auto scaling settings across replicas of the specified global table.
```
aws dynamodb update-table-replica-auto-scaling \
--table-name MusicCollection \
--provisioned-write-capacity-auto-scaling-update file://auto-scaling-policy.json
```
Contents of `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"
}
]
}
}
```
For more information, see [DynamoDB Global Tables](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateTableReplicaAutoScaling](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-table-replica-auto-scaling.html) in *AWS CLI Command Reference*.
### `update-table`
The following code example shows how to use `update-table`.
**AWS CLI**
**Example 1: To modify a table's billing mode**
The following `update-table` example increases the provisioned read and write capacity on the `MusicCollection` table.
```
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"
}
}
}
```
For more information, see [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) in the *Amazon DynamoDB Developer Guide*.
**Example 2: To create a global secondary index**
The following example adds a global secondary index to the `MusicCollection` table.
```
aws dynamodb update-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=AlbumTitle,AttributeType=S \
--global-secondary-index-updates file://gsi-updates.json
```
Contents of `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"
}
]
}
}
```
For more information, see [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) in the *Amazon DynamoDB Developer Guide*.
**Example 3: To enable DynamoDB Streams on a table**
The following command enables DynamoDB Streams on the `MusicCollection` table.
```
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"
}
}
```
For more information, see [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) in the *Amazon DynamoDB Developer Guide*.
**Example 4: To enable server-side encryption**
The following example enables server-side encryption on the `MusicCollection` table.
```
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"
}
}
}
```
For more information, see [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-table.html) in *AWS CLI Command Reference*.
### `update-time-to-live`
The following code example shows how to use `update-time-to-live`.
**AWS CLI**
**To update Time to Live settings on a table**
The following `update-time-to-live` example enables Time to Live on the specified table.
```
aws dynamodb update-time-to-live \
--table-name MusicCollection \
--time-to-live-specification Enabled=true,AttributeName=ttl
```
Output:
```
{
"TimeToLiveSpecification": {
"Enabled": true,
"AttributeName": "ttl"
}
}
```
For more information, see [Time to Live](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html) in the *Amazon DynamoDB Developer Guide*.
+ For API details, see [UpdateTimeToLive](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-time-to-live.html) in *AWS CLI Command Reference*.