UPDATE para actualizar datos

Curso de Serverless Framework en AWS

Bienvenida

Bienvenida al curso de Serverless Framework

Presentación de proyecto

Conceptos Claves

Definiciones claves del ecosistema Serverless

Ventajas y desventajas de Serverless framework

Explicación de Serverless Framework

Serverless en local

Herramientas necesarias para un ambiente de trabajo con serverless framework

Instalación en macOS

Conociendo el serverless.yml: provider, functions, custom, plugins, etc

Ecosistema Serverless en AWS

Iniciar proyecto con Serverless Framework

Revisión de los recursos creados

Probar y debuggear en local y en la nube

Desarrollando con Serverless Framework

Recapitulación de la aplicación y método GET

DynamoDB en local

Despliegue y Testing de nuestro GET

Creación y despliegue de POST

UPDATE para actualizar datos

Hacemos un DELETE con python

Otros servicios AWS y presentación de casos de uso del segundo curso

Bonus

Creación de Budget en AWS

Indicaciones de GitHub Actions

CI/CD para nuestro proyecto

Refactor y alistamiento para Prod

Cierre del curso

Limpiemos nuestro workspace en AWS

Recapitulación y cierre de curso

Crea tus API’s con Serverless Framework y ChatGPT

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

¿Cómo integrar updates en una aplicación serverless con DynamoDB?

La integración y actualización de datos en una aplicación serverless con DynamoDB es un componente esencial que te permitirá tener un sistema CRUD totalmente funcional. Hasta este punto, hemos cubierto los métodos de creación y consulta. La lógica de actualización tiene sus propios matices, y aquí te llevaremos paso a paso para implementar el método update usando Amazon DynamoDB con lambda functions.

¿Cómo estructurar el proyecto para implementar la función update?

Para comenzar, debes contar con una estructura de carpetas adecuada. Crea una carpeta llamada updateUsers donde incluirás un archivo handler.js. Es importante modificar el serverless.yml para añadir una nueva función lambda que representará la funcionalidad de updateUsers. Recuerda:

Actualizar el nombre de la función: Cambia el nombre en el archivo de configuración serverless.yml.
Definir el handler correspondiente: Asegúrate de que el handler apunta al archivo handler.js dentro de tu carpeta updateUsers.
Seleccionar el método HTTP correcto: Según las buenas prácticas de DynamoDB, utiliza el método HTTP PATCH para las actualizaciones.

¿Cómo hacer el refactoring del código para el update?

Un punto crucial al implementar la función de update es el refactoring del código base. A continuación, te explico cómo hacerlo:

Obtener los parámetros necesarios: La función toma un ID desde la URL y un body que contiene los datos que se deben actualizar.
```
const userId = // obtener ID de la URL
const body = JSON.parse(event.body); // parsear el body para usarlo
```

Configurar los params de DynamoDB: Adaptar los parámetros necesarios, incluyendo UpdateExpression, ExpressionAttributeNames, y ExpressionAttributeValues.

const params = {
    TableName: 'users_table',
    Key: { 'userId': userId },
    UpdateExpression: 'SET #name = :name',
    ExpressionAttributeNames: { '#name': 'name' },
    ExpressionAttributeValues: { ':name': body.name }
};

Hacer el update llamado: Cambia la lógica para realizar la operación de update que incorpore los parámetros previamente configurados.

Esto te permitirá actualizar los datos según los inputs proporcionados en el body de la solicitud.

¿Cómo desplegar la función lambda actualizada?

Una vez que tu lógica está lista, es hora de desplegar la función. Usa el comando serverless deploy para iniciar el despliegue. Este proceso es sencillo y automatizado gracias a las capacidades del framework serverless.

Mira cómo se despliega una función lambda:

serverless deploy

Después de un despliegue exitoso, utiliza herramientas como Postman para verificar que la aplicación efectivamente realiza las actualizaciones sobre los registros de DynamoDB. Asegúrate de proporcionar el ID correcto y un body en formato JSON.

