Construir API Rest Nodejs Serverless con AWS Lambda y Aurora Serverless

Esta es la segunda guía para construir una API Serverless con AWS, la primera la puedes encontrar acá la diferencía son las bases de datos, si quieres saber un poco más sobre que opino al respecto de Serverless pros y contras en ese árticulo explico un poco más, en este vamos a ir directo a donde las papas queman.

Objetivo

Terminar la guía con una API desplegada de AWS y conectada con Aurora Serverless SQL.

Resultado

Puedes encontrar el resultado de esta guía aquí

Requisitos previos

  • Tener nodejs 10 o superior
  • Cuenta en AWS
  • CLI Tool de Serverless

Primeros pasos

La base

Con las herramientas que nos ofrece el CLI de Serverless podemos iniciar el proyecto muy r√°pidamente usando el comando:

sls create -t aws-nodejs -p note-api && cd note-api

En un par de minutos ya tendr√°s la base del proyecto lista para comenzar.

Las dependencias

Serverless tiene un gran sistema de plugins que podemos utilizar, uno de las más utilizadas es serverless-offline que vamos a instalar en conjunto con los módulos que necesitamos para conectarnos con la base de datos, para ello ejecutamos los siguientes comandos en la raíz del proyecto:

npm init -y npm i --save-dev serverless-offline npm i --save mysql2 sequelize

Comenzamos a escribir código

En la base de nuestro proyecto /note-api tendr√°s un archivo serverless.yml con configuraciones previas por defecto, ese archivo lo vamos a sustituir complementa con el siguiente contenido:

serverless.yml

1service: note-api 2 3custom: 4 secrets: ${file(secrets.json)} 5 6provider: 7 name: aws 8 runtime: nodejs12.x 9 timeout: 30 10 stage: ${self:custom.secrets.NODE_ENV} 11 environment: 12 NODE_ENV: ${self:custom.secrets.NODE_ENV} 13 DB_NAME: ${self:custom.secrets.DB_NAME} 14 DB_USER: ${self:custom.secrets.DB_USER} 15 DB_PASSWORD: ${self:custom.secrets.DB_PASSWORD} 16 DB_HOST: ${self:custom.secrets.DB_HOST} 17 DB_PORT: ${self:custom.secrets.DB_PORT} 18 vpc: 19 securityGroupIds: 20 - ${self:custom.secrets.SECURITY_GROUP_ID} 21 subnetIds: 22 - ${self:custom.secrets.SUBNET1_ID} 23 - ${self:custom.secrets.SUBNET2_ID} 24 - ${self:custom.secrets.SUBNET3_ID} 25 - ${self:custom.secrets.SUBNET4_ID} 26 - ${self:custom.secrets.SUBNET5_ID} 27 - ${self:custom.secrets.SUBNET6_ID} 28 29functions: 30 healthCheck: 31 handler: handler.healthCheck 32 events: 33 - http: 34 path: / 35 method: get 36 cors: true 37 create: 38 handler: handler.create 39 events: 40 - http: 41 path: notes 42 method: post 43 cors: true 44 getOne: 45 handler: handler.getOne 46 events: 47 - http: 48 path: notes/{id} 49 method: get 50 cors: true 51 getAll: 52 handler: handler.getAll 53 events: 54 - http: 55 path: notes 56 method: get 57 cors: true 58 update: 59 handler: handler.update 60 events: 61 - http: 62 path: notes/{id} 63 method: put 64 cors: true 65 destroy: 66 handler: handler.destroy 67 events: 68 - http: 69 path: notes/{id} 70 method: delete 71 cors: true 72 73plugins: 74 - serverless-offline

En este archivo estan pasando varias cosas, primero declaramos el nombre del servicio o de la app que contendrá las funciones lambda, luego cargamos un archivo de configuración secrets: ${file(secrets.json)} personalizado que nos ayudará más adelante para definir variables de entorno, en el provider.environment definimos las variables de entorno para el proyecto, en functions todas las funciones y los endpoints de las mismas, al final pero no menos importante plugins donde cargamos los plugins que vamos a utilizar en este proyecto.

secrets.json

En la raíz del proyecto al lado de nuestro archivo serverless.yml crearemos un nuevo archivo llamado secrests.json que deberá verse así:

{ "DB_NAME": "test", "DB_USER": "root", "DB_PASSWORD": "root", "DB_HOST": "127.0.0.1", "DB_PORT": 3306, "NODE_ENV": "dev", "SECURITY_GROUP_ID": "sg-xx", "SUBNET1_ID": "subnet-xx", "SUBNET2_ID": "subnet-xx", "SUBNET3_ID": "subnet-xx", "SUBNET4_ID": "subnet-xx", "SUBNET5_ID": "subnet-xx", "SUBNET6_ID": "subnet-xx" }

