DynamoDB usando AWS SDK para Javascript/Node.js

Dec 30 2022

¿Qué es DynamoDB? Amazon DynamoDB es un servicio de base de datos NoSQL completamente administrado. Te permite trabajar con Big Data.

¿Qué es DynamoDB?

Amazon DynamoDB es un servicio de base de datos NoSQL completamente administrado. Te permite trabajar con Big Data. Proporciona características como:

Escalado bajo demanda sin inconvenientes
Operaciones simultáneas ilimitadas de lectura/escritura
Latencia de milisegundos de un solo dígito
Latencia de microsegundos con DAX (servicio de almacenamiento en caché)
Tolerante a fallas, compatible con la replicación entre regiones y altamente escalable
Puede procesar datos en gran parte no estructurados con alto volumen y frecuencia
Precios basados en la capacidad que aprovisione para cada mesa.

Tipos de datos en DynamoDB

1. Tipos escalares: Representa exactamente un valor que puede ser cadena, números, binario, booleano o nulo.

2. Tipos de conjuntos: representa múltiples valores escalares que pueden ser conjuntos de cadenas, conjuntos de números o conjuntos binarios.

3. Tipos de documentos: tiene una estructura compleja con atributos anidados que pueden ser mapas o listas.

Requisitos previos para usar DynamoDB con AWS SDK en Node.js/Javascript

En primer lugar, asegúrese de que aws-cli esté instalado en su sistema junto con la variable de entorno aws y las configuraciones configuradas. Puede verificar esto simplemente ejecutando el comando: aws — version.

Vaya a la terminal y ejecute las instrucciones:

inicio npm
npm instalar aws-sdk - -guardar

Listado de tablas de DynamoDB

//referencing sdk in js file
const AWS = require("aws-sdk");
//specifying aws region where dynamodb table will be created
AWS.config.update({ region: 'us-east-1' });
//instantiate dynamodb class
const dynamodb = new AWS.DynamoDB();
//listing tables
dynamodb.listTables({}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

dynamodb.describeTable({
     TableName: "demo_sdk"
 }, (err, data)=>{
     if(err) {
         console.log(err);
     } else {
         console.log(JSON.stringify(data, null, 2));// '2' is to beautify the output 
     }
 });

1 unidad de capacidad = 1 solicitud por segundo

dynamodb.createTable({
    TableName: "demo_sdk",
    AttributeDefinitions: [
        {
            AttributeName: "id",
            AttributeType: "S" //string
        },
        {
            AttributeName: "timestamp",
            AttributeType: "N" //number
        }
    ],
    KeySchema: [
        {
            AttributeName: "id",
            KeyType: "HASH"
        },
        {
            AttributeName: "timestamp",
            KeyType: "RANGE"
        }
    ],
    ProvisionedThroughput: {
        ReadCapacityUnits: 1,
        WriteCapacityUnits: 1
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(JSON.stringify(data, null, 2));
    }
});

//Changing read capacity units from 1 to 2 for the table
dynamodb.updateTable({
    TableName: "demo_sdk",
    ProvisionedThroughput: {
        ReadCapacityUnits: 2,
        WriteCapacityUnits: 1
    }
}, (err, data) => {
    if(err) {
        console.log(err);
    } else {
        console.log(JSON.stringify(data, null, 2));
    }
});

dynamodb.deleteTable({
    TableName: "demo_sdk"
}, (err, data) => {
    if(err) {
        console.log(err);
    } else {
        console.log(JSON.stringify(data, null, 2));
    }
});

Si revisa cuidadosamente la sintaxis de los fragmentos de código, es bastante simple, ¿no es así? Entonces, suponiendo que ahora tiene un poco de control sobre el uso de AWS SDK para dynamodb, pasaremos a un poco más de operaciones de tabla detalladas.

Anteriormente usamos la clase AWS.DynamoDB que utiliza un enfoque de programación de bajo nivel. Ahora usaremos otra clase de dynamodb, que es AWS.DynamoDB.DocumentClient, que nos brinda acceso de alto nivel mientras trabajamos con elementos. Decimos que proporciona acceso de alto nivel porque abstrae todos los detalles innecesarios del usuario, como la asignación de los tipos de datos internos de DynamoDB a los tipos de datos de JavaScript.

Operaciones de tabla de acceso de alto nivel

Poner artículo

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.put({
    TableName: 'demo_sdk',
    Item: {
// specify attributes as key value pairs
        user_id: 'first',
  //timestamp is the primary key
        timestamp: 3,
        title: 'The Secret',
        content: 'Book'
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

¿Quiere actualizar la entrada del artículo pero no quiere perder el tiempo buscando y modificando su valor? DynamoDB también proporciona una solución para eso, que es la función docClient.update.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.update({
    TableName: 'demo_sdk',
    Key: {
        user_id: 'first',
        timestamp: 3
    },
    UpdateExpression: 'set #old = :new',
    ExpressionAttributeNames: {
        '#old': 'The Secret' 
    },
    ExpressionAttributeValues: {
       //Title of item is updated
        ':new': "Hall of Games"
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Una vez que comienza a ver el patrón en la sintaxis del código, se vuelve bastante fácil escribirlo por su cuenta, así que intente este y luego compare su código.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.delete({
    TableName: 'demo_sdk',
    Key: {
        user_id: 'first',
        timestamp: 3
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Esta función nos ayuda a colocar o eliminar varios elementos a la vez, lo que simplifica mucho nuestro trabajo cuando trabajamos con un gran conjunto de entradas de tabla.

const docClient = new AWS.DynamoDB.DocumentClient();
docClient.batchWrite({
    RequestItems: {
        'demo_sdk': [
            {
              // deletes item , here, only one
                DeleteRequest: {
                    Key: {
                        user_id: 'first',
                        timestamp: 3
                    }
                }
            },
            {
              // inserting two items in the table
                PutRequest: {
                    Item: {
                        user_id: 'new',
                        timestamp: 1,
                        title: 'To Kill a MockingBird',
                        content: 'Harper Lee'
                    }
                }
            },
            {
                PutRequest: {
                    Item: {
                        user_id: 'two',
                        timestamp: 2,
                        title: 'Harry Potter',
                        content: 'J.K Rowling'
                    }
                }
            }
        ]
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

const docClient = new AWS.DynamoDB.DocumentClient();
// to get an item with the corresponding key parameters
docClient.get({
    TableName: 'demo_sdk',
    Key: {
        user_id: 'two',
        timestamp: 2
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

const docClient = new AWS.DynamoDB.DocumentClient();
//here we specify th query condition or the where clause, for instance if we
// have multiple table entries for a user_id and want to get all those items at
//once (in this case we don't, but for the sake of learning XD)
docClient.query({
    TableName: 'demo_sdk',
// condition is: user_id must be equal to the value of expression attribute id
    KeyConditionExpression: "user_id = :id",
    ExpressionAttributeValues: {
        ":id": "new"
    }
}, (err, data)=>{
    if(err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

Se ha familiarizado con una comprensión básica de lo que es AWS DynamoDB y luego aprendió más sobre cómo trabajar con dynamodb utilizando códigos javascript simples con AWS SDK. Más información sobre las clases de dynamodb y las operaciones de tabla de bajo y alto nivel como: Crear tabla, Eliminar tabla, Describir tabla, Poner elemento, Obtener elemento, Eliminar elemento, Escribir elemento por lotes, Consultar un elemento y actualizar el elemento.

DynamoDB usando AWS SDK para Javascript/Node.js

¡Gracias por leer!