crtdrops
NOTA · ESPAÑOL ·

La cola que no se vacía

Mensajes guardados por segundo por un consumidor que hace un commit por mensaje, vaciando la cola durante 15 minutos en el N100: unos 1,160 por segundo los primeros tres minutos y, de golpe, unos 270. Minuto 1: 1,159 por segundo; minutos 11 a 15: 266.

En una plataforma de telemetría, los equipos GPS mandan sus posiciones a gateways TCP; los gateways las publican en RabbitMQ; servicios consumidores las toman, las guardan en MySQL y Socket.IO las entrega a las aplicaciones. Hay colas dedicadas a posiciones, a eventos JT808, a alarmas y a otros mensajes.

La cola está ahí para que cada pieza haga lo suyo sin esperar a la siguiente: el gateway recibe aunque la base esté ocupada, y el consumidor procesa a su ritmo. Pero una cola de mensajes permite desacoplar sistemas, no elimina los problemas de capacidad ni garantiza por sí sola la integridad de la información.

Quise ver eso medido, no contado. No tengo documentado un incidente en el que una cola se acumulara durante horas ni una causa confirmada de saturación, y no voy a atribuirle un problema a RabbitMQ, a la base o a un consumidor sin registros que lo demuestren. Así que lo monté en el laboratorio.

Todo lo de esta nota se midió el 29 de octubre de 2026 en un Intel N100 (4 núcleos, 8 GB, un NVMe de 128 GB), con RabbitMQ 3.12.1 aislado y mensajes sintéticos con la forma de una posición: ni colas de producción ni datos de equipos reales. La persistencia es SQLite, no MySQL: el N100 no tiene MySQL. Las cifras son de este equipo; otro servidor tendrá otros números.

La regla: confirmar después de guardar

El consumidor del laboratorio sigue una regla: confirma el mensaje (el ACK) sólo después de que la posición quedó guardada. SQLite en modo WAL con synchronous=FULL y un commit por mensaje: cuando el consumidor confirma, la posición ya está en disco.

Y conviene saber qué dice ese ACK. No demuestra que el equipo recibió nada, ni que la aplicación ya tiene el dato: sólo que el consumidor reconoció el mensaje ante el broker. Con eso, RabbitMQ lo borra. Si el consumidor muere antes de confirmar, RabbitMQ lo vuelve a entregar.

El prefetch limita cuántos mensajes tiene el consumidor en la mano sin confirmar. En el laboratorio, 10.

Si entra más de lo que sale

La cuenta es sencilla. Si entran 1,000 mensajes por segundo y sólo se pueden procesar 800, se acumulan 200 por segundo. RabbitMQ los guarda mientras tenga recursos, pero el problema sigue creciendo.

Primero medí cuánto procesa el consumidor: con una cola precargada de 10,000 mensajes, vació 1,095 por segundo. Luego puse un productor a tasa fija, dos minutos por prueba (las tasas, del segundo minuto):

Llegan Salen El atraso
1,041/s 1,041/s no crece
1,150/s 1,122/s crece 28 por segundo
1,314/s 1,103/s crece 211 por segundo

La última es la cuenta del ejemplo, medida: entran 211 por segundo más de los que salen, y el atraso crece justo eso. Al terminar esos dos minutos, las posiciones que se guardaban llevaban 18 segundos esperando en la cola. Nada falló: ningún error, ningún mensaje perdido. Sólo datos cada vez más viejos.

La capacidad de una prueba corta no es la que se sostiene

Hasta aquí, 1,095 por segundo parecía la capacidad del consumidor. Luego dejé un solo consumidor vaciando una cola grande durante 15 minutos:

Minuto 1 2 3 4 5 al 15
Guardados por segundo 1,159 1,169 1,130 275 261 a 272

A los tres minutos, la capacidad se cayó a la cuarta parte y ahí se quedó: 266 por segundo de media en los últimos cinco.

