Tutorial do Amazon DynamoDB para AWS Cloud9 - AWS Cloud9
Pré-requisitosEtapa 1: Instalar e configurar a AWS CLI, o AWS CloudShell ou ambos no ambienteEtapa 2: Criar uma tabelaEtapa 3: Adicionar um item à tabelaEtapa 4: Adicionar diversos itens à tabelaEtapa 5: Criar um índice secundário globalEtapa 6: Obter itens da tabelaEtapa 7: Limpar

AWS Cloud9 não está mais disponível para novos clientes. Os clientes atuais do AWS Cloud9 podem continuar usando o serviço normalmente. Saiba mais

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tutorial do Amazon DynamoDB para AWS Cloud9

Este tutorial permite que você configure um ambiente de AWS Cloud9 desenvolvimento para trabalhar com o Amazon DynamoDB.

O DynamoDB é um serviço sem banco de dados totalmente gerenciadoSQL. Use o DynamoDB para criar uma tabela do banco de dados que possa armazenar e recuperar qualquer quantidade de dados e atender qualquer nível de tráfego solicitado. O DynamoDB distribui automaticamente os dados e tráfego da tabela por um número suficiente de servidores, a fim de lidar com a capacidade da solicitação especificada e com a quantidade de dados armazenados, mantendo uma performance consistente e rápida. Para obter mais informações, consulte Amazon DynamoDB no site. AWS

A criação dessa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por serviços como Amazon EC2 e DynamoDB. Para obter mais informações, consulte Amazon EC2 Pricing e Amazon DynamoDB Pricing.

Para obter informações sobre ofertas adicionais AWS de bancos de dados, consulte Amazon Relational Database Service RDS (), ElastiCacheAmazon e Amazon Redshift no site. AWS Consulte também AWS Database Migration Service no site da AWS .

Pré-requisitos

Antes de usar esse exemplo, verifique se suas configurações cumprem os requisitos a seguir.

  • Você deve ter um ambiente de AWS Cloud9 EC2 desenvolvimento existente. Este exemplo pressupõe que você já tenha um EC2 ambiente conectado a uma EC2 instância da Amazon que executa Amazon Linux ou Ubuntu Server. Caso tenha um tipo diferente de ambiente ou sistema operacional, poderá ser necessário adaptar as instruções desse exemplo para configurar ferramentas relacionadas. Para ter mais informações, consulte Criando um ambiente em AWS Cloud9.

  • Você tem o AWS Cloud9 IDE para o ambiente existente já aberto. Quando você abre um ambiente, AWS Cloud9 abre o IDE para esse ambiente em seu navegador da web. Para ter mais informações, consulte Abrir um ambiente no AWS Cloud9.

Etapa 1: Instalar e configurar a AWS CLI, o AWS CloudShell ou ambos no ambiente

Nesta etapa, você usa o AWS Cloud9 IDE para instalar e configurar o AWS CLI AWS CloudShell, o ou ambos em seu ambiente para poder executar comandos para interagir com o DynamoDB. Em seguida, use a AWS CLI para executar um comando básico do DynamoDB para testar a instalação e a configuração.

  1. Para configurar o gerenciamento de credenciais para o AWS CLI ou o AWS CloudShell e instalar o AWS CLI AWS CloudShell, o ou ambos em seu ambiente, siga as etapas 1 e 2 no AWS CloudShell exemplo AWS CLI e, em seguida, retorne a este tópico. Se você já instalou e configurou o AWS CLI AWS CloudShell, o ou ambos em seu ambiente, não precisa fazer isso novamente.

  2. Teste a instalação e a configuração do AWS CLI, do aws-shell ou de ambos executando o list-tablescomando do DynamoDB em uma sessão de terminal em seu ambiente para listar suas tabelas existentes do DynamoDB, se houver alguma. Para iniciar uma nova sessão de terminal, na barra de menus, selecione Windows (Janelas), New Terminal (Novo terminal).

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

    Ao longo dessa amostra, se estiver usando o aws-shell, omita aws de cada comando que começa com aws. Para iniciar o aws-shell, execute o comando aws-shell . Para parar de usar o aws-shell, execute o comando .exit ou .quit .

    Se esse comando for bem-sucedido, ele gera uma matriz TableNames que contém uma lista das tabelas do DynamoDB existentes que você já pode ter. Caso ainda não possua tabelas do DynamoDB, a matriz TableNames estará vazia.

    {
  "TableNames": []
}

    Se você tiver tabelas do DynamoDB, a matriz TableNames conterá uma lista dos nomes das tabelas.

