Cómo instalar, configurar y usar RabbitMQ

Los message brokers son aplicaciones intermediarias utilizadas en diversas arquitecturas de software, como los microservicios. Transfieren información en forma de mensajes de un servicio a otro.

Un concepto común asociado con los message brokers es el patrón publicador-suscriptor, en el que los eventos son enviados por los llamados publicadores (Producers) a los consumidores (Consumers).

Normalmente, un componente intermediario, un message broker, participa en la implementación de este patrón.

Para simplificar, usemos una analogía. Piensa en YouTube: hay canales a los que puedes suscribirte para recibir notificaciones. Cuando se publica un nuevo video (un evento), recibes una notificación porque estás suscrito.

Cómo funcionan las aplicaciones con message brokers

Tres términos principales son relevantes aquí: Exchange, Queue y Binding.

• Exchange. Es donde se envían los eventos de mensajes. El Exchange decide qué eventos van a qué cola, basándose en las conexiones o bindings, que explicaremos más adelante.

• Queue. La cola es una estructura de datos que funciona bajo el principio de "primero en entrar, primero en salir" (FIFO). Almacena datos en disco o en memoria, representando directamente los mensajes. La cola proporciona copias de estos mensajes a los consumidores.

• Binding. Se refiere al conjunto de reglas que indican al Exchange a qué colas deben dirigirse los mensajes. Puede haber múltiples bindings con diferentes parámetros entre un Exchange y una cola.

Otros términos importantes son:

• Producer es un servicio que genera mensajes y los envía al broker.
• Consumer es otro servicio que comienza a procesarlos al recibir un mensaje. En nuestra analogía con YouTube, el publicador es YouTube en sí, y el consumidor es tu teléfono, que recibe las notificaciones push.

Aquí tienes una explicación paso a paso de cómo funciona el proceso:

1. El Producer envía un mensaje, que va al Exchange.

2. La Queue almacena este mensaje, por ejemplo, en el disco.

3. Cuando un Consumer está listo para recibir un mensaje (ya sea porque terminó de procesar el anterior o porque la aplicación de manejo de eventos se ha iniciado), el servidor envía una copia de los datos desde la cola al consumidor.

4. El Consumer recibe el mensaje, lo procesa y luego envía una confirmación (ACK) de vuelta al broker.

5. Después de que el broker recibe la confirmación, el mensaje se elimina.

Qué es RabbitMQ

RabbitMQ es un popular message broker de código abierto construido sobre AMQP (Advanced Message Queuing Protocol), un protocolo abierto para la transmisión de mensajes de eventos mediante un broker dedicado. AMQP ofrece una amplia gama de funcionalidades y, además de RabbitMQ, también es implementado por otros sistemas como Apache Qpid.

RabbitMQ está escrito en el lenguaje de programación Erlang, y sus principales ventajas son su alto rendimiento y su máxima flexibilidad en el enrutamiento. RabbitMQ ofrece numerosas opciones de configuración para definir reglas sobre qué mensajes se envían y a dónde se procesan.

Las conexiones a RabbitMQ se realizan a través del protocolo TCP: el cliente inicia una conexión con la dirección del host y la mantiene abierta mientras sea necesaria la interacción con RabbitMQ. RabbitMQ también admite autenticación, como usuario y contraseña, para garantizar un acceso seguro.

Instalación en diferentes sistemas operativos

RabbitMQ se compone del servidor y de la interfaz web (WebUI o consola de administración). La WebUI permite supervisar lo que ocurre dentro del broker, como comprobar si los nodos del clúster están activos, ver cuántos mensajes están en proceso, y más. Veamos cómo instalar RabbitMQ en varios sistemas operativos.

Antes de empezar, debemos actualizar el nombre de host del servidor. Ejecuta el siguiente comando:

sudo hostnamectl set-hostname <nuevo-hostname>

Por ejemplo, usaremos rabbitmq como nombre de host para este servidor:

sudo hostnamectl set-hostname rabbitmq

Instala nano:

sudo apt install nano

Y edita el archivo /etc/hosts para incluir el nuevo nombre de host:

sudo nano /etc/hosts

Debe verse así:

127.0.0.1 <nuevo-hostname>

En nuestro ejemplo:

127.0.0.1 rabbitmq

Ubuntu / Debian

Instalaremos RabbitMQ en Ubuntu 22.04. Para otras distribuciones de Ubuntu/Debian, consulta la guía en el sitio oficial.

1. Actualiza la lista de paquetes e instala las dependencias:

sudo apt-get update -y
sudo apt-get install curl gnupg -y
sudo apt-get install apt-transport-https

2. Agrega las claves de firma del repositorio:

curl -1sLf "https://keys.openpgp.org/vks/v1/by-fingerprint/0A9AF2115F4687BD29803A206B73A36E6026DFCA" | sudo gpg --dearmor | sudo tee /usr/share/keyrings/com.rabbitmq.team.gpg > /dev/null
curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-erlang.E495BB49CC4BBE5B.key | sudo gpg --dearmor | sudo tee /usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg > /dev/null
curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-server.9F4587F226208342.key | sudo gpg --dearmor | sudo tee /usr/share/keyrings/rabbitmq.9F4587F226208342.gpg > /dev/null

3. Crea el archivo del repositorio (Apt Source List):

sudo tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb [arch=amd64 signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.rabbitmq.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
EOF

4. Actualiza nuevamente la lista de paquetes:

sudo apt-get update -y

5. Instala Erlang:

sudo apt-get install -y erlang-base \
                       erlang-asn1 erlang-crypto erlang-eldap erlang-ftp erlang-inets \
                       erlang-mnesia erlang-os-mon erlang-parsetools erlang-public-key \
                       erlang-runtime-tools erlang-snmp erlang-ssl \
                       erlang-syntax-tools erlang-tftp erlang-tools erlang-xmerl

6. Por último, instala RabbitMQ:

sudo apt-get install rabbitmq-server -y --fix-missing

Una vez completada la instalación, verifica que el servidor RabbitMQ esté en ejecución:

systemctl status rabbitmq-server

Crea un usuario personalizado:

sudo rabbitmqctl add_user <tu-usuario> <tu-contraseña>

Asigna los permisos necesarios:

sudo rabbitmqctl set_user_tags  <tu-usuario> administrator
sudo rabbitmqctl set_permissions -p /  <tu-usuario> ".*" ".*" ".*"

Luego, habilita la consola de administración de RabbitMQ:

sudo rabbitmq-plugins enable rabbitmq_management

Accede a [tu IP del servidor]:15672. Ingresa tu nombre de usuario y contraseña para entrar en la interfaz web de RabbitMQ.

Windows

La guía de instalación está disponible en el sitio web de RabbitMQ. Básicamente, puedes usar Chocolatey o el instalador clásico.

Antes de instalar RabbitMQ, primero debes instalar Erlang/OTP desde el sitio web oficial de Erlang.

Ejecuta el archivo descargado y sigue el proceso de instalación.

Después de instalar Erlang, puedes instalar RabbitMQ utilizando el instalador oficial.

Luego, habilita la interfaz web:

cd 'C:\Program Files\RabbitMQ Server\rabbitmq_server-3.13.0\sbin'
./rabbitmq-plugins.bat enable rabbitmq_management

Ahora puedes acceder a localhost:15672 con el usuario y contraseña predeterminados guest:guest.

Docker

Instalar mediante Docker es probablemente la forma más sencilla y conveniente de configurar RabbitMQ.

Puedes instalar RabbitMQ con el siguiente comando:

docker run --rm -p 15672:15672 rabbitmq:3.13.7-management

La interfaz de administración estará disponible en el puerto 15672, donde puedes iniciar sesión con el usuario y contraseña predeterminados guest:guest.

Sin embargo, este método no es adecuado para entornos de producción. Docker asigna un nombre de servidor al contenedor, y el broker almacena su estado en una carpeta con ese nombre. En cada nueva compilación del contenedor, RabbitMQ perderá la información del estado.

Podemos definir cómodamente todos los parámetros necesarios del servicio con docker-compose, como cambiar el usuario y contraseña predeterminados o montar una carpeta para la persistencia del estado. Aquí tienes un ejemplo de archivo docker-compose.yml:

version: "3.3"
services:
  rabbit:
    image: rabbitmq:3.13.7-management
    environment:
      - RABBITMQ_DEFAULT_USER=admin #enter your username
      - RABBITMQ_DEFAULT_PASS=password #enter your password
    volumes:
      - ./rabbit:/var/lib/rabbitmq # mounting folder for state persistence
    ports:
      - 15672:15672 # expose port for the admin interface

Ejecuta:

docker compose up -d

La interfaz web de RabbitMQ ya estará disponible.

Descripción general de RabbitMQ Management

En la página principal de la interfaz de administración de RabbitMQ, puedes ver información general, como los nodos, su estado, el número total de mensajes y más.

• Connections – la lista de conexiones al clúster.

• Channels – la lista de canales. Dentro de una conexión se pueden crear varios canales a través de los cuales se envían mensajes, evitando así crear múltiples conexiones TCP.

Exchanges

Veamos los Exchanges más de cerca.

Existen varios tipos de Exchanges, cada uno con su propio mecanismo de filtrado de mensajes. Según estas reglas, los eventos se enrutan a colas específicas.

Direct Exchange

Cada mensaje tiene una clave llamada Routing Key. Los mensajes se enviarán a las colas cuyo binding especifique la misma clave.

Topic Exchange

El enrutamiento se realiza basándose en un patrón de clave. Al crear el patrón, se pueden usar 0 o más palabras (letras y números) separadas por puntos, por ejemplo key.event, y los símbolos # y *.

Fanout Exchange

No se aplican reglas de filtrado. Cada mensaje enviado a un Fanout Exchange se enruta a todas las colas.

Headers Exchange

Usa los encabezados del mensaje y los encabezados de binding comparando pares clave-valor.

Queues

Al ver una cola específica, puedes observar un gráfico que muestra cuántos mensajes hay en la cola, junto con estadísticas sobre los tiempos de entrega y aceptación.

Los mensajes pueden tener dos estados:

• Ready – esperando ser procesado.
• Unacked – siendo procesado por el consumidor.

Implementar publicador-suscriptor en Python

Veamos cómo usar RabbitMQ para implementar el patrón Pub-Sub en Python. Debes tener Python instalado (en este ejemplo, la versión 3.11.5) y la biblioteca Pika.

1. Crea o selecciona una carpeta donde residirá el código de la aplicación:

mkdir rabbitmq-article

2. Abre esta carpeta en tu IDE (por ejemplo, Visual Studio Code o PyCharm).

3. Instala la biblioteca Pika:

pip install pika

4. Crea dos archivos: sender.py y receiver.py.

Código de sender.py

from pika import BlockingConnection, ConnectionParameters
from pika.exchange_type import ExchangeType

# Create connection, specifying parameters in the ConnectionParameters object
connection = BlockingConnection(ConnectionParameters(host='localhost'))

# Create a channel
channel = connection.channel()

# Declare an exchange
channel.exchange_declare('new_exchange', ExchangeType.direct)

# Declare a queue
queue = channel.queue_declare(queue='new_queue')

# Bind the queue to the exchange
channel.queue_bind(exchange='new_exchange', queue='new_queue', routing_key='key')

# Publish a message
channel.basic_publish(exchange='new_exchange', routing_key='key', body='Hello World!')

print("Message 'Hello World!' sent")
connection.close()

En el código anterior de sender.py:

• Se establece una conexión con RabbitMQ en localhost.

• Se declara un exchange directo llamado new_exchange.

• Se declara una cola llamada new_queue.

• Se vincula la cola al exchange usando la clave de enrutamiento key.

• Finalmente, se publica el mensaje 'Hello World!' en el exchange con la clave de enrutamiento especificada.

Código de receiver.py

from pika import BlockingConnection, ConnectionParameters
from pika.exchange_type import ExchangeType
import sys, os

def main():
    # Create connection
    connection = BlockingConnection(ConnectionParameters(host='localhost'))
    # Create channel
    channel = connection.channel()

    # Declare an exchange
    channel.exchange_declare('new_exchange', ExchangeType.direct)

    # Declare a queue
    queue = channel.queue_declare(queue='new_queue')

    # Bind the queue to the exchange
    channel.queue_bind(exchange='new_exchange', queue='new_queue', routing_key='key')

    # Function to handle incoming messages
    def handle(ch, method, properties, body):
        print(f"Received message: {body.decode()}")

    # Bind the callback function and queue
    channel.basic_consume(queue='new_queue', on_message_callback=handle, auto_ack=True)

    print('Waiting for messages. Press Ctrl+C to exit.')
    channel.start_consuming()

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        try:
            sys.exit(0)
        except SystemExit:
            os._exit(0)

En este código del receiver.py:

• Se establece una conexión y un canal con RabbitMQ, igual que en el remitente.

• Se declara el exchange directo (new_exchange) y la cola (new_queue).

• La cola se vincula al exchange mediante la clave de enrutamiento key.

• La función handle() procesa los mensajes imprimiéndolos al recibirlos.

• El método basic_consume() suscribe la función de callback a la cola.

• Se usa start_consuming() para mantener el proceso a la espera de mensajes indefinidamente.

Ejecutar el código

Primero, inicia el receptor:

python receiver.py

Deberías ver:

Waiting for messages. Press Ctrl+C to exit.

Luego, ejecuta el remitente:

python sender.py

Salida:

Message 'Hello World!' sent

En la terminal donde se ejecuta el receptor, verás:

Received message: Hello World!

En la consola de administración de RabbitMQ, podrás ver en el exchange new_exchange que está vinculado a la cola new_queue mediante la clave de enrutamiento key.

Conclusión

En este artículo exploramos qué son los message brokers, cómo interactúan las aplicaciones con ellos y cómo instalar y usar RabbitMQ como broker de mensajes. Implementamos con éxito un patrón publicador-suscriptor usando Python, RabbitMQ y la biblioteca Pika, donde el remitente publica mensajes en un exchange y el receptor los consume.