NATS vs RabbitMQ vs Kafka en un solo VPS
Compare NATS, RabbitMQ, Kafka y Postgres en un solo VPS: garantías de entrega, memoria, disco, reinicios y comprobación de acumulaciones.
La respuesta breve para un solo servidor
Una cola de mensajes en un único VPS es una decisión sobre las garantías de entrega, no sobre la velocidad. En un solo equipo, el broker rara vez es el cuello de botella, porque el código de la aplicación, la base de datos y el único disco suelen llegar antes a sus límites. Elija la herramienta cuyo comportamiento ante fallos esté dispuesto a aceptar y mida el equipo que realmente tiene.
Estas son cuatro opciones, en el orden que la mayoría de los lectores debería considerar.
- Use la base de datos que ya ejecuta. Postgres con
SELECT ... FOR UPDATE SKIP LOCKEDes una cola de trabajos funcional y no añade ningún proceso nuevo que deba monitorizar. - Use RabbitMQ cuando cada mensaje sea una unidad de trabajo que deba confirmarse, reintentarse un número limitado de veces y después almacenarse en un lugar que una persona pueda revisar.
- Use NATS cuando los mensajes sean eventos a los que reaccionen varias partes del sistema. Active JetStream para los eventos que deban sobrevivir a un reinicio.
- Use Kafka cuando una herramienta posterior sólo hable el protocolo Kafka. En un solo servidor, esa es casi la única razón que queda.
El resto de esta guía explica los motivos: cuánto cuesta cada opción en memoria y disco en un VPS pequeño, qué ocurre cuando se reinicia el equipo y cuál es el comando exacto que muestra una acumulación de mensajes antes de que los usuarios la perciban.
Qué significa realmente una garantía de entrega
Como máximo una vez significa que el broker entrega el mensaje y lo descarta. Si no hay ningún consumidor conectado o un consumidor falla a mitad del trabajo, el mensaje se pierde y no se informa de ello.
Al menos una vez significa que el consumidor envía una confirmación (un ack) después de completar correctamente el trabajo. Hasta que llega ese ack, el broker conserva el mensaje y lo volverá a entregar. La redelivery es la razón por la que los handlers deben ser idempotentes: procesar dos veces el mismo mensaje no debe cargar dos veces la tarjeta. La entrega exactamente una vez, de extremo a extremo, no es algo que proporcione un broker. Se consigue mediante una clave única en su propia base de datos.
Replay es una propiedad independiente. Una cola descarta un mensaje cuando recibe su confirmación. Un log lo conserva durante un periodo de retención, por lo que un consumidor nuevo puede empezar desde el principio y leer todo el historial. Kafka y NATS JetStream son logs. RabbitMQ ofrece colas y streams reproducibles; en esta guía se usan quorum queues. Esta diferencia determina más arquitecturas que el rendimiento.
Dead lettering es lo que ocurre con un mensaje que sigue fallando. Sin esta función, un mensaje poison entra en un bucle infinito, y el bucle parece un worker ocupado en lugar de uno averiado.
Empiece con Postgres y haga que el broker demuestre su utilidad
La mayoría de las cargas de trabajo de una sola aplicación generan unos pocos miles de trabajos en segundo plano al día. Eso cabe en una tabla.
CREATE TABLE job (
id bigserial PRIMARY KEY,
payload jsonb NOT NULL,
run_after timestamptz NOT NULL DEFAULT now(),
attempts int NOT NULL DEFAULT 0
);
CREATE INDEX job_ready_idx ON job (run_after, id);Un worker reclama un trabajo dentro de una transacción.
BEGIN;
SELECT id, payload
FROM job
WHERE run_after <= now()
ORDER BY id
FOR UPDATE SKIP LOCKED
LIMIT 1;
-- run the work, then remove the row
DELETE FROM job WHERE id = $1;
COMMIT;FOR UPDATE SKIP LOCKED es todo el mecanismo. Bloquea la fila que devuelve e ignora cualquier fila que otra transacción ya haya bloqueado, de modo que dos workers nunca reclaman el mismo trabajo. Si un worker falla, Postgres aborta su transacción, libera el bloqueo y la fila vuelve a estar disponible para el siguiente worker. Obtiene entrega al menos una vez, reintentos incrementando attempts y una tabla de mensajes fallidos, todo ello con la durabilidad que ya está pagando. El backlog se consulta con una sola consulta: SELECT count(*) FROM job WHERE run_after <= now();
Cuándo deja de funcionar. Cada reclamación y cada eliminación es una escritura, por lo que una tasa alta de trabajos deja versiones de filas obsoletas, y una tabla de cola es el caso clásico en que la fragmentación supera la capacidad de autovacuum. Los trabajos largos lo empeoran, porque una transacción abierta durante toda la ejecución también retrasa el horizonte de vacuum de toda la base de datos. El polling añade latencia, y LISTEN con NOTIFY elimina el polling, pero no las escrituras. Cuando la tabla de trabajos es la tabla más activa que tiene, o cuando un segundo servicio necesita los mismos eventos, saque el trabajo de la base de datos. Esta decisión depende de cómo se despliega la propia base de datos, así que determine si la base de datos se ejecuta en Docker o en el host antes de añadir un broker junto a ella.
Redis es la otra opción que quizá ya ejecute. Redis Streams proporciona grupos de consumidores con XADD y XREADGROUP, una lista de pendientes por grupo y XAUTOCLAIM para recuperar el trabajo de un consumidor que ha fallado. Es pequeño y rápido. La limitación importante en un solo equipo: con la configuración habitual de appendfsync everysec, un corte de alimentación puede hacer que se pierda aproximadamente un segundo de escrituras. Eso es aceptable para la invalidación de caché y no lo es para los pagos. Si su aplicación es un único proceso basado en SQLite en producción en un VPS, funciona el mismo patrón de reclamar y eliminar, aunque SQLite no tiene un equivalente de SKIP LOCKED y todos los workers se serializan en el único bloqueo de escritura.
NATS Core: enrutamiento por subject sin persistencia
docker run -d --name nats \
-p 4222:4222 -p 127.0.0.1:8222:8222 \
nats:2.15 -m 8222A octubre de 2026, la rama actual del servidor es 2.15. -m 8222 activa el puerto de monitorización HTTP, que está desactivado de forma predeterminada y no tiene autenticación. Por eso, vincúlelo a localhost como se indicó anteriormente.
Core NATS ofrece entrega como máximo una vez y no almacena nada. Un publicador envía un mensaje a un subject como orders.created y todos los suscriptores cuyo filtro coincide reciben una copia. Si no hay ningún suscriptor, el mensaje se descarta y el publicador no recibe ningún error, porque su trabajo termina cuando el servidor acepta los bytes. Un queue group, formado por varios suscriptores que comparten el mismo nombre de grupo, hace que el servidor elija un miembro por mensaje. Así se distribuye el trabajo sin almacenar una cola.
El consumo de recursos consiste en el estado de las suscripciones y un búfer de escritura por cada conexión. Por tanto, depende del número de conexiones y no del volumen de mensajes. No se acumula nada en disco. El comportamiento tras un reinicio se deduce de esto: los mensajes en curso se pierden, los clientes se vuelven a conectar por su cuenta y no hay ningún paso de recuperación que deba esperar.
No hay un backlog que monitorizar, así que debe monitorizar las pérdidas. Cuando un suscriptor lee su socket más despacio de lo que el servidor escribe en él, se llena el búfer del servidor para ese cliente. Si el cliente no se ha puesto al día cuando vence el plazo de escritura, el servidor cierra toda la conexión e incrementa un contador.
curl -s http://localhost:8222/varz | jq '.slow_consumers, .connections, .in_msgs, .out_msgs'Un valor de slow_consumers que sigue aumentando indica que se están descartando mensajes. Configure una alerta para ese caso en lugar de leer el valor una sola vez. Core NATS es adecuado para mensajes cuyo valor caduca rápidamente: una métrica, una actualización de presencia o una invalidación de caché que el siguiente evento sustituirá de todos modos.
NATS JetStream: streams duraderos y reproducción en el mismo proceso
JetStream no es un producto independiente. Es un subsistema del mismo binario que se habilita con un solo indicador.
docker run -d --name nats \
-p 4222:4222 -p 127.0.0.1:8222:8222 \
-v nats-data:/data \
nats:2.15 -js -sd /data -m 8222-sd /data establece el directorio de almacenamiento. Si se omite, JetStream almacena los datos en /tmp, con una durabilidad tan limitada como indica el nombre. Cree un stream con la CLI, incluida en la imagen nats-box.
docker run --rm -it --network host natsio/nats-box:latest \
nats stream add ORDERS \
--subjects 'orders.>' \
--storage file \
--retention limits \
--max-age 72h \
--max-bytes=1073741824 \
--discard old \
--defaultsCada límite tiene una función en un servidor pequeño. El almacenamiento en archivos sobrevive a un fallo del proceso del broker, pero el intervalo predeterminado de fsync, de dos minutos, implica que un fallo del sistema operativo o un corte de alimentación puede provocar la pérdida de mensajes confirmados; los streams en memoria pierden sus datos cuando termina el proceso. --max-bytes=1073741824 limita el stream a 1 GiB, expresado como una cantidad de bytes, y --discard old descarta los mensajes más antiguos cuando se alcanza el límite en lugar de rechazar nuevas escrituras. Si no establece el límite, un publicador descontrolado llena el disco. En ese momento, la base de datos también se detiene porque comparte ese disco.
Un consumidor duradero conserva su propia posición en el stream y la mantiene después de un reinicio. Establezca --max-deliver en el consumidor para que un mensaje que siempre falla no se vuelva a entregar indefinidamente. Cuando un mensaje agota el número de entregas, JetStream publica un aviso en $JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>. Suscribirse a ese subject es la forma de crear la ruta de mensajes fallidos que RabbitMQ ofrece como una función integrada. Esa lógica debe implementarla usted.
Para consultar los mensajes pendientes, ejecute nats stream report para obtener el número de mensajes almacenados y nats consumer report ORDERS para consultar las confirmaciones pendientes y los mensajes sin procesar de cada consumidor. El número de mensajes sin procesar es el que debe activar una alerta. El uso de disco se puede consultar con du -sh sobre el directorio de almacenamiento y aumenta hasta que un límite de retención lo reduce.
RabbitMQ: confirmar cada mensaje y apartar los fallos
docker run -d --name rabbitmq \
-p 5672:5672 -p 127.0.0.1:15672:15672 \
-v rabbitmq-data:/var/lib/rabbitmq \
rabbitmq:4-managementA fecha de 1 de noviembre de 2026, la serie actual es la 4.4 y la última versión es la 4.4.0. El puerto 5672 corresponde a AMQP (protocolo avanzado de colas de mensajes) y el 15672 es la interfaz de administración. Mantenga la interfaz en localhost y acceda a ella mediante un túnel SSH.
Declare las colas con el argumento x-queue-type establecido en quorum; el valor predeterminado sigue siendo classic. Las colas quorum siempre son duraderas y escriben los datos en disco antes de hacer cualquier otra cosa, por lo que en un nodo se obtiene un comportamiento único y claro, en lugar de una combinación de opciones duraderas y transitorias. Configure el destino de mensajes no entregados mediante una política.
docker exec rabbitmq rabbitmqctl set_policy DLX ".*" \
'{"dead-letter-exchange":"my-dlx", "dead-letter-routing-key":"my-routing-key"}' \
--apply-to queues --priority 7Declare my-dlx y vincule a ella una cola duradera de mensajes no entregados con my-routing-key; la política no las crea.
Un mensaje pasa a la cola de mensajes no entregados por cuatro motivos: un consumidor lo rechaza con basic.reject o basic.nack y requeue está establecido en false; caduca su TTL por mensaje (tiempo de vida); la cola supera un límite de longitud; o supera el límite de entregas de una cola quorum. Desde RabbitMQ 4.0, ese límite es 20 de forma predeterminada. Desde RabbitMQ 4.3, los nack explícitos con requeue no incrementan delivery-count, por lo que pueden repetirse indefinidamente. Use basic.reject con requeue para los fallos que deban contar para el límite. Superar el límite envía el mensaje a la cola de mensajes no entregados sólo si hay un DLX configurado; de lo contrario, el mensaje se descarta.
La memoria es una fuente habitual de sorpresas con RabbitMQ en un VPS pequeño. El umbral alto predeterminado es 0.6 de la RAM disponible. Cuando el nodo lo supera, RabbitMQ bloquea todas las conexiones que publican. La aplicación no recibe un error. Recibe una operación de publicación que nunca retorna, lo que en su código se interpreta como un bloqueo. El registro de inicio muestra el valor que calculó el nodo:
Memory high watermark set to 1024 MiB (1073741824 bytes) of 8192 MiB (8589934592 bytes) totalLa alarma de disco bloquea a los publicadores del mismo modo cuando el espacio libre cae por debajo de 50 MB de forma predeterminada. Las colas quorum añaden sus propios requisitos: la documentación calcula al menos 32 bytes de metadatos en memoria por mensaje, aproximadamente 1 MB por cada 30,000 mensajes, y recomienda disponer en RAM de al menos tres veces el tamaño efectivo del registro de escritura anticipada. El límite del WAL es de 512 MiB de forma predeterminada, por lo que sólo esa recomendación requiere 1.5 GiB. En un servidor de 2 GB, reduzca este valor en rabbitmq.conf en lugar de confiar en que el valor predeterminado sea suficiente.
raft.wal_max_size_bytes = 64000000
vm_memory_high_watermark.relative = 0.5El backlog se expresa mediante dos números, y la combinación indica qué tipo de fallo se ha producido.
docker exec rabbitmq rabbitmqctl list_queues name messages messages_ready messages_unacknowledgedmessages_ready está esperando a un consumidor. messages_unacknowledged se entregó y nunca recibió un ack. Un aumento del número de mensajes no confirmados junto con un número de mensajes listos estable indica que los workers tomaron los trabajos y dejaron de completarlos. Es un fallo distinto del de una cola que simplemente acumula retraso.
Kafka en un solo equipo y cuándo deja de tener sentido
KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"
bin/kafka-storage.sh format --standalone -t $KAFKA_CLUSTER_ID -c config/server.properties
bin/kafka-server-start.sh config/server.propertiesEse es el inicio rápido de Kafka 4.4.0, actualizado al 1 de noviembre de 2026, ejecutándose en modo KRaft (Kafka Raft, el controlador integrado que sustituyó a ZooKeeper en Kafka 4.0). El equivalente con contenedores es apache/kafka:4.4.0.
El script de inicio establece export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" cuando no lo ha configurado usted, por lo que el broker reserva un heap de Java de 1 GB antes de almacenar un solo mensaje y espera disponer de RAM libre adicional para la caché de páginas desde la que lee. En una VPS de 2 GB, la aplicación compite con la JVM por la memoria restante.
La retención es la siguiente sorpresa. log.retention.hours tiene el valor predeterminado 168, es decir, siete días, y log.retention.bytes tiene el valor predeterminado -1, que significa que no existe ningún límite de tamaño. Kafka conserva los mensajes durante toda la ventana, independientemente de que cada consumidor los haya leído. Esa es la función que buscaba y, en un disco pequeño, también es la causa del fallo. Por eso, establezca un límite en bytes por tema antes de descubrirlo por las malas. El límite en bytes se aplica a cada partición, así que multiplíquelo por el número de particiones al calcular el espacio de disco necesario.
Ahora, la parte objetiva. Un solo broker implica un factor de replicación de 1, por lo que acks=all espera sólo a ese broker, no a un fsync; con el vaciado predeterminado, los datos confirmados todavía pueden encontrarse en la caché de páginas del sistema operativo. Obtiene la durabilidad de un solo equipo, con el coste operativo de un broker JVM más un controlador. Las particiones también permiten que varios consumidores de un grupo compartan el trabajo en un solo broker. La replicación, la distribución por racks y el resto de las funciones para flotas permanecen inactivos. JetStream ofrece la misma reproducción duradera en el mismo equipo con una fracción de la memoria. Aquí todavía hay dos motivos para elegir Kafka: una herramienta posterior sólo admite el protocolo de Kafka (por ejemplo, la captura de cambios de datos con Debezium o un cargador de analítica), o está reproduciendo a pequeña escala una topología de producción. Planificar el crecimiento hacia un clúster implica comprar más equipos y, hasta entonces, el intercambio es el mismo que en ejecutar k3s en un solo nodo, donde paga la complejidad de un clúster por la fiabilidad de un solo nodo.
El backlog en Kafka es el desfase del consumidor.
bin/kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group my-groupLea la columna LAG, que es LOG-END-OFFSET menos CURRENT-OFFSET para cada partición. Si el desfase aumenta en una partición mientras las demás permanecen estables, probablemente existe una distribución desigual de claves, porque todos los mensajes con la misma clave llegan a la misma partición y un solo consumidor los procesa.
Qué ocurre cuando se reinicia el servidor
Core NATS pierde todo lo que está en tránsito y vuelve a estar disponible de inmediato porque no hay nada que recuperar. JetStream vuelve a cargar los streams y las posiciones de los consumidores desde el directorio de almacenamiento, por lo que los consumidores reanudan la lectura desde el offset que tenían. RabbitMQ recupera las colas quorum desde el disco independientemente del modo de entrega de los mensajes; las colas transient y non-persistent clásicas, así como los mensajes non-persistent de las colas clásicas, se pierden. Desde RabbitMQ 4.3, las colas clásicas non-durable y non-exclusive no se pueden declarar de forma predeterminada. Kafka reproduce sus segmentos de log al iniciar, y después de un cierre no limpio ese análisis de recuperación puede tardar minutos en un disco pequeño antes de que el broker acepte una conexión.
Conviene configurar dos aspectos una sola vez. Asigne al contenedor una política de reinicio (restart: unless-stopped) o habilite la unidad de systemd para que el broker vuelva a ejecutarse después de un reinicio por una actualización del kernel sin intervención manual. Después, gestione el orden de inicio: un broker que está listo veinte segundos después de la aplicación rechazará las primeras conexiones, y algunas bibliotecas cliente terminan el proceso en lugar de reintentarlo. Haga que la aplicación dependa del broker mediante healthchecks de Compose que mantienen detenido un servicio dependiente hasta que el broker esté listo.
Coste en tu propio VPS, medido en lugar de tomado de una cifra publicada
Las cifras de rendimiento publicadas se miden en hardware que no tienes, normalmente un servidor multinúcleo con NVMe local. Trátalas como un límite superior y mide tu propio equipo.
docker stats --no-stream
free -m
sudo du -sh /var/lib/docker/volumes/*/_dataEjecuta esas pruebas con el broker inactivo y repítelas con tu tráfico real. La diferencia entre ambas mediciones determina si el broker puede convivir con tu aplicación. Para obtener una referencia aproximada del rendimiento mínimo, usa el generador de carga del propio proyecto en lugar de una publicación de un blog: nats bench pub test --msgs 100000 --clients 2 para NATS, bin/kafka-producer-perf-test.sh para Kafka y PerfTest para RabbitMQ. Si ejecutas el generador en el mismo VPS, medirás el broker y el generador conjuntamente. Esto es válido siempre que lo indiques al informar del resultado.
Hay un límite común a todos ellos. El almacenamiento persistente acaba dependiendo del disco, pero la confirmación no siempre espera a fsync: la configuración predeterminada de Kafka desactiva fsync de la aplicación y el intervalo de sincronización predeterminado de JetStream es de dos minutos. En un VPS con almacenamiento conectado por red, mide el rendimiento del disco y la latencia de vaciado junto con los ajustes de durabilidad que elijas.
Tres cargas de trabajo y la cola de mensajes que necesita cada una
- Tareas en segundo plano para una aplicación web, como enviar correo electrónico, cambiar el tamaño de imágenes o entregar webhooks. Empiece con Postgres y
SKIP LOCKED. Cambie a RabbitMQ con colas de quórum cuando necesite confirmaciones por mensaje, un límite de entregas y una cola de mensajes no entregados que pueda inspeccionar sin implementar esa lógica, o cuando la tabla de tareas se haya convertido en la tabla más activa de la base de datos. - Eventos a los que reaccionan varios servicios internos y que un mensaje más reciente sustituye rápidamente si se pierde. Use Core NATS, con subjects como esquema de enrutamiento y queue groups cuando necesite compartir el trabajo. Añada un stream de JetStream para el conjunto reducido de subjects que deba sobrevivir a un reinicio y deje el resto en memoria.
- Un registro de eventos que los consumidores leen desde el principio, para una pista de auditoría, reconstruir un modelo de lectura o alimentar análisis posteriormente. Use JetStream con almacenamiento en archivos y un límite explícito en bytes. Elija Kafka sólo cuando una herramienta posterior requiera el protocolo de Kafka y acepte el heap de la JVM como coste de esa compatibilidad.
El coste de elegir mal en un solo servidor no es el rendimiento. Es la recuperación a las tres de la mañana, cuando necesita saber si los mensajes siguen existiendo. Elija teniendo eso en cuenta.
FAQ
¿Puedo ejecutar Kafka en un VPS de 2 GB?
Arranca, pero funcionará con recursos muy ajustados. bin/kafka-server-start.sh establece KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" cuando no lo ha sobrescrito, por lo que la JVM reclama 1 GB antes de almacenar cualquier mensaje. Además, Kafka necesita memoria libre adicional para la caché de páginas. Si añade la aplicación y la base de datos en el mismo equipo, empezará a usar swap. También tendrá un factor de replicación de 1, es decir, una sola copia sin réplica redundante; acks=all no requiere fsync, por lo que los datos confirmados todavía pueden estar en la caché de páginas del sistema operativo. NATS JetStream permite reproducir los mensajes de forma persistente en el mismo hardware con mucha menos memoria.
¿Necesito una cola de mensajes si ya ejecuto Postgres?
A menudo, no. Una lectura de la tabla job con SELECT ... FOR UPDATE SKIP LOCKED dentro de una transacción proporciona entrega al menos una vez, workers concurrentes seguros, reintentos y una tabla de mensajes fallidos, sin ningún servicio adicional que monitorizar y con copias de seguridad que ya realiza. Las señales para migrar a otra solución son concretas: la tabla de la cola se convierte en la carga de escritura más pesada y autovacuum se queda atrás, los trabajos de larga duración mantienen abiertas las transacciones y bloquean vacuum en toda la base de datos, o un segundo servicio necesita consumir los mismos eventos de forma independiente.
¿Debo usar NATS JetStream o RabbitMQ para trabajos en segundo plano?
RabbitMQ si necesita confirmación por mensaje, un límite de entregas y enrutamiento a mensajes fallidos como funciones integradas. Las colas de quórum siempre son persistentes, y el límite de entregas tiene el valor predeterminado 20 desde RabbitMQ 4.0. Desde 4.3, los nack explícitos con requeue no cuentan para ese límite; use basic.reject con requeue para contabilizar los fallos y configure un DLX para conservar los mensajes que agoten el límite. JetStream si otros consumidores también necesitan reproducir los mismos eventos más adelante, ya que un stream conserva los mensajes después de la confirmación, mientras que una cola no lo hace. Con JetStream, establezca --max-deliver y cree usted mismo la ruta de mensajes fallidos a partir del aviso $JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>.
¿Cómo puedo saber cuánto retraso tienen mis consumidores?
Cada broker tiene un comando. En RabbitMQ, rabbitmqctl list_queues name messages messages_ready messages_unacknowledged separa el trabajo que espera a un consumidor del trabajo entregado cuya confirmación todavía no se ha recibido. En JetStream, nats consumer report <stream> muestra los mensajes sin procesar y las confirmaciones pendientes de cada consumidor. En Kafka, kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group <group> imprime una columna LAG por partición. Core NATS no tiene una acumulación de mensajes que consultar porque no almacena nada. En su lugar, supervise el contador slow_consumers en http://localhost:8222/varz: cuenta las conexiones que el servidor cerró porque se quedaron atrás, lo que implica pérdida de mensajes.