Cuando el consumidor se cae: ack, reencolado y dead letter

󰃭 2026-11-03 · 9 min de lectura

Contenido

En la entrada anterior saqué el envío del correo del endpoint y lo mandé a una cola de RabbitMQ. El endpoint pasó de dos segundos a cuarenta milisegundos y un worker.py se encarga de los correos. Todo bonito mientras nada falla.

Esta entrada va de que algo falle. Cuatro veces, cada una peor que la anterior, y arreglándolas por orden.

Fallo 1: el worker muere y el mensaje desaparece #

El worker de la entrada anterior tenía esto:

canal.basic_consume(queue=COLA, on_message_callback=procesar, auto_ack=True)

auto_ack=True significa que RabbitMQ da el mensaje por entregado en el momento en que lo manda al consumidor. Vamos a ver qué implica.

Arranca el worker, lanza un pedido, y en los dos segundos de sleep que simulan el envío del correo, mata el proceso sin contemplaciones:

ignacio@zeus:~/lab-colas$ python worker.py
[worker] esperando mensajes
[worker] recibido pedido 510
Killed

(Desde otra terminal: pkill -9 -f worker.py. Tiene que ser -9; con un Ctrl+C pika cierra la conexión limpiamente y no es lo que quiero probar.)

Ahora mira la interfaz web, pestaña Queues, cola correos: Ready 0, Unacked 0, Total 0. Arranca el worker otra vez: no recibe nada. El pedido 510 está en la base de datos y su correo de confirmación no existe ni va a existir. Nadie se ha enterado.

Esto es lo que compra auto_ack=True: rendimiento a cambio de que cualquier caída del consumidor se lleve lo que tenía entre manos. Hay casos en que vale (métricas, logs, cosas que si se pierde una no pasa nada), pero un correo de confirmación no es uno de ellos.

Arreglo 1: ack manual #

El consumidor tiene que decirle a RabbitMQ “ya he terminado con este” después de haber terminado, no antes.

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


...
canal.basic_qos(prefetch_count=1)
canal.basic_consume(queue=COLA, on_message_callback=procesar, auto_ack=False)

Dos cambios. auto_ack=False y el basic_ack explícito al final de procesar, con el delivery_tag que identifica esa entrega concreta. Y basic_qos(prefetch_count=1): sin esto, RabbitMQ le manda al consumidor todos los mensajes que haya en la cola de golpe y los deja todos en Unacked mientras el worker los va procesando uno a uno; con prefetch_count=1 le manda uno, espera el ack, y manda el siguiente. Para un worker que tarda dos segundos por mensaje es lo que quieres.

Repite el experimento. Lanza el pedido, y durante el sleep mira la interfaz: Ready 0, Unacked 1. El mensaje está entregado pero no confirmado. Ahora pkill -9:

Ready 1, Unacked 0. RabbitMQ ha detectado que la conexión del consumidor se ha cerrado sin confirmar y ha devuelto el mensaje a la cola. Arranca el worker:

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

El correo se envía. Con un detalle que importa y que dejo apuntado para la tercera entrada: en metodo.redelivered viene True. RabbitMQ sabe que este mensaje ya se entregó una vez, y te lo dice.

Fallo 2: el correo falla y el worker se cae #

Hasta ahora el worker moría por causas externas. Vamos a que falle por las suyas. Hago que el servidor de correo simulado rechace los pedidos grandes:

# worker.py (modificado)
def enviar_correo(pedido: dict) -> None:
    time.sleep(2)
    if float(pedido["total"]) > 1000:
        raise RuntimeError("el servidor de correo ha rechazado el mensaje")
    print(f"[correo] confirmación del pedido {pedido['id']} enviada", flush=True)

Lanza un pedido de 2000 euros:

ignacio@zeus:~/lab-colas$ python worker.py
[worker] esperando mensajes
[worker] recibido pedido 512
Traceback (most recent call last):
  ...
RuntimeError: el servidor de correo ha rechazado el mensaje

El worker se ha caído entero. Como no había hecho ack, el mensaje vuelve a Ready. Arranca el worker: recibe el 512, falla, se cae. Y así hasta que alguien edite el código. Mientras tanto, todos los demás correos, los que sí se podrían enviar, están detrás del 512 esperando.

