Redis: Cache y Lock distribuido (I)

La arquitectura microservicios nació por la creciente necesidad de ofrecer una mayor calidad de servicio ante el aumento de los volúmenes de tráfico.

Introducción

Antes de comenzar la “moda” de los microservicios, las aplicaciones eran mayoritariamente monolíticas y sus posibilidades de soportar el aumento del tráfico de operación se basa en un escalamiento vertical mayoritariamente. Básicamente una aplicación puede escalar de dos formas, vertical u horizontalmente.

Escalamiento vertical: Tiene lugar cuando el método que se aplica para que la infraestructura soporte mayor cantidad de transacciones se basa en aumentar los recursos de hardware donde se ejecuta el software, por ejemplo subir de 16 GB de RAM a 32GB, o aumentar el poder de procesamiento.

Escalamiento horizontal: En lugar de crecer la infraestructura se despliega una infraestructura paralela (o varias), con recursos similares entre todos los nodos y se despliegan nuevas instancias. Este es el tipo de escalamiento que se emplea en la arquitectura de microservicios para lograr mayor resiliencia, calidad de servicio, rendimiento, etc.

Ambas aproximaciones son válidas, y no vamos a detallar los ventajas de un u otro enfoque en este artículo.

Sin embargo, centrémonos en el enfoque del escalamiento horizontal y uno de los retos que trae consigo: ¿Cómo lograr que varias instancias de un mismo microservicio compartan datos en memoria y puedan controlar el acceso a los recursos ?

Para poder resolver este problema se precisa de un sistema que permita gestionar de forma distribuida los recursos, la solución puede ser desde desarrollar un mecanismo propio hasta usar alguno de los existentes en el mercado, por experiencia del autor podemos usar Hazelcast, del que ya hablamos en otra entrada, o mirar hacia una solución similar, competidor del primero que posibilita resolver el problema: Redis.

¿Qué es Redis?

Redis es un motor de bases de datos, empleado usualmente como una base de datos en memoria que funciona bajo el esquema de clave-valor, puede ser usado como cache y cola de mensajes. Esta escrito en el lenguaje Ansi C, y es ofrecido como una solución de código abierto (Licencia BSD) por Redis Labs.

Redis incorpora además un interprete de Lua y escala horizontalmente bajo la filosofía de maestro-esclavo, permitiendo jerarquizar en forma de árbol a partir de que un esclavo puede ser maestro para otros. Ofrece librerías clientes para los lenguajes más populares del mercado.

En esta serie de artículos que vamos a escribir, del cual este es la primera parte usaremos Redis desde Java / Spring, para ello existen varias librerías, las más populares Redisson, Jedis y Lettuce. En los siguientes artículos usaremos Redis para caché distribuida y luego para lock distribuido.

Instalando Redis con docker

El objetivo de esta seria no está centrado en la administración de un cluster de Redis, el foco principal lo pondremos en como trabajar desde Spring, con Redis en un ambiente distribuido, entonces usaremos una sola instancia de Redis, que pondremos en operación desde una imagen de docker.

En un artículo anterior hablamos de Portainer, un fantástico manejador de imágenes de docker basado en la web, que podemos montar en el propio docker sin requerir privilegios administrativos o aplicaciones de escritorio. Puedes ver esta entrada.

Para instalar Redis, teniendo instalado previamente docker / docker-compose podemos hacerlo usando la siguiente secuencia de pasos:

• Cree una carpeta llamada redis
• Dentro cree un fichero llamado docker-compose.yml.
• Agregue al fichero la receta de creación mostrada debajo.
• Ejecute el comando docker-compose up -d

Receta de instalación de redis

version: '3'
services:
  redis:
    image: redis
    container_name: redis-cache
    ports:
        - 6379:6379

Al ejecutar el comando docker-compose up -d en el directorio “redis” debe salir una lista de acciones similar a la siguiente:

yoandypv@scv:~/Escritorio/redis$ docker-compose up -d
Creating network "redis_default" with the default driver
Pulling redis (redis:)...
latest: Pulling from library/redis
bb79b6b2107f: Pulling fs layer
1ed3521a5dcb: Pulling fs layer
1ed3521a5dcb: Downloading [============>                                      ] 1ed3521a5dcb: Downloading [==================================================>] 1ed3521a5dcb: Download complete
bb79b6b2107f: Downloading [>                                                  ]  277.5kB/27.09MBwnloading [=========================>                         ] bb79b6b2107f: Downloading [=>                                                 ] bb79b6b2107f: Pull complete
1ed3521a5dcb: Pull complete
5999b99cee8f: Pull complete
dd17877d8f2d: Pull complete
4863b56b12a8: Pull complete
069e700bc397: Pull complete
Creating redis-cache ... done

Al terminar este proceso puede verificar si redis está en ejecución y con el puerto expuesto hacia el localhost de varias formas, las más sencilla es verificando si hay conectividad con el puerto de redis (6379)

 nc -zv localhost 6379

La respuesta correcta, si todo fue bien debería ser:

Connection to localhost 6379 port [tcp/*] succeeded!

Adicionalmente, si usa portainer puede fijarse en la lista de imágenes docker y debería mostrarse:

Llegado a este punto ya tenemos Redis operativo, en la próxima entrega haremos un ejemplo de Cache distribuida con Redis.