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
nodejs
open source
tutorial