Usando AWS DynamoDB em um aplicativo Node.js

Principais conclusões

• DynamoDB é um banco de dados NoSQL poderoso oferecido pela AWS que pode lidar com grandes quantidades de dados diversos sem comprometer o desempenho, a durabilidade ou a confiabilidade.
• Para começar a usar o DynamoDB no Node.js, você precisa instalar o pacote client-dynamodb do aws-sdk e configurar suas credenciais.
• O DynamoDB permite criar facilmente tabelas, gravar e ler dados, atualizar registros e excluir registros usando métodos e parâmetros do cliente. Ele oferece flexibilidade e escalabilidade para o desenvolvimento eficiente de aplicativos.

Uma grande parte do desenvolvimento de aplicativos modernos precisa de uma combinação de linguagens de programação robustas e bancos de dados poderosos.

Uma das soluções que a Amazon Web Services (AWS) oferece é o DynamoDB, uma ferramenta que pode revolucionar o gerenciamento de seus dados. Usando-o, você pode provisionar rapidamente um banco de dados para lidar com grandes quantidades de dados diversos.

O que é DynamoDB?

A AWS oferece serviços para diferentes necessidades de banco de dados, como Amazon RDS para bancos de dados relacionais e DocumentDB para bancos de dados de documentos como MongoDB. DynamoDB é um banco de dados NoSQL para armazenar dados em formato chave-valor.

O DynamoDB pode lidar com grandes quantidades de dados em infraestruturas distribuídas sem comprometer o desempenho, a durabilidade ou a confiabilidade. Ele oferece um modelo flexível, permitindo armazenar e consultar facilmente dados, sejam eles estruturados ou não estruturados.

Você pode usar o DynamoDB como banco de dados para vários tipos de aplicativos. Você pode acessá-lo diretamente do console da web da AWS e programaticamente por meio da AWS-CLI ou de aplicativos da web usando o AWS-SDK.

Primeiros passos com DynamoDB em Node.js

Existem muitas ferramentas para construir APIs de backend em Node.js e você é livre para escolher o banco de dados para sua API ao trabalhar com qualquer uma dessas ferramentas. Node.js oferece amplo suporte para serviços externos, incluindo bancos de dados como AWS DynamoDB.

Tudo que você precisa para acessar um serviço AWS a partir de seu aplicativo Node é o pacote cliente aws-sdk para esse serviço. Por exemplo, para acessar o DynamoDB, você precisa instalar o pacote client-dynamodb em aws-sdk.

Execute este comando no diretório do seu projeto para instalar o pacote:

 npm install @aws-sdk/client-dynamodb

Depois de instalar aws-sdk/client-dynamodb em seu projeto Node.js, você precisa adicionar a região da sua tabela DynamoDB à configuração antes de interagir com ela. Você fará isso ao inicializar o cliente DynamoDB.

Se você já instalou e usou AWS-CLI em seu computador antes, provavelmente já tem credenciais da AWS definidas em seu ambiente e o SDK obterá automaticamente seus valores do ambiente.

Mas se ainda não o fez, você pode ir para o Gerenciamento de acesso de identidade da AWS (IAM) service em seu console e crie um novo usuário. Depois de criar o usuário, você pode obter um ID de chave de acesso e uma chave secreta, que são suas credenciais pessoais.

Adicione essas credenciais ao seu ambiente executando os seguintes comandos de terminal para sua plataforma:

No Unix, Linux ou macOS:

 export AWS_ACCESS_KEY_ID='your access key ID'
export AWS_SECRET_ACCESS_KEY='you secret access key'

No Windows (CMD):

 set AWS_ACCESS_KEY_ID='your access key ID'
set AWS_SECRET_ACCESS_KEY='you secret access key'

No Windows (PowerShell):

 $env:AWS_ACCESS_KEY_ID='your access key ID'
$env:AWS_SECRET_ACCESS_KEY='you secret access key'

Em seguida, de volta ao seu projeto Node.js, crie um novo arquivo e nomeie-o como dynamodb.js. Neste arquivo, instancie um novo cliente AWS DynamoDB usando o seguinte código:

 const { DynamoDB } = require('@aws-sdk/client-dynamodb')
const region = "us-east-1" 
const client = new DynamoDB({ region })
 

Bem simples! A AWS garante que você não exponha nenhuma de suas credenciais de segurança em seu código; portanto, enquanto o código acima tenta criar o cliente, ele primeiro lê a chave de acesso e a chave secreta do seu ambiente.

O cliente recém-criado permite realizar diversas operações, como criação de tabelas e leitura e gravação de dados.