En este archivo vamos a sustituir las variables cuando creemos la base de datos en la consola de AWS, recuerda agregarlo a tu archivo `.gitignore

Las funciones

En nuestro archivo serverless.yml ya definimos las funciones, nombres y el endpoint correspondiente e indicamos que esas funciones estar√≠an en el archivo handlers.js pero en este momento a√ļn no est√°n, para agregarlas debemos sustituir el c√≥digo por defecto que tiene este archivo por este:

1module.exports.healthCheck = async () => { 2 await connectToDatabase() 3 console.log('Connection successful.') 4 return { 5 statusCode: 200, 6 body: JSON.stringify({ message: 'Connection successful.' }) 7 } 8} 9 10module.exports.create = async (event) => { 11 try { 12 const { Note } = await connectToDatabase() 13 const note = await Note.create(JSON.parse(event.body)) 14 return { 15 statusCode: 200, 16 body: JSON.stringify(note) 17 } 18 } catch (err) { 19 return { 20 statusCode: err.statusCode || 500, 21 headers: { 'Content-Type': 'text/plain' }, 22 body: 'Could not create the note.' 23 } 24 } 25} 26 27module.exports.getOne = async (event) => { 28 try { 29 const { Note } = await connectToDatabase() 30 const note = await Note.findByPk(event.pathParameters.id) 31 if (!note) throw new HTTPError(404, `Note with id: ${event.pathParameters.id} was not found`) 32 return { 33 statusCode: 200, 34 body: JSON.stringify(note) 35 } 36 } catch (err) { 37 return { 38 statusCode: err.statusCode || 500, 39 headers: { 'Content-Type': 'text/plain' }, 40 body: err.message || 'Could not fetch the Note.' 41 } 42 } 43} 44 45module.exports.getAll = async () => { 46 try { 47 const { Note } = await connectToDatabase() 48 const notes = await Note.findAll() 49 return { 50 statusCode: 200, 51 body: JSON.stringify(notes) 52 } 53 } catch (err) { 54 return { 55 statusCode: err.statusCode || 500, 56 headers: { 'Content-Type': 'text/plain' }, 57 body: 'Could not fetch the notes.' 58 } 59 } 60} 61 62module.exports.update = async (event) => { 63 try { 64 const input = JSON.parse(event.body) 65 const { Note } = await connectToDatabase() 66 const note = await Note.findByPk(event.pathParameters.id) 67 if (!note) throw new HTTPError(404, `Note with id: ${event.pathParameters.id} was not found`) 68 if (input.title) note.title = input.title 69 if (input.description) note.description = input.description 70 await note.save() 71 return { 72 statusCode: 200, 73 body: JSON.stringify(note) 74 } 75 } catch (err) { 76 return { 77 statusCode: err.statusCode || 500, 78 headers: { 'Content-Type': 'text/plain' }, 79 body: err.message || 'Could not update the Note.' 80 } 81 } 82} 83 84module.exports.destroy = async (event) => { 85 try { 86 const { Note } = await connectToDatabase() 87 const note = await Note.findByPk(event.pathParameters.id) 88 if (!note) throw new HTTPError(404, `Note with id: ${event.pathParameters.id} was not found`) 89 await note.destroy() 90 return { 91 statusCode: 200, 92 body: JSON.stringify(note) 93 } 94 } catch (err) { 95 return { 96 statusCode: err.statusCode || 500, 97 headers: { 'Content-Type': 'text/plain' }, 98 body: err.message || 'Could destroy fetch the Note.' 99 } 100 } 101}

Con esto tendremos definidas las funciones, puede parecer confuso todo lo que está pasando en este gran trozo de código pero básicamente es un controlador que trabajar en conjunto con nuestro Modelo de Note (o notas), para crear un CRUD.

Conexión a la base de datos

Ahora que ya tenemos los endpoint en el serverless.yml y el controlador en el handler.js nos hace falta la conexión con la base de datos y el modelo, para esto vamos a crear un archivo db.js en la raíz del proyecto que tenga el siguiente contenido:

1const Sequelize = require('sequelize') 2const NoteModel = require('./models/Note') 3 4const sequelize = new Sequelize( 5 process.env.DB_NAME, 6 process.env.DB_USER, 7 process.env.DB_PASSWORD, 8 { 9 dialect: 'mysql', 10 host: process.env.DB_HOST, 11 port: process.env.DB_PORT 12 } 13) 14 15const Note = NoteModel(sequelize, Sequelize) 16const Models = { Note } 17const connection = {} 18 19module.exports = async () => { 20 if (connection.isConnected) { 21 console.log('=> Using existing connection.') 22 return Models 23 } 24 25 await sequelize.sync() 26 await sequelize.authenticate() 27 connection.isConnected = true 28 console.log('=> Created a new connection.') 29 return Models 30}

Lo m√°s importante de este archivo es c√≥mo se administran las conexiones a la base de datos, si no existe alguna conexi√≥n se crear y en caso de que a√ļn est√© viva una conexi√≥n de reutiliza.

Modelo de datos

Para nuestro modelo creamos una carpeta llamada models y dentro un archivo Note.js este archivo lo llenamos con el siguiente código:

1module.exports = (sequelize, type) => { 2 return sequelize.define('note', { 3 id: { 4 type: type.INTEGER, 5 primaryKey: true, 6 autoIncrement: true 7 }, 8 title: type.STRING, 9 description: type.STRING 10 }) 11}

En este modelo estamos definiendo la table note y los campos que tendr√° esta tabla en la base de datos, gracias a sequelize es bastante sencillo.

Volvemos al handler.js

Ahora agregamos al comienzo del handler.js la función para iniciar la conexión con la base de datos y una función para manejar los errores de HTTP de forma sencilla

const connectToDatabase = require('./db') function HTTPError (statusCode, message) { const error = new Error(message) error.statusCode = statusCode return error }

¬ŅYa y estamos listos para probar? Aun no, nos falta un gran detalle, para poder probar nuestra aplicaci√≥n offline tenemos que tener una base de datos local, recuerdas el archivo secrets.json si ya tienes instalado mysql en tu computador puedes sustituir all√≠ las variables de tu base de datos por otro lado si no te gusta tener bases de datos instaladas en tu sistema siempre te puedes ayudar con el amigo docker, para eso te dejo este otro articulo: No instales Mysql o Mariadb, utiliza docker.

Pruebas

Una vez que tengas las variables de tu base de datos local o en docker agregadas en el archivo secrets.json ya puedes ejecutar la aplicación, con el comando:

sls offline start --skipCacheInvalidation

La propiedad --skipCacheInvalidation nos ayuda a que se recarguen los m√≥dulos m√°s r√°pidamente. Se lo podemos sacar en caso de tengamos alg√ļn error.

Si todo está correcto como debería ya podemos probar con nuestro Cliente de API favorita, Postman, Insomnia...

1# Las rutas que tenemos definidas son: 2GET - http://localhost:3000/ # Raíz - healthCheck 3POST - http://localhost:3000/notes # Crear una nota - create 4GET - http://localhost:3000/notes/{id} # Leer una nota - getOne 5GET - http://localhost:3000/notes # Leer todas la snotas - getAll 6PUT - http://localhost:3000/notes/{id} # Actualizar una nota - update 7DELETE - http://localhost:3000/notes/{id} # Borrar una nota - destroy

Si revisamos la terminal podrás ver cuando se crear una nueva conexión a la base de datos using new database connection o cuando se utiliza using existing database connection. Hasta este punto todo funciona en local pero el objetivo de esta guía es terminar con una API desplegada en AWS y conectada con Aurora Serverless SQL.

Crear la base de datos Aurora Serverless

Accedemos a la consola de AWS buscamos el servicio RDS y Create databaselas opciones van casi por defecto, las elegimos en el siguiente orden:

Choose a database creation method

  • Standard Create

Engine options

  • Amazon Aurora
  • Amazon Aurora with MySQL compatibilit
  • Versi√≥n (la √ļltima disponible)
  • Regional

Database features

  • Serverless

Templates

  • Dev/Test

Settings

  • DB cluster identifier: El nombre de nuestro cluster o servidor de bases de datos.
  • Credentials Settings: username y password de tu preferencia pero recuerda que las necesitar√°s m√°s adelante.

DB instance size

  • Memory Optimized classes
  • db.r5.large

Availability & durability

  • Create an Aurora Replica/Reader node in a different AZ (recommended for scaled availability).

Connectivity

  • Virtual Private Cloud (VPC): Por defecto crear√° una nueva.

Database authentication

  • Password authentication

Additional configuration

  • Initial database name: importantes necesitamos agregar el nombre a tu base de datos ya que sequelize no es capaz de crear la base de datos.

... los campos no mencionados quedan con el valor por defecto.

Luego confirmamos que queremos crear la base de datos en Create database y esto comienza el proceso que demora un par de minutos (15 ~ 20) luego de que esté creada nuestra base de datos en AWS, tendremos los valores que necesitamos sustituir en el archivo secrets.json.

Deploy

Una vez sustituido las variables en el archivo secrets.json podemos hacer el deploy de nuestra api, con el comando:

sls deploy

Luego de un par de minutos tendremos una url en la que podemos probar como funciona nuestra aplicación desplegada sustituyendo.

Recuerda que puedes ver el resultado de esta guía implementado aquí

Comandos √ļtiles

  • sls config nos ayuda a validar la configuraci√≥n del archivo serverless.yml.
  • sls print nos imprime el archivo serverless.yml tal y como lo ver√≠a el int√©rprete.
  • sls remove si quieres eliminar todos los servicios creados por tu aplicaci√≥n en AWS.

Gracias por llegar hasta ac√°, recuerda si tienes alg√ļn comentario o duda me lo puedes hacer llegar por twitter: @enBonnet o directamente por telegram @enBonnet.

Actualizado 19/04/2020 a las 20:58