Instalación y Configuración de RabbitMQ

RabbitMQ es un intermediario de mensajes robusto y completo que implementa el protocolo AMQP (Advanced Message Queuing Protocol). Proporciona entrega confiable de mensajes, enrutamiento flexible, capacidades de clustering y una interfaz de gestión integral. Esta guía cubre instalación, configuración básica, gestión de usuarios y configuración de intercambios, colas y hosts virtuales en sistemas Linux.

Requisitos Previos

Antes de instalar RabbitMQ, asegúrate de tener:

Un sistema Linux (Ubuntu 20.04+ o CentOS 8+)
Acceso root o sudo
Al menos 2GB de RAM disponible
Conectividad a Internet para descargas de paquetes
Conocimiento básico de colas de mensajes y conceptos AMQP

Instalación de Erlang/OTP

RabbitMQ se ejecuta en el tiempo de ejecución de Erlang, por lo que debes instalarlo primero. Erlang/OTP proporciona la base para el modelo de concurrencia de RabbitMQ.

Para sistemas Ubuntu/Debian, añade el repositorio de RabbitMQ que incluye paquetes de Erlang:

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
sudo tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
deb [signed-by=/usr/share/keyrings/com.rabbitmq.team.gpg] https://ppa.launchpadcontent.net/rabbitmq/rabbitmq-erlang/ubuntu focal main
deb-src [signed-by=/usr/share/keyrings/com.rabbitmq.team.gpg] https://ppa.launchpadcontent.net/rabbitmq/rabbitmq-erlang/ubuntu focal main
EOF
sudo apt-get update

Instala el paquete de Erlang:

sudo apt-get install -y erlang-nox

Verifica la instalación:

erl -version

Para CentOS/RHEL, habilita el repositorio EPEL e instala Erlang:

sudo yum install -y centos-release-scl
sudo yum install -y erlang
erl -version

Instalación de RabbitMQ

Después de instalar Erlang, procede con la instalación de RabbitMQ. Añade el repositorio oficial de RabbitMQ:

sudo tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
deb [signed-by=/usr/share/keyrings/com.rabbitmq.team.gpg] https://dl.bintray.com/rabbitmq-erlang/debian focal erlang
deb [signed-by=/usr/share/keyrings/com.rabbitmq.team.gpg] https://dl.bintray.com/rabbitmq/debian focal main
EOF

Actualiza el caché de paquetes e instala RabbitMQ:

sudo apt-get update
sudo apt-get install -y rabbitmq-server

Inicia el servicio RabbitMQ y habilítalo para que se inicie al arranque:

sudo systemctl start rabbitmq-server
sudo systemctl enable rabbitmq-server

Verifica que el servicio está funcionando:

sudo systemctl status rabbitmq-server
sudo rabbitmqctl version

La salida debe mostrar las versiones de RabbitMQ y Erlang instaladas.

Configuración Básica

El archivo de configuración principal de RabbitMQ se encuentra en /etc/rabbitmq/rabbitmq.conf. Crea o modifica este archivo para personalizar el comportamiento de RabbitMQ:

sudo nano /etc/rabbitmq/rabbitmq.conf

Aquí están las opciones de configuración esenciales:

# Configuración de red y protocolo
listeners.tcp.default = 5672

# Puerto del complemento de gestión
management.tcp.port = 15672

# Umbral de memoria - dispara alarma de memoria al 80% de uso de RAM
vm_memory_high_watermark.relative = 0.8

# Umbral de espacio en disco
disk_free_limit.absolute = 2GB

# vhost y usuario predeterminados (creados automáticamente)
default_vhost = /
default_user = guest
default_pass = guest

# Conexiones máximas por canal
channel_max = 2048

# Canales máximos por conexión
max_channels = 4096

# Timeout de latido en segundos
heartbeat = 60

# Ubicación del archivo de registro
log.file.level = info
log.console.level = info

# Directorio de base de datos Mnesia
mnesia.dir = /var/lib/rabbitmq/mnesia

Después de modificar la configuración, reinicia RabbitMQ:

sudo systemctl restart rabbitmq-server

