# Exemplos do DynamoDB usando o AWS CLI
Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o DynamoDB.
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.
**Topics**
+ [Ações](#actions)
## Ações
### `batch-get-item`
O código de exemplo a seguir mostra como usar `batch-get-item`.
**AWS CLI**
**Para recuperar vários itens de uma tabela**
O exemplo de `batch-get-items` a seguir lê vários itens da tabela `MusicCollection` usando um lote de três solicitações `GetItem` e solicita o número de unidades de capacidade de leitura consumidas pela operação. O comando retorna somente o atributo `AlbumTitle`.
```
aws dynamodb batch-get-item \
--request-items file://request-items.json \
--return-consumed-capacity TOTAL
```
Conteúdo de `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"
}
}
```
Resultado:
```
{
"Responses": {
"MusicCollection": [
{
"AlbumTitle": {
"S": "Somewhat Famous"
}
},
{
"AlbumTitle": {
"S": "Blue Sky Blues"
}
},
{
"AlbumTitle": {
"S": "Louder Than Ever"
}
}
]
},
"UnprocessedKeys": {},
"ConsumedCapacity": [
{
"TableName": "MusicCollection",
"CapacityUnits": 1.5
}
]
}
```
Para obter mais informações, consulte [Operações em lote](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.BatchOperations) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [BatchGetItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/batch-get-item.html) na *Referência de comandos da AWS CLI*.
### `batch-write-item`
O código de exemplo a seguir mostra como usar `batch-write-item`.
**AWS CLI**
**Como adicionar vários itens a uma tabela**
O exemplo de `batch-write-item` a seguir adiciona três novos itens à tabela `MusicCollection` usando um lote de três solicitações `PutItem`. Ele também solicita informações sobre o número de unidades de capacidade de gravação consumidas pela operação e quaisquer coleções de itens modificadas pela operação.
```
aws dynamodb batch-write-item \
--request-items file://request-items.json \
--return-consumed-capacity INDEXES \
--return-item-collection-metrics SIZE
```
Conteúdo de `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"}
}
}
}
]
}
```
Resultado:
```
{
"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
}
}
}
]
}
```
Para obter mais informações, consulte [Operações em lote](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.BatchOperations) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [BatchWriteItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/batch-write-item.html) na *Referência de comandos da AWS CLI*.
### `create-backup`
O código de exemplo a seguir mostra como usar `create-backup`.
**AWS CLI**
**Para criar um backup de uma tabela do DynamoDB existente**
O exemplo `create-backup` a seguir cria um backup da tabela `MusicCollection`.
```
aws dynamodb create-backup \
--table-name MusicCollection \
--backup-name MusicCollectionBackup
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [CreateBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-backup.html) na *Referência de comandos da AWS CLI*.
### `create-global-table`
O código de exemplo a seguir mostra como usar `create-global-table`.
**AWS CLI**
**Para criar uma tabela global**
O exemplo `create-global-table` a seguir cria uma tabela global a partir de duas tabelas idênticas nas regiões da AWS separadas e especificadas.
```
aws dynamodb create-global-table \
--global-table-name MusicCollection \
--replication-group RegionName=us-east-2 RegionName=us-east-1 \
--region us-east-2
```
Resultado:
```
{
"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"
}
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [CreateGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-global-table.html) na *Referência de comandos da AWS CLI*.
### `create-table`
O código de exemplo a seguir mostra como usar `create-table`.
**AWS CLI**
**Exemplo 1: como criar uma tabela com tags**
O exemplo de `create-table` a seguir usa os atributos especificados e o esquema de chaves para criar uma tabela chamada `MusicCollection`. Essa tabela usa um throughput provisionado e é criptografada em repouso usando a CMK de propriedade padrão da AWS. O comando também aplica uma tag à tabela, com uma chave `Owner` e valor de `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
```
Resultado:
```
{
"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"
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como criar uma tabela no modo sob demanda**
O exemplo a seguir cria uma tabela chamada `MusicCollection` usando o modo sob demanda, em vez do modo de throughput provisionado. Esse método é útil para tabelas com workloads imprevisíveis.
```
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
```
Resultado:
```
{
"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"
}
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 3: como criar uma tabela e criptografá-la com uma CMK gerenciada pelo cliente**
O exemplo a seguir cria uma tabela chamada `MusicCollection` e a criptografa usando uma CMK gerenciada pelo cliente.
```
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
```
Resultado:
```
{
"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"
}
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 4: como criar uma tabela com um índice secundário local**
O exemplo a seguir usa os atributos especificados e o esquema de chaves para criar uma tabela chamada `MusicCollection` com um índice secundário local chamado `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\"]
}
}
]"
```
Resultado:
```
{
"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"
}
]
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 5: como criar uma tabela com um índice secundário global**
O exemplo a seguir cria uma tabela chamada `GameScores` com um índice secundário global chamado `GameTitleIndex`. A tabela-base tem uma chave de partição `UserId` e uma chave de classificação `GameTitle`, permitindo que você encontre a melhor pontuação de um usuário individual para um jogo específico de forma eficiente, enquanto o GSI tem uma chave de partição `GameTitle` e uma chave de classificação `TopScore`, permitindo que você encontre rapidamente a pontuação mais alta geral para um jogo específico.
```
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
}
}
]"
```
Resultado:
```
{
"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"
}
]
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 6: como criar uma tabela com vários índices secundários globais ao mesmo tempo**
O exemplo a seguir cria uma tabela chamada `GameScores` com dos índices secundários globais. Os esquemas do GSI são passados por meio de um arquivo, e não pela linha de comando.
```
aws dynamodb create-table \
--table-name GameScores \
--attribute-definitions AttributeName=UserId,AttributeType=S AttributeName=GameTitle,AttributeType=S AttributeName=TopScore,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema AttributeName=UserId,KeyType=HASH AttributeName=GameTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5 \
--global-secondary-indexes file://gsi.json
```
Conteúdo de `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
}
}
]
```
Resultado:
```
{
"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"
}
]
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 7: como criar uma tabela com o Streams habilitado**
O exemplo a seguir cria uma tabela chamada `GameScores` com o DynamoDB Streams habilitado. Imagens novas e antigas de cada item serão gravadas no fluxo.
```
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
```
Resultado:
```
{
"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"
}
}
```
Para obter mais informações, consulte [Operações básicas nas tabelas](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 8: como criar uma tabela com o fluxo somente de chaves habilitado**
O exemplo a seguir cria uma tabela chamada `GameScores` com o DynamoDB Streams habilitado. Somente os atributos-chave dos itens modificados são gravados no fluxo.
```
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
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Captura de dados de alterações com o Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 9: como criar uma tabela com a classe Standard-Infrequent Access**
O exemplo a seguir cria uma tabela chamada `GameScores` e atribui a classe de tabela Standard-Infrequent Access (DynamoDB Standard-IA). Essa classe de tabela é otimizada para que o armazenamento seja o custo dominante.
```
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
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Classes de tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 10: como criar uma tabela com a proteção contra exclusão habilitada**
O exemplo a seguir cria uma tabela chamada `GameScores` e habilita a proteção contra exclusão.
```
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
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Usar a proteção contra exclusão](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeletionProtection) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [CreateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/create-table.html) na *Referência de comandos da AWS CLI*.
### `delete-backup`
O código de exemplo a seguir mostra como usar `delete-backup`.
**AWS CLI**
**Para excluir um backup existente do DynamoDB**
O exemplo `delete-backup` a seguir exclui o backup existente especificado.
```
aws dynamodb delete-backup \
--backup-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a
```
Resultado:
```
{
"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": {}
}
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DeleteBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-backup.html) na *Referência de comandos da AWS CLI*.
### `delete-item`
O código de exemplo a seguir mostra como usar `delete-item`.
**AWS CLI**
**Exemplo 1: como excluir um item**
O exemplo de `delete-item` a seguir exclui um item da tabela `MusicCollection` e solicita detalhes sobre o item excluído e a capacidade usada pela solicitação.
```
aws dynamodb delete-item \
--table-name MusicCollection \
--key file://key.json \
--return-values ALL_OLD \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Conteúdo de `key.json`:
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Scared of My Shadow"}
}
```
Resultado:
```
{
"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
]
}
}
```
Para obter mais informações, consulte [Gravar um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como excluir um item de forma condicional**
O exemplo a seguir exclui um item da tabela `ProductCatalog` somente se a `ProductCategory` for `Sporting Goods` ou `Gardening Supplies` e o preço estiver entre 500 e 600. Ele retorna detalhes sobre o item que foi excluído.
```
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
```
Conteúdo de `names.json`:
```
{
"#P": "Price"
}
```
Conteúdo de `values.json`:
```
{
":cat1": {"S": "Sporting Goods"},
":cat2": {"S": "Gardening Supplies"},
":lo": {"N": "500"},
":hi": {"N": "600"}
}
```
Resultado:
```
{
"Attributes": {
"Id": {
"N": "456"
},
"Price": {
"N": "550"
},
"ProductCategory": {
"S": "Sporting Goods"
}
}
}
```
Para obter mais informações, consulte [Gravar um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [DeleteItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-item.html) na *Referência de comandos da AWS CLI*.
### `delete-table`
O código de exemplo a seguir mostra como usar `delete-table`.
**AWS CLI**
**Como excluir uma tabela**
O exemplo de `delete-table` a seguir exclui a tabela `MusicCollection`.
```
aws dynamodb delete-table \
--table-name MusicCollection
```
Resultado:
```
{
"TableDescription": {
"TableStatus": "DELETING",
"TableSizeBytes": 0,
"ItemCount": 0,
"TableName": "MusicCollection",
"ProvisionedThroughput": {
"NumberOfDecreasesToday": 0,
"WriteCapacityUnits": 5,
"ReadCapacityUnits": 5
}
}
}
```
Para obter mais informações, consulte [Excluir uma tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DeleteTable) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [DeleteTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/delete-table.html) na *Referência de comandos da AWS CLI*.
### `describe-backup`
O código de exemplo a seguir mostra como usar `describe-backup`.
**AWS CLI**
**Para obter informações sobre um backup existente de uma tabela**
O exemplo `describe-backup` a seguir mostra as informações do backup existente especificado.
```
aws dynamodb describe-backup \
--backup-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a
```
Resultado:
```
{
"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": {}
}
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-backup.html) na *Referência de comandos da AWS CLI*.
### `describe-continuous-backups`
O código de exemplo a seguir mostra como usar `describe-continuous-backups`.
**AWS CLI**
**Para obter informações sobre backups contínuos em uma tabela do DynamoDB**
O exemplo `describe-continuous-backups` a seguir exibe detalhes sobre as configurações de backup contínuo da tabela `MusicCollection`.
```
aws dynamodb describe-continuous-backups \
--table-name MusicCollection
```
Resultado:
```
{
"ContinuousBackupsDescription": {
"ContinuousBackupsStatus": "ENABLED",
"PointInTimeRecoveryDescription": {
"PointInTimeRecoveryStatus": "DISABLED"
}
}
}
```
Para obter mais informações, consulte [Recuperação para um ponto no tempo para o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeContinuousBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-continuous-backups.html) na *Referência de comandos da AWS CLI*.
### `describe-contributor-insights`
O código de exemplo a seguir mostra como usar `describe-contributor-insights`.
**AWS CLI**
**Como visualizar as configurações do Contributor Insights em uma tabela do DynamoDB**
O exemplo `describe-contributor-insights` a seguir exibe as configurações do Contributor Insights para a tabela `MusicCollection` e o índice secundário global `AlbumTitle-index`.
```
aws dynamodb describe-contributor-insights \
--table-name MusicCollection \
--index-name AlbumTitle-index
```
Resultado:
```
{
"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
}
```
Para obter mais informações, consulte [Analisar acesso a dados usando o CloudWatch Contributor Insights para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-contributor-insights.html) na *Referência de comandos da AWS CLI*.
### `describe-endpoints`
O código de exemplo a seguir mostra como usar `describe-endpoints`.
**AWS CLI**
**Como visualizar informações de endpoints regionais**
O exemplo `describe-endpoints` a seguir exibe detalhes sobre os endpoints da região da AWS atual.
```
aws dynamodb describe-endpoints
```
Resultado:
```
{
"Endpoints": [
{
"Address": "dynamodb.us-west-2.amazonaws.com",
"CachePeriodInMinutes": 1440
}
]
}
```
Para obter mais informações, consulte [Endpoints e cotas do Amazon DynamoDB](https://docs.aws.amazon.com/general/latest/gr/ddb.html) na *Referência geral da AWS*.
+ Para ver detalhes da API, consulte [DescribeEndpoints](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-endpoints.html) na *Referência de comandos da AWS CLI*.
### `describe-global-table-settings`
O código de exemplo a seguir mostra como usar `describe-global-table-settings`.
**AWS CLI**
**Para obter informações sobre as configurações de uma tabela global do DynamoDB**
O exemplo `describe-global-table-settings` a seguir exibe as configurações da tabela global `MusicCollection`.
```
aws dynamodb describe-global-table-settings \
--global-table-name MusicCollection
```
Resultado:
```
{
"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
}
}
]
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeGlobalTableSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-global-table-settings.html) na *Referência de comandos da AWS CLI*.
### `describe-global-table`
O código de exemplo a seguir mostra como usar `describe-global-table`.
**AWS CLI**
**Como exibir informações sobre uma tabela global do DynamoDB**
O exemplo `describe-global-table` a seguir exibe detalhes sobre a tabela global `MusicCollection`.
```
aws dynamodb describe-global-table \
--global-table-name MusicCollection
```
Resultado:
```
{
"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"
}
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-global-table.html) na *Referência de comandos da AWS CLI*.
### `describe-limits`
O código de exemplo a seguir mostra como usar `describe-limits`.
**AWS CLI**
**Como ver os limites da capacidade provisionada**
O exemplo `describe-limits` a seguir mostra os limites de capacidade provisionada para sua conta na região da AWS atual.
```
aws dynamodb describe-limits
```
Resultado:
```
{
"AccountMaxReadCapacityUnits": 80000,
"AccountMaxWriteCapacityUnits": 80000,
"TableMaxReadCapacityUnits": 40000,
"TableMaxWriteCapacityUnits": 40000
}
```
Para obter mais informações, consulte [Limites do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html) no *Guia do desenvolvedor Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeLimits](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-limits.html) na *Referência de comandos da AWS CLI*.
### `describe-table-replica-auto-scaling`
O código de exemplo a seguir mostra como usar `describe-table-replica-auto-scaling`.
**AWS CLI**
**Como visualizar as configurações de ajuste de escala automático em réplicas de uma tabela global**
O exemplo `describe-table-replica-auto-scaling` a seguir exibe as configurações de ajuste de escala automático nas réplicas da tabela global `MusicCollection`.
```
aws dynamodb describe-table-replica-auto-scaling \
--table-name MusicCollection
```
Resultado:
```
{
"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"
}
]
}
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [DescribeTableReplicaAutoScaling](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-table-replica-auto-scaling.html) na *Referência de comandos da AWS CLI*.
### `describe-table`
O código de exemplo a seguir mostra como usar `describe-table`.
**AWS CLI**
**Como descrever uma tabela**
O exemplo a seguir de `describe-table` descreve a tabela `MusicCollection`.
```
aws dynamodb describe-table \
--table-name MusicCollection
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Descrever uma tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.DescribeTable) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [DescribeTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-table.html) na *Referência de comandos da AWS CLI*.
### `describe-time-to-live`
O código de exemplo a seguir mostra como usar `describe-time-to-live`.
**AWS CLI**
**Como ver as configurações de vida útil de uma tabela**
O exemplo `describe-time-to-live` a seguir exibe as configurações de vida útil da tabela `MusicCollection`.
```
aws dynamodb describe-time-to-live \
--table-name MusicCollection
```
Resultado:
```
{
"TimeToLiveDescription": {
"TimeToLiveStatus": "ENABLED",
"AttributeName": "ttl"
}
}
```
Para obter mais informações, consulte [Vida útil](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [DescribeTimeToLive](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/describe-time-to-live.html) na *Referência de comandos da AWS CLI*.
### `get-item`
O código de exemplo a seguir mostra como usar `get-item`.
**AWS CLI**
**Exemplo 1: como ler um item em uma tabela**
O exemplo de `get-item` a seguir recupera um item da tabela `MusicCollection`. A tabela tem uma chave primária de hash e intervalo (`Artist` e `SongTitle`), portanto, você deve especificar esses dois atributos. O comando também solicita informações sobre a capacidade de leitura consumida pela operação.
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--return-consumed-capacity TOTAL
```
Conteúdo de `key.json`:
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Resultado:
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
Para obter mais informações, consulte [Ler um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como ler um item usando uma leitura consistente**
O exemplo a seguir recupera um item da tabela `MusicCollection` usando leituras altamente consistentes.
```
aws dynamodb get-item \
--table-name MusicCollection \
--key file://key.json \
--consistent-read \
--return-consumed-capacity TOTAL
```
Conteúdo de `key.json`:
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Resultado:
```
{
"Item": {
"AlbumTitle": {
"S": "Songs About Life"
},
"SongTitle": {
"S": "Happy Day"
},
"Artist": {
"S": "Acme Band"
}
},
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
}
}
```
Para obter mais informações, consulte [Ler um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 3: como recuperar atributos específicos de um item**
O exemplo a seguir usa uma expressão de projeção para recuperar apenas três atributos do item desejado.
```
aws dynamodb get-item \
--table-name ProductCatalog \
--key '{"Id": {"N": "102"}}' \
--projection-expression "#T, #C, #P" \
--expression-attribute-names file://names.json
```
Conteúdo de `names.json`:
```
{
"#T": "Title",
"#C": "ProductCategory",
"#P": "Price"
}
```
Resultado:
```
{
"Item": {
"Price": {
"N": "20"
},
"Title": {
"S": "Book 102 Title"
},
"ProductCategory": {
"S": "Book"
}
}
}
```
Para obter mais informações, consulte [Ler um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.ReadingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [GetItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/get-item.html) na *Referência de comandos da AWS CLI*.
### `list-backups`
O código de exemplo a seguir mostra como usar `list-backups`.
**AWS CLI**
**Exemplo 1: listar todos os backups existentes do DynamoDB**
O exemplo `list-backups` a seguir lista todos os seus backups existentes.
```
aws dynamodb list-backups
```
Resultado:
```
{
"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
}
]
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: listar backups criados pelo usuário em um intervalo de tempo específico**
O exemplo a seguir lista somente os backups da tabela `MusicCollection` que foram criados pelo usuário (não aqueles criados automaticamente pelo DynamoDB) com uma data de criação entre 1º de janeiro de 2020 e 1º de março de 2020.
```
aws dynamodb list-backups \
--table-name MusicCollection \
--time-range-lower-bound 1577836800 \
--time-range-upper-bound 1583020800 \
--backup-type USER
```
Resultado:
```
{
"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
}
]
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 3: limitar o tamanho da página**
O exemplo a seguir retorna uma lista de todos os backups existentes, mas recupera apenas um item em cada chamada. Pode ser necessário realizar várias chamadas para obter a lista completa. Limitar o tamanho da página é útil ao executar os comandos da lista em um grande número de recursos, o que pode resultar em um erro de “tempo limite” ao usar o tamanho de página padrão de 1.000.
```
aws dynamodb list-backups \
--page-size 1
```
Resultado:
```
{
"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
}
]
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 4: limitar o número de itens retornados**
O exemplo a seguir limita o número de itens retornados para um. A resposta inclui um valor `NextToken` a ser usado para recuperar a próxima página de resultados.
```
aws dynamodb list-backups \
--max-items 1
```
Resultado:
```
{
"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"
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 5: recuperar a próxima página de resultados**
O comando a seguir usa o valor `NextToken` de uma chamada anterior feita ao comando `list-backups` para recuperar outra página de resultados. Como a resposta nesse caso não inclui um valor para `NextToken`, sabemos que chegamos ao final dos resultados.
```
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
}
]
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [ListBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-backups.html) na *Referência de comandos da AWS CLI*.
### `list-contributor-insights`
O código de exemplo a seguir mostra como usar `list-contributor-insights`.
**AWS CLI**
**Exemplo 1: visualizar uma lista de resumos do Contributor Insights**
O exemplo `list-contributor-insights` a seguir exibe uma lista de resumos do Contributor Insights.
```
aws dynamodb list-contributor-insights
```
Resultado:
```
{
"ContributorInsightsSummaries": [
{
"TableName": "MusicCollection",
"IndexName": "AlbumTitle-index",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "ProductCatalog",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "Forum",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "Reply",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "Thread",
"ContributorInsightsStatus": "ENABLED"
}
]
}
```
Para obter mais informações, consulte [Analisar acesso a dados usando o CloudWatch Contributor Insights para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: limitar o número de itens retornados**
O exemplo a seguir limita o número de itens retornados para quatro. A resposta inclui um valor `NextToken` a ser usado para recuperar a próxima página de resultados.
```
aws dynamodb list-contributor-insights \
--max-results 4
```
Resultado:
```
{
"ContributorInsightsSummaries": [
{
"TableName": "MusicCollection",
"IndexName": "AlbumTitle-index",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "ProductCatalog",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "Forum",
"ContributorInsightsStatus": "ENABLED"
}
],
"NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
Para obter mais informações, consulte [Analisar acesso a dados usando o CloudWatch Contributor Insights para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 3: recuperar a próxima página de resultados**
O comando a seguir usa o valor `NextToken` de uma chamada anterior feita ao comando `list-contributor-insights` para recuperar outra página de resultados. Como a resposta nesse caso não inclui um valor para `NextToken`, sabemos que chegamos ao final dos resultados.
```
aws dynamodb list-contributor-insights \
--max-results 4 \
--next-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Resultado:
```
{
"ContributorInsightsSummaries": [
{
"TableName": "Reply",
"ContributorInsightsStatus": "ENABLED"
},
{
"TableName": "Thread",
"ContributorInsightsStatus": "ENABLED"
}
]
}
```
Para obter mais informações, consulte [Analisar acesso a dados usando o CloudWatch Contributor Insights para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [ListContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-contributor-insights.html) na *Referência de comandos da AWS CLI*.
### `list-global-tables`
O código de exemplo a seguir mostra como usar `list-global-tables`.
**AWS CLI**
**Para listar tabelas globais do DynamoDB existentes**
O exemplo `list-global-tables` a seguir lista todas as suas tabelas globais existentes.
```
aws dynamodb list-global-tables
```
Resultado:
```
{
"GlobalTables": [
{
"GlobalTableName": "MusicCollection",
"ReplicationGroup": [
{
"RegionName": "us-east-2"
},
{
"RegionName": "us-east-1"
}
]
}
]
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [ListGlobalTables](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-global-tables.html) na *Referência de comandos da AWS CLI*.
### `list-tables`
O código de exemplo a seguir mostra como usar `list-tables`.
**AWS CLI**
**Exemplo 1: listar tabelas**
O exemplo de `list-tables` a seguir lista todas as tabelas associadas à conta e região atuais da AWS.
```
aws dynamodb list-tables
```
Resultado:
```
{
"TableNames": [
"Forum",
"ProductCatalog",
"Reply",
"Thread"
]
}
```
Para obter mais informações, consulte [Listar nomes de tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) no *Guia do desenvolvedor Amazon DynamoDB*.
**Exemplo 2: como limitar o tamanho da página**
O exemplo a seguir retorna uma lista de todas as tabelas existentes, mas recupera apenas um item em cada chamada. Pode ser necessário realizar várias chamadas para obter a lista completa. Limitar o tamanho da página é útil ao executar os comandos da lista em um grande número de recursos, o que pode resultar em um erro de “tempo limite” ao usar o tamanho de página padrão de 1.000.
```
aws dynamodb list-tables \
--page-size 1
```
Resultado:
```
{
"TableNames": [
"Forum",
"ProductCatalog",
"Reply",
"Thread"
]
}
```
Para obter mais informações, consulte [Listar nomes de tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) no *Guia do desenvolvedor Amazon DynamoDB*.
**Exemplo 3: como limitar o número de itens retornados**
O exemplo a seguir limita o número de itens retornados para dois. A resposta inclui um valor `NextToken` a ser usado para recuperar a próxima página de resultados.
```
aws dynamodb list-tables \
--max-items 2
```
Resultado:
```
{
"TableNames": [
"Forum",
"ProductCatalog"
],
"NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
Para obter mais informações, consulte [Listar nomes de tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) no *Guia do desenvolvedor Amazon DynamoDB*.
**Exemplo 4: como recuperar a próxima página de resultados**
O comando a seguir usa o valor `NextToken` de uma chamada anterior feita ao comando `list-tables` para recuperar outra página de resultados. Como a resposta nesse caso não inclui um valor para `NextToken`, sabemos que chegamos ao final dos resultados.
```
aws dynamodb list-tables \
--starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Resultado:
```
{
"TableNames": [
"Reply",
"Thread"
]
}
```
Para obter mais informações, consulte [Listar nomes de tabela](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.ListTables) no *Guia do desenvolvedor Amazon DynamoDB*.
+ Consulte detalhes da API em [ListTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-tables.html) na *Referência de comandos da AWS CLI*.
### `list-tags-of-resource`
O código de exemplo a seguir mostra como usar `list-tags-of-resource`.
**AWS CLI**
**Exemplo 1: listar as tags de um recurso do DynamoDB**
O exemplo `list-tags-of-resource` a seguir exibe tags para a tabela `MusicCollection`.
```
aws dynamodb list-tags-of-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection
```
Resultado:
```
{
"Tags": [
{
"Key": "Owner",
"Value": "blueTeam"
},
{
"Key": "Environment",
"Value": "Production"
}
]
}
```
Para obter mais informações, consulte [Marcação no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) no *Guia do desenvolvedor Amazon DynamoDB*.
**Exemplo 2: limitar o número de tags retornadas**
O exemplo a seguir limita o número de tags retornadas para um. A resposta inclui um valor `NextToken` a ser usado para recuperar a próxima página de resultados.
```
aws dynamodb list-tags-of-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--max-items 1
```
Resultado:
```
{
"Tags": [
{
"Key": "Owner",
"Value": "blueTeam"
}
],
"NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}
```
Para obter mais informações, consulte [Marcação no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) no *Guia do desenvolvedor Amazon DynamoDB*.
**Exemplo 3: recuperar a próxima página de resultados**
O comando a seguir usa o valor `NextToken` de uma chamada anterior feita ao comando `list-tags-of-resource` para recuperar outra página de resultados. Como a resposta nesse caso não inclui um valor para `NextToken`, sabemos que chegamos ao final dos resultados.
```
aws dynamodb list-tags-of-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9
```
Resultado:
```
{
"Tags": [
{
"Key": "Environment",
"Value": "Production"
}
]
}
```
Para obter mais informações, consulte [Marcação no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) no *Guia do desenvolvedor Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [ListTagsOfResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/list-tags-of-resource.html) na *Referência de comandos da AWS CLI*.
### `put-item`
O código de exemplo a seguir mostra como usar `put-item`.
**AWS CLI**
**Exemplo 1: como adicionar um item a uma tabela**
O exemplo de `put-item` a seguir adiciona um novo item à tabela *MusicCollection*.
```
aws dynamodb put-item \
--table-name MusicCollection \
--item file://item.json \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Conteúdo de `item.json`:
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Greatest Hits"}
}
```
Resultado:
```
{
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
},
"ItemCollectionMetrics": {
"ItemCollectionKey": {
"Artist": {
"S": "No One You Know"
}
},
"SizeEstimateRangeGB": [
0.0,
1.0
]
}
}
```
Para obter mais informações, consulte [Gravar um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como substituir condicionalmente um item em uma tabela**
O exemplo de `put-item` a seguir substitui um item existente na tabela `MusicCollection` somente se o item existente tiver um atributo `AlbumTitle` com o valor `Greatest Hits`. O comando retorna o valor anterior do 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
```
Conteúdo de `item.json`:
```
{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"},
"AlbumTitle": {"S": "Somewhat Famous"}
}
```
Conteúdo de `names.json`:
```
{
"#A": "AlbumTitle"
}
```
Conteúdo de `values.json`:
```
{
":A": {"S": "Greatest Hits"}
}
```
Resultado:
```
{
"Attributes": {
"AlbumTitle": {
"S": "Greatest Hits"
},
"Artist": {
"S": "No One You Know"
},
"SongTitle": {
"S": "Call Me Today"
}
}
}
```
Se a chave já existir, você verá a seguinte saída:
```
A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.
```
Para obter mais informações, consulte [Gravar um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [PutItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/put-item.html) na *Referência de comandos da AWS CLI*.
### `query`
O código de exemplo a seguir mostra como usar `query`.
**AWS CLI**
**Exemplo 1: como consultar uma tabela**
O exemplo da `query` a seguir consulta itens da tabela `MusicCollection`. A tabela tem uma chave primária de hash e intervalo (`Artist` e `SongTitle`), mas essa consulta especifica apenas o valor da chave de hash. Ela retorna nomes de músicas do artista “No One You Know”.
```
aws dynamodb query \
--table-name MusicCollection \
--projection-expression "SongTitle" \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json \
--return-consumed-capacity TOTAL
```
Conteúdo de `expression-attributes.json`:
```
{
":v1": {"S": "No One You Know"}
}
```
Resultado:
```
{
"Items": [
{
"SongTitle": {
"S": "Call Me Today"
},
"SongTitle": {
"S": "Scared of My Shadow"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 0.5
}
}
```
Para obter mais informações, consulte [Operações de consulta no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como consultar uma tabela usando leituras altamente consistentes e percorrer o índice em ordem decrescente**
O exemplo a seguir executa a mesma consulta do primeiro exemplo, mas retorna os resultados na ordem inversa e usa leituras altamente consistentes.
```
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
```
Conteúdo de `expression-attributes.json`:
```
{
":v1": {"S": "No One You Know"}
}
```
Resultado:
```
{
"Items": [
{
"SongTitle": {
"S": "Scared of My Shadow"
}
},
{
"SongTitle": {
"S": "Call Me Today"
}
}
],
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": {
"TableName": "MusicCollection",
"CapacityUnits": 1.0
}
}
```
Para obter mais informações, consulte [Operações de consulta no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 3: como filtrar resultados específicos**
O exemplo a seguir consulta o `MusicCollection`, mas exclui os resultados com valores específicos no atributo `AlbumTitle`. Observe que isso não afeta `ScannedCount` ou `ConsumedCapacity` já que o filtro é aplicado após a leitura dos itens.
```
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
```
Conteúdo de `values.json`:
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Blue Sky Blues"},
":v3": {"S": "Greatest Hits"}
}
```
Conteúdo de `names.json`:
```
{
"#n1": "Artist",
"#n2": "AlbumTitle"
}
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Operações de consulta no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 4: como recuperar somente uma contagem de itens**
O exemplo a seguir recupera uma contagem de itens que correspondem à consulta, mas não recupera os itens em si.
```
aws dynamodb query \
--table-name MusicCollection \
--select COUNT \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json
```
Conteúdo de `expression-attributes.json`:
```
{
":v1": {"S": "No One You Know"}
}
```
Resultado:
```
{
"Count": 2,
"ScannedCount": 2,
"ConsumedCapacity": null
}
```
Para obter mais informações, consulte [Operações de consulta no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 5: como consultar um índice**
O exemplo a seguir consulta o índice secundário local `AlbumTitleIndex`. A consulta retorna todos os atributos da tabela base projetados no índice secundário local. Ao consultar um índice secundário local ou global, você deve fornecer o nome da tabela base usando o parâmetro `table-name`.
```
aws dynamodb query \
--table-name MusicCollection \
--index-name AlbumTitleIndex \
--key-condition-expression "Artist = :v1" \
--expression-attribute-values file://expression-attributes.json \
--select ALL_PROJECTED_ATTRIBUTES \
--return-consumed-capacity INDEXES
```
Conteúdo de `expression-attributes.json`:
```
{
":v1": {"S": "No One You Know"}
}
```
Resultado:
```
{
"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
}
}
}
}
```
Para obter mais informações, consulte [Operações de consulta no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [Query](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/query.html) na *Referência de comandos da AWS CLI*.
### `restore-table-from-backup`
O código de exemplo a seguir mostra como usar `restore-table-from-backup`.
**AWS CLI**
**Como restaurar uma tabela do DynamoDB de um backup existente**
O exemplo `restore-table-from-backup` a seguir restaura a tabela especificada de um backup existente.
```
aws dynamodb restore-table-from-backup \
--target-table-name MusicCollection \
--backup-arnarn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection/backup/01576616366715-b4e58d3a
```
Resultado:
```
{
"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
}
}
}
```
Para obter mais informações, consulte [Backup e restauração do DynamoDB sob demanda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [RestoreTableFromBackup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/restore-table-from-backup.html) na *Referência de comandos da AWS CLI*.
### `restore-table-to-point-in-time`
O código de exemplo a seguir mostra como usar `restore-table-to-point-in-time`.
**AWS CLI**
**Como restaurar uma tabela do DynamoDB para um ponto no tempo**
O exemplo `restore-table-to-point-in-time` a seguir restaura a tabela `MusicCollection` no momento especificado.
```
aws dynamodb restore-table-to-point-in-time \
--source-table-name MusicCollection \
--target-table-name MusicCollectionRestore \
--restore-date-time 1576622404.0
```
Resultado:
```
{
"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
}
}
}
```
Para obter mais informações, consulte [Recuperação para um ponto no tempo para o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [RestoreTableToPointInTime](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/restore-table-to-point-in-time.html) na *Referência de comandos da AWS CLI*.
### `scan`
O código de exemplo a seguir mostra como usar `scan`.
**AWS CLI**
**Como verificar uma tabela**
O exemplo de `scan` faz uma varredura da tabela `MusicCollection` e restringe os resultados a músicas do artista “No One You Know”. Em cada item, somente o nome do álbum e da música são retornados.
```
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
```
Conteúdo de `expression-attribute-names.json`:
```
{
"#ST": "SongTitle",
"#AT":"AlbumTitle"
}
```
Conteúdo de `expression-attribute-values.json`:
```
{
":a": {"S": "No One You Know"}
}
```
Resultado:
```
{
"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
}
```
Para obter mais informações, consulte [Trabalhar com verificações no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [Scan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/scan.html) na *Referência de comandos da AWS CLI*.
### `tag-resource`
O código de exemplo a seguir mostra como usar `tag-resource`.
**AWS CLI**
**Para adicionar tags a um recurso do DynamoDB**
O exemplo `tag-resource` a seguir adiciona uma tag com o par de chave-valor à tabela `MusicCollection`.
```
aws dynamodb tag-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--tags Key=Owner,Value=blueTeam
```
Este comando não produz saída.
Para obter mais informações, consulte [Marcação no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) no *Guia do desenvolvedor Amazon DynamoDB*.
+ Consulte detalhes da API em [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/tag-resource.html) na *Referência de comandos da AWS CLI*.
### `transact-get-items`
O código de exemplo a seguir mostra como usar `transact-get-items`.
**AWS CLI**
**Para recuperar vários itens atomicamente de uma ou mais tabelas**
O exemplo `transact-get-items` a seguir recupera vários itens atomicamente.
```
aws dynamodb transact-get-items \
--transact-items file://transact-items.json \
--return-consumed-capacity TOTAL
```
Conteúdo de `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"
}
}
]
```
Resultado:
```
{
"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"
}
}
}
]
}
```
Para obter mais informações, consulte [Gerenciamento de fluxos de trabalho complexos com transações do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [TransactGetItems](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/transact-get-items.html) na *Referência de comandos da AWS CLI*.
### `transact-write-items`
O código de exemplo a seguir mostra como usar `transact-write-items`.
**AWS CLI**
**Exemplo 1: gravar itens atomicamente em uma ou mais tabelas**
O exemplo `transact-write-items` a seguir atualiza um item e exclui outro. A operação falhará se uma das operações falhar ou se um dos itens contiver um atributo `Rating`.
```
aws dynamodb transact-write-items \
--transact-items file://transact-items.json \
--return-consumed-capacity TOTAL \
--return-item-collection-metrics SIZE
```
Conteúdo do arquivo `transact-items.json`:
```
[
{
"Update": {
"Key": {
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
},
"UpdateExpression": "SET AlbumTitle = :newval",
"ExpressionAttributeValues": {
":newval": {"S": "Updated Album Title"}
},
"TableName": "MusicCollection",
"ConditionExpression": "attribute_not_exists(Rating)"
}
},
{
"Delete": {
"Key": {
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"}
},
"TableName": "MusicCollection",
"ConditionExpression": "attribute_not_exists(Rating)"
}
}
]
```
Resultado:
```
{
"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
]
}
]
}
}
```
Para obter mais informações, consulte [Gerenciamento de fluxos de trabalho complexos com transações do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: escrever itens atomicamente usando um token de solicitação do cliente**
O comando a seguir usa um token de solicitação do cliente para fazer a chamada para `transact-write-items` idempotente, o que significa que várias chamadas têm o mesmo efeito de uma única chamada.
```
aws dynamodb transact-write-items \
--transact-items file://transact-items.json \
--client-request-token abc123
```
Conteúdo do arquivo `transact-items.json`:
```
[
{
"Update": {
"Key": {
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
},
"UpdateExpression": "SET AlbumTitle = :newval",
"ExpressionAttributeValues": {
":newval": {"S": "Updated Album Title"}
},
"TableName": "MusicCollection",
"ConditionExpression": "attribute_not_exists(Rating)"
}
},
{
"Delete": {
"Key": {
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"}
},
"TableName": "MusicCollection",
"ConditionExpression": "attribute_not_exists(Rating)"
}
}
]
```
Este comando não produz saída.
Para obter mais informações, consulte [Gerenciamento de fluxos de trabalho complexos com transações do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [TransactWriteItems](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/transact-write-items.html) na *Referência de comandos da AWS CLI*.
### `untag-resource`
O código de exemplo a seguir mostra como usar `untag-resource`.
**AWS CLI**
**Para remover uma tag de um recurso do DynamoDB**
O exemplo `untag-resource` a seguir remove a tag com a chave `Owner` da tabela `MusicCollection`.
```
aws dynamodb untag-resource \
--resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
--tag-keys Owner
```
Este comando não produz saída.
Para obter mais informações, consulte [Marcação no DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html) no *Guia do desenvolvedor Amazon DynamoDB*.
+ Para obter detalhes sobre a API, consulte [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/untag-resource.html) na *Referência de comandos da AWS CLI*.
### `update-continuous-backups`
O código de exemplo a seguir mostra como usar `update-continuous-backups`.
**AWS CLI**
**Para atualizar as configurações de backup contínuo para uma tabela do DynamoDB**
O exemplo `update-continuous-backups` a seguir permite a recuperação de ponto no tempo para a tabela `MusicCollection`.
```
aws dynamodb update-continuous-backups \
--table-name MusicCollection \
--point-in-time-recovery-specification PointInTimeRecoveryEnabled=true
```
Resultado:
```
{
"ContinuousBackupsDescription": {
"ContinuousBackupsStatus": "ENABLED",
"PointInTimeRecoveryDescription": {
"PointInTimeRecoveryStatus": "ENABLED",
"EarliestRestorableDateTime": 1576622404.0,
"LatestRestorableDateTime": 1576622404.0
}
}
}
```
Para obter mais informações, consulte [Recuperação para um ponto no tempo para o DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [UpdateContinuousBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-continuous-backups.html) na *Referência de comandos da AWS CLI*.
### `update-contributor-insights`
O código de exemplo a seguir mostra como usar `update-contributor-insights`.
**AWS CLI**
**Para habilitar o Contributor Insights em uma tabela**
O exemplo `update-contributor-insights` a seguir ativa o Contributor Insights na tabela `MusicCollection` e no índice secundário global `AlbumTitle-index`.
```
aws dynamodb update-contributor-insights \
--table-name MusicCollection \
--index-name AlbumTitle-index \
--contributor-insights-action ENABLE
```
Resultado:
```
{
"TableName": "MusicCollection",
"IndexName": "AlbumTitle-index",
"ContributorInsightsStatus": "ENABLING"
}
```
Para obter mais informações, consulte [Analisar acesso a dados usando o CloudWatch Contributor Insights para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/contributorinsights.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [UpdateContributorInsights](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-contributor-insights.html) na *Referência de comandos da AWS CLI*.
### `update-global-table-settings`
O código de exemplo a seguir mostra como usar `update-global-table-settings`.
**AWS CLI**
**Para atualizar as configurações de capacidade de gravação provisionada em uma tabela global do DynamoDB**
O exemplo `update-global-table-settings` a seguir define a capacidade de gravação provisionada da tabela global `MusicCollection` como 15.
```
aws dynamodb update-global-table-settings \
--global-table-name MusicCollection \
--global-table-provisioned-write-capacity-units 15
```
Resultado:
```
{
"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
}
}
]
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [UpdateGlobalTableSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-global-table-settings.html) na *Referência de comandos da AWS CLI*.
### `update-global-table`
O código de exemplo a seguir mostra como usar `update-global-table`.
**AWS CLI**
**Para atualizar uma tabela global do DynamoDB**
O exemplo `update-global-table` a seguir adiciona uma réplica na região especificada à tabela global `MusicCollection`.
```
aws dynamodb update-global-table \
--global-table-name MusicCollection \
--replica-updates Create={RegionName=eu-west-1}
```
Resultado:
```
{
"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"
}
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [UpdateGlobalTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-global-table.html) na *Referência de comandos da AWS CLI*.
### `update-item`
O código de exemplo a seguir mostra como usar `update-item`.
**AWS CLI**
**Exemplo 1: como atualizar um item em uma tabela**
O exemplo da `update-item` a seguir atualiza um item da tabela `MusicCollection`. Ele adiciona um novo atributo (`Year`) e modifica o atributo `AlbumTitle`. Todos os atributos no item, conforme aparecem após a atualização, são retornados na resposta.
```
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
```
Conteúdo de `key.json`:
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Conteúdo de `expression-attribute-names.json`:
```
{
"#Y":"Year", "#AT":"AlbumTitle"
}
```
Conteúdo de `expression-attribute-values.json`:
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
Resultado:
```
{
"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
]
}
}
```
Para obter mais informações, consulte [Gravar um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como atualizar um item de forma condicional**
O exemplo a seguir atualiza um item na tabela `MusicCollection`, mas somente se o item existente ainda não tiver um atributo `Year`.
```
aws dynamodb update-item \
--table-name MusicCollection \
--key file://key.json \
--update-expression "SET #Y = :y, #AT = :t" \
--expression-attribute-names file://expression-attribute-names.json \
--expression-attribute-values file://expression-attribute-values.json \
--condition-expression "attribute_not_exists(#Y)"
```
Conteúdo de `key.json`:
```
{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"}
}
```
Conteúdo de `expression-attribute-names.json`:
```
{
"#Y":"Year",
"#AT":"AlbumTitle"
}
```
Conteúdo de `expression-attribute-values.json`:
```
{
":y":{"N": "2015"},
":t":{"S": "Louder Than Ever"}
}
```
Se o item já tiver um atributo `Year`, o DynamoDB retornará saída a seguir.
```
An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed
```
Para obter mais informações, consulte [Gravar um item](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [UpdateItem](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-item.html) na *Referência de comandos da AWS CLI*.
### `update-table-replica-auto-scaling`
O código de exemplo a seguir mostra como usar `update-table-replica-auto-scaling`.
**AWS CLI**
**Para atualizar as configurações de ajuste de escala automático em réplicas de uma tabela global**
O exemplo `update-table-replica-auto-scaling` a seguir atualiza as configurações de ajuste de escala automático da capacidade de gravação em réplicas da tabela global especificada.
```
aws dynamodb update-table-replica-auto-scaling \
--table-name MusicCollection \
--provisioned-write-capacity-auto-scaling-update file://auto-scaling-policy.json
```
Conteúdo de `auto-scaling-policy.json`:
```
{
"MinimumUnits": 10,
"MaximumUnits": 100,
"AutoScalingDisabled": false,
"ScalingPolicyUpdate": {
"PolicyName": "DynamoDBWriteCapacityUtilization:table/MusicCollection",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 80
}
}
}
```
Resultado:
```
{
"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"
}
]
}
}
```
Para obter mais informações, consulte [Tabelas do globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ver detalhes da API, consulte [UpdateTableReplicaAutoScaling](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-table-replica-auto-scaling.html) na *Referência de comandos da AWS CLI*.
### `update-table`
O código de exemplo a seguir mostra como usar `update-table`.
**AWS CLI**
**Exemplo 1: como modificar o modo de faturamento de uma tabela**
O exemplo `update-table` a seguir aumenta a capacidade de leitura e gravação provisionada na tabela `MusicCollection`.
```
aws dynamodb update-table \
--table-name MusicCollection \
--billing-mode PROVISIONED \
--provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10
```
Resultado:
```
{
"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"
}
}
}
```
Para ter mais informações, consulte [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 2: como criar um índice secundário global**
O exemplo a seguir adiciona um índice secundário global à tabela `MusicCollection`.
```
aws dynamodb update-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=AlbumTitle,AttributeType=S \
--global-secondary-index-updates file://gsi-updates.json
```
Conteúdo de `gsi-updates.json`:
```
[
{
"Create": {
"IndexName": "AlbumTitle-index",
"KeySchema": [
{
"AttributeName": "AlbumTitle",
"KeyType": "HASH"
}
],
"ProvisionedThroughput": {
"ReadCapacityUnits": 10,
"WriteCapacityUnits": 10
},
"Projection": {
"ProjectionType": "ALL"
}
}
}
]
```
Resultado:
```
{
"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"
}
]
}
}
```
Para ter mais informações, consulte [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 3: como habilitar o DynamoDB Streams em uma tabela**
O comando a seguir habilita o DynamoDB Streams na tabela `MusicCollection`.
```
aws dynamodb update-table \
--table-name MusicCollection \
--stream-specification StreamEnabled=true,StreamViewType=NEW_IMAGE
```
Resultado:
```
{
"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"
}
}
```
Para ter mais informações, consulte [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) no *Guia do desenvolvedor do Amazon DynamoDB*.
**Exemplo 4: como habilitar a criptografia do lado do servidor**
O exemplo a seguir habilita a criptografia do lado do servidor na tabela `MusicCollection`.
```
aws dynamodb update-table \
--table-name MusicCollection \
--sse-specification Enabled=true,SSEType=KMS
```
Resultado:
```
{
"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"
}
}
}
```
Para ter mais informações, consulte [Updating a Table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.UpdateTable) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Para ter detalhes da API, consulte [UpdateTable](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-table.html) na *Referência de comandos da AWS CLI*.
### `update-time-to-live`
O código de exemplo a seguir mostra como usar `update-time-to-live`.
**AWS CLI**
**Como atualizar as configurações de vida útil de uma tabela**
O exemplo `update-time-to-live` a seguir habilita a vida útil na tabela especificada.
```
aws dynamodb update-time-to-live \
--table-name MusicCollection \
--time-to-live-specification Enabled=true,AttributeName=ttl
```
Resultado:
```
{
"TimeToLiveSpecification": {
"Enabled": true,
"AttributeName": "ttl"
}
}
```
Para obter mais informações, consulte [Vida útil](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html) no *Guia do desenvolvedor do Amazon DynamoDB*.
+ Consulte detalhes da API em [UpdateTimeToLive](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/update-time-to-live.html) na *Referência de comandos da AWS CLI*.