Ejemplos de DynamoDB que utilizan AWS CLI

Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante DynamoDB. AWS Command Line Interface

Las acciones son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.

En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.

Temas

Acciones

Acciones

En el siguiente ejemplo de código, se muestra cómo utilizar batch-get-item.

AWS CLI

Recuperación de varios elementos de una tabla

En el siguiente ejemplo batch-get-items, se leen varios elementos de la tabla MusicCollection mediante un lote de tres solicitudes GetItem y se solicita el número de unidades de capacidad de lectura consumidas por la operación. El comando devuelve solo el atributo AlbumTitle.


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

Contenido 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"
    }
}

Salida:


{
    "Responses": {
        "MusicCollection": [
            {
                "AlbumTitle": {
                    "S": "Somewhat Famous"
                }
            },
            {
                "AlbumTitle": {
                    "S": "Blue Sky Blues"
                }
            },
            {
                "AlbumTitle": {
                    "S": "Louder Than Ever"
                }
            }
        ]
    },
    "UnprocessedKeys": {},
    "ConsumedCapacity": [
        {
            "TableName": "MusicCollection",
            "CapacityUnits": 1.5
        }
    ]
}

Para obtener más información, consulte Operaciones por lotes en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte la Referencia BatchGetItemde AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar batch-write-item.

AWS CLI

Adición de varios elementos a una tabla

En el siguiente ejemplo de batch-write-item, se añaden tres elementos nuevos a la tabla MusicCollection mediante un lote de tres solicitudes PutItem. También solicita información sobre el número de unidades de capacidad de escritura consumidas por la operación y cualquier colección de elementos modificada por la operación.


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

Contenido 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"}
                }
            }
        }
    ]
}

Salida:


{
    "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 obtener más información, consulte Operaciones por lotes en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte BatchWriteItemla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar create-backup.

AWS CLI

Creación de una copia de seguridad de una tabla de DynamoDB existente

En el siguiente ejemplo de create-backup, se crea una copia de seguridad de la tabla MusicCollection.


aws dynamodb create-backup \
    --table-name MusicCollection \
    --backup-name MusicCollectionBackup

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte CreateBackupla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar create-global-table.

AWS CLI

Creación de una tabla global

El siguiente create-global-table ejemplo crea una tabla global a partir de dos tablas idénticas en las AWS regiones separadas especificadas.


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

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte CreateGlobalTablela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar create-table.

AWS CLI

Ejemplo 1: Creación de una tabla con etiquetas

En el siguiente ejemplo create-table, se utilizan los atributos y el esquema de claves especificados para crear una tabla denominada MusicCollection. Esta tabla utiliza el rendimiento aprovisionado y se cifra en reposo mediante la CMK de AWS propiedad predeterminada. El comando también aplica una etiqueta a la tabla, con una clave de Owner y un 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

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: Creación de una tabla en modo bajo demanda

En el siguiente ejemplo, se crea una tabla denominada MusicCollection mediante el modo bajo demanda, en lugar del modo de rendimiento aprovisionado. Esto resulta útil para tablas con cargas de trabajo impredecibles.


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

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: creación de una tabla y cifrarla con una CMK administrada por el cliente

En el siguiente ejemplo, se crea una tabla denominada MusicCollection y se cifra mediante una CMK administrada por el 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

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 4: creación de una tabla con un índice secundario local

En el siguiente ejemplo, se utilizan los atributos y el esquema de claves especificados para crear una tabla denominada MusicCollection con un índice secundario local denominado 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\"]
                }
            }
        ]"

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 5: creación de una tabla con un índice secundario global

En el siguiente ejemplo, se crea una tabla llamada GameScores con un índice secundario global denominado GameTitleIndex. La tabla base tiene una clave de partición de UserId y una clave de ordenación de GameTitle, lo que le permite encontrar eficientemente la mejor puntuación de un usuario individual para un juego específico, mientras que el GSI tiene una clave de partición de GameTitle y una clave de ordenación de TopScore, lo que te permite encontrar rápidamente la puntuación más alta en general para un juego en particular.


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
                }
            }
        ]"

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 6: creación de una tabla con varios índices secundarios globales a la vez

En el siguiente ejemplo, se crea una tabla denominada GameScores con dos índices secundarios globales. Los esquemas GSI se transfieren mediante un archivo, en lugar de hacerlo a través de la línea de comandos.


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

