Al menos una vez, y lo que eso te obliga a hacer

󰃭 2026-11-06 · 8 min de lectura

Contenido

Tercera y última entrada. En la primera saqué el correo del endpoint a una cola; en la segunda rompí el consumidor de cuatro formas y acabé con ack manual, reintentos con espera y una cola de fallidos. El sistema ya no pierde mensajes.

Lo que hace ahora, en cambio, es repetirlos. Y eso no es un bug: es la única garantía que una cola puede darte de verdad.

Fallo 5: el correo se envía dos veces #

Vuelve al worker de la segunda entrada y fíjate en el orden de las cosas dentro de procesar: primero enviar_correo, después basic_ack. Entre una y otra hay un hueco. Lo voy a hacer más ancho para poder meter el dedo:

# worker.py (modificado solo para el experimento)
def procesar(canal, metodo, propiedades, cuerpo: bytes) -> None:
    pedido = json.loads(cuerpo)
    intento = intentos_previos(propiedades) + 1
    print(f"[worker] pedido {pedido['id']}, intento {intento}, redelivered={metodo.redelivered}", flush=True)
    try:
        enviar_correo(pedido)
    except Exception as e:
        ...
        return
    time.sleep(3)  # el hueco entre hacer el trabajo y confirmarlo
    canal.basic_ack(delivery_tag=metodo.delivery_tag)

Lanza un pedido, espera a ver la línea de [correo] ... enviada, y en los tres segundos siguientes, pkill -9:

ignacio@zeus:~/lab-colas$ python worker.py
[worker] esperando mensajes
[worker] pedido 520, intento 1, redelivered=False
[correo] confirmación del pedido 520 enviada
Killed

El correo ha salido. El ack no. RabbitMQ ve caer la conexión y devuelve el mensaje a la cola, como debe. Arranca el worker:

[worker] pedido 520, intento 1, redelivered=True
[correo] confirmación del pedido 520 enviada

Dos correos de confirmación del mismo pedido. El usuario tiene dos mensajes en su bandeja y, si en vez de un correo fuera un cargo en la tarjeta, dos cargos.

Y aquí va la frase que cuesta aceptar viniendo del mundo síncrono: esto no tiene arreglo en la cola. Si haces ack antes de enviar, el fallo 1 de la entrada anterior vuelve (el worker muere después del ack y antes del envío: correo perdido). Si haces ack después, el worker puede morir entre el envío y el ack: correo duplicado. No hay un tercer sitio donde poner el ack. Puedes elegir entre como mucho una vez (ack antes) y al menos una vez (ack después), y para un correo de confirmación, o un cargo, o cualquier cosa que no quieras perder, eliges al menos una vez y asumes el duplicado.

Hay brókers que anuncian “exactamente una vez”. Lo que dan, cuando lo dan, es exactamente una vez dentro del bróker; en cuanto el consumidor hace algo fuera (un correo, una llamada HTTP, un INSERT en otra base de datos), vuelves a tener el hueco.

Arreglo 5: que repetir no haga daño #

Si no puedes evitar que un mensaje llegue dos veces, haz que la segunda vez no haga nada. Eso es idempotencia, y se consigue apuntando lo que ya has hecho en un sitio que sobreviva a la muerte del worker. Tengo un PostgreSQL al lado; sirve.

-- añadido a init.sql
CREATE TABLE correos_enviados (
  pedido_id  int PRIMARY KEY REFERENCES pedidos(id),
  enviado_en timestamptz NOT NULL DEFAULT now()
);

Y el worker, antes de enviar, intenta reservar el pedido:

# worker.py (versión final)
from db import conectar


def reservar(pedido_id: int) -> bool:
    """True si somos los primeros en ocuparnos de este pedido."""
    with conectar() as con:
        fila = con.execute(
            """
            INSERT INTO correos_enviados (pedido_id) VALUES (%s)
            ON CONFLICT (pedido_id) DO NOTHING
            RETURNING pedido_id
            """,
            (pedido_id,),
        ).fetchone()
    return fila is not None


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

    if not reservar(pedido["id"]):
        print(f"[worker] pedido {pedido['id']} ya tratado, ignoro", flush=True)
        canal.basic_ack(delivery_tag=metodo.delivery_tag)
        return

    try:
        enviar_correo(pedido)
    except Exception as e:
        ...  # igual que en la segunda entrada
        return
    canal.basic_ack(delivery_tag=metodo.delivery_tag)

El INSERT ... ON CONFLICT DO NOTHING RETURNING es el truco: si la fila no existía, la inserta y devuelve el id; si existía, no hace nada y no devuelve nada. Atómico, en una sola sentencia, sin ventana para que dos workers se cuelen. Repite el experimento del pkill -9 tras el envío:

[worker] pedido 521, intento 1, redelivered=True
[worker] pedido 521 ya tratado, ignoro

Un correo. La reentrega llega, la reserva falla porque ya está hecha, y el worker se limita a confirmar el mensaje para que RabbitMQ lo olvide.

El hueco se ha movido, no ha desaparecido #

