Empezar

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.

11 MIN DE LECTURA

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.

ServicioElígelo para
Valkeycolas de tareas sencillas (colas de Laravel y Horizon, BullMQ, Celery, RQ) y eventos en Streams, cuando ya lo usas para caché y sesiones
NATSmensajería ligera entre servicios: eventos, petición y respuesta, y streams persistentes con JetStream
RabbitMQun 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 redis y 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: XADD añade un evento a un stream, los consumidores de un grupo lo leen con XREADGROUP y lo confirman con XACK. 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: PUBLISH y SUBSCRIBE entregan 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.created y 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:

VariableValor
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTel nombre del servicio
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDel 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=redis

Ejecuta 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:

  1. Instala el paquete: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Añade la conexión rabbitmq a config/queue.php como indica el README del paquete para tu versión. Lee RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD y RABBITMQ_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', '/'),
        ],
    ],
],
  1. Configura QUEUE_CONNECTION=rabbitmq en la pestaña Variables y despliega. El worker sigue siendo php 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

ServicioEmpieza conMemoria mínima
NATS256 MB de memoria · 1 núcleo de CPU · 5 GB de disco256 MB
RabbitMQ1 GB de memoria · 1 núcleo de CPU · 10 GB de disco512 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.

¿Sigues con dudas?

Escríbenos por chat: la AI responde al momento y un ingeniero se une cuando hace falta, a cualquier hora del día.

Contactar con soporte