Tutorial de Amazon DynamoDB para AWS Cloud9

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.

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

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.

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.