Sé honesto con esto o el lector lo descubrirá solo. Ahora el orden es: reservar, enviar, ack. Si el worker muere entre reservar y enviar, el pedido queda marcado como tratado y el correo no sale nunca. He cambiado un duplicado por una pérdida, en una ventana mucho más pequeña (unos milisegundos frente a los dos segundos del envío) y, sobre todo, detectable: la fila en correos_enviados existe, y el correo no. Un trabajo de limpieza que compare esa tabla con el registro del servidor de correo, o una columna estado (reservado → enviado) con un reintento para los que llevan demasiado tiempo en reservado, lo cierra del todo. Lo dejo fuera porque ya no es sobre colas, pero que conste que el circuito completo tiene una pieza más.

La regla general, que vale para cualquier cosa que haga efectos fuera de la base de datos: o la operación es naturalmente idempotente (poner estado = 'enviado' lo es; saldo = saldo - 10 no), o le pones una clave que lo haga idempotente (el id del pedido, un UUID generado por el productor y viajando en el mensaje). Si no hay ninguna de las dos, el duplicado acabará ocurriendo.

Lo mismo, del lado del productor #

He hablado todo el rato del consumidor, pero el endpoint de la primera entrada tiene exactamente el mismo problema al revés:

    with conectar() as con:
        pedido = con.execute("INSERT INTO pedidos ... RETURNING ...").fetchone()
    publicar(pedido)
    return pedido

Si publicar falla (RabbitMQ caído, un corte de red), el pedido está en la base de datos y el mensaje no existe: un pedido sin correo. Si inviertes el orden y publicas antes de insertar, puedes tener un correo de un pedido que nunca se guardó. Es el mismo hueco de siempre, entre dos sistemas que no comparten transacción.

La solución tiene nombre, transactional outbox, y es más sencilla de lo que suena: en la misma transacción que inserta el pedido, insertas también una fila en una tabla mensajes_pendientes. Las dos filas se guardan o ninguna. Y un proceso aparte lee esa tabla, publica en RabbitMQ y borra la fila al conseguirlo. Ese proceso vuelve a ser un “al menos una vez” (puede publicar y morir antes de borrar), así que el consumidor tiene que ser idempotente. Que ya lo es. Todo encaja.

No lo implemento aquí porque son treinta líneas más y la entrada ya va larga, pero es la pieza que convierte el laboratorio en algo que pondrías en producción.

Cuándo una cola es demasiado #

Tres entradas después, la pregunta que debería ir antes de instalar RabbitMQ: ¿lo necesito?

Un bróker de mensajes es un sistema más que mantener, monitorizar, actualizar y que puede caerse. Antes de meterlo, dos alternativas que resuelven una parte sorprendente de los casos:

  • Una tarea en segundo plano en el propio servidor web. FastAPI tiene BackgroundTasks: el endpoint responde y el correo se envía después en el mismo proceso. Resuelve el problema de la latencia (el primero de la serie) y nada más: si el proceso muere, la tarea se pierde, y no hay reintentos ni cola de fallidos. Para cosas que da igual perder, sobra.
  • Una tabla de tareas en PostgreSQL. INSERT INTO tareas en la misma transacción que el pedido, y un worker que hace SELECT ... FOR UPDATE SKIP LOCKED para cogerlas de una en una. Tienes persistencia, reintentos (una columna intentos), fallidos (una columna estado), varios workers en paralelo, y la transacción con el pedido gratis, que es justo lo que el outbox intentaba conseguir. Lo que no tienes es un bróker que empuje los mensajes: el worker sondea cada segundo o cada cinco. Para la inmensa mayoría de sistemas que no son de alta frecuencia es más que suficiente, y es una dependencia menos.

RabbitMQ (o cualquier bróker) empieza a compensar cuando hay varios productores y consumidores que son sistemas distintos, cuando el volumen hace que sondear una tabla sea un problema, cuando quieres enrutar un mismo mensaje a varios consumidores que no se conocen, o cuando necesitas que el bróker esté entre dos sistemas que no deben compartir una base de datos.

Y aun entonces, la cola es la fontanería. Lo que se ha visto en esta serie (ack, reintentos, fallidos, idempotencia, outbox) no lo resuelve el bróker: lo resuelves tú en el diseño de lo que viaja por la cola y de lo que hace quien lo recibe. Cambiar RabbitMQ por otro producto cambia los nombres de las piezas, no el trabajo.

Lo que ha enseñado la serie #

  • Una cola desacopla en el tiempo: el productor termina sin esperar al consumidor, y el consumidor puede no existir en ese momento.
  • auto_ack pierde mensajes; el ack manual los conserva, pero convierte las caídas en reentregas.
  • Reencolar a la misma cola es un bucle; rechazar hacia un DLX con una cola de espera son reintentos con pausa, y una cola de fallidos aparta lo irrecuperable.
  • Al menos una vez es lo único que hay. Idempotencia en el consumidor, con una clave en una tabla, es el precio.
  • El productor tiene el hueco simétrico; el outbox lo cierra.
  • Antes de un bróker, una tabla de tareas en la base de datos que ya tienes resuelve más de lo que parece.

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


¿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