Un mensaje que tumba al consumidor cada vez que lo intenta tiene nombre: poison message. Y la solución ingenua lo empeora.

Arreglo 2 (malo): capturar la excepción y reencolar #

Lo primero que se le ocurre a cualquiera:

def procesar(canal, metodo, propiedades, cuerpo: bytes) -> None:
    pedido = json.loads(cuerpo)
    print(f"[worker] recibido pedido {pedido['id']}", flush=True)
    try:
        enviar_correo(pedido)
    except Exception as e:
        print(f"[worker] error: {e}, reencolando", flush=True)
        canal.basic_nack(delivery_tag=metodo.delivery_tag, requeue=True)
        return
    canal.basic_ack(delivery_tag=metodo.delivery_tag)

basic_nack con requeue=True es “no he podido, devuélvelo a la cola”. Y RabbitMQ lo devuelve, al principio de la cola, y se lo vuelve a entregar al mismo worker, que vuelve a fallar:

[worker] recibido pedido 512
[worker] error: el servidor de correo ha rechazado el mensaje, reencolando
[worker] recibido pedido 512
[worker] error: el servidor de correo ha rechazado el mensaje, reencolando
[worker] recibido pedido 512
...

El worker ya no se cae, pero está en un bucle infinito con el mismo mensaje, cada dos segundos, para siempre, y en la interfaz ves el contador de Redelivered subir sin parar. Los demás correos siguen sin salir. Hemos cambiado un proceso muerto por un proceso ocupado haciendo nada.

Arreglo 2 (bueno): reintentos con espera y una cola de fallidos #

Lo que quiero es: si el correo falla, esperar un poco y volver a intentarlo, porque igual el servidor de correo estaba saturado y a la tercera va. Y si tras unos cuantos intentos sigue fallando, apartar el mensaje a un sitio donde alguien pueda mirarlo, y seguir con los demás.

RabbitMQ tiene la pieza para esto: el dead letter exchange (DLX). Es un atributo de la cola que dice “cuando un mensaje de esta cola sea rechazado o caduque, en vez de tirarlo, mándalo a este exchange con esta clave”. Con eso y una cola intermedia con caducidad se monta el circuito entero sin escribir ningún temporizador:

correos ──(nack)──▶ correos.reintentos ──(caduca a los 5 s)──▶ correos
   │
   └──(tras 3 intentos, el worker lo publica)──▶ correos.fallidos

Las declaraciones:

# cola.py (modificado)
COLA = "correos"
COLA_REINTENTOS = "correos.reintentos"
COLA_FALLIDOS = "correos.fallidos"
MAX_INTENTOS = 3


def declarar_colas(canal) -> None:
    canal.queue_declare(
        queue=COLA,
        durable=True,
        arguments={
            "x-dead-letter-exchange": "",
            "x-dead-letter-routing-key": COLA_REINTENTOS,
        },
    )
    canal.queue_declare(
        queue=COLA_REINTENTOS,
        durable=True,
        arguments={
            "x-message-ttl": 5000,
            "x-dead-letter-exchange": "",
            "x-dead-letter-routing-key": COLA,
        },
    )
    canal.queue_declare(queue=COLA_FALLIDOS, durable=True)

correos manda sus rechazados a correos.reintentos. Esa cola no tiene consumidores; los mensajes se quedan ahí cinco segundos (x-message-ttl), caducan, y al caducar su propio DLX los devuelve a correos. correos.fallidos es una cola normal donde van a parar los que se rinden.

Un aviso antes de ejecutar nada: correos ya existe de la entrada anterior, declarada sin argumentos, y RabbitMQ no deja cambiar los argumentos de una cola existente. El queue_declare nuevo falla con un PRECONDITION_FAILED. Hay que borrarla primero, desde la interfaz web o con:

ignacio@zeus:~/lab-colas$ podman compose exec rabbitmq rabbitmqctl delete_queue correos

(Y que publicar() en cola.py llame a declarar_colas(canal) en vez de a su queue_declare suelto, para que productor y consumidor declaren lo mismo.)

