Tutorial de Amazon DynamoDB para AWS Cloud9

Para configurar la administración de credenciales para la AWS CLI o el AWS CloudShell y para instalar la AWS CLI, el AWS CloudShell o ambos en su entorno, siga los pasos 1 y 2 de Muestra de AWS CLI y AWS CloudShell y, a continuación, vuelva a este tema. Si ya ha instalado y configurado la AWS CLI, el AWS CloudShell o ambos en su entorno, no es necesario hacerlo de nuevo.

Pruebe la instalación y configuración de AWS CLI, aws-shell o ambos ejecutando el comando list-tables desde una sesión del terminal en su entorno para obtener una lista de las tablas de DynamoDB, si hay alguna. 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.

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.

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

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.

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.

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": {}
}

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.

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:

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:

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.

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:

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:

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.