La cola que no se vacía
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:
- 213, 253 y 293 por segundo: al día los diez minutos; ninguna posición esperó más de 34 ms.
- 400 por segundo: al día ocho minutos; en el noveno empezó a atrasarse, en el décimo salían unas 286 por segundo, y al apagar el productor las posiciones llevaban 22 s esperando.
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:
- la tasa de entrada contra la de salida, sostenida, no la de un minuto;
- la antigüedad del mensaje más viejo, que es lo que convierte un atraso en un dato que ya no sirve;
- cuánto tarda en ponerse al día después de una caída;
- las reentregas y el estado de los consumidores, no sólo cuántos hay conectados.
Lo que no sabemos
- Producción. Nada de esto es una medición de producción. No sé dónde confirman hoy los consumidores ni con qué prefetch, y las políticas de reintentos, expiración y supervisión de las DLQ no están documentadas de forma uniforme.
- El disco. Por qué el NVMe se frena tras unos minutos de un commit por mensaje es una hipótesis. Aquí, además, el broker y la base escriben en el mismo disco; en un servidor con discos separados, los números pueden cambiar.
- Más tiempo. Ninguna prueba con productor duró más de quince minutos. Que 293 por segundo aguantara diez minutos no dice qué pasa en una hora.
- MySQL. La persistencia fue SQLite. Espero que el fenómeno sea el mismo —la capacidad la pone lo que el consumidor le pide a la base por cada mensaje—, pero no lo medí.
- El tipo de cola. Fueron colas clásicas de RabbitMQ 3.12, una versión que ya no recibe soporte de la comunidad. Las colas quorum guardan y replican distinto.
Lo que haría
- Medir la capacidad sostenida del consumidor con la carga real durante el tiempo suficiente, no en una prueba de un minuto. Y repetirla cuando cambie la base, el disco o el volumen.
- Confirmar después de guardar, con persistencia idempotente: el ACK puede perderse, y la reentrega va a llegar.
- Confirmar por lote cuando el costo por mensaje está en el commit, sin romper la regla.
- Separar lo inválido de lo transitorio: lo inválido a la DLQ de inmediato; lo transitorio, reintentos con espera y un máximo.
- Alertar por la antigüedad y por las tasas, no sólo por la profundidad de la cola.
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.