Requisitos previos Paso 1: instalar y configurar la AWS CLI, el AWS CloudShell o ambos en el entorno Paso 2: Crear una tabla Paso 3: Agregar un elemento a la tabla Paso 4: Agregar varios elementos a la tabla Paso 5: Crear un índice secundario global Paso 6: Obtener elementos de la tabla Paso 7: limpiar

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 un servicio sin base de datos totalmente gestionadoSQL. 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 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 Amazon EC2 Pricing y Amazon DynamoDB Pricing.

Para obtener información sobre ofertas AWS de bases de datos adicionales, consulte Amazon Relational Database Service RDS (), ElastiCacheAmazon y Amazon Redshift AWS en el sitio web. Consulte también AWS Database Migration Service en el sitio web de AWS .

Requisitos previos
Paso 1: instalar y configurar la AWS CLI, el AWS CloudShell o ambos en el entorno
Paso 2: crear una tabla
Paso 3 agregar un elemento a la tabla
Paso 4: agregar varios elementos a la tabla
Paso 5: crear un índice secundario global
Paso 6: obtener elementos de la tabla
Paso 7: limpieza

Requisitos previos

Antes de utilizar este ejemplo, asegúrese de que su configuración cumpla los siguientes requisitos:

Debe tener un entorno de AWS Cloud9 EC2 desarrollo existente. En este ejemplo se supone que ya tienes un EC2 entorno conectado a una EC2 instancia de Amazon 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.
Ya tiene abierto el entorno existente. AWS Cloud9 IDE Al abrir un entorno, AWS Cloud9 abre el IDE correspondiente a ese entorno en el navegador web. Para obtener más información, consulte Apertura de un entorno en AWS Cloud9.

Paso 1: instalar y configurar la AWS CLI, el AWS CloudShell o ambos en el entorno

En este paso, se utiliza AWS Cloud9 IDE para instalar y configurar el AWS CLI, el o ambos en su entorno AWS CloudShell, de modo 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.

Para configurar la administración de credenciales para el AWS CLI o el AWS CloudShell e instalar el AWS CLI AWS CloudShell, el o ambos en su entorno, siga los pasos 1 y 2 del AWS CloudShell ejemplo AWS CLI 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.
Pruebe la instalación y la configuración del AWS CLI aws-shell o de ambos ejecutando el list-tablescomando 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, ejecute el AWS Cloud9 IDE comando DynamoDB create-tableen una sesión de terminal.


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 su AWS cuenta.
--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 mediante una combinación de un ID atributo numérico y un Date atributo 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 generen cargos adicionales en tu cuenta. AWS
Para obtener más información acerca de este comando y otros comandos de DynamoDB, consulte dynamodb, 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.

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 en la Guía para desarrolladores de Amazon DynamoDB.
Ejecute el comando put-itemDynamoDB y especifique el nombre de la tabla --table-name () y la ruta al JSON elemento con formato (). --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.
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.

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-itemDynamoDB en el siguiente paso, debe proporcionar JSON un objeto con formato que incluya Item cada objeto de un objeto contenedor. PutRequest A continuación, debe incluir esos objetos PutRequest en una matriz principal que tenga el mismo nombre que la tabla.

Ejecute el comando batch-write-itemDynamoDB y especifique la ruta a los elementos con formato que JSON desee añadir (). --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": {}
}
```
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 .

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 atributosState, 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.
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.

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" } }'
```
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" }'
```
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 CityState, 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 hagan cargos continuos a su AWS cuenta una vez que haya terminado de usar este ejemplo, debe 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.

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

tutorial sobre AWS CodeCommit

tutorial sobre AWS CDK