Ahora el worker. ¿Cómo sabe cuántas veces ha fallado ya un mensaje? RabbitMQ lo apunta por él: cada vez que un mensaje pasa por un DLX, le añade (o actualiza) una cabecera x-death con la cola de origen, el motivo y un contador.

# worker.py (versión final)
import json
import time

import pika

from cola import COLA, COLA_FALLIDOS, MAX_INTENTOS, URL, declarar_colas


def enviar_correo(pedido: dict) -> None:
    time.sleep(2)
    if float(pedido["total"]) > 1000:
        raise RuntimeError("el servidor de correo ha rechazado el mensaje")
    print(f"[correo] confirmación del pedido {pedido['id']} enviada", flush=True)


def intentos_previos(propiedades) -> int:
    """Cuántas veces ha sido rechazado este mensaje desde la cola principal."""
    muertes = (propiedades.headers or {}).get("x-death", [])
    return sum(m["count"] for m in muertes if m["queue"] == COLA and m["reason"] == "rejected")


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}", flush=True)
    try:
        enviar_correo(pedido)
    except Exception as e:
        if intento >= MAX_INTENTOS:
            print(f"[worker] error: {e}; me rindo, va a fallidos", flush=True)
            canal.basic_publish(
                exchange="",
                routing_key=COLA_FALLIDOS,
                body=cuerpo,
                properties=propiedades,
            )
            canal.basic_ack(delivery_tag=metodo.delivery_tag)
        else:
            print(f"[worker] error: {e}; reintento en 5 s", flush=True)
            canal.basic_nack(delivery_tag=metodo.delivery_tag, requeue=False)
        return
    canal.basic_ack(delivery_tag=metodo.delivery_tag)


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

La diferencia clave con el arreglo malo está en una palabra: requeue=False. Antes el nack devolvía el mensaje a la misma cola; ahora lo rechaza, y rechazarlo activa el DLX, que lo manda a la cola de reintentos. El worker no sabe nada de esperas ni de temporizadores; solo cuenta cuántas veces ha pasado por ahí y decide.

Cuando se rinde, publica el mensaje tal cual (mismo cuerpo, mismas cabeceras, incluida x-death, que es útil para quien lo examine después) en correos.fallidos, y entonces sí hace ack del original.

Lanza el pedido de 2000 euros y otro normal justo detrás:

ignacio@zeus:~/lab-colas$ python worker.py
[worker] esperando mensajes
[worker] pedido 513, intento 1
[worker] error: el servidor de correo ha rechazado el mensaje; reintento en 5 s
[worker] pedido 514, intento 1
[correo] confirmación del pedido 514 enviada
[worker] pedido 513, intento 2
[worker] error: el servidor de correo ha rechazado el mensaje; reintento en 5 s
[worker] pedido 513, intento 3
[worker] error: el servidor de correo ha rechazado el mensaje; me rindo, va a fallidos

El 514 ha salido mientras el 513 esperaba su reintento: ya no bloquea a los demás. Tras tres intentos, el 513 está en correos.fallidos, donde en la interfaz web puedes abrirlo con Get messages y ver el cuerpo y la cabecera x-death con el historial. Lo que hagas con esa cola (una alerta, un reintento manual, un informe) ya es cosa de tu aplicación; lo importante es que el mensaje no se ha perdido y no está molestando.

Dónde estamos #

Cuatro fallos y lo que se ha aprendido de cada uno:

  • auto_ack=True pierde mensajes si el consumidor muere. Ack manual, después de hacer el trabajo.
  • Una excepción sin capturar tumba al worker y bloquea la cola con el mismo mensaje.
  • Capturar y reencolar en la misma cola es un bucle infinito.
  • Rechazar sin reencolar, con un DLX hacia una cola de espera que devuelve el mensaje a los pocos segundos, da reintentos con pausa gratis; y una cola de fallidos aparta lo que no tiene remedio.

Queda un problema que se ha colado dos veces en esta entrada sin que lo señalara: con ack manual, el mensaje del fallo 1 se volvió a entregar con redelivered=True. ¿Y si el correo sí se había enviado y el worker murió justo antes del ack? Entonces se envía dos veces. Eso es la tercera entrada.


¿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