Kong: El King de los Microservicios

— Bueno, Denham, los aviones lo mataron.

— No, no fueron los aviones… fue Bella quien mató a la bestia.

Uno de los grandes problemas a lo que nos enfrentamos cuando tenemos una arquitectura dividida en diferentes microservicios, es lo difícil que se puede llegar a ser gestionar tantas entidades independientes dentro de una infraestructura común.

Además, y por normal general, cuando tu arquitectura se encuentra dividida en partes de negocio segregadas, necesitas presentar tu API de una manera homogénea al exterior evitando dar pistas de cómo es tu infraestructura de servicios interna.

Es por ello que es necesario contar con una herramienta que nos permita homogeneizar ciertos procesos y que nos permita gestionar todas las APIs de las que cuenta la arquitectura. Una buena opción puede ser por medio de Kong: Una herramienta que rápidamente se convertirá en un auténtico aliado para nosotros.

¿Qué es Kong?

Dentro de las arquitectura de microservicios, Kong desempeñaría las funciones de API Gateway, ese módulo inicial donde se integran cada uno de nuestros servicios. Lo vemos mejor en el dibujo:

Arquitectura de ejemplo

Kong es una herramienta Open Source creada sobre NGINX para ayudarnos en un gran número de cosas. Kong nos permite:

1. Homogeneizar las diferentes APIs de nuestro negocio.
2. Securizar nuestra API para que no tengan que encargarse los microservicios.
3. Obtener métricas de uso de las diferentes partes de la API.
4. Obtener logs en un repositorio común.
5. Transformar peticiones y respuestas.
6. Almacenar variables de entorno.

Kong se caracteriza por escalar muy bien ya que si necesitamos crear dos o más instancias por el contexto en el que nos encontremos, esto será posible. La información importante de Kong es persistida en base de datos. Kong da soporte para Apache Cassandra y PostgreSQL pudiendo seleccionar la opción que más nos convenga por medio de configuración.

Funcionamiento alto nivel de Kong

Aunque Kong cuenta con mucha funcionalidad preestablecida. Uno de sus puntos fuertes radica en la posibilidad de extender la herramienta por medio de plugins. Kong es una herramienta muy modulable que permite ir agregando funcionalidades según la necesitemos. Los plugins son desarrollados con lenguaje de programación LUA y permite acceso completo a los recursos de la base de datos.

La forma de administrar la herramienta es por medio de una API REST que nos permite añadir, eliminar o modificar servicios, usuarios o plugins. Es una buena funcionalidad ya que en cualquier momento podríamos crearnos una aplicación cliente que nos permitiese administrar Kong a nuestro gusto.

Stack interno de Kong

Lo bueno de Kong es que cuenta con una funcionalidad tan potente que puede ser hasta una buena alternativa para aplicaciones monolito que quiera delegar la seguridad a un módulo externo o que quieran monitorizar ciertos aspectos. Por lo que es para tenerla muy en cuenta. Incluir Kong en tu sistema, puede ser el principio de la rotura de tu monolito :)

Ejemplo práctico: homogeneizando nuestra API

Vamos a hacer un ejemplo práctico para demostrar el potencial de la herramienta. Lo primero que vamos a hacer son dos microservicios que expongan una ruta GET que devuelve un mensaje. Queremos que la funcionalidad se exponga en Internet como una única API por lo que vamos a apoyarnos de Kong para conseguir este cometido. La arquitectura de nuestro sistema queremos que quede parecida a esta:

La estructura en carpetas de lo que intentamos hacer es algo muy simple:

-- demo-kong-api
---- api-user
------- node_modules
------- app.js
------- package.json
---- api-account
------- node_modules
------- app.js
------- package.json

El código de los dos microservicios es el siguiente:

// api-account/app.js
const express = require('express');
const app = express();
const port = 8901;
app.get('/accounts', (req, res, error) => {
    res.status(200).send('Envío cuentas');
});
app.listen(port, error => {
    if (error) {
        console.log(error);
    }
    console.log('Servicio levantado correctamente en ' + port);
});

// api-user/app.js
const express = require('express');
const app = express();
const port = 8765;
app.get('/users', (req, res, error) => {
   res.status(200).send('Envío usuarios');
});
app.listen(port, error => {
    if (error) {
        console.log(error);
    }
    console.log('Servicio levantado correctamente en ' + port);
});

Levantamos cada uno de los servicios con un terminal por medio del comando:

$ node app

Lo siguiente que vamos a hacer es preparar toda nuestra infraestructura. Para ello instalamos Kong. Kong solo se encuentra disponible para distribuciones que soportan UNIX. En este apartado Kong os explica qué opciones tenéis y cómo instalarlo en cada una de ellas.

Una vez que tenemos instalado Kong, abrimos un terminal y ejecutamos la siguiente línea:

$ sudo kong start

Esto inicia el servicio de Kong. Kong por defecto, recibe las peticiones por el puerto 8000. El puerto 8001 está reservado para comunicarnos con la Admin API. Esta API está muy bien documentada aquí, aunque en próximos posts hablaremos más de ella.

Lo siguiente es indicarle a Kong cómo tiene que comportarse con las llamadas que reciba, para lanzamos una petición POST por cada uno de los microservicios a la Admin API de la siguiente manera:

• Esta es la forma de enlazar el microservicio api-user:

$ curl -i -X POST 
    \ --url http://localhost:8001/apis/ 
    \ --data 'name=api-user' 
    \ --data 'upstream_url=http://localhost:8765' 
    \ --data 'request_path=/users'

• Y esta la forma de enlazar el microservicio de api-account:

$ curl -i -X POST 
    \ --url http://localhost:8001/apis/ 
    \ --data 'name=api-account' 
    \ --data 'upstream_url=http://localhost:8901' 
    \ --data 'request_path=/accounts'

El significado de los campos es el siguiente:

• name: nombre descriptivo que queremos que tenga el microservicio dentro de Kong
• upstream_url: url hacia donde se va a redirigir el tráfico.
• request_path: ruta que dispara esta parte de la API.

Ahora para verlo funcionar es muy sencillo. Vamos al navegador y probemos:

• Si ponemos http://localhost:8000/users obtenemos esto:

Ejemplo llamando a la API

• Si ponemos http://localhost:8000/accounts obtenemos esto:

Ejemplo llamando a la API

Para los clientes de nuestro sistema siempre es un monolito. Perfecto :)

Conclusión

Hemos visto como una herramienta como Kong puede ayudarnos mucho a gestionar nuestra API. Existen en el mercado muchas alternativas, pero una que saque tanto partido del proxy inverso NGINX y que nos permita extenderlo por medio de LUA es una opción a tener muy en cuenta.

En próximos capítulos del blog intentaremos securizar nuestro sistema por medio del protocolo oAuth 2 e intentaremos crear nuestro propio plugin para realizar una tarea muy específica de nuestro sistema.

Espero que os guste la idea.

Nos leemos :)