O DynamoDB não tem esquema, assim como outros bancos de dados NoSQL, então você sempre pode adicionar novos atributos (campos) a uma tabela a qualquer momento. É por isso que você só precisa adicionar atributos que servirão como chaves primárias a uma tabela do DynamoDB ao criá-la.

Confira o código a seguir que cria uma nova tabela (Cliente) no DynamoDB:

 const createCustomerTable = async () => {
    const params = {
        TableName: "Customer",
        AttributeDefinitions: [
            {
                AttributeName: "Email",
                AttributeType: "S"
            },
        ],
        KeySchema: [
            {
                AttributeName: "Email",
                KeyType: "HASH"
            }
        ],
        ProvisionedThroughput: {
            ReadCapacityUnits: 5,
            WriteCapacityUnits: 5
        }
    };
    client.createTable(params, (err, data) => {
        if (err) {
           console.log(err);
        } else {
            console.log(data);
        }
    });
}
createCustomerTable();
 

O campo AttributeDefinitions é onde você define os principais atributos da tabela e seus tipos. O atributo Email aqui tem tipo S, o que significa que o campo espera uma String como valor. Os três tipos de atributos disponíveis são S, N e B (String, Número e Binário).

Você precisa do KeySchema para definir chaves primárias que ajudam a localizar e organizar itens rapidamente. O DynamoDB espera que os atributos adicionados ao criar a tabela sejam atributos-chave, portanto Email é a chave primária aqui. Você deve adicioná-lo ao KeySchema e especificar seu KeyType (HASH).

O outro valor KeyType disponível é RANGE, usado para chaves de classificação. As chaves de classificação são úteis nos casos em que você pode ter dados com as mesmas chaves HASH em uma tabela e deseja agrupá-los de acordo com alguns dados extras, como data ou cor. Você pode transformar os dados extras em uma chave RANGE.

O terceiro parâmetro importante no código acima é o ProvisionedThroughput. É aqui que você define o número de leituras e gravações que deseja que o DynamoDb permita na tabela por segundo.

Ao executar o código acima, você deverá obter uma saída semelhante a esta:

Se você verificar o painel de tabelas do DynamoDB no console da web, verá a tabela ainda sendo provisionada ou já com status ativo.

Sempre considere as necessidades do seu aplicativo ao especificar ReadCapacityUnits e WriteCapacityUnits porque um valor inadequado pode levar a problemas de desempenho ou altos custos de faturamento em sua conta.

Quando tiver certeza de que a tabela já está ativa, você poderá realizar operações CRUD nela.

A seguir estão alguns exemplos de código que mostram como gravar e ler dados da tabela Cliente.

 const createCustomer = async (customer) => {
    const params = {
        TableName: "Customer",
        Item: customer
    }
    client.putItem(params, (err, data) => {
        if (err) {
           console.error(err)
        } else {
            console.log(data)
        }
    })
}
const customerData = {
    Name: { "S": "Timilehin O." },
    Email: { "S": "[email protected]" },
    Age: { "N": "18"},
    Country: { "S": "Nigeria" }
}
createCustomer(customerData)
 

 const getAllCustomers = async () => {
    const params = {
        TableName: "Customer"
    }
    const customers = await client.scan(params)
    console.log(customers)
}
 

 const getCustomerByEmail = async (email) => {
    const params = {
        TableName: "Customer",
        Key: {
            Email: { "S": email } 
        }
    }
    const customer = await client.getItem(params)
    console.log(customer)
}
getCustomerByEmail("[email protected]")
 

  const updateCustomerLocation = async (email, age) => {
     const params = {
         TableName: "Customer",
         Key: {
             Email: { "S": email }
         },
         UpdateExpression: "SET Age = :newAge",
         ExpressionAttributeValues: {
             ':newAge': { "N": age }
         },
         ReturnValues: "ALL_NEW"
     }
     const updatedCustomer = await client.updateItem(params)
     console.log(updatedCustomer.Attributes)
 }
 

 const deleteCustomer = async (email) => {
    const params = {
        TableName: "Customer",
        Key: {
            Email: { "S": email }
        }
    }
    client.deleteItem(params, (err, data) => {
        if (err) {
           console.error(err)
        } else {
            console.log("Customer deleted successfully")
        }
    })
}
deleteCustomer("[email protected]")
 

Construindo aplicações eficientes com DynamoDB

Amazon Web Services continua a prosperar. Ele fornece uma plataforma acessível que você pode usar para fornecer soluções digitais eficientes e seguras. O DynamoDB é a escolha perfeita se você procura um banco de dados para funcionar sem se preocupar com infraestrutura ou segurança.

Agora você está equipado com tudo o que precisa para começar a usar o DynamoDB no Node.js e pode escolher o DynamoDB com segurança para seu próximo aplicativo Node.js.