Nada indica que fuera el procesador: la temperatura se quedó en unos 46 °C de media en las dos fases, y la frecuencia media bajó, de 1,727 a 1,441 MHz, como baja cuando tiene menos trabajo. Lo que cambió fue el disco: el NVMe pasó de unas 3,200 escrituras por segundo, a 0.5 ms de mediana, a unas 835, a 1.75 ms, con picos de 11.5 ms. Por qué se frena por dentro no lo sé: es un disco sin memoria DRAM propia, y la sospecha es su caché, pero no lo comprobé. Lo que sí medí es que con descansar se recupera: tras una pausa de 30 segundos, volvió a más de 1,000 por segundo.

Entonces puse el productor a tasa fija, diez minutos por prueba, empezando con el disco descansado:

A 400 por segundo —poco más de un tercio de lo que había medido en la prueba corta— la cola aguantó ocho minutos y empezó a crecer. Una prueba de carga de cinco minutos la habría aprobado. A 550 y 700 por segundo, ya con el disco cansado por la prueba anterior, el consumidor bajó a unas 300 por segundo desde el segundo minuto; al terminar había 143,000 y 217,000 mensajes en la cola, y las posiciones llevaban más de cuatro y cinco minutos esperando.

Y 293 por segundo aguantó diez minutos, pero no lo probé más tiempo: no puedo decir que aguante una hora. Que aguantara siendo más que 266 dice algo más: esos 266 son lo que sale vaciando a toda velocidad, no un techo fijo. Cuándo se frena el disco depende de cuánto se le pide y de cuánto descansó antes.

La capacidad que importa es la que se sostiene con la carga real, el tiempo suficiente. Una prueba corta mide otra cosa.

Más consumidores casi no ayudaron; el lote sí

La reacción natural es agregar consumidores. Con la cola precargada:

Prefetch 1 consumidor 2 4
1 723/s 751/s 897/s
10 1,095/s 1,001/s 925/s
100 1,096/s 1,104/s 920/s

Con prefetch 1, más consumidores sí ayudaron: de 723 a 897 por segundo. Con prefetch 10 y 100 dieron lo mismo o menos, y con cuatro, menos que con uno. Subir el prefetch de 1 a 10 ayudó más que cualquier número de consumidores; de 10 a 100 ya no. Mi lectura, que no medí, es que SQLite escribe de uno en uno y lo que se agrega compite por lo mismo. Y cada cifra es una sola corrida de unos nueve segundos, justo la prueba corta de la sección anterior: sirve para comparar configuraciones, no como la capacidad de ninguna.

Lo que cambió la escala fue confirmar por lote: guardar hasta 10 posiciones en un solo commit (o las que se junten en 50 ms) y, sólo después, confirmarlas juntas, con prefetch 20. La regla se respeta: nada se confirma antes de estar en disco. Vaciando una cola de un millón, ese consumidor guardó unas 7,750 por segundo, aunque fue otra prueba corta: 129 segundos. Con un productor a 3,000 por segundo durante diez minutos, el primer minuto salió todo; luego fue bajando, de 2,512 a cerca de 2,000 por segundo, y la cola llegó a 448,000. Unas siete veces la capacidad sostenida de uno por uno, pero tampoco fue constante; supongo que también por el disco, aunque en esa corrida no lo registré.

Todo apunta a que el cuello de botella no estaba en RabbitMQ, sino en lo que el consumidor le pide al disco por cada mensaje.

Cuando el consumidor se cae

Si el consumidor se detiene un minuto y el productor sigue, el atraso es lo que llegó en ese minuto. Cuando el consumidor vuelve, lo vacía con lo que le sobra de capacidad: lo que procesa menos lo que sigue llegando. El tiempo para ponerse al día es el atraso entre ese margen.

Con el productor a la mitad y al 70 % de la capacidad de la prueba corta (1,095 por segundo):

Carga Atraso al volver Previsto Medido
50 % 32,987 60 s 57 s
70 % 45,835 140 s 134 s

(“Al día”: las posiciones que se guardan vuelven a esperar menos de un segundo.)

La fórmula funciona mientras el margen exista. Con 50 % de carga, el margen es la mitad de la capacidad; con 70 %, menos de un tercio, y el mismo minuto de caída tardó más del doble en recuperarse.