Gestión de Usuarios y Hosts Virtuales

RabbitMQ utiliza hosts virtuales (vhosts) para aislar intermediarios de mensajes y usuarios para controlar el acceso. Por defecto, existe un usuario invitado pero debe eliminarse en producción.

Lista todos los usuarios:

sudo rabbitmqctl list_users

Crea un nuevo usuario administrativo:

sudo rabbitmqctl add_user admin_user secure_password123
sudo rabbitmqctl set_user_tags admin_user administrator

Crea un nuevo usuario de aplicación con permisos limitados:

sudo rabbitmqctl add_user app_user app_password456
sudo rabbitmqctl set_user_tags app_user none

Crea un host virtual para aislamiento de aplicaciones:

sudo rabbitmqctl add_vhost production_app

Otorga permisos a usuarios en vhosts específicos. El formato de permiso es configure/write/read:

# Otorga al usuario administrador acceso completo al vhost production_app
sudo rabbitmqctl set_permissions -p production_app admin_user ".*" ".*" ".*"

# Otorga al usuario app_user acceso limitado - solo puede escribir y leer
sudo rabbitmqctl set_permissions -p production_app app_user "" ".*" ".*"

Ver los permisos del usuario:

sudo rabbitmqctl list_user_permissions admin_user
sudo rabbitmqctl list_permissions -p production_app

Elimina el usuario invitado predeterminado en producción:

sudo rabbitmqctl delete_user guest

Cambia la contraseña de un usuario:

sudo rabbitmqctl change_password admin_user new_secure_password

Configuración de Intercambios y Colas

Los intercambios son entidades de enrutamiento de mensajes y las colas son almacenamiento de mensajes. Usa la interfaz de gestión de RabbitMQ o las herramientas de línea de comandos para crearlos.

Usar la interfaz de gestión (cubierta en la siguiente sección) proporciona una interfaz gráfica. Alternativamente, usa clientes AMQP o la API HTTP.

Aquí hay un ejemplo usando Python con la biblioteca pika para configurar la infraestructura de mensajería:

sudo apt-get install -y python3-pip
pip3 install pika

Crea un script de Python para configurar la infraestructura de mensajería:

#!/usr/bin/env python3
import pika
import sys

# Conectar a RabbitMQ
credentials = pika.PlainCredentials('app_user', 'app_password456')
connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='localhost',
    port=5672,
    virtual_host='production_app',
    credentials=credentials
))
channel = connection.channel()

# Declara un intercambio duradero de tema
channel.exchange_declare(
    exchange='orders',
    exchange_type='topic',
    durable=True,
    auto_delete=False
)

# Declara colas duraderas
channel.queue_declare(queue='order_processing', durable=True)
channel.queue_declare(queue='order_notifications', durable=True)

# Vincula colas a intercambio con claves de enrutamiento
channel.queue_bind(
    exchange='orders',
    queue='order_processing',
    routing_key='order.create'
)

channel.queue_bind(
    exchange='orders',
    queue='order_notifications',
    routing_key='order.*'
)

print("Intercambios y colas configurados exitosamente")
connection.close()

Ejecuta el script:

python3 setup_rabbitmq.py

Interfaz de Gestión de RabbitMQ

RabbitMQ incluye un complemento de gestión que proporciona una interfaz web para la administración. Habilítalo:

sudo rabbitmq-plugins enable rabbitmq_management

Se puede acceder a la interfaz de gestión en http://localhost:15672 o http://tu-ip-servidor:15672. Inicia sesión con tus credenciales de administrador.

Desde la interfaz de gestión, puedes:

Crear y eliminar intercambios, colas y vinculaciones
Gestionar usuarios y permisos
Monitorizar el flujo de mensajes y la profundidad de las colas
Configurar políticas para alta disponibilidad
Ver estadísticas de conexión y canal

Navega por las pestañas:

Overview: Estado del cluster y velocidad de mensajes
Connections: Conexiones AMQP activas
Channels: Canales activos con uso de memoria
Queues: Detalles de cola, conteos de mensajes, consumidores
Admin: Gestión de usuarios y vhost

