Colas de mensajes para gente de síncrono

󰃭 2026-11-01 · 8 min de lectura

Contenido

Toda mi vida profesional ha sido síncrona: alguien pide, yo respondo, y hasta que no respondo nadie hace nada. HTTP, SQL, una llamada a función. Las colas de mensajes me parecieron durante mucho tiempo una complicación para gente con problemas que yo no tenía.

El problema sí lo tenía. Lo que no tenía era el vocabulario para reconocerlo. Esta serie es para quien esté en ese punto: tres entradas, la primera de teoría y montaje, y las otras dos rompiendo cosas a propósito para ver qué pasa, que es la única forma de entender para qué sirve una cola.

Reutilizo el laboratorio de la serie de GraphQL: PostgreSQL en Podman con una tabla de usuarios y otra de pedidos, y una API REST en FastAPI. Si no la has leído no pasa nada; lo que hace falta está aquí.

El código está en Codeberg: https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-colas.

El problema, sin colas #

Un endpoint que crea un pedido. Al crearlo hay que mandar un correo de confirmación al usuario.

# api_rest/main.py (añadido)
import time

from pydantic import BaseModel


class NuevoPedido(BaseModel):
    usuario_id: int
    total: float


def enviar_correo(pedido: dict) -> None:
    """Simula un servidor de correo lento."""
    time.sleep(2)
    print(f"[correo] confirmación del pedido {pedido['id']} enviada")


@app.post("/pedidos", status_code=201)
def crear_pedido(nuevo: NuevoPedido):
    with conectar() as con:
        pedido = con.execute(
            """
            INSERT INTO pedidos (usuario_id, fecha, total, estado)
            VALUES (%s, CURRENT_DATE, %s, 'pendiente')
            RETURNING id, usuario_id, fecha, total, estado
            """,
            (nuevo.usuario_id, nuevo.total),
        ).fetchone()
    enviar_correo(pedido)
    return pedido

enviar_correo no manda nada: duerme dos segundos y escribe una línea. Es a propósito. Un servidor SMTP de verdad tarda, falla y a veces no contesta, y para el laboratorio quiero controlar todo eso con un sleep y, más adelante, con un random().

ignacio@zeus:~$ time curl -s -X POST localhost:8000/pedidos \
  -H 'Content-Type: application/json' \
  -d '{"usuario_id": 42, "total": 19.9}'
{"id":501,"usuario_id":42,"fecha":"2026-11-02","total":19.9,"estado":"pendiente"}

real    0m2.031s

Dos segundos. El pedido estaba guardado en la base de datos a los pocos milisegundos; el resto del tiempo el cliente ha estado esperando a que el correo saliera. Y hay un segundo problema peor que el primero: si enviar_correo lanza una excepción, el endpoint devuelve un 500 con el pedido ya insertado. El cliente ve un error, reintenta, y tienes dos pedidos.

Esto es lo que una cola resuelve: separar “lo que tiene que pasar ahora” (guardar el pedido y contestar) de “lo que tiene que pasar, pero no necesariamente ahora ni necesariamente bien a la primera” (el correo). Lo segundo se apunta en una cola y otro proceso lo hace cuando puede.

Las piezas, traducidas #

RabbitMQ tiene más vocabulario del que necesitas el primer día. Lo mínimo:

Mensaje. Unos bytes y unas cabeceras. RabbitMQ no mira dentro; tú decides el formato. Aquí será JSON, igual que en HTTP.

Cola. Una lista de mensajes esperando a que alguien los lea. Tiene nombre. Si vienes de HTTP, piensa en ella como una bandeja de entrada.

Productor y consumidor. Quien escribe en la cola y quien lee de ella. No se conocen, no se esperan, pueden no estar vivos al mismo tiempo. Esto último es el punto: el productor publica aunque no haya ningún consumidor, y el consumidor lee lo que se publicó mientras estaba apagado.