Etapa 2: Criar uma tabela

Nesta etapa, você criará uma tabela no DynamoDB e especificará o nome, o layout, a chave primária simples e as configurações de transferência de dados.

Este exemplo de tabela, chamada Weather, contém informações sobre as previsões meteorológicas para algumas cidades nos Estados Unidos. A tabela contém os seguintes tipos de informações (no DynamoDB, cada informação é conhecida como um atributo):

  • ID de cidade exclusivo obrigatório (CityID)

  • Data da previsão obrigatória (Date)

  • Nome da cidade (City)

  • Nome do estado (State)

  • Condições da previsão meteorológica (Conditions)

  • Temperaturas previstas (Temperatures)

    • Previsão alta, em graus Fahrenheit (HighF)

    • Previsão baixa, em graus Fahrenheit (LowF)

Para criar a tabela, em uma sessão de terminal no AWS Cloud9 IDE, execute o comando do create-tableDynamoDB.

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

Neste comando:

  • --table-name representa o nome da tabela (Weather neste exemplo). Os nomes das tabelas devem ser exclusivos em cada AWS região da sua AWS conta.

  • --attribute-definitions representa os atributos que são usados para identificar de forma única os itens da tabela. Cada um dos itens dessa tabela é identificado exclusivamente por uma combinação de um ID atributo numérico e um atributo representado como uma string Date formatada em ISO -8601.

  • --key-schema representa o esquema de chaves da tabela. Essa tabela tem uma chave primária composta de CityID e Date. Isso significa que cada um dos itens da tabela deve ter um valor de atributo CityID e um valor de atributo Date, mas dois itens na tabela não podem ter os mesmos valores de CityID e Date.

  • --provisioned-throughput representa a capacidade de leitura e gravação da tabela. O DynamoDB permite até cinco leituras fortemente consistentes por segundo para itens de até 4 KB de tamanho, ou até cinco leituras eventualmente consistentes por segundo para itens de até 4 KB. O DynamoDB também permite até 5 gravações por segundo para itens de até 1 KB de tamanho.

    nota

    Definir uma taxa de transferência provisionada mais alta pode resultar em cobranças adicionais em sua conta. AWS

    Para mais informações sobre esse e outros comandos do DynamoDB, consulte dynamodb na Referência de comandos da AWS CLI .

Se esse comando for bem-sucedido, ele exibe informações resumidas sobre a nova tabela que está sendo criada. Para confirmar se a tabela foi criada com sucesso, execute o comando describe-table do DynamoDB, especificando o nome da tabela (--table-name).

aws dynamodb describe-table --table-name Weather

Quando a tabela for criada com sucesso, o valor TableStatus muda de CREATING para ACTIVE. Não avance para a próxima etapa até que a tabela seja criada com sucesso.

Etapa 3: Adicionar um item à tabela