Contenido 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
        }
    }
]

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 7: creación de una tabla que tiene habilitado Streams

En el siguiente ejemplo, se crea una tabla denominada GameScores con DynamoDB Streams habilitado. En el flujo se escribirán tanto las imágenes nuevas como las antiguas de cada elemento.


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

Salida:


{
    "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 obtener más información, consulte Operaciones básicas con tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 8: creación de una tabla con un flujo habilitado solo de claves

En el siguiente ejemplo, se crea una tabla denominada GameScores con DynamoDB Streams habilitado. Solo se escriben en el flujo los atributos de clave del elementos modificados.


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

Salida:


{
    "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 obtener más información, consulte Captura de datos de cambios para DynamoDB Streams en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 9: creación de una tabla mediante la clase de tabla de acceso poco frecuente estándar de DynamoDB

En el siguiente ejemplo se crea una tabla denominada GameScores y asigna la clase de tabla Estándar - Acceso poco frecuente (DynamoDB Standard-IA). Esta clase de tabla está optimizada para que el almacenamiento sea el costo 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

Salida:


{
    "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 obtener más información, consulte Clases de tabla en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 10: creación de una tabla con la protección contra eliminación habilitada

En el siguiente ejemplo, se crea una tabla denominada GameScores y habilita la protección contra eliminación.


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

Salida:


{
    "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 obtener más información, consulte Uso de la protección contra eliminación en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte la Referencia de CreateTablecomandos AWS CLI .

En el siguiente ejemplo de código, se muestra cómo utilizar delete-backup.

AWS CLI

Creación de una copia de seguridad de DynamoDB existente

En el siguiente ejemplo de delete-backup, se elimina una copia de seguridad especificada existente.


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

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DeleteBackupla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-item.

AWS CLI

Ejemplo 1: Eliminación de un elemento

En el siguiente ejemplo delete-item, se elimina un elemento de la tabla MusicCollection y se solicitan detalles sobre el elemento que se ha eliminado y la capacidad utilizada por la solicitud.


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

Contenido de key.json:


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

Salida:


{
    "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 obtener más información, consulte Escritura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: Eliminación de un elemento de forma condicional

En el siguiente ejemplo, se elimina un elemento de la tabla ProductCatalog solo si ProductCategory es Sporting Goods o Gardening Supplies y su precio está comprendido entre 500 y 600. Devuelve detalles sobre el elemento que se ha eliminado.


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

Contenido de names.json:


{
    "#P": "Price"
}

Contenido de values.json:


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

Salida:


{
    "Attributes": {
        "Id": {
            "N": "456"
        },
        "Price": {
            "N": "550"
        },
        "ProductCategory": {
            "S": "Sporting Goods"
        }
    }
}

Para obtener más información, consulte Escritura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DeleteItemla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-table.

AWS CLI

Eliminación de una tabla

En el siguiente ejemplo de delete-table se elimina la tabla MusicCollection.


aws dynamodb delete-table \
    --table-name MusicCollection

Salida:


{
    "TableDescription": {
        "TableStatus": "DELETING",
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableName": "MusicCollection",
        "ProvisionedThroughput": {
            "NumberOfDecreasesToday": 0,
            "WriteCapacityUnits": 5,
            "ReadCapacityUnits": 5
        }
    }
}

Para obtener más información, consulte Eliminación de una tabla en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DeleteTablela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-backup.

AWS CLI

Obtención de información sobre una copia de seguridad existente de una tabla

En el siguiente ejemplo de describe-backup, se muestra información sobre la copia de seguridad existente especificada.


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

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeBackupla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-continuous-backups.

AWS CLI

Obtención de información sobre las copias de seguridad continuas de una tabla de DynamoDB

En el siguiente ejemplo de describe-continuous-backups, se muestran detalles sobre la configuración de copias de seguridad continuas para la tabla MusicCollection.


aws dynamodb describe-continuous-backups \
    --table-name MusicCollection

Salida:


{
    "ContinuousBackupsDescription": {
        "ContinuousBackupsStatus": "ENABLED",
        "PointInTimeRecoveryDescription": {
            "PointInTimeRecoveryStatus": "DISABLED"
        }
    }
}

Para obtener más información, consulte Point-in-Time Recuperación de DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeContinuousBackupsla Referencia de comandos.AWS CLI

En el siguiente ejemplo de código, se muestra cómo utilizar describe-contributor-insights.

AWS CLI

Visualización de la configuración de Contributor Insights de una tabla de DynamoDB

En el siguiente ejemplo de describe-contributor-insights, se muestra la configuración de Contributor Insights para la tabla MusicCollection y el índice secundario global de AlbumTitle-index.


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

Salida:


{
    "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 obtener más información, consulte Análisis del acceso a los datos mediante CloudWatch Contributor Insights for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeContributorInsightsla Referencia de comandos.AWS CLI

En el siguiente ejemplo de código, se muestra cómo utilizar describe-endpoints.

AWS CLI

Visualización de la información de los puntos de conexión regionales

En el siguiente describe-endpoints ejemplo, se muestran detalles sobre los puntos finales de la AWS región actual.


aws dynamodb describe-endpoints

Salida:


{
    "Endpoints": [
        {
            "Address": "dynamodb.us-west-2.amazonaws.com",
            "CachePeriodInMinutes": 1440
        }
    ]
}

Para obtener más información, consulte Amazon DynamoDB Endpoints and Quotas en la Referencia general de AWS .

Para obtener más información sobre la API, consulte DescribeEndpointsla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-global-table-settings.

AWS CLI

Obtención de información sobre la configuración de una tabla global de DynamoDB

En el siguiente ejemplo de describe-global-table-settings, se muestra la configuración de la tabla global de MusicCollection.


aws dynamodb describe-global-table-settings \
    --global-table-name MusicCollection

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeGlobalTableSettingsla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-global-table.

AWS CLI

Visualización de información sobre una tabla global de DynamoDB

En el siguiente ejemplo de describe-global-table, se muestran detalles sobre la tabla global de MusicCollection.


aws dynamodb describe-global-table \
    --global-table-name MusicCollection

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeGlobalTablela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-limits.

AWS CLI

Visualización de los límites de capacidad aprovisionada

En el siguiente describe-limits ejemplo, se muestran los límites de capacidad aprovisionada de tu cuenta en la región actual AWS .


aws dynamodb describe-limits

Salida:


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

Para obtener más información, consulte Límites en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte la Referencia DescribeLimitsde AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-table-replica-auto-scaling.

AWS CLI

Visualización de la configuración de escalado automático en las réplicas de una tabla global

En el siguiente ejemplo de describe-table-replica-auto-scaling, se muestra la configuración de escalado automático en todas las réplicas de la tabla global de MusicCollection.


aws dynamodb describe-table-replica-auto-scaling \
    --table-name MusicCollection

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeTableReplicaAutoScalingla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-table.

AWS CLI

Descripción de una tabla

En el siguiente ejemplo describe-table, se describe la tabla MusicCollection.


aws dynamodb describe-table \
    --table-name MusicCollection

Salida:


{
    "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 obtener más información, consulte Descripción de una tabla en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeTablela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-time-to-live.

AWS CLI

Visualización de la configuración de tiempo de vida de una tabla

En el siguiente ejemplo de describe-time-to-live, se muestra la configuración de tiempo de vida de la tabla MusicCollection.


aws dynamodb describe-time-to-live \
    --table-name MusicCollection

Salida:


{
    "TimeToLiveDescription": {
        "TimeToLiveStatus": "ENABLED",
        "AttributeName": "ttl"
    }
}

Para obtener más información, consulte Tiempo de vida en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte DescribeTimeToLivela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar get-item.

AWS CLI

Ejemplo 1: Lectura de un elemento de una tabla

En el siguiente ejemplo get-item, se recupera un elemento de la tabla MusicCollection. La tabla tiene una clave hash-and-range principal (ArtistySongTitle), por lo que debes especificar estos dos atributos. El comando también solicita información sobre la capacidad de lectura consumida por la operación.


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

Contenido de key.json:


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

Salida:


{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}

Para obtener más información, consulte Lectura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: Lectura de un elemento mediante una lectura coherente

En el siguiente ejemplo, se recupera un elemento de la tabla MusicCollection con lecturas altamente coherentes.


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

Contenido de key.json:


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

Salida:


{
    "Item": {
        "AlbumTitle": {
            "S": "Songs About Life"
        },
        "SongTitle": {
            "S": "Happy Day"
        },
        "Artist": {
            "S": "Acme Band"
        }
    },
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    }
}

Para obtener más información, consulte Lectura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: recuperación de atributos específicos de un elemento

En el siguiente ejemplo, se utiliza una expresión de proyección para recuperar solo tres atributos del elemento deseado.


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

Contenido de names.json:


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

Salida:


{
    "Item": {
        "Price": {
            "N": "20"
        },
        "Title": {
            "S": "Book 102 Title"
        },
        "ProductCategory": {
            "S": "Book"
        }
    }
}

Para obtener más información, consulte Lectura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte GetItemla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar list-backups.

AWS CLI

Ejemplo 1: enumerar todas las copias de seguridad de DynamoDB existentes

En el siguiente ejemplo de list-backups, se enumeran todas sus copias de seguridad existentes.


aws dynamodb list-backups

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: lista de las copias de seguridad creadas por los usuarios en un intervalo de tiempo específico

En el siguiente ejemplo, se muestran solo las copias de seguridad de la tabla MusicCollection que ha creado el usuario (no las que DynamoDB ha creado automáticamente) con una fecha de creación entre el 1 de enero de 2020 y el 1 de marzo de 2020.


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

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: limitación del tamaño de la página

En el siguiente ejemplo, se devuelve una lista de todas las copias de seguridad existentes, pero recupera solo un elemento en cada llamada y, si es necesario, realiza varias llamadas para obtener la lista completa. Limitar el tamaño de página resulta útil cuando se ejecutan comandos de la lista en un gran número de recursos, lo que puede provocar un error de “tiempo de espera” cuando se utiliza el tamaño de página predeterminado de 1000.


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

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 4: limitación del número de elementos devueltos

En el siguiente ejemplo, se limita el número de elementos devueltos a 1. La respuesta incluye un valor NextToken con el que recuperar la siguiente página de resultados.


aws dynamodb list-backups \
    --max-items 1

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 5: recuperar la siguiente página de resultados

El comando siguiente utiliza el valor NextToken de una llamada anterior al comando list-backups para recuperar otra página de resultados. Puesto que la respuesta en este caso no incluye ningún valor NextToken, sabemos que hemos llegado al final de los 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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte ListBackupsla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar list-contributor-insights.

AWS CLI

Ejemplo 1: ver una lista de resúmenes de Contributor Insights

En el siguiente ejemplo de list-contributor-insights, se muestra una lista de resúmenes de Contributor Insights.


aws dynamodb list-contributor-insights

Salida:


{
    "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 obtener más información, consulte Análisis del acceso a los datos mediante CloudWatch Contributor Insights for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: limitación del número de elementos devueltos

En el siguiente ejemplo, se limita el número de filas devueltas a cuatro. La respuesta incluye un valor NextToken con el que recuperar la siguiente página de resultados.


aws dynamodb list-contributor-insights \
    --max-results 4

Salida:


{
    "ContributorInsightsSummaries": [
        {
            "TableName": "MusicCollection",
            "IndexName": "AlbumTitle-index",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "ProductCatalog",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Forum",
            "ContributorInsightsStatus": "ENABLED"
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Para obtener más información, consulte Análisis del acceso a los datos mediante CloudWatch Contributor Insights for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: recuperar la siguiente página de resultados

El comando siguiente utiliza el valor NextToken de una llamada anterior al comando list-contributor-insights para recuperar otra página de resultados. Puesto que la respuesta en este caso no incluye ningún valor NextToken, sabemos que hemos llegado al final de los resultados.


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

Salida:


{
    "ContributorInsightsSummaries": [
        {
            "TableName": "Reply",
            "ContributorInsightsStatus": "ENABLED"
        },
        {
            "TableName": "Thread",
            "ContributorInsightsStatus": "ENABLED"
        }
    ]
}

Para obtener más información, consulte Análisis del acceso a los datos mediante CloudWatch Contributor Insights for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte ListContributorInsightsla Referencia de comandos.AWS CLI

En el siguiente ejemplo de código, se muestra cómo utilizar list-global-tables.

AWS CLI

Para enumerar las tablas globales de DynamoDB existentes

En el siguiente ejemplo de list-global-tables, se enumeran todas sus tablas globales existentes.


aws dynamodb list-global-tables

Salida:


{
    "GlobalTables": [
        {
            "GlobalTableName": "MusicCollection",
            "ReplicationGroup": [
                {
                    "RegionName": "us-east-2"
                },
                {
                    "RegionName": "us-east-1"
                }
            ]
        }
    ]
}

Para obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte ListGlobalTablesla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar list-tables.

AWS CLI

Ejemplo 1: Creación de una lista de tablas

En el siguiente list-tables ejemplo, se enumeran todas las tablas asociadas a la AWS cuenta corriente y a la región.


aws dynamodb list-tables

Salida:


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

Para obtener más información, consulte Enumeración de nombres de tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: Limitación del tamaño de la página

En el siguiente ejemplo, se devuelve una lista de todas las tablas existentes, pero recupera solo un elemento en cada llamada y, si es necesario, realiza varias llamadas para obtener la lista completa. Limitar el tamaño de página resulta útil cuando se ejecutan comandos de la lista en un gran número de recursos, lo que puede provocar un error de “tiempo de espera” cuando se utiliza el tamaño de página predeterminado de 1000.


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

Salida:


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

Para obtener más información, consulte Enumeración de nombres de tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: limitación del número de elementos devueltos

En el siguiente ejemplo, se limita el número de elementos devueltos a 2. La respuesta incluye un valor NextToken con el que recuperar la siguiente página de resultados.


aws dynamodb list-tables \
    --max-items 2

Salida:


{
    "TableNames": [
        "Forum",
        "ProductCatalog"
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Para obtener más información, consulte Enumeración de nombres de tablas en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 4: recuperación de la siguiente página de resultados

El comando siguiente utiliza el valor NextToken de una llamada anterior al comando list-tables para recuperar otra página de resultados. Puesto que la respuesta en este caso no incluye ningún valor NextToken, sabemos que hemos llegado al final de los resultados.


aws dynamodb list-tables \
    --starting-token abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9

Salida:


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

Para obtener más información, consulte Enumeración de nombres de tablas en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte ListTablesla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar list-tags-of-resource.

AWS CLI

Ejemplo 1: enumerar las etiquetas de un recurso de DynamoDB

En el siguiente ejemplo de list-tags-of-resource, se muestran las etiquetas de la tabla MusicCollection.


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

Salida:


{
    "Tags": [
        {
            "Key": "Owner",
            "Value": "blueTeam"
        },
        {
            "Key": "Environment",
            "Value": "Production"
        }
    ]
}

Para obtener más información, consulte Etiquetado para DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: limitación del número de etiquetas devueltas

En el siguiente ejemplo, se limita el número de etiquetas devueltas a 1. La respuesta incluye un valor NextToken con el que recuperar la siguiente página de resultados.


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

Salida:


{
    "Tags": [
        {
            "Key": "Owner",
            "Value": "blueTeam"
        }
    ],
    "NextToken": "abCDeFGhiJKlmnOPqrSTuvwxYZ1aBCdEFghijK7LM51nOpqRSTuv3WxY3ZabC5dEFGhI2Jk3LmnoPQ6RST9"
}

Para obtener más información, consulte Etiquetado para DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: recuperar la siguiente página de resultados

El comando siguiente utiliza el valor NextToken de una llamada anterior al comando list-tags-of-resource para recuperar otra página de resultados. Puesto que la respuesta en este caso no incluye ningún valor NextToken, sabemos que hemos llegado al final de los resultados.


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

Salida:


{
    "Tags": [
        {
            "Key": "Environment",
            "Value": "Production"
        }
    ]
}

Para obtener más información, consulte Etiquetado para DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte ListTagsOfResourcela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar put-item.

AWS CLI

Ejemplo 1: Adición de un elemento a una tabla

En el siguiente put-item ejemplo, se agrega un elemento nuevo a la MusicCollectiontabla.


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

Contenido de item.json:


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

Salida:


{
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    },
    "ItemCollectionMetrics": {
        "ItemCollectionKey": {
            "Artist": {
                "S": "No One You Know"
            }
        },
        "SizeEstimateRangeGB": [
            0.0,
            1.0
        ]
    }
}

Para obtener más información, consulte Escritura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: Sobrescritura condicional de un elemento de una tabla

En el siguiente ejemplo de put-item se sobrescribe un elemento existente de la tabla MusicCollection solo si ese elemento existente tiene un atributo AlbumTitle con un valor de Greatest Hits. El comando devuelve el valor anterior del elemento.


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

Contenido de item.json:


{
    "Artist": {"S": "No One You Know"},
    "SongTitle": {"S": "Call Me Today"},
    "AlbumTitle": {"S": "Somewhat Famous"}
}

Contenido de names.json:


{
    "#A": "AlbumTitle"
}

Contenido de values.json:


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

Salida:


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

Si la clave ya existe, debería ver el siguiente resultado:


A client error (ConditionalCheckFailedException) occurred when calling the PutItem operation: The conditional request failed.

Para obtener más información, consulte Escritura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte PutItemla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar query.

AWS CLI

Ejemplo 1: Consulta de una tabla

En el siguiente ejemplo de query se consultan elementos de la tabla MusicCollection. La tabla tiene una clave hash-and-range principal (ArtistySongTitle), pero esta consulta solo especifica el valor de la clave hash. Devuelve los títulos de las canciones del artista llamado “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

Contenido de expression-attributes.json:


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

Salida:


{
    "Items": [
        {
            "SongTitle": {
                "S": "Call Me Today"
            },
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 0.5
    }
}

Para obtener más información, consulte Uso de consultas en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: Consulta de una tabla con lecturas altamente coherentes y recorrer el índice en orden descendente

En el siguiente ejemplo se realiza la misma consulta que en el primer ejemplo, pero se devuelven los resultados en orden inverso y se utilizan lecturas altamente coherentes.


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

Contenido de expression-attributes.json:


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

Salida:


{
    "Items": [
        {
            "SongTitle": {
                "S": "Scared of My Shadow"
            }
        },
        {
            "SongTitle": {
                "S": "Call Me Today"
            }
        }
    ],
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": {
        "TableName": "MusicCollection",
        "CapacityUnits": 1.0
    }
}

Para obtener más información, consulte Uso de consultas en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: filtrado de resultados específicos

En el siguiente ejemplo se consulta MusicCollection pero se excluyen los resultados con valores específicos en el atributo AlbumTitle. Tenga en cuenta que esto no afecta a ScannedCount o ConsumedCapacity, ya que el filtro se aplica después de leer los elementos.


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

Contenido de values.json:


{
    ":v1": {"S": "No One You Know"},
    ":v2": {"S": "Blue Sky Blues"},
    ":v3": {"S": "Greatest Hits"}
}

Contenido de names.json:


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

Salida:


{
    "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 obtener más información, consulte Uso de consultas en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 4: Recuperación de un solo recuento de elementos

En el siguiente ejemplo, se recupera un recuento de los elementos que coinciden con la consulta, pero no recupera ninguno de los elementos en sí.


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

Contenido de expression-attributes.json:


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

Salida:


{
    "Count": 2,
    "ScannedCount": 2,
    "ConsumedCapacity": null
}

Para obtener más información, consulte Uso de consultas en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 5: consulta de un índice

El siguiente ejemplo consulta el índice secundario global AlbumTitleIndex. La consulta devuelve todos los atributos de la tabla base que se han proyectado en el índice secundario local. Tenga en cuenta que, al consultar un índice secundario local o un índice secundario global, también debe proporcionar el nombre de la tabla base mediante el 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

Contenido de expression-attributes.json:


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

Salida:


{
    "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 obtener más información, consulte Uso de consultas en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener información sobre la API, consulte Query en la Referencia de comandos de la AWS CLI .

En el siguiente ejemplo de código, se muestra cómo utilizar restore-table-from-backup.

AWS CLI

Creación de una tabla de DynamoDB a partir de una copia de seguridad existente

En el siguiente ejemplo de restore-table-from-backup, se restaura la tabla especificada a partir de una copia de seguridad existente.


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

Salida:


{
    "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 obtener más información, consulte On-Demand Backup and Restore for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte RestoreTableFromBackupla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar restore-table-to-point-in-time.

AWS CLI

Restauración de una tabla de DynamoDB a un momento específico

En el siguiente ejemplo de restore-table-to-point-in-time, se restaura la tabla MusicCollection al momento especificado.


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

Salida:


{
    "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 obtener más información, consulte Point-in-Time Recuperación de DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte RestoreTableToPointInTimela Referencia de comandos.AWS CLI

En el siguiente ejemplo de código, se muestra cómo utilizar scan.

AWS CLI

Análisis de una tabla

En el siguiente ejemplo de scan se escanea toda la tabla MusicCollection y, a continuación, se reducen los resultados a las canciones del artista “No One You Know”. Para cada elemento, solo se devuelven el título del álbum y el título de la canción.


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

Contenido de expression-attribute-names.json:


{
    "#ST": "SongTitle",
    "#AT":"AlbumTitle"
}

Contenido de expression-attribute-values.json:


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

Salida:


{
    "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 obtener más información, consulte Uso de operaciones de análisis en DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener información sobre la API, consulte Scan en la Referencia de comandos de la AWS CLI .

En el siguiente ejemplo de código, se muestra cómo utilizar tag-resource.

AWS CLI

Adición de etiquetas a un recurso de DynamoDB

En el siguiente tag-resource ejemplo, se agrega un key/value par de etiquetas a la MusicCollection tabla.


aws dynamodb tag-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --tags Key=Owner,Value=blueTeam

Este comando no genera ninguna salida.

Para obtener más información, consulte Etiquetado para DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte TagResourcela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar transact-get-items.

AWS CLI

Recuperación de varios elementos de manera granular de una o más tablas

En el siguiente ejemplo de transact-get-items, se recuperan varios elementos de manera granular.


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

Contenido 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"
        }
    }
]

Salida:


{
    "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 obtener más información, consulte Administración de flujos de trabajo complejos con transacciones de DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte TransactGetItemsla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar transact-write-items.

AWS CLI

Ejemplo 1: escritura de elementos de manera granular en una o más tablas

En el siguiente ejemplo de transact-write-items, se actualiza un elemento y se elimina otro. La operación da error si alguna de las operaciones falla o si alguno de los elementos contiene un atributo Rating.


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

Contenido del archivo 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)"
        }
    }
]

Salida:


{
    "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 obtener más información, consulte Administración de flujos de trabajo complejos con transacciones de DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: cómo escribir elementos de manera granular mediante un token de solicitud del cliente

El siguiente comando usa un token de solicitud de cliente para hacer que la llamada a transact-write-items sea idempotente, lo que significa que la llamada produce el mismo resultado tanto si se ejecuta una como varias veces.


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

Contenido del archivo 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 no genera ninguna salida.

Para obtener más información, consulte Administración de flujos de trabajo complejos con transacciones de DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte TransactWriteItemsla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar untag-resource.

AWS CLI

Eliminación de una etiqueta de un recurso de DynamoDB

En el siguiente ejemplo de untag-resource, se elimina la etiqueta con la clave Owner de la tabla MusicCollection.


aws dynamodb untag-resource \
    --resource-arn arn:aws:dynamodb:us-west-2:123456789012:table/MusicCollection \
    --tag-keys Owner

Este comando no genera ninguna salida.

Para obtener más información, consulte Etiquetado para DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UntagResourcela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar update-continuous-backups.

AWS CLI

Actualización de la configuración de copia de seguridad continua de una tabla de DynamoDB

El siguiente update-continuous-backups ejemplo permite point-in-time la recuperación de la MusicCollection tabla.


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

Salida:


{
    "ContinuousBackupsDescription": {
        "ContinuousBackupsStatus": "ENABLED",
        "PointInTimeRecoveryDescription": {
            "PointInTimeRecoveryStatus": "ENABLED",
            "EarliestRestorableDateTime": 1576622404.0,
            "LatestRestorableDateTime": 1576622404.0
        }
    }
}

Para obtener más información, consulte Point-in-Time Recuperación de DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateContinuousBackupsla Referencia de comandos.AWS CLI

En el siguiente ejemplo de código, se muestra cómo utilizar update-contributor-insights.

AWS CLI

Habilitación de Contributor Insights en una tabla

En el siguiente ejemplo de update-contributor-insights, se habilita la configuración de Contributor Insights para la tabla MusicCollection y el índice secundario global de AlbumTitle-index.


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

Salida:


{
    "TableName": "MusicCollection",
    "IndexName": "AlbumTitle-index",
    "ContributorInsightsStatus": "ENABLING"
}

Para obtener más información, consulte Análisis del acceso a los datos mediante CloudWatch Contributor Insights for DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateContributorInsightsla Referencia de comandos.AWS CLI

En el siguiente ejemplo de código, se muestra cómo utilizar update-global-table-settings.

AWS CLI

Actualización de la configuración de la capacidad de escritura aprovisionada en una tabla global de DynamoDB

El siguiente ejemplo de update-global-table-settings, se establece la capacidad de escritura aprovisionada de la tabla global MusicCollection en 15.


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

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateGlobalTableSettingsla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar update-global-table.

AWS CLI

Actualización de una tabla global de DynamoDB

En el siguiente ejemplo de update-global-table, se agrega una réplica de la región especificada a la tabla global MusicCollection.


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

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateGlobalTablela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar update-item.

AWS CLI

Ejemplo 1: Actualización de un elemento de una tabla

En el siguiente ejemplo de update-item, se actualiza un elemento de la tabla MusicCollection. Añade un nuevo atributo (Year) y modifica el atributo AlbumTitle. En la respuesta se muestran todos los atributos del elemento, tal como aparecen después de la actualización.


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

Contenido de key.json:


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

Contenido de expression-attribute-names.json:


{
    "#Y":"Year", "#AT":"AlbumTitle"
}

Contenido de expression-attribute-values.json:


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

Salida:


{
    "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 obtener más información, consulte Escritura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 2: actualización de un elemento de forma condicional

En el siguiente ejemplo se actualiza un elemento de la tabla MusicCollection, pero solo si el elemento existente aún no tiene un 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)"

Contenido de key.json:


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

Contenido de expression-attribute-names.json:


{
    "#Y":"Year",
    "#AT":"AlbumTitle"
}

Contenido de expression-attribute-values.json:


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

Si el elemento ya tiene un atributo Year, DynamoDB devuelve el siguiente resultado.


An error occurred (ConditionalCheckFailedException) when calling the UpdateItem operation: The conditional request failed

Para obtener más información, consulte Escritura de un elemento en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateItemla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar update-table-replica-auto-scaling.

AWS CLI

Actualización de la configuración de escalado automático en las réplicas de una tabla global

En el siguiente ejemplo de update-table-replica-auto-scaling, se actualiza la configuración de escalado automático de la capacidad en todas las réplicas de la tabla global especificada.


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

Contenido de auto-scaling-policy.json:


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

Salida:


{
    "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 obtener más información, consulte Tablas globales de Amazon DynamoDB en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateTableReplicaAutoScalingla Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar update-table.

AWS CLI

Ejemplo 1: modificar el modo de facturación de una tabla

El siguiente ejemplo de update-table aumenta la capacidad de lectura y escritura aprovisionada en la tabla MusicCollection.


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

Salida:


{
    "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 obtener más información, consulte Actualización de una tabla en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 5: crear un índice secundario global

En el siguiente ejemplo se añade un índice secundario global a la tabla MusicCollection.


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

Contenido de gsi-updates.json:


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

Salida:


{
    "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 obtener más información, consulte Actualización de una tabla en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 3: activar DynamoDB Streams en una tabla

El siguiente comando activa DynamoDB Streams en la tabla MusicCollection.


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

Salida:


{
    "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 obtener más información, consulte Actualización de una tabla en la Guía para desarrolladores de Amazon DynamoDB.

Ejemplo 4: activar el cifrado en el lado del servidor

El siguiente ejemplo activa el cifrado del lado del servidor en la tabla MusicCollection.


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

Salida:


{
    "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 obtener más información, consulte Actualización de una tabla en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateTablela Referencia de AWS CLI comandos.

En el siguiente ejemplo de código, se muestra cómo utilizar update-time-to-live.

AWS CLI

Actualización de la configuración de tiempo de vida en una tabla

El siguiente ejemplo de update-time-to-live activa Tiempo de vida en la tabla especificada.


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

Salida:


{
    "TimeToLiveSpecification": {
        "Enabled": true,
        "AttributeName": "ttl"
    }
}

Para obtener más información, consulte Tiempo de vida en la Guía para desarrolladores de Amazon DynamoDB.

Para obtener más información sobre la API, consulte UpdateTimeToLivela Referencia de AWS CLI comandos.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Amazon DocumentDB

DynamoDB Streams