AWS Cloud9 ya no está disponible para nuevos clientes. Los clientes existentes de AWS Cloud9 pueden seguir utilizando el servicio con normalidad. [Más información](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial de Amazon DynamoDB para AWS Cloud9
Este tutorial le permite configurar un entorno de AWS Cloud9 desarrollo para trabajar con Amazon DynamoDB.
DynamoDB es una base de datos NoSQL completamente administrada. Puede utilizar DynamoDB para crear una tabla de base de datos capaz de almacenar y recuperar cualquier cantidad de datos, así como de atender cualquier nivel de tráfico de solicitudes. DynamoDB distribuye automáticamente los datos y el tráfico de la tabla entre un número de servidores suficiente como para administrar la capacidad de solicitudes especificada y la cantidad de datos almacenados, manteniendo al mismo tiempo un rendimiento uniforme y rápido. Para obtener más información, consulte [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) en el sitio web. AWS
La creación de este ejemplo puede conllevar cargos a su cuenta. AWS Estos incluyen posibles cargos por servicios como Amazon EC2 y DynamoDB. Para obtener más información, consulte [Precios de Amazon EC2](https://aws.amazon.com/ec2/pricing/) y [Precios de Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Para obtener información sobre ofertas AWS de bases de datos adicionales, consulte [Amazon Relational Database Service (RDS](https://aws.amazon.com/rds/)) [ ElastiCache,](https://aws.amazon.com/elasticache/) [Amazon y Amazon Redshift](https://aws.amazon.com/redshift/) en el sitio web. AWS Consulte también [AWS Database Migration Service](https://aws.amazon.com/dms/) en el sitio web de AWS .
+ [Requisitos previos](#sample-dynamodb-prereqs)
+ [Paso 1: instalar y configurar la AWS CLI, el AWS CloudShell o ambos en el entorno](#sample-dynamodb-cli-setup)
+ [Paso 2: crear una tabla](#sample-dynamodb-create-table)
+ [Paso 3 agregar un elemento a la tabla](#sample-dynamodb-add-item)
+ [Paso 4: agregar varios elementos a la tabla](#sample-dynamodb-add-items)
+ [Paso 5: crear un índice secundario global](#sample-dynamodb-create-index)
+ [Paso 6: obtener elementos de la tabla](#sample-dynamodb-get-items)
+ [Paso 7: limpieza](#sample-dynamodb-clean-up)
## Requisitos previos
Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:
+ **Debe tener un entorno de desarrollo AWS Cloud9 EC2 existente.** En este ejemplo, se da por hecho que ya tiene un entorno de EC2 que está conectado a una instancia de Amazon EC2 que ejecuta Amazon Linux o Ubuntu Server. Si tiene otro tipo de entorno o sistema operativo, es posible que tenga que adaptar las instrucciones de este ejemplo para configurar herramientas relacionadas. Para obtener más información, consulte [Crear un entorno en AWS Cloud9](create-environment.md).
+ **Ya tiene abierto el AWS Cloud9 IDE del entorno existente.** Al abrir un entorno, AWS Cloud9 abre el IDE de ese entorno en el navegador web. Para obtener más información, consulte [Abrir un entorno en AWS Cloud9](open-environment.md).
## Paso 1: Instale y configure el AWS CLI AWS CloudShell, el o ambos en su entorno
En este paso, utilizará el AWS Cloud9 IDE para instalar y configurar el entorno AWS CLI AWS CloudShell, o ambos, de forma que pueda ejecutar comandos para interactuar con DynamoDB. A continuación, utilice AWS CLI para ejecutar un comando de DynamoDB básico para probar la instalación y la configuración.
1. Para configurar la administración de credenciales AWS CloudShell e instalar el AWS CLI, el AWS CLI o ambos en su entorno AWS CloudShell, siga los pasos 1 y 2 del [AWS CLIAWS CloudShell ejemplo](sample-aws-cli.md) y y, a continuación, vuelva a este tema. Si ya instaló y configuró el AWS CLI AWS CloudShell, el o ambos en su entorno, no necesita volver a hacerlo.
1. Pruebe la instalación y la configuración del AWS CLI aws-shell o de ambos ejecutando el **`list-tables`**comando DynamoDB desde una sesión de terminal de su entorno para enumerar las tablas de DynamoDB existentes, si las hubiera. Para comenzar una nueva sesión de terminal, en la barra de menús, seleccione **Windows (Ventanas)**, **New Terminal (Nuevo terminal)**.
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**nota**
En este ejemplo, si está utilizando el aws-shell, omita `aws` de cada comando que comience por `aws`. Para iniciar el shell de AWS, ejecute el comando ** `aws-shell` **. Para dejar de usar el shell de AWS, ejecute el comando ** `.exit` ** o ** `.quit` **.
Si este comando se ejecuta correctamente, genera una matriz `TableNames` que contiene una lista de tablas de DynamoDB existentes que es posible que ya tenga. Si no tiene aún tablas de DynamoDB, la matriz de `TableNames` estará vacía.
```
{
"TableNames": []
}
```
Si tiene cualquier tabla de DynamoDB, la matriz de `TableNames` contiene una lista de los nombres de las tablas.
## Paso 2: Crear una tabla
En este paso, se crea una tabla en DynamoDB y se especifica el nombre de la tabla, el diseño, la clave principal simple y la configuración de rendimiento de los datos.
Esta tabla de ejemplo, denominada `Weather`, contiene información acerca de las previsiones meteorológicas para algunas ciudades de Estados Unidos. La tabla contiene los siguientes tipos de información (en DynamoDB, cada fragmento de información se denomina *atributo*):
+ ID único y obligatorio de la ciudad (`CityID`)
+ Fecha de previsión obligatoria (`Date`)
+ Nombre de ciudad (`City`)
+ Nombre de estado (`State`)
+ Condiciones meteorológicas de la previsión (`Conditions`)
+ Temperaturas de la previsión (`Temperatures`)
+ Temperatura máxima de la previsión, en grados Fahrenheit (`HighF`)
+ Temperatura mínima de la previsión, en grados Fahrenheit (`LowF`)
Para crear la tabla, en una sesión de terminal en el AWS Cloud9 IDE, ejecute el comando **`create-table`**DynamoDB.
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
En este comando:
+ `--table-name` representa el nombre de la tabla (`Weather` en este ejemplo). Los nombres de las tablas deben ser únicos en cada AWS región de la cuenta. AWS
+ `--attribute-definitions` representa los atributos que se utilizan para identificar de forma única los elementos de la tabla. Cada uno de los elementos de esta tabla se identifica de forma única por medio de una combinación de un atributo `ID` numérico y un atributo `Date` representado como una cadena con formato ISO-8601.
+ `--key-schema` representa el esquema de claves de la tabla. Esta tabla tiene una clave principal compuesta de `CityID` y `Date`. Esto significa que cada uno de los elementos de la tabla debe tener un valor de atributo `CityID` y un valor de atributo `Date`, pero no puede haber dos elementos de la tabla que tengan el mismo valor de atributo `CityID` y valor de atributo `Date`.
+ `--provisioned-throughput` representa la capacidad de lectura-escritura de la tabla. DynamoDB permite hasta 5 lecturas de alta consistencia por segundo para elementos de hasta 4 KB de tamaño o hasta 5 lecturas eventualmente consistentes por segundo para los elementos de hasta 4 KB de tamaño. DynamoDB también permite hasta 5 escrituras por segundo para los elementos con un tamaño de hasta 1 KB.
**nota**
Si se establece un mayor rendimiento aprovisionado, es posible que se apliquen cargos adicionales a tu AWS cuenta.
Para obtener más información acerca de este comando y otros comandos de DynamoDB, consulte [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html), en la *Referencia de comandos de AWS CLI *.
Si este comando se ejecuta correctamente, se muestra información resumida sobre la tabla nueva que se está creando. Para confirmar que la tabla se ha creado correctamente, ejecute el comando ** `describe-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Cuando la tabla se crea correctamente, el valor de `TableStatus` cambia de `CREATING` a `ACTIVE`. No siga realizando los pasos hasta que la tabla se haya creado correctamente.
## Paso 3: Agregar un elemento a la tabla
En este paso, se añade un elemento a la tabla que se acaba de crear.
1. Cree un archivo llamado `weather-item.json` con el siguiente contenido. Para crear un archivo nuevo, en la barra de menús, elija **File (Archivo)**, **New File (Nuevo archivo)**. Para guardar el archivo, elija **File (Archivo)**, **Save (Guardar)**.
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
En este código, `N` representa un valor de atributo que es un número. `S` es un valor de atributo de cadena. `M` es un atributo de mapa, que es un conjunto de pares de atributo-valor. Debe especificar un tipo de datos del atributo siempre que trabaje con elementos. Para obtener tipos de datos de atributos disponibles adicionales, consulte [Tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) en la *Guía para desarrolladores de Amazon DynamoDB*.
1. Ejecute el comando ** `put-item` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`) y la ruta del elemento con formato JSON (`--item`).
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
Si el comando se ejecuta correctamente, no habrá errores y no aparecerá ningún mensaje de confirmación.
1. Para confirmar el contenido actual de la tabla, ejecute el comando ** `scan` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb scan --table-name Weather
```
Si el comando se ejecuta correctamente, aparece la información resumida sobre la tabla y el elemento que acaba de agregar.
## Paso 4: Agregar varios elementos a la tabla
En este paso, agregamos varios elementos más a la tabla `Weather`.
1. Cree un archivo llamado `more-weather-items.json` con el siguiente contenido.
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
En este código, hay 8 objetos `Item` que definen los 8 elementos que se van a añadir a la tabla, de forma similar al elemento único que se ha definido en el paso anterior. Sin embargo, al ejecutar el comando ** `batch-write-item` ** de DynamoDB en el siguiente paso, debe proporcionar un objeto con formato JSON que incluya cada uno de los objetos `Item` en un objeto `PutRequest` contenedor. A continuación, debe incluir esos objetos `PutRequest` en una matriz principal que tenga el mismo nombre que la tabla.
1. Ejecute el comando ** `batch-write-item` ** de DynamoDB y especifique la ruta de los elementos con formato JSON que se van a agregar (`--request-items`).
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
Si el comando se ejecuta correctamente, se muestra el siguiente mensaje, que confirma que los elementos se han agregado correctamente.
```
{
"UnprocessedItems": {}
}
```
1. Para confirmar el contenido actual de la tabla, ejecute de nuevo el comando ** `scan` ** de DynamoDB.
```
aws dynamodb scan --table-name Weather
```
Si el comando se ejecuta correctamente, ahora se muestran 9 elementos.
## Paso 5: Crear un índice secundario global
La ejecución del comando ** `scan` ** de DynamoDB para obtener información sobre elementos puede ser lenta, especialmente cuando la tabla aumenta de tamaño o si el tipo de información que desea obtener es complejo. Puede crear uno o varios índices secundarios para acelerar las cosas y obtener información más fácilmente. En este paso, conocerá dos tipos de índices secundarios que DynamoDB admite para hacer precisamente eso. Se denominan *índice secundario local* e *índice secundario global*. A continuación, se crea un índice secundario global.
Para comprender estos tipos de índices secundarios, primero debe conocer las claves primarias, que identifican de forma única los elementos de una tabla. DynamoDB admite una *clave principal simple* o una *clave principal compuesta*. Una clave principal simple posee un único atributo y ese valor del atributo debe ser único para cada elemento de la tabla. Este atributo también se conoce como *clave de partición* (o un *atributo hash*), que DynamoDB puede utilizar para particionar elementos para que el acceso sea más rápido. Una tabla también puede tener una clave principal compuesta, que contiene dos atributos. El primer atributo es la clave de partición y el segundo es una *clave de ordenación* (también conocida como *atributo de rango*). En una tabla con una clave principal compuesta, puede haber dos elementos que tengan el mismo valor de clave de partición, pero no pueden tener también el mismo valor de clave de ordenación. La tabla `Weather` tiene una clave principal compuesta.
Un índice secundario local tiene la misma clave de partición que la propia tabla, pero este tipo de índice puede tener una clave de ordenación diferente. Un índice secundario global puede tener una clave de partición y una clave de ordenación que son diferentes a la tabla en sí.
Por ejemplo, ya puede utilizar la clave principal para obtener acceso a elementos `Weather` por `CityID`. Para obtener acceso a los elementos `Weather` por `State`, puede crear un índice secundario local que tenga una clave de partición de `CityID` (debe ser la misma que la tabla) y una clave de ordenación de `State`. Para obtener acceso a los elementos `Weather` por `City`, puede crear un índice secundario global que tenga una clave de partición de `City` y una clave de ordenación de `Date`.
Solo puede crear índices secundarios locales mientras está creando una tabla. Dado que la tabla `Weather` ya existe, no puede añadirle cualquier índice secundario local. Sin embargo, puede añadir índices secundarios globales. Añada uno ahora para practicar.
**nota**
La creación de índices secundarios puede producir cargos adicionales en su cuenta de AWS .
1. Cree un archivo llamado `weather-global-index.json` con el siguiente contenido.
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
En este código:
+ El nombre del índice secundario global es `weather-global-index`.
+ El atributo `City` es la clave de partición (atributo hash) y el atributo `Date` es la clave de ordenación (atributo de rango).
+ `Projection` define los atributos que se van a recuperar de forma predeterminada (además del atributo hash y cualquier atributo de rango) por cada elemento que coincida con una búsqueda de tabla que utilice este índice. En este ejemplo, se recuperan los atributos`State`, `Conditions`, `HighF` (parte de `Temperatures`) y `LowF` ( `Temperatures`) (así como los atributos `City` y `Date`) para cada elemento coincidente.
+ Al igual que las tablas, un índice secundario global debe definir su configuración de desempeño aprovisionado.
+ La configuración de `IndexName`, `KeySchema`, `Projection` y `ProvisionedThroughput` debe estar incluida en un objeto `Create`, que define el índice secundario global que se va a crear al ejecutar el comando **`update-table`** de DynamoDB en el siguiente paso.
1. Ejecute el comando ** `update-table` ** de DynamoDB.
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
En este comando:
+ `--table-name` es el nombre de la tabla que se va a actualizar.
+ `--attribute-definitions` son los atributos que se van a incluir en el índice. La clave de partición siempre aparece primero y cualquier clave de ordenación aparece siempre en segundo lugar.
+ `--global-secondary-index-updates` es la ruta al archivo que define el índice secundario global.
Si este comando se ejecuta correctamente, se muestra información resumida sobre el nuevo índice secundario global que se está creando. Para confirmar que el índice secundario global se ha creado correctamente, ejecute el comando ** `describe-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Cuando el índice secundario global se haya creado correctamente, el valor de `TableStatus` cambia de `UPDATING` a `ACTIVE` y el valor de `IndexStatus` cambia de `CREATING` a `ACTIVE`. No siga realizando los pasos hasta que el índice secundario global se haya creado correctamente. Esto puede tardar varios minutos.
## Paso 6: Obtener elementos de la tabla
Existen muchas formas de obtener elementos de las tablas. En este paso, se obtienen elementos mediante la clave principal de la tabla, mediante otros atributos de la tabla y utilizando el índice secundario global.
### Para obtener un solo elemento de una tabla en función del valor de la clave principal del elemento
Si conoce el valor de la clave principal del elemento, puede obtener el elemento coincidente ejecutando el comando ** `get-item` **, ** `scan` ** o ** `query` ** de DynamoDB. A continuación, se muestran las principales diferencias en estos comandos:
+ ** `get-item` ** devuelve un conjunto de atributos del elemento con la clave principal especificada.
+ ** `scan` ** devuelve uno o más elementos y atributos de elementos obteniendo acceso a todos los elementos de una tabla o un índice secundario.
+ ** `query` ** busca elementos según los valores de clave principal. Puede consultar cualquier tabla o índice secundario que cuente con una clave principal compuesta (una clave de partición y una clave de ordenación).
En este ejemplo, así es cómo se utiliza cada uno de estos comandos para obtener el elemento que contiene el valor del atributo `CityID` de `1` y el valor del atributo `Date` de `2017-04-12`.
1. Para ejecutar el comando** `get-item` ** de DynamoDB, especifique el nombre de la tabla (`--table-name`), el valor de clave principal (`--key`) y los valores de los atributos del elemento que se va a mostrar (`--projection-expression`). Dado que `Date` es una palabra clave reservada en DynamoDB, también debe proporcionar un alias para el valor del atributo `Date` (`--expression-attribute-names`). (`State` también es una palabra clave reservada, por lo que verá un alias proporcionado para este valor en pasos posteriores).
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
En este y otros comandos, para ver todos los atributos del elemento, no incluya `--projection-expression`. En este ejemplo, dado que no está incluyendo `--projection-expression`, tampoco es necesario incluir `--expression-attribute-names`.
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. Para ejecutar el comando ** `scan` ** de DynamoDB, especifique:
+ El nombre de la tabla (`--table-name`).
+ La búsqueda que se va a realizar (`--filter-expression`).
+ Los criterios de búsqueda que se van a utilizar (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Los valores de atributos del elemento que se va a mostrar (`--projection-expression`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos atributos (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. Para ejecutar el comando ** `query` ** de DynamoDB, especifique:
+ El nombre de la tabla (`--table-name`).
+ La búsqueda que se va a realizar (`--key-condition-expression`).
+ Los valores de los atributos que se van a utilizar en la búsqueda (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Los valores de atributos del elemento que se va a mostrar (`--projection-expression`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos atributos (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
Fíjese en que el comando ** `scan` ** ha tenido que analizar los 9 elementos para obtener el resultado, mientras que el comando ** `query` ** solo ha tenido que analizar 1 elemento.
### Para obtener varios elementos de una tabla en función de los valores de la clave principal de los elementos
Si conoce los valores de la clave principal de los elementos, puede obtener los elementos coincidentes ejecutando el comando ** `batch-get-item` ** de DynamoDB. En este ejemplo, se muestra cómo se obtienen los elementos que contienen el valor del atributo `CityID` de `3` y los valores del atributo `Date` de `2017-04-13` o `2017-04-14`.
Ejecute el comando ** `batch-get-item` ** de DynamoDB y especifique la ruta a un archivo que describa los elementos que se van a obtener (`--request-items`).
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
Para este ejemplo, el código del archivo `batch-get-item.json` especifica que se deben buscar en la tabla `Weather` los elementos con un `CityID` de `3` y un `Date` de `2017-04-13` o `2017-04-14`. Para cada elemento encontrado, se muestran los valores de atributo de `City``State`, `Date` y `HighF` (parte de `Temperatures`), si existen.
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### Para obtener todos los elementos coincidentes de una tabla
Si conoce algo sobre los valores de los atributos de la tabla, puede obtener los elementos coincidentes mediante la ejecución del comando ** `scan` ** de DynamoDB. En este ejemplo, se muestra cómo se obtienen las fechas cuando el valor del atributo `Conditions` contiene `Sunny` y el valor del atributo `HighF` (parte de `Temperatures`) es mayor que `53`.
Especifique lo siguiente para ejecutar el comando ** `scan` ** de DynamoDB:
+ El nombre de la tabla (`--table-name`).
+ La búsqueda que se va a realizar (`--filter-expression`).
+ Los criterios de búsqueda que se van a utilizar (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Los valores de atributos del elemento que se va a mostrar (`--projection-expression`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos atributos (`--expression-attribute-names`).
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### Para obtener todos los elementos coincidentes de un índice secundario global
Para realizar una búsqueda mediante un índice secundario global, utilice el comando ** `query` ** de DynamoDB. En este ejemplo, se muestra cómo se utiliza el índice secundario `weather-global-index` para obtener las condiciones de la previsión en ciudades con el nombre `Portland` para las fechas `2017-04-13` y `2017-04-14`.
Especifique lo siguiente para ejecutar el comando ** `query` ** de DynamoDB:
+ El nombre de la tabla (`--table-name`).
+ El nombre del índice secundario global (`--index-name`).
+ La búsqueda que se va a realizar (`--key-condition-expression`).
+ Los valores de los atributos que se van a utilizar en la búsqueda (`--expression-attribute-values`).
+ Los tipos de atributos que se van a mostrar del elemento coincidente (`--select`).
+ Si alguno de los atributos utiliza palabras reservadas de DynamoDB, los alias de esos atributos (`--expression-attribute-names`).
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## Paso 7: limpiar
Para evitar que se sigan cobrando en tu AWS cuenta una vez que hayas terminado de usar este ejemplo, debes eliminar la tabla. Al eliminar la tabla, también se elimina el índice secundario global. También debe eliminar su entorno.
Para eliminar la tabla, ejecute el comando ** `delete-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb delete-table --table-name Weather
```
Si el comando se ejecuta correctamente, se muestra información sobre la tabla, incluido el valor de `TableStatus` de `DELETING`.
Para confirmar que la tabla se ha eliminado correctamente, ejecute el comando ** `describe-table` ** de DynamoDB y especifique el nombre de la tabla (`--table-name`).
```
aws dynamodb describe-table --table-name Weather
```
Si la tabla se elimina correctamente, se muestra un mensaje que contiene la frase `Requested resource not found`.
Para eliminar su entorno, consulte [Eliminación de entornos](delete-environment.md).