Nesta etapa, adicione um item à tabela que acabou de criar.

  1. Crie um arquivo chamado weather-item.json com o conteúdo a seguir. Para criar um novo arquivo, na barra de menus, selecione File (Arquivo), New File (Novo arquivo). Para salvar o arquivo, selecione File (Arquivo), Save (Salvar).

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

    Neste código, N representa um valor de atributo que é um número. S é um valor de atributo de string. M é um atributo de mapa, que é um conjunto de pares de valores de atributos. É necessário especificar o tipo de dados de um atributo sempre que trabalhar com itens. Para obter os tipos de dados de atributos adicionais disponíveis, consulte Data Types (Tipos de dados) no Manual do desenvolvedor do Amazon DynamoDB.

  2. Execute o comando do put-itemDynamoDB, especificando o nome da tabela --table-name () e o caminho para JSON o item formatado (). --item

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

    Se o comando for bem-sucedido, ele é executado sem erros e nenhuma mensagem de confirmação é exibida.

  3. Para confirmar o conteúdo atual da tabela, execute o comando scan do DynamoDB, especificando o nome da tabela (--table-name).

    aws dynamodb scan --table-name Weather

    Se o comando for bem-sucedido, são exibidas informações resumidas sobre a tabela e sobre o item que acabou de adicionar.

Etapa 4: Adicionar diversos itens à tabela

Nesta etapa, adicione vários outros itens à tabela Weather.

  1. Crie um arquivo chamado more-weather-items.json com o conteúdo a seguir.

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

    Neste código, oito objetos Item definem os oito itens para adicionar à tabela, semelhante ao único item definido na etapa anterior. No entanto, ao executar o comando do batch-write-itemDynamoDB na próxima etapa, você deve fornecer JSON um objeto formatado que inclua Item cada objeto em um objeto contido. PutRequest Em seguida, será necessário incluir os objetos PutRequest em uma matriz pai com o mesmo nome que a tabela.

  2. Execute o comando do batch-write-itemDynamoDB, especificando o caminho para os itens formatados JSON a serem adicionados (). --request-items

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

    Se o comando for bem-sucedido, ele exibe a seguinte mensagem, confirmando que os itens foram adicionados com sucesso.

    {
  "UnprocessedItems": {}
}

  3. Para confirmar o conteúdo atual da tabela, execute o comando scan do DynamoDB novamente.

    aws dynamodb scan --table-name Weather

    Se o comando for bem-sucedido, serão exibidos nove itens.

Etapa 5: Criar um índice secundário global

Executar o comando scan do DynamoDB para obter informações sobre itens pode ser lento, especialmente à medida que uma tabela cresce ou se o tipo de informação que você deseja obter for complexo. Crie um ou mais índices secundários para acelerar o processo e facilitar a obtenção das informações. Nesta etapa, você aprenderá sobre dois tipos de índices secundários compatíveis com DynamoDB para fazer exatamente isso. Eles são conhecidos como um índice secundário local e um índice secundário global. Em seguida, crie um índice secundário global.

Para entender esses tipos de índices secundários, primeiro é necessário conhecer mais sobre as chaves primárias, que identificam com exclusividade os itens de uma tabela. O DynamoDB oferece suporte a uma chave primária simples ou uma chave primária composta. Uma chave primária simples possui um único atributo e o valor desse atributo deve ser único para cada item da tabela. Esse atributo também é conhecido como uma chave de partição (ou um atributo de hash), que o DynamoDB pode usar para particionar os itens para um acesso mais rápido. Uma tabela também pode ter uma chave primária composta, que contém dois atributos. O primeiro atributo é a chave de partição e o segundo é uma chave de classificação (também conhecida como um atributo de intervalo). Em uma tabela com uma chave primária composta, quaisquer dois itens podem ter o mesmo valor de chave de partição, mas não podem ter o mesmo valor de chave de classificação, simultaneamente. A tabela Weather tem uma chave primária composta.

Um índice secundário local tem a mesma chave de partição que a própria tabela, mas esse tipo de índice pode ter uma chave de classificação diferente. Um índice secundário global pode ter uma chave de partição e uma chave de classificação que são ambas diferentes da própria tabela.

Por exemplo, use a chave primária para acessar itens Weather por CityID. Para acessar os itens Weather por State, crie um índice secundário local que tenha uma chave de partição de CityID (ela deve ser igual à própria tabela) e uma chave de classificação de State. Para acessar os itens Weather por City, crie um índice secundário global que tenha uma chave de partição de City e uma chave de classificação de Date.

