Deploy y orquestación de microservicios con now.sh

Crear una aplicación usando microservicios tiene sus ventajas, una de estas es poder escalar cada servicio individualmente según nuestras necesidades. Así un servicio poco usado puede usar un servidor de menor capacidad y un servicio muy usado uno de mayor capacidad y hasta múltiples instancias del mismo.

Sin embargo no todo es color de rosas, manejar múltiples servicios es complicado y mientras más servicios tengamos más complicado se vuelve. Este proceso se lo llama orquestación, que básicamente significa manejar (de forma automatizada) múltiples servicios y sistemas.

Hay varias herramientas que nos ayudan a hacer esto, uno de ellas es Zeit Now, un servicio para hacer deploy de aplicaciones hechas con Node.js, contenedores de Docker o archivos estáticos y lo más mágico es que Now se encarga de que estas aplicaciones escalen automáticamente con base a nuestra necesidad.

Haciendo nuestro primer deploy

Vamos a hacer deploy de una aplicación muy simple.

Lo primero que tenemos que hacer es instalar Now desde https://zeit.co/download, una aplicación de escritorio hecha con Electron que funciona en Windows, Linux y Mac. También tenemos la posibilidad de instalarlo desde npm usando el comando:

yarn global add now

Una vez instalado Now creamos una carpeta para nuestra aplicación y dentro iniciamos un package.json usando el comando:

yarn init --yes

Instalamos una librería para crear microservicios con Node.js llamada micro con el comando:

yarn add micro

Luego vamos a crear un pequeño archivo .js con el siguiente contenido:

module.exports =()=>`La hora actual es ${Date()}`;

Y agregamos el siguiente script a nuestro package.json:

"scripts": {
    "start": "micro index.js"
}

Ahora sí, por último realizamos el deploy usando un comando muy simple:

now

Si es la primera vez que lo usamos nos va a pedir que iniciemos sesión usando now --login. Ya cuando empiece el deploy obtenemos una URL única similar a mi-deploy-{uid}.now.sh y que al entrar nos muestra como avanza el deploy y cuando termine se va a recargar y nos va a mostrar el resultado.

Con eso ya tenemos un microservicio corriendo en producción, pero la URL no es muy amigable, así que lo que vamos a hacer es colocar un alias a nuestro deploy, eso se logra con otro comando:

now alias mi-deploy-{uid} mi-dominio.com

Luego de alias colocamos la primera parte de la URL del deploy (lo que viene antes del .now.sh) y luego colocamos el alias que queremos usar que puede ser un dominio personalizado. En este caso necesitamos configurar nuestros nameservers para que apunten a Now, o podemos colocar un alias usando algo.now.sh, si esta disponible va a crear el alias y desde ese momento vamos a poder acceder cada vez que queramos a nuestro deploy mediante el mismo.

¿Qué ocurre cuando tengamos que volver a hacer deploy? Simplemente volvemos a correr now y luego now alias usando la nueva URL única. De esa forma se actualiza el alias para apuntar al nuevo deploy y listo, ya tenemos nuestra aplicación actualizada y gracias a que cada deploy es inmutable (no afecta a los demás) ¡No tenemos downtime!

Simplificando el deploy con now.json

Estar corriendo dos comandos cada vez que hagamos el deploy puede volverse una tarea muy repetitiva, más aún cuando el segundo comando requiere de un dato dinámico y único de cada deploy. Sin embargo Now nos ofrece la posibilidad de dejar todo esto preconfigurado creando un simple archivo llamado now.json con el siguiente contenido.

{
	"name": "mi-deploy",
	"alias": "mi-dominio.com",
	"env": {
		"NODE_ENV": "production"
	},
	"type": "npm"
}

Con eso cada vez que corramos now se va a generar un deploy con el nombre mi-deploy (usado para la URL única), en el alias mi-dominio.com, con las variables de entorno NODE_ENV=production y de tipo npm (acá podemos colocar docker si no es una aplicación de Node.js).

Y listo, ahora es muy fácil hacer un deploy. Podríamos tener múltiples repositorios o uno solo (monorepo) con varias carpetas y crear un archivo now.json por cada uno y hacer super simple el proceso, incluso automatizarlo mediante una herramienta de integración continua como Travis CI.

Orquestación

Recién dijimos que podríamos tener múltiples microservicios y que a cada uno se le haga deploy por separado, supongamos entonces que tenemos 3 servicios:

• auth.api.mi-dominio.com
• user.api.mi-dominio.com
• frontend.mi-dominio.com

Los dos primeros son parte de un API Rest, en el que tenemos uno para nuestros usuarios y otro para iniciar sesión (obtener un JWT) y por último una aplicación para nuestro frontend (nuestras rutas, peticiones al API y render del HTML). Ahora, todos estamos de acuerdo que esas API no son muy amigables. En cambio si tuviésemos mi-dominio.com, mi-dominio.com/api/auth y mi-dominio.com/api/user sería mucho más fácil tanto para nosotros como para nuestros usuarios. Resulta que Now nos permite hacer esto creando un archivo rules.json (el cual podría estar en la raíz de nuestro monorepo) con el siguiente contenido:

{
	"rules": [
		{ "pathname": "/api/auth", "dest": "auth.api.mi-dominio.com" },
		{ "pathname": "/api/user", "dest": "user.api.mi-dominio.com" },
		{ "pathname": "/", "dest": "frontend.mi-dominio.com" },
	]
}

Luego vamos a correr el siguiente comando:

now alias mi-dominio.com -r rules.json

Desde ahora Now va a encargarse de que todo corra bajo un mismo dominio usando los path que definimos. Si volvemos a hacer deploy de el API de usuarios y actualizamos el alias al nuevo deploy entonces /api/user va a empezar a apuntar directamente al nuevo deploy sin necesidad de hacer ningún otro cambio.

Igualmente podemos modificar rules.json y volver a correr el comando anterior para actualizarlo y que así agregar nuevos servicios bajo nuestro dominio. También es posible definir method en cada regla para indicar que ese servicio solo sirve para un método HTTP específico (o una lista de ellos).

Por último nuestras reglas pueden apuntar a una URL de destino que no este controlada por Now (por ejemplo un servicio de AWS) y este se encarga de funcionar como un Proxy que recibe las peticiones del usuario y las redirige al servicio original.

Conclusiones

Gracias a Now podemos fácilmente hacer deploy a la nube de nuestras aplicaciones web y con su sistemas de orquestación y composición de microservicios podemos al mismo tiempo tener la facilidad de uso de una aplicación monolítica y todo corriendo un simple comando, now.

Si quieres tener la experiencia de usar Now para tu aplicación y recibir capacitación y mentoría presencial, entra a Platzi y regístrate en el Diplomado de Desarrollo de Aplicaciones con React.JS.