Eventos y colas: Valkey, NATS y RabbitMQ.
Tareas en segundo plano, eventos y mensajes entre los servicios de una aplicación: cuándo elegir Valkey, NATS o RabbitMQ, las variables de conexión, ejemplos para Laravel, Node.js y Python, recursos, copias de seguridad y límites.
Cuando un sitio pasa trabajo a un worker (enviar un correo, redimensionar una imagen, cobrar un pedido) o cuando un servicio avisa a los demás de que ha ocurrido algo, el mensaje pasa por una cola o un broker de mensajes. Un proyecto puede tener tres, y cada uno se añade como un servicio: Resumen → Servicios → Añadir un servicio.
| Servicio | Elígelo para |
|---|---|
| Valkey | colas de tareas sencillas (colas de Laravel y Horizon, BullMQ, Celery, RQ) y eventos en Streams, cuando ya lo usas para caché y sesiones |
| NATS | mensajería ligera entre servicios: eventos, petición y respuesta, y streams persistentes con JetStream |
| RabbitMQ | un broker de mensajes clásico: enrutamiento mediante exchanges, confirmaciones, reintentos y dead-lettering, colas quorum |
Si no lo tienes claro, empieza con Valkey para las tareas en segundo plano: la mayoría de los frameworks lo admiten de serie. Elige RabbitMQ cuando los mensajes se tengan que repartir entre muchas colas y no se pueda perder ninguno, y NATS cuando los servicios intercambien muchos mensajes pequeños o se pidan respuestas entre ellos.
Valkey: colas de tareas y Streams
Valkey es un almacén compatible con Redis, el mismo servicio gestionado que en Bases de datos. El primer Valkey de la aplicación da a cada servicio de código REDIS_URL, REDIS_HOST, REDIS_PORT y REDIS_PASSWORD; cada Valkey ofrece además su propia RIVERVO_<NAME>_URL.
Hay tres formas de enviar mensajes a través de él:
- Colas de tareas: colas de Laravel con el driver
redisy Horizon, BullMQ, Celery, RQ. La librería guarda las tareas en Valkey; un worker las va tomando una a una y reintenta las que fallan. - Streams con grupos de consumidores:
XADDañade un evento a un stream, los consumidores de un grupo lo leen conXREADGROUPy lo confirman conXACK. Los eventos se guardan: un consumidor que estaba detenido sigue donde lo dejó, un evento no confirmado se puede volver a tomar y un grupo nuevo puede leer el stream desde el principio. - Pub/Sub:
PUBLISHySUBSCRIBEentregan un mensaje solo a los suscriptores conectados en ese momento. El mensaje no se guarda: un suscriptor que se está reiniciando o que aún no se ha conectado se lo pierde. Usa Pub/Sub solo donde perder un mensaje no haga daño (por ejemplo, una señal de «actualizar») y Streams o una cola para todo lo demás.
Valkey se copia cada día como las demás bases de datos; también se puede acceder a él desde fuera si abres el acceso. Consulta Bases de datos.
NATS
NATS es un sistema de mensajería ligero y rápido, con JetStream activado:
- Publicar y suscribirse: un servicio publica en un subject como
orders.createdy cada suscriptor de ese subject recibe el mensaje. Sin JetStream, esto es «enviar y olvidar», como el Pub/Sub de arriba. - Petición y respuesta: un servicio pregunta y otro responde. Cuando varias instancias responden como un grupo de cola, NATS reparte las peticiones entre ellas.
- JetStream: streams persistentes. Los mensajes se guardan en el disco del servicio, un consumidor recuerda lo que ha leído y cada mensaje se entrega al menos una vez hasta que se confirma.
- Almacén clave-valor y de objetos construido sobre JetStream: para pequeños ajustes compartidos, bloqueos o archivos entre servicios.
Variables. El primer NATS de la aplicación da a cada servicio de código:
NATS_URL=nats://<user>:<password>@<service name>:4222
Cada servicio NATS ofrece también RIVERVO_<NAME>_URL con una dirección del mismo formato. NAME es el nombre del servicio en mayúsculas, con los guiones convertidos en _: un servicio llamado events ofrece RIVERVO_EVENTS_URL.
JetStream guarda sus streams en el disco del servicio; los streams en memoria pueden usar aproximadamente una cuarta parte de la memoria del servicio.
RabbitMQ
RabbitMQ 4.1 es un broker de mensajes clásico: los productores publican en exchanges, los exchanges enrutan los mensajes a colas según las claves de enrutamiento, los consumidores confirman cada mensaje y un mensaje rechazado o caducado puede ir a un exchange de dead-letter. Para colas cuyos mensajes deban sobrevivir a un reinicio, usa colas quorum (el argumento x-queue-type: quorum) y publica los mensajes como persistentes.
Variables. El primer RabbitMQ de la aplicación da a cada servicio de código:
| Variable | Valor |
|---|---|
AMQP_URL | amqp://<user>:<password>@<service name>:5672/%2f |
RABBITMQ_HOST | el nombre del servicio |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | el usuario y la contraseña |
RABBITMQ_VHOST | / |
El %2f del final de AMQP_URL es el host virtual por defecto /, escrito como lo exigen las direcciones de conexión. Cada servicio RabbitMQ ofrece también su propia RIVERVO_<NAME>_URL con una dirección del mismo formato.
API de gestión. La API HTTP de gestión escucha en el puerto 15672 dentro de la red privada de la aplicación: los servicios de la aplicación llegan a ella en http://<service name>:15672 con el mismo usuario y la misma contraseña, por ejemplo:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"No hay página de gestión accesible desde internet. La página del servicio en el panel muestra una lista breve de solo lectura con sus colas: mensajes listos, sin confirmar y consumidores.
Solo interno
NATS y RabbitMQ no tienen dirección pública y no se puede llegar a ellos desde fuera de la aplicación: ni desde tu equipo, ni desde otro servidor, ni desde otra aplicación. A diferencia de PostgreSQL, MySQL y Valkey, para ellos no se ofrece acceso externo. Los servicios que publican y consumen mensajes funcionan como servicios de la misma aplicación: servicios web, workers en segundo plano y tareas programadas.
Un segundo servicio del mismo tipo
Solo el primer Valkey, NATS y RabbitMQ de la aplicación reciben los nombres habituales (REDIS_*, NATS_URL, AMQP_URL y RABBITMQ_*). El siguiente del mismo tipo añade solo su propia RIVERVO_<NAME>_URL; lee esa variable en tu código o pon sus valores en los nombres habituales desde la pestaña Variables. Las variables llegan a un servicio con su siguiente despliegue. Consulta Variables de entorno.
Laravel
Valkey. Configura en la pestaña Variables:
QUEUE_CONNECTION=redisEjecuta php artisan queue:work (o php artisan horizon si usas Horizon) como worker en segundo plano. Consulta Laravel.
RabbitMQ. Laravel no trae un driver de RabbitMQ y Rivervo no cambia QUEUE_CONNECTION por su cuenta. Para usar RabbitMQ en las colas de Laravel:
- Instala el paquete:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Añade la conexión
rabbitmqaconfig/queue.phpcomo indica el README del paquete para tu versión. LeeRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDyRABBITMQ_VHOST, que la aplicación ya tiene:
'rabbitmq' => [
'driver' => 'rabbitmq',
'hosts' => [
[
'host' => env('RABBITMQ_HOST', '127.0.0.1'),
'port' => env('RABBITMQ_PORT', 5672),
'user' => env('RABBITMQ_USER', 'guest'),
'password' => env('RABBITMQ_PASSWORD', 'guest'),
'vhost' => env('RABBITMQ_VHOST', '/'),
],
],
],- Configura
QUEUE_CONNECTION=rabbitmqen la pestaña Variables y despliega. El worker sigue siendophp artisan queue:work.
NATS. No hay un driver de colas oficial de Laravel para NATS. Usa un cliente de NATS para PHP en tu propio código (por ejemplo, basis-company/nats) y pásale el host, el puerto, el usuario y la contraseña de NATS_URL. Comprueba que el cliente admite las funciones que necesitas (JetStream, clave-valor) antes de construir sobre él.
Node.js
BullMQ (Valkey)
import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
// in the web service
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// in the background worker
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })BullMQ necesita maxRetriesPerRequest: null en la conexión que usan sus workers.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// producer
await redis.xadd('orders', '*', 'id', '42')
// consumer of the group «billing»
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // the group already exists
})
const me = process.env.HOSTNAME ?? 'worker'
for (;;) {
const res = await redis.xreadgroup('GROUP', 'billing', me, 'COUNT', 10, 'BLOCK', 5000, 'STREAMS', 'orders', '>')
for (const [, entries] of res ?? []) {
for (const [id, fields] of entries) {
await handleOrder(fields)
await redis.xack('orders', 'billing', id)
}
}
}Una entrada leída pero no confirmada queda pendiente en el grupo; XAUTOCLAIM se la pasa a otro consumidor.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// once: a stream for the subjects orders.* and a durable consumer
const jsm = await nc.jetstreamManager()
await jsm.streams.add({ name: 'ORDERS', subjects: ['orders.>'] })
await jsm.consumers.add('ORDERS', { durable_name: 'billing', ack_policy: AckPolicy.Explicit })
// producer
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
// consumer
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
await handleOrder(jc.decode(m.data))
m.ack()
}Petición y respuesta: un servicio responde con nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }) y otro pregunta con await nc.request('prices.get', jc.encode({ sku: 'A1' }), { timeout: 2000 }).
RabbitMQ (amqplib)
import amqp from 'amqplib'
const conn = await amqp.connect(process.env.AMQP_URL)
const ch = await conn.createChannel()
await ch.assertQueue('emails', { durable: true, arguments: { 'x-queue-type': 'quorum' } })
// producer
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
// consumer: at most 10 unacknowledged messages at a time
await ch.prefetch(10)
await ch.consume('emails', async (msg) => {
try {
await sendWelcome(JSON.parse(msg.content.toString()).userId)
ch.ack(msg)
} catch {
ch.nack(msg, false, false) // to the dead-letter exchange, if the queue has one
}
})Todos los servicios que declaran la cola deben declararla con los mismos argumentos.
Python
Celery (Valkey o RabbitMQ)
import os
from celery import Celery
app = Celery("tasks", broker=os.environ["REDIS_URL"]) # or os.environ["AMQP_URL"]
@app.task(acks_late=True)
def send_welcome(user_id):
...Ejecuta celery -A tasks worker --loglevel=info como worker en segundo plano. Celery acepta las direcciones amqp:// tal cual. Con RabbitMQ, las versiones recientes de Celery pueden declarar colas quorum (task_default_queue_type = "quorum"); consulta la documentación de Celery para tu versión.
RQ (Valkey)
import os
from redis import Redis
from rq import Queue
queue = Queue("emails", connection=Redis.from_url(os.environ["REDIS_URL"]))
queue.enqueue(send_welcome, 42)El worker: rq worker emails --url "$REDIS_URL".
NATS (nats-py)
import asyncio, json, os
import nats
from nats.errors import TimeoutError
async def main():
nc = await nats.connect(os.environ["NATS_URL"])
js = nc.jetstream()
await js.add_stream(name="ORDERS", subjects=["orders.>"])
await js.publish("orders.created", json.dumps({"id": 42}).encode())
sub = await js.pull_subscribe("orders.>", durable="billing")
while True:
try:
msgs = await sub.fetch(10, timeout=5)
except TimeoutError:
continue
for msg in msgs:
await handle_order(json.loads(msg.data))
await msg.ack()
asyncio.run(main())RabbitMQ (pika)
import json, os
import pika
conn = pika.BlockingConnection(pika.URLParameters(os.environ["AMQP_URL"]))
ch = conn.channel()
ch.queue_declare(queue="emails", durable=True, arguments={"x-queue-type": "quorum"})
# producer
ch.basic_publish(exchange="", routing_key="emails",
body=json.dumps({"user_id": 42}),
properties=pika.BasicProperties(delivery_mode=2))
# consumer
def on_message(ch, method, properties, body):
send_welcome(json.loads(body)["user_id"])
ch.basic_ack(delivery_tag=method.delivery_tag)
ch.basic_qos(prefetch_count=10)
ch.basic_consume(queue="emails", on_message_callback=on_message)
ch.start_consuming()Mensajes entregados más de una vez
Las colas y los brokers vuelven a entregar un mensaje cuando un worker se detiene antes de confirmarlo: durante un despliegue, un reinicio o una restauración. Escribe los consumidores de forma que procesar dos veces el mismo mensaje no cause daño: guarda el ID de cada mensaje procesado o haz que la propia acción se pueda repetir (por ejemplo, «poner el estado en pagado» en lugar de «añadir un pago»).
Recursos y precio
| Servicio | Empieza con | Memoria mínima |
|---|---|---|
| NATS | 256 MB de memoria · 1 núcleo de CPU · 5 GB de disco | 256 MB |
| RabbitMQ | 1 GB de memoria · 1 núcleo de CPU · 10 GB de disco | 512 MB |
Cada uno tiene un precio según su memoria, CPU y disco, como cualquier servicio. Consulta Servicios de un proyecto. Puedes cambiar los recursos más adelante en Ajustes del servicio.
Copias de seguridad y restauración
NATS y RabbitMQ se copian cada día; conservamos los últimos 7 días y 4 semanas, como con los demás servicios.
- La copia de seguridad copia los archivos de datos del servicio mientras funciona. En RabbitMQ, esa misma copia incluye también una exportación de sus definiciones: usuarios, hosts virtuales, colas, exchanges, bindings y políticas.
- No hay restauración a un momento exacto: eso solo existe para PostgreSQL y MySQL. Restauras una de las copias diarias.
- Una restauración detiene el servicio durante un rato breve, vuelve a poner los archivos y lo arranca de nuevo. Los mensajes que llegaron o se confirmaron en torno al momento de la copia pueden faltar o entregarse otra vez: otro motivo para que los consumidores toleren repeticiones.
- En RabbitMQ, si los archivos copiados no consiguen arrancar, el servicio arranca solo con las definiciones: las colas, los exchanges y los usuarios están ahí, pero los mensajes de la copia se pierden.
Mantenimiento y traslados
NATS y RabbitMQ no tienen una ventana de mantenimiento que configurar. No se trasladan a otro servidor automáticamente; si alguna vez hace falta, el soporte lo organiza contigo.