Somente é possível criar índices secundários locais durante a criação de uma tabela. Como a tabela Weather já existe, não é possível adicionar índices secundários locais a ela. No entanto, você pode adicionar índices secundários globais. Pratique adicionando um agora mesmo.

nota

A criação de índices secundários pode resultar em cobranças adicionais na conta da AWS .

  1. Crie um arquivo chamado weather-global-index.json com o conteúdo a seguir.

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

    Neste código:

    • O nome do índice secundário global é weather-global-index.

    • O atributo City é a chave de partição (atributo de hash) e o atributo Date é a chave de classificação (atributo de intervalo).

    • Projection define os atributos a serem recuperados por padrão (além do atributo de hash e qualquer atributo de intervalo) para todos os itens correspondentes a uma pesquisa de tabela que usa esse índice. Neste exemplo, os atributos State, Conditions, HighF (parte do Temperatures) e LowF (também parte do Temperatures) (bem como os atributos City e Date) são recuperados para cada item correspondente.

    • Semelhante às tabelas, um índice secundário global deve definir as configurações de transferência provisionada.

    • As configurações IndexName, KeySchema, Projection e ProvisionedThroughput devem estar contidas em um objeto Create, que define o índice secundário global a ser criado na execução do comando update-table do DynamoDB na próxima etapa.

  2. Execute o comando update-table do 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

    Neste comando:

    • --table-name é o nome da tabela para atualização.

    • --attribute-definitions são os atributos a serem incluídos no índice. A chave de partição sempre é listada primeiro e qualquer chave de classificação é sempre listada em segundo.

    • --global-secondary-index-updates é o caminho para o arquivo que define o índice secundário global.

    Se esse comando for bem-sucedido, ele exibe informações resumidas sobre o novo índice secundário global que está sendo criado. Para confirmar se o índice secundário global foi criado com sucesso, execute o comando describe-table do DynamoDB, especificando o nome da tabela (--table-name).

    aws dynamodb describe-table --table-name Weather

    Quando o índice secundário global for criado com sucesso, o valor TableStatus muda de UPDATING para ACTIVE e o valor IndexStatus muda de CREATING para ACTIVE. Não avance para a próxima etapa até que o índice secundário global seja criado com sucesso. Isso pode demorar vários minutos.

Etapa 6: Obter itens da tabela

Existem muitas formas de obter itens das tabelas. Nesta etapa, obtenha os itens usando a chave primária da tabela ao usar os outros atributos da tabela e o índice secundário global.

Para obter um único item de uma tabela com base no valor da chave primária do item

Se você souber o valor da chave primária de um item, você poderá obter o item correspondente, executando o comando get-item , scan ou query do DynamoDB. Veja a seguir as principais diferenças nesses comandos:

  • get-item retorna um conjunto de atributos para o item com a chave primária fornecida.

  • scan retorna um ou mais itens e atributos de item ao acessar cada item em uma tabela ou um índice secundário.

  • query encontra itens com base nos valores de chave primária. Consulte qualquer tabela ou índice secundário que tenha uma chave primária composta (uma chave de partição e uma de classificação).

