Creando una API con Lambda, API Gateway y DynamoDB  en  AWS

¿Quieres saber cómo empezar con AWS Lambda, AWS API Gateway y DynamoDB para crear APIs fáciles de escalar y mantener?, chécate este tutorial.

Creando una sencilla API Rest con Lambda, API Gateway y DynamoDB — AWS Serverless

En estos días ando trabajando con serverless, Lambda, API Gateway, DynamoDB, RDS, Cognito, y se me ocurrió la idea de que, basado en la publicación que tengo con hacer un API Rest en NodeJS, hacer una en Lambda, para aquellos que les interesa el serverless o que quieren hacer una API Rest por diversión.

Antes de empezar, quiero aclarar que, esto será un modo muy sencillo y “dummy”, un punto de entrada, así que no aplico mejores prácticas para serverless, usamos todo a lo más básico y solamente mostraremos Lambda, API Gateway y una pequeña conexión a DynamoDB.

IAM

Lo primero es entonces, ya estando en nuestra cuenta dirigirnos a IAM para crear un rol, hacemos clic en el botón “Crear Rol” y veremos lo siguiente:

Dentro, dejamos “Servicio de AWS” y seleccionamos “Lambda”, damos clic en “Siguiente” abajo a la derecha.

Después nos pedirá las políticas, asignamos la relacional a DynamoDBFullAccess:

En la parte de etiquetas, podemos dejar todo como está.

En la parte final, le pondremos “dummy-api” en el nombre.

Listo, al hacer clic en “Crear un rol” ya terminamos.

LAMBDA

Ahora sí, vamos a Lambda. Vamos a crear una función llamada DummyApiIndex que será nuestro “punto de entrada”. Hacemos clic en el botón naranja “Crear una función”, ya dentro veremos lo siguiente:

Le dejamos “Crear desde cero”, luego en información básica ponemos el nombre dummyApiIndex, dejamos NodeJS 12.x y en permisos seleccionamos: Uso de un rol existente, en el dropdown que veremos, seleccionamos el rol que creamos en el primer paso y damos clic en “Crear función”.

Una vez realizado el paso anterior veremos lo siguiente:

Aquí, vamos a nuestro editor y agregar el siguiente código borrando el anterior:

exports.handler = async (event) => {
    return { message: 'Mi primer API en Serverless' };
};

En la barra superior, veremos el botón “Guardar”, le damos clic y después, vamos a generar un sistema para probarlo, para ello ahí al lado hacemos clic en “Seleccionar un evento de pruebas”, nos abrirá un dropdown con “Configurar grupo de pruebas” y hacemos clic ahí.

Nos saltará un modal y dejamos algo como esto:

Guardamos y …¡Listo!, creamos nuestra primer función Lambda, si hacen clic en “Probar” podrán ver que nos muestra nuestro mensaje.

API Gateway

Ahora, hay que vincular este endpoint a API Gateway, que es quien genera las rutas.

Vamos a API Gateway entonces y veremos una lista de opciones, vamos a seleccionar “API Rest”:

Esta a diferencia de la última es que la última solo conecta entre servicios internos de AWS, pero a nosotros nos interesa que otros puedan conectarse a nuestro API.

Dentro vamos a configurar nuestra API de la siguiente forma:

Así una vez guardada, veremos la interfaz de API Gateway para crear rutas.

Por default, veremos que hay una ruta “/” la cual es “el index”, para ello hay que asignarle todavía la primer función Lambda que creamos, para ello hacemos clic en “Acciones” y en el desplegable seleccionamos un “Método” (“Crear método”) y en el dropdown que aparece seleccionamos “GET”, algo como esto:

Le damos clic en la palomita, y se crea nuestra primer ruta. Vamos a configurarla de la siguiente forma:

Al darle clic en Guardar, aceptamos el modal que nos aparece (básicamente dice que se va a vincular con Lambda…). Ahora, como queremos que nuestro API sea público, vamos a seleccionar la ruta raíz “/”, y en “Acciones” seleccionamos “Habilitar CORS”, esto permitirá a cualquiera conectarse a nuestro API, solo damos en “Guardar” nos saltará un “Warning” y aceptamos, recuerden eliminar esta API después, ya que aquí no estamos agregando seguridad y puede que alguien utilice esta API Dummy y les haga peticiones haciéndolos que el Free-Tier que estamos usando se dispare y tengan que pagar por su uso.

Ahora necesitamos crear una etapa y estamos listos para liberar nuestro primer endpoint en la raíz de nuestro API. Para ello en el menú “Acciones” una vez más vamos a hacer clic en “Implementar la API”, dentro del modal veremos lo siguiente y lo configuraremos de la siguiente forma:

Después veremos que nos asignó un dominio en la parte superior, ese será nuestra URL, por ejemplo:

https://xxxxxxxx.execute-api.us-east-1.amazonaws.com/staging

Una vez dentro veremos nuestro mensaje de Lambda. ¡Listo!, tenemos nuestro primer endpoint de nuestra primer API en Serverless dentro de AWS.

DynamoDB

Bueno, ahora sigue crear 2 endpoints más, uno para crear un recurso y otro para obtener esos recursos, es decir, vamos a crear una tabla en Dynamo para guardarlos. Así que nos dirigimos a DynamoDB para crearla:

Una vez dentro, le damos clic a “Crear tabla” y se nos mostrará un formulario como el siguiente:

Solamente hay que crear dos cosas, el nombre de la tabla y la clave principal, esta es algo como la típica “ID” de las tablas MySQL y eso, un identificador vamos, así que pondremos “frases” y le pondremos “id” a la clave principal, es todo, damos clic en “Crear”, tomará un rato en lo que se crea, pero ya no ocupamos estar ahí, podemos regresar a Lambda mientras hace el proceso.

Dentro de Lambda vamos a agregar dos nuevas funciones “dummyApiAgregarFrase” y “dummyApiListarFrases”. No olviden asignar el rol como se mencionó previamente.

Primero haremos el listado, en el código agregaremos:

const AWS = require("aws-sdk");
const documentClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async(event) => {
    const params = {
        TableName: "frases"
    };
    try {
        const data = await documentClient.scan(params).promise();
        return {
            error: false,
            message: 'Lista de frases',
            data: data,
            code: 200
        };
    }
    catch (e) {
        return {
            error: false,
            message: 'Hubo un problema al obtener las frases',
            code: 502
        };
    }
};

Básicamente lo que hace es llamar el cliente de Dynamo, se conecta, manda pedir los datos de la tabla “frases” y luego los retorna. En caso de algún problema nos mostrará “Hubo un problema al obtener las frases”, guardamos y generamos una prueba, de igual forma que en el Index, en la respuesta veremos (cabe mencionar que el código debería solamente mostrar la parte de Items, pero como dije, esto es lo más básico):

Response:
{
  "error": false,
  "message": "Lista de frases",
  "data": {
    "Items": [],
    "Count": 0,
    "ScannedCount": 0
  },
  "code": 200
}

Porque no hay frases todavía, pero, vamos a agregar unas con nuestro endpoint. Para ello vamos a la función “agregar”, en el código pondremos lo siguiente:

const AWS = require("aws-sdk");
const crypto = require("crypto");
const generarId = () => crypto.randomBytes(16).toString("hex");
const documentClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async(event) => {
    const { frase } = event;
    const params = {
        TableName: "frases",
        Item: {
            id: generarId(),
            frase: frase
        }
    };
    try {
        const data = await documentClient.put(params).promise();
        return {
            error: false,
            message: 'Frase agregada',
            code: 200
        };
    }
    catch (e) {
        return {
            error: false,
            message: 'Hubo un problema al agrear la frase',
            code: 502
        };
    }
};

¡Y listo!, ahora, vamos a probar, para ello generamos un nuevo evento de prueba y dentro le pondremos el siguiente JSON:

{ "frase": "Hola mundo" }

Veremos que al cliquear en probar nos sale el aviso de que la Frase fue agregada.

Ahora, si regresamos al endpoint de listar, veremos nuestra primer frase, “Hola mundo”.

Response:
{
  "error": false,
  "message": "Lista de frases",
  "data": {
    "Items": [
      {
        "id": "8530b556a6f32dc3d66880eea7dd712a",
        "frase": "Hola mundo"
      }
    ],
    "Count": 1,
    "ScannedCount": 1
  },
  "code": 200
}

Ahora hay que vincular estas nuevas funciones a API Gateway y terminamos.

Finalizando

Vamos a API Gateway a agregar los dos endpoints. De la misma forma que agregamos un Recurso para “/” vamos a agregar otro para “/frases”. Así que hacemos clic en “Acciones” luego en “Crear recurso”, en el nombre pondremos: “frases” y tildamos “Habilitar API Gateway CORS”:

¡Listo!, tenemos nuestra ruta, ahora faltan los métodos. Seleccionado “/frases”, hacemos clic en “Agregar método” dentro de “Acciones”, agregamos dos repitiendo el proceso, un GET y un POST.

Dentro del GET asignaremos nuestra función de Lambda para listar:

Y en el POST igual, pero, la función Lambda de agregar.

Recuerda aceptar el modal en ambos casos.

Listo, ya tenemos nuestros dos métodos. Ahora hay que hacer el proceso de implementación de nueva cuenta, damos clic en “Acciones” y luego “Implementar la API”, esta vez solamente nos mostrará el estado, seleccionamos “staging” y le damos implementar.

Si accedemos a la URL con el endpoint /frases veremos su contenido, por ejemplo:

https://xxxxxx.execute-api.us-east-1.amazonaws.com/staging/frases

En este caso yo tengo 2, sin querer cliquee demás “Probar” y pues ¯\_(ツ)_/¯

Por último probemos el POST:

Y si vemos nuestro GET veremos las nuevas agregadas:

¡LISTO!, hemos terminado con el tutorial, el siguiente paso es que investigues cómo hacer el DELETE y el PUT y termines tu primer API Serverless con API Gateway, Lambda y DynamoDB.

Conclusión

Con serverless como puedes ver podemos hacer APIs muy sencillas, aunque es difícil aprender a configurarlas correctamente, pero una vez que lo comprendes puedes lograr cosas excelentes. Recuerda eliminar todo lo que generamos en este tutorial para evitar que generes algún gasto.

¿Cuál es tu reacción?
+1
0
+1
0
+1
0
+1
0
+1
0
Total
0
Shares
Publicación anterior

Obteniendo e imprimiendo HTML externo con React

Siguiente Publicación

10 Tips para iniciarte en la programación

Publicaciones Relacionadas