¿Cuál es el siguiente paso?

Ahora que tienes una aplicación parcialmente completa con create, read, y update, el siguiente paso será implementar la funcionalidad de delete para completar el ciclo CRUD. Mantente atento a la próxima clase donde exploraremos cómo eliminar registros utilizando lambda functions.

En cada paso del camino, vamos construyendo un sistema cada vez más robusto y eficiente que se aprovecha de la escalabilidad y facilidad de implementación que AWS y el framework serverless ofrecen. ¡Sigue adelante y comparte tus experiencias con la comunidad!

Aportes 5

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Julio Sarango

hace 2 años

Mi función par actualizar tanto name como teléfono:

const aws = require("aws-sdk")

let dynamoDbClientParams = {}



const dynamodb = new aws.DynamoDB.DocumentClient(dynamoDbClientParams)


const updateUsers = async(event, context) => {

  let userId = event.pathParameters.id

  const body = JSON.parse(event.body)
  const params = {
    TableName: 'usersTable',
    Key: { pk: userId },
    UpdateExpression: "set #name = :name, #telefono = :telefono",
    ExpressionAttributeNames : {"#name":"name", "#telefono": "telefono"},
    ExpressionAttributeValues: { ':name': body.name, ":telefono": body.telefono },
    ReturnValues: "ALL_NEW"
  }

  return dynamodb.update(params)
    .promise()
    .then(res => {
      console.log(res)
      return {        
          "statusCode": 200,
          "body": JSON.stringify({"user": res})        
      }
    })
}


module.exports = {
  updateUsers
}

Ciro Villafraz

hace 2 años

Con ayuda de ChatGPT creé una función que genera un objeto params para el update, tal que sea posible actualizar una cantidad arbitraria de propiedades. Este fue el resultado.

function makeUpdateParams(tableName, key, attributesToUpdate) {
  const ExpressionAttributeNames = {};
  const ExpressionAttributeValues = {};
  let UpdateExpression = "SET ";

  // For each attribute to update, add it to the UpdateExpression and build the ExpressionAttributeNames and ExpressionAttributeValues objects
  Object.entries(attributesToUpdate).forEach(
    ([attributeName, attributeValue]) => {
      const keyName = `#${attributeName}`;
      const valueName = `:${attributeName}`;
      UpdateExpression += `${keyName} = ${valueName}, `;
      ExpressionAttributeNames[keyName] = attributeName;
      ExpressionAttributeValues[valueName] = attributeValue;
    }
  );

  // Remove the trailing comma and space from the UpdateExpression
  UpdateExpression = UpdateExpression.slice(0, -2);

  // Build the params object with the tableName, key, UpdateExpression, and ExpressionAttributeNames and ExpressionAttributeValues objects
  const params = {
    TableName: tableName,
    Key: { pk: key },
    UpdateExpression,
    ExpressionAttributeNames,
    ExpressionAttributeValues,
    ReturnValues: "ALL_NEW",
  };

  return params;
}

Alejandro Chavez

hace 2 años

Consejos

En mi caso, antes de hacer el sls deploy me gusta hacer todas las pruebas con sls offline server para corregir todo en local en caso de haber fallas y una vez validado si mandar todo a la nube. Así evitamos constantemente hacer actualizaciones al stack de CloudFormation (lo cual resulta un poco lento y genera pequeños costos innecesarios).
Por otro lado, les recomiendo mucho a los que usan Insomnia (creo que debe haber una manera en Postman) crear estos entornos, para siempre hacer llamados a las mismas direcciones y solo cambiando el URL de la API de acuerdo a desarrollo o producción:
Así va mi DynamoDB por ahora:
Mi GitHub

Eneida Sumaya Gonzales Lema

hace 2 años

Así va quedando mi tabla 😃

Mijail Antonio Pulgar Ciro

hace 24 días

note que si le paso un id que no existe en la db la crea y para evitar esto agregue en los params ConditionExpression: "attribute\_exists(pk)"