Neste exemplo, veja como usar cada um desses comandos para obter o item que contém o valor do atributo CityID de 1 e o valor do atributo Date de 2017-04-12.

  1. Para executar o comando get-item do DynamoDB, especifique o nome da tabela (--table-name), o valor da chave primária (--key) e os valores do atributo do item para exibição (--projection-expression). Como Date é uma palavra-chave reservada no DynamoDB você também deverá fornecer um alias para o valor do atributo Date (--expression-attribute-names). (O State também é uma palavra-chave reservada e, portanto, você verá um alias fornecido a ela em etapas 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" }'

    Neste e em outros comandos, para exibir todos os atributos do item, não inclua --projection-expression. Neste exemplo, como --projection-expression não está incluso, também não é necessário incluir --expression-attribute-names.

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

  2. Para executar o comando scan do DynamoDB, especifique:

    • O nome da tabela (--table-name).

    • A pesquisa a ser executada (--filter-expression).

    • Os critérios de pesquisa a serem usados (--expression-attribute-values).

    • Os tipos de atributos a serem exibidos para o item correspondente (--select).

    • Os valores de atributo do item a serem exibidos (--projection-expression).

    • Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses 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" }'

  3. Para executar o comando query do DynamoDB, especifique:

    • O nome da tabela (--table-name).

    • A pesquisa a ser executada (--key-condition-expression).

    • Os valores de atributo a serem usados na pesquisa (--expression-attribute-values).

    • Os tipos de atributos a serem exibidos para o item correspondente (--select).

    • Os valores de atributo do item a serem exibidos (--projection-expression).

    • Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses 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" }'

    Observe que o comando scan precisou verificar todos os nove itens para obter o resultado, enquanto o comando query precisou verificar apenas um item.

Para obter diversos itens de uma tabela com base nos valores de chave primária dos itens

Se você souber os valores de chave primária dos itens, poderá obter os itens correspondentes, executando o comando batch-get-item do DynamoDB. Neste exemplo, veja como obter os itens que contêm o valor do atributo CityID de 3 e valores do atributo Date de 2017-04-13 ou 2017-04-14.

Execute o comando batch-get-item , especificando o caminho para um arquivo que descreve os itens a serem obtidos (--request-items).

aws dynamodb batch-get-item --request-items file://batch-get-item.json

Para este exemplo, o código no arquivo batch-get-item.json especifica a pesquisa na tabela Weather dos itens com um CityID de 3 e uma Date de 2017-04-13 ou 2017-04-14. Para cada item encontrado, os valores de atributo para City, State, Date e HighF (parte do Temperatures) são exibidos, se existirem.

{
  "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 obter todos os itens correspondentes de uma tabela

Se você souber algo sobre os valores de atributos na tabela, você poderá obter os itens correspondentes, executando o comando scan do DynamoDB. Neste exemplo, veja como obter as datas quando o valor do atributo Conditions contém Sunny e o valor do atributo HighF (parte do Temperatures) é maior que 53.

Execute o comando scan do DynamoDB, especificando:

  • O nome da tabela (--table-name).

  • A pesquisa a ser executada (--filter-expression).

  • Os critérios de pesquisa a serem usados (--expression-attribute-values).

  • Os tipos de atributos a serem exibidos para o item correspondente (--select).

  • Os valores de atributo do item a serem exibidos (--projection-expression).

  • Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses 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 obter todos os itens correspondentes de um índice secundário global

Para pesquisar usando um índice secundário global, use o comando query do DynamoDB. Neste exemplo, veja como usar o índice secundário weather-global-index para obter as condições de previsão para cidades com o nome Portland e para as datas de 2017-04-13 e 2017-04-14.

Execute o comando query do DynamoDB, especificando:

  • O nome da tabela (--table-name).

  • O nome do índice secundário global (--index-name).

  • A pesquisa a ser executada (--key-condition-expression).

  • Os valores de atributo a serem usados na pesquisa (--expression-attribute-values).

  • Os tipos de atributos a serem exibidos para o item correspondente (--select).

  • Se qualquer um dos atributos estiver usando palavras-chave reservadas em aliases do DynamoDB para esses 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" }'

Etapa 7: Limpar

Para evitar cobranças contínuas em sua AWS conta depois que você terminar de usar essa amostra, exclua a tabela. Excluir a tabela também excluirá o índice secundário global. Exclua também o ambiente.

Para excluir a tabela, execute o comando delete-table do DynamoDB, especificando o nome da tabela (--table-name).

aws dynamodb delete-table --table-name Weather

Se o comando for bem-sucedido, serão exibidas informações sobre a tabela, incluindo o valor do TableStatus de DELETING.

Para confirmar se a tabela foi excluída com sucesso, execute o comando describe-table do DynamoDB, especificando o nome da tabela (--table-name).

aws dynamodb describe-table --table-name Weather

Se a tabela for excluída com sucesso, será exibida uma mensagem que contém a frase Requested resource not found.

Para excluir o ambiente, consulte Deleting an Environment (Excluir um ambiente).