Con 90 %, el margen previsto daba nueve minutos. No se recuperó nunca. La prueba empezó con el disco cansado por la anterior: el primer minuto salieron 554 por segundo de 986 que llegaban. La caída le sirvió de descanso: al volver, salieron unas 1,100 por segundo durante tres minutos y el atraso bajó. Luego cayeron a unas 300, y a los quince minutos había 470,000 mensajes en la cola. Y la de 70 %, después de ponerse al día, se volvió a atrasar en el minuto seis; esa corrida no registró el disco, pero el patrón es el mismo.

Aunque después recuperemos capacidad, todavía hay que procesar todo el atraso acumulado. Y si el margen es chico, eso tarda mucho más que la caída.

El mensaje que nunca se va

Un mensaje inválido —JSON roto— falla siempre. La pregunta es qué hace el consumidor con él. Probé tres políticas, con un productor a la mitad de la capacidad de la prueba corta durante un minuto y tres mensajes especiales: uno inválido, uno con una falla transitoria que se recupera al tercer intento y uno que nunca se recupera.

Devolverlo a la cola. El inválido se reentregó 233,330 veces en un minuto, unas 3,850 por segundo. Y la cola se veía sana: 0 mensajes listos, entre 1 y 3 sin confirmar, las demás posiciones saliendo a 548 por segundo. Una alerta que sólo mirara cuántos mensajes hay en la cola nunca se habría disparado. El síntoma estaba en la tasa de reentregas: miles de entregas por segundo de un mensaje que nunca se va a guardar.

Mandarlo a la cola de mensajes muertos (DLQ) a la primera falla. El inválido se fue a la DLQ, que es lo correcto. Pero el de la falla transitoria también: una posición buena, perdida en la DLQ por una falla que se habría resuelto sola al tercer intento.

Distinguir. Inválido: a la DLQ de inmediato, porque reintentarlo no lo arregla. Falla transitoria: esperar un segundo en otra cola y volver a intentar, hasta tres intentos. El transitorio se guardó al tercer intento; el que nunca se recupera llegó a la DLQ al agotar sus intentos.

Y un detalle que importa: en este laboratorio, a la DLQ sólo llega lo que el consumidor rechaza sin reencolar, porque así está configurada la cola. En general, RabbitMQ también manda ahí los mensajes cuyo tiempo de vida venció o que exceden el largo máximo de la cola, si la cola lo tiene configurado; los reintentos de este laboratorio usan justo eso, un tiempo de vida de un segundo. A una DLQ que nadie configuró no llega nada.

Guardado, pero no confirmado

El caso más incómodo: el consumidor guarda la posición, y antes de confirmar se cae. RabbitMQ no recibió el ACK, así que la vuelve a entregar, y el consumidor la guarda otra vez.

Lo provoqué cinco veces en un minuto, con dos tablas:

Tabla Caídas Filas de más
sin clave 5 5
clave (equipo, hora del evento) 5 0

En la corrida con clave hubo 22 reentregas (21 en la corrida sin ella): los cinco mensajes ya guardados y los que el consumidor tenía en la mano sin confirmar. Con la clave, los cinco mensajes ya guardados se detectaron como duplicados y no se insertaron. Sin ella, cinco posiciones quedaron dos veces: un recorrido con puntos repetidos, una alarma contada doble.

RabbitMQ no garantiza que cada operación de negocio se ejecute exactamente una vez. La garantía tiene que estar en la persistencia: un identificador del evento o una clave compuesta que tenga sentido para el protocolo.

Qué vigilar

Una cola vacía no basta como señal de salud: con el mensaje envenenado, la cola estaba vacía. Y una cola con mensajes tampoco significa que algo esté fallando: después de una caída, un atraso que baja es el sistema recuperándose.

Lo que dice algo es:

Lo que no sabemos

Lo que haría

El código, la configuración del laboratorio y las series de las tres corridas están en el repositorio.

El verdadero problema no es tener mensajes esperando. Es que el sistema acumule trabajo más rápido de lo que puede resolverlo y nadie se dé cuenta hasta que la información deja de ser oportuna.

Israel Negrete Lepe es ingeniero en electrónica. Veinticinco años haciendo que sistemas distintos funcionen juntos en condiciones reales: del sensor, el vehículo o la transacción al backend, los datos, la seguridad y la operación. Hoy, cada vez más, IA en el borde. Acepto proyectos por hora o por entrega: israel0negrete@gmail.com.