Para restablecer la base de datos de gestión (úsalo con cuidado):

sudo rabbitmqctl reset
sudo rabbitmqctl start_app

Políticas y Limitación de Velocidad

Las políticas te permiten aplicar configuraciones a colas e intercambios que coincidan con ciertos criterios. Son esenciales para configuraciones de alta disponibilidad y limitación de velocidad.

Establece una política para habilitar el espejamiento de colas en nodos del cluster:

sudo rabbitmqctl set_policy -p production_app ha-all "^" \
  '{"ha-mode":"all","ha-sync-batch-size":5}' \
  --priority 0 \
  --apply-to queues

Esta política se aplica a todas las colas que coincidan con el patrón ^ (todas las colas) en el vhost production_app.

Establece política de limitación de velocidad en colas:

sudo rabbitmqctl set_policy -p production_app rate-limit "^limited.*" \
  '{"max-length":10000,"message-ttl":300000}' \
  --priority 10 \
  --apply-to queues

Lista todas las políticas:

sudo rabbitmqctl list_policies -p production_app

Limpia una política:

sudo rabbitmqctl clear_policy -p production_app ha-all

Prueba del Flujo de Mensajes

Verifica tu configuración de RabbitMQ publicando y consumiendo mensajes de prueba. Crea un script de editor de prueba:

#!/usr/bin/env python3
import pika
import json
from datetime import datetime

credentials = pika.PlainCredentials('app_user', 'app_password456')
connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='localhost',
    virtual_host='production_app',
    credentials=credentials
))
channel = connection.channel()

message = {
    'order_id': '12345',
    'customer': 'John Doe',
    'timestamp': datetime.now().isoformat(),
    'total': 99.99
}

channel.basic_publish(
    exchange='orders',
    routing_key='order.create',
    body=json.dumps(message),
    properties=pika.BasicProperties(
        delivery_mode=2,  # Hacer que el mensaje sea persistente
        content_type='application/json'
    )
)

print(f"Mensaje enviado: {json.dumps(message, indent=2)}")
connection.close()

Crea un script de consumidor:

#!/usr/bin/env python3
import pika
import json

def callback(ch, method, properties, body):
    message = json.loads(body)
    print(f"Recibido: {json.dumps(message, indent=2)}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

credentials = pika.PlainCredentials('app_user', 'app_password456')
connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='localhost',
    virtual_host='production_app',
    credentials=credentials
))
channel = connection.channel()

channel.basic_consume(
    queue='order_processing',
    on_message_callback=callback
)

print("Esperando mensajes...")
channel.start_consuming()

Prueba el flujo:

# Terminal 1
python3 consumer.py

# Terminal 2
python3 publisher.py

Solución de Problemas

Verifica los registros de RabbitMQ en busca de errores:

sudo tail -f /var/log/rabbitmq/[email protected]

Verifica que RabbitMQ está escuchando en los puertos esperados:

sudo netstat -tuln | grep -E '5672|15672'

Comprueba el estado del nodo del cluster:

sudo rabbitmqctl cluster_status

Monitoriza el uso de memoria y disco:

sudo rabbitmqctl status | grep -A 10 "memory\|disk"

Restablece RabbitMQ completamente (destructivo):

sudo systemctl stop rabbitmq-server
sudo rm -rf /var/lib/rabbitmq/mnesia/*
sudo systemctl start rabbitmq-server

Conclusión

RabbitMQ proporciona una plataforma de intermediación de mensajes poderosa y confiable adecuada para sistemas distribuidos, microservicios y arquitecturas orientadas a eventos. Esta guía cubrió instalación, configuración, gestión de usuarios y vhost, configuración de intercambios y colas, y pruebas básicas. Para implementaciones en producción, implementa clustering para alta disponibilidad, configura almacenamiento persistente, implementa monitoreo con Prometheus y establece procedimientos de copia de seguridad. El monitoreo regular de la profundidad de colas, el uso de memoria y el conteo de conexiones ayudará a mantener un rendimiento óptimo en tu infraestructura de mensajería.

Instalación y configuración de RabbitMQ