Amazon DynamoDB tutorial for AWS Cloud9

To set up credentials management for the AWS CLI or the AWS CloudShell and to install the AWS CLI, the AWS CloudShell, or both in your environment, follow Steps 1 and 2 in the AWS CLI and AWS CloudShell Sample, and then return to this topic. If you already installed and configured the AWS CLI, the AWS CloudShell, or both in your environment, you don't need to do it again.

Test the installation and configuration of the AWS CLI, the aws-shell, or both by running the DynamoDB list-tables command from a terminal session in your environment to list your existing DynamoDB tables, if there are any. To start a new terminal session, on the menu bar, choose Windows, New Terminal.

aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables     # For the aws-shell.

If this command succeeds, it outputs a TableNames array containing a list of existing DynamoDB tables that you might already have. If you have no DynamoDB tables yet, the TableNames array will be empty.

{
  "TableNames": []
}

If you do have any DynamoDB tables, the TableNames array contains a list of the table names.

Create a file named weather-item.json with the following content. To create a new file, on the menu bar, choose File, New File. To save the file, choose File, Save.

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

In this code, N represents an attribute value that is a number. S is a string attribute value. M is a map attribute, which is a set of attribute-value pairs. You must specify an attribute's data type whenever you work with items. For additional available attribute data types, see Data Types in the Amazon DynamoDB Developer Guide.

Run the DynamoDB put-item command, specifying the table's name (--table-name) and the path to the JSON-formatted item (--item).

aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json

If the command succeeds, it runs without error, and no confirmation message is displayed.

To confirm the table's current contents, run the DynamoDB scan command, specifying the table's name (--table-name).

aws dynamodb scan --table-name Weather

If the command succeeds, summary information about the table and the item you just added is displayed.

Create a file named more-weather-items.json with the following content.

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

In this code, 8 Item objects define the 8 items to add to the table, similar to the single item defined in the previous step. However, when you run the DynamoDB batch-write-item command in the next step, you must provide a JSON-formatted object that includes each Item object in a containing PutRequest object. Then you must include those PutRequest objects in a parent array that has the same name as the table.

Run the DynamoDB batch-write-item command, specifying the path to the JSON-formatted items to add (--request-items).

aws dynamodb batch-write-item \
--request-items file://more-weather-items.json

If the command succeeds, it displays the following message, confirming that the items were successfully added.

{
  "UnprocessedItems": {}
}

To confirm the table's current contents, run the DynamoDB scan command again.

aws dynamodb scan --table-name Weather

If the command succeeds, 9 items are now displayed.

Create a file named weather-global-index.json with the following content.

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

In this code:

Run the DynamoDB update-table command.

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

In this command:

If this command succeeds, it displays summary information about the new global secondary index that is being created. To confirm the global secondary index is successfully created, run the DynamoDB describe-table command, specifying the table's name (--table-name).

aws dynamodb describe-table --table-name Weather

When the global secondary index is successfully created, the TableStatus value changes from UPDATING to ACTIVE, and the IndexStatus value changes from CREATING to ACTIVE. Do not proceed past this step until the global secondary index is successfully created. This can take several minutes.

To run the DynamoDB get-item command, specify the name of the table (--table-name), the primary key value (--key), and the attribute values for the item to display (--projection-expression). Because Date is a reserved keyword in DynamoDB, you must also provide an alias for the Date attribute value (--expression-attribute-names). (State is also a reserved keyword, and so you will see an alias provided for it in later steps.)

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

In this and the other commands, to display all of the item's attributes, don't include --projection-expression. In this example, because you are not including --projection-expression, you also don't need to include --expression-attribute-names.

aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'

To run the DynamoDB scan command, specify:

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

To run the DynamoDB query command, specify:

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

Notice that the scan command needed to scan all 9 items to get the result, while the query command only needed to scan for 1 item.