Exchange. La pieza que despista. Un productor nunca escribe en una cola directamente; escribe en un exchange con una clave (routing_key), y el exchange decide a qué colas va el mensaje según unas reglas (bindings). Sirve para repartir un mensaje a varias colas, o para enrutar por patrón. Hoy no vamos a usar nada de eso: el exchange por defecto (nombre vacío) entrega el mensaje a la cola que se llame igual que la routing_key. Es la forma de usar RabbitMQ como una cola simple, y es perfectamente legítima.

Ack. La confirmación del consumidor de que ha terminado con un mensaje. Es la pieza más importante de toda la serie, y hoy la voy a usar mal a propósito.

Todo lo demás (exchanges de tipo topic, fanout, colas con TTL, dead letter, quorum queues) existe y es útil, pero no hace falta para entender para qué sirve una cola.

RabbitMQ en Podman #

Al compose.yaml del laboratorio le añado un servicio:

# compose.yaml (añadido)
  rabbitmq:
    image: docker.io/library/rabbitmq:4-management
    environment:
      RABBITMQ_DEFAULT_USER: lab
      RABBITMQ_DEFAULT_PASS: lab
    ports:
      - "5672:5672"
      - "15672:15672"

La etiqueta -management trae la interfaz web, que va a ser nuestro instrumento de medida en esta serie, como lo fue log_statement en la anterior. El usuario lab lo defino yo porque el guest que viene de serie solo acepta conexiones desde localhost del contenedor, y con Podman rootless las conexiones desde el anfitrión no cuentan como tal; es la primera piedra con la que tropieza todo el mundo.

ignacio@zeus:~/lab-colas$ podman compose up -d rabbitmq
ignacio@zeus:~/lab-colas$ podman compose logs rabbitmq | grep -i 'server startup complete'
rabbitmq  | 2026-11-02 17:40:12.118 [info] <0.690.0> Server startup complete; 4 plugins started.

Y la interfaz, en http://localhost:15672, con lab/lab. Déjala abierta en la pestaña Queues.

ignacio@zeus:~/lab-colas$ pip install pika

pika es el cliente de Python que mantiene el propio equipo de RabbitMQ. Es síncrono y bloqueante, que es exactamente lo que quiero para que el código se lea de arriba abajo.

El productor #

# cola.py
import json

import pika

URL = "amqp://lab:lab@localhost:5672/"
COLA = "correos"


def publicar(mensaje: dict) -> None:
    conexion = pika.BlockingConnection(pika.URLParameters(URL))
    canal = conexion.channel()
    canal.queue_declare(queue=COLA, durable=True)
    canal.basic_publish(
        exchange="",
        routing_key=COLA,
        body=json.dumps(mensaje, default=str),
        properties=pika.BasicProperties(delivery_mode=2),
    )
    conexion.close()

Línea a línea:

  • queue_declare crea la cola si no existe y no hace nada si existe. Es idempotente, y es costumbre que tanto el productor como el consumidor la declaren, para que dé igual cuál arranca primero. durable=True hace que la cola sobreviva a un reinicio de RabbitMQ.
  • exchange="" es el exchange por defecto, y routing_key=COLA hace que el mensaje caiga en la cola correos.
  • delivery_mode=2 marca el mensaje como persistente: se escribe a disco. Sin esto, un reinicio del bróker se lleva los mensajes aunque la cola sea durable. Cola durable y mensaje persistente son dos cosas distintas, y hacen falta las dos.
  • default=str en el json.dumps es para que el date y el Decimal que vienen de PostgreSQL no rompan la serialización.

Abrir y cerrar una conexión por mensaje es un despilfarro; en un servidor de verdad la conexión se mantiene abierta. Lo dejo así para que no haya nada que explicar sobre el ciclo de vida de la conexión.

Y el endpoint, en vez de enviar el correo, publica:

# api_rest/main.py (modificado)
from cola import publicar


@app.post("/pedidos", status_code=201)
def crear_pedido(nuevo: NuevoPedido):
    with conectar() as con:
        pedido = con.execute(
            """
            INSERT INTO pedidos (usuario_id, fecha, total, estado)
            VALUES (%s, CURRENT_DATE, %s, 'pendiente')
            RETURNING id, usuario_id, fecha, total, estado
            """,
            (nuevo.usuario_id, nuevo.total),
        ).fetchone()
    publicar(pedido)
    return pedido
ignacio@zeus:~$ time curl -s -X POST localhost:8000/pedidos \
  -H 'Content-Type: application/json' \
  -d '{"usuario_id": 42, "total": 19.9}'
{"id":502,"usuario_id":42,"fecha":"2026-11-02","total":19.9,"estado":"pendiente"}

real    0m0.047s

De dos segundos a cuarenta y pico milisegundos. El correo no se ha enviado todavía; lo que se ha hecho es dejar constancia de que hay que enviarlo. En la interfaz web, la cola correos tiene un mensaje en Ready.

Lanza cuatro o cinco pedidos más. Se van acumulando. No hay nadie leyendo, y a RabbitMQ le da igual: ese es el desacoplamiento del que hablaba. El productor ha terminado su trabajo aunque el consumidor no exista aún.

El consumidor #

# worker.py
import json
import time

import pika

from cola import COLA, URL


def enviar_correo(pedido: dict) -> None:
    time.sleep(2)
    print(f"[correo] confirmación del pedido {pedido['id']} enviada", flush=True)


def procesar(canal, metodo, propiedades, cuerpo: bytes) -> None:
    pedido = json.loads(cuerpo)
    print(f"[worker] recibido pedido {pedido['id']}", flush=True)
    enviar_correo(pedido)


conexion = pika.BlockingConnection(pika.URLParameters(URL))
canal = conexion.channel()
canal.queue_declare(queue=COLA, durable=True)
canal.basic_consume(queue=COLA, on_message_callback=procesar, auto_ack=True)
print("[worker] esperando mensajes", flush=True)
canal.start_consuming()

basic_consume registra procesar como la función que RabbitMQ llamará por cada mensaje, y start_consuming se queda en bucle esperando. auto_ack=True le dice a RabbitMQ que dé el mensaje por entregado en cuanto lo manda al consumidor, antes de que procesar haga nada. Guárdate esa frase.

ignacio@zeus:~/lab-colas$ python worker.py
[worker] esperando mensajes
[worker] recibido pedido 502
[correo] confirmación del pedido 502 enviada
[worker] recibido pedido 503
[correo] confirmación del pedido 503 enviada
[worker] recibido pedido 504
...

Los mensajes que se acumularon mientras no había consumidor salen todos seguidos, de dos en dos segundos, y en la interfaz web la cola vuelve a cero. Si ahora lanzas otro pedido con el worker vivo, aparece en el log del worker medio segundo después y el curl sigue tardando cuarenta milisegundos.

Dos terminales más y tienes dos workers consumiendo de la misma cola: RabbitMQ reparte los mensajes entre ellos por turnos. Escalar el envío de correos es arrancar otro proceso; el endpoint ni se entera.

Dónde estamos #

Hemos separado el pedido del correo, el endpoint responde en milisegundos, los correos se envían cuando se puede y añadir capacidad es arrancar otro worker. Todo lo que promete la portada de cualquier bróker de mensajes.

Y hay un auto_ack=True ahí en medio que lo echa todo a perder, pero solo cuando algo falla. En la siguiente entrada mato al worker a mitad de un correo y miro qué ha pasado con el mensaje.


¿Comentarios? Esta entrada tiene un hilo en Mastodon: responde allí y la conversación se queda en el fediverso.

Cargando comentarios desde mastodon.social…

Ingrese la dirección de su instancia


Más posts como este