Eventos e filas: Valkey, NATS e RabbitMQ.
Tarefas em segundo plano, eventos e mensagens entre os serviços de um aplicativo: quando escolher Valkey, NATS ou RabbitMQ, as variáveis de conexão, exemplos para Laravel, Node.js e Python, recursos, backups e limites.
Quando um site passa um trabalho para um worker — enviar um e-mail, redimensionar uma imagem, cobrar um pedido — ou quando um serviço avisa os outros de que algo aconteceu, a mensagem passa por uma fila ou por um message broker. Um projeto pode ter três deles, cada um adicionado como um serviço: Visão geral → Serviços → Adicionar um serviço.
| Serviço | Escolha para |
|---|---|
| Valkey | filas de tarefas simples (filas do Laravel e Horizon, BullMQ, Celery, RQ) e eventos em Streams — quando você já o usa para cache e sessões |
| NATS | mensagens leves entre serviços: eventos, request e reply, e streams duráveis com JetStream |
| RabbitMQ | um message broker clássico: roteamento por exchanges, confirmações, novas tentativas e dead-lettering, filas quorum |
Se estiver em dúvida, comece com o Valkey para tarefas em segundo plano: a maioria dos frameworks o suporta de fábrica. Escolha o RabbitMQ quando as mensagens precisam ser roteadas entre muitas filas e nenhuma pode se perder, e o NATS quando os serviços trocam muitas mensagens pequenas ou pedem respostas uns aos outros.
Valkey: filas de tarefas e Streams
O Valkey é um armazenamento compatível com Redis — o mesmo serviço gerenciado de Bancos de dados. O primeiro Valkey do aplicativo fornece a todos os serviços de código REDIS_URL, REDIS_HOST, REDIS_PORT e REDIS_PASSWORD; todo Valkey também fornece a própria RIVERVO_<NAME>_URL.
Três formas de enviar mensagens por ele:
- Filas de tarefas — filas do Laravel com o driver
redise Horizon, BullMQ, Celery, RQ. A biblioteca guarda as tarefas no Valkey; um worker as pega uma a uma e tenta de novo as que falham. - Streams com grupos de consumidores —
XADDadiciona um evento a um stream, os consumidores de um grupo o leem comXREADGROUPe o confirmam comXACK. Os eventos ficam guardados: um consumidor que estava parado continua de onde parou, um evento não confirmado pode ser pego de novo, e um grupo novo pode ler o stream desde o início. - Pub/Sub —
PUBLISHeSUBSCRIBEentregam uma mensagem só aos assinantes conectados naquele momento. A mensagem não fica guardada: um assinante que está reiniciando ou ainda não se conectou a perde. Use Pub/Sub só onde uma mensagem perdida não causa problema (por exemplo, um sinal de «atualizar»), e Streams ou uma fila para todo o resto.
O Valkey tem backup diário, como os outros bancos de dados; ele também pode ser acessado de fora quando você libera o acesso. Veja Bancos de dados.
NATS
O NATS é um sistema de mensagens leve e rápido, com o JetStream ativado:
- Publish e subscribe — um serviço publica em um subject como
orders.created, e todos os assinantes do subject recebem a mensagem. Sem JetStream, isso é «dispara e esquece», como o Pub/Sub acima. - Request e reply — um serviço pergunta, outro responde. Quando várias instâncias respondem como um queue group, o NATS distribui as requisições entre elas.
- JetStream — streams duráveis: as mensagens ficam guardadas no disco do serviço, um consumidor lembra o que já leu, e cada mensagem é entregue pelo menos uma vez até ser confirmada.
- Armazenamento chave-valor e de objetos construído sobre o JetStream — para pequenas configurações compartilhadas, locks ou arquivos entre serviços.
Variáveis. O primeiro NATS do aplicativo fornece a todos os serviços de código:
NATS_URL=nats://<user>:<password>@<service name>:4222
Todo serviço NATS também fornece RIVERVO_<NAME>_URL com um endereço no mesmo formato — NAME é o nome do serviço em letras maiúsculas, com os hífens trocados por _: um serviço chamado events fornece RIVERVO_EVENTS_URL.
O JetStream guarda os streams no disco do serviço; streams mantidos na memória podem usar cerca de um quarto da memória do serviço.
RabbitMQ
O RabbitMQ 4.1 é um message broker clássico: os produtores publicam em exchanges, os exchanges roteiam as mensagens para filas por routing keys, os consumidores confirmam cada mensagem, e uma mensagem rejeitada ou expirada pode ir para um exchange de dead-letter. Para filas cujas mensagens precisam sobreviver a uma reinicialização, use filas quorum (o argumento x-queue-type: quorum) e publique as mensagens como persistentes.
Variáveis. O primeiro RabbitMQ do aplicativo fornece a todos os serviços de código:
| Variável | Valor |
|---|---|
AMQP_URL | amqp://<user>:<password>@<service name>:5672/%2f |
RABBITMQ_HOST | o nome do serviço |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | o usuário e a senha |
RABBITMQ_VHOST | / |
O %2f no fim da AMQP_URL é o virtual host padrão /, escrito do jeito que os endereços de conexão exigem. Todo serviço RabbitMQ também fornece a própria RIVERVO_<NAME>_URL com um endereço no mesmo formato.
API de gerenciamento. A API HTTP de gerenciamento escuta na porta 15672 dentro da rede privada do aplicativo: os serviços do aplicativo a acessam em http://<service name>:15672 com o mesmo usuário e senha, por exemplo:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Não há página de gerenciamento na internet. A página do serviço no painel mostra uma lista curta, somente leitura, das filas dele: mensagens prontas, não confirmadas e consumidores.
Somente interno
O NATS e o RabbitMQ não têm endereço público e não podem ser acessados de fora do aplicativo — do seu computador, de outro servidor ou de outro aplicativo. Diferente do PostgreSQL, do MySQL e do Valkey, o acesso externo não é oferecido para eles. Os serviços que publicam e consomem mensagens rodam como serviços do mesmo aplicativo: serviços web, workers em segundo plano e tarefas agendadas.
Segundo serviço do mesmo tipo
Só o primeiro Valkey, NATS e RabbitMQ do aplicativo recebem os nomes de sempre (REDIS_*, NATS_URL, AMQP_URL e RABBITMQ_*). O próximo do mesmo tipo adiciona apenas a própria RIVERVO_<NAME>_URL; leia essa variável no seu código ou defina os nomes de sempre com os valores dele na aba Variáveis. As variáveis chegam a um serviço no próximo deploy — veja Variáveis de ambiente.
Laravel
Valkey. Defina na aba Variáveis:
QUEUE_CONNECTION=redisRode php artisan queue:work — ou php artisan horizon com o Horizon — como worker em segundo plano. Veja Laravel.
RabbitMQ. O Laravel não tem driver de RabbitMQ embutido, e a Rivervo não altera a QUEUE_CONNECTION sozinha. Para usar o RabbitMQ nas filas do Laravel:
- Instale o pacote:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Adicione a conexão
rabbitmqaoconfig/queue.phpcomo o README do pacote mostra para a sua versão. Ela lêRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDeRABBITMQ_VHOST, que o aplicativo já tem:
'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', '/'),
],
],
],- Defina
QUEUE_CONNECTION=rabbitmqna aba Variáveis e faça o deploy. O worker continua sendophp artisan queue:work.
NATS. Não existe driver oficial de filas do Laravel para NATS. Use um cliente NATS para PHP no seu próprio código — por exemplo, basis-company/nats — e passe para ele o host, a porta, o usuário e a senha da NATS_URL. Confira se o cliente suporta os recursos de que você precisa (JetStream, chave-valor) antes de construir em cima dele.
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 })O BullMQ exige maxRetriesPerRequest: null na conexão usada pelos workers dele.
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)
}
}
}Uma entrada lida mas não confirmada fica pendente no grupo; o XAUTOCLAIM a passa para outro 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()
}Request e reply: um serviço responde com nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), outro pergunta com 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
}
})Todo serviço que declara a fila precisa declará-la com os mesmos argumentos.
Python
Celery (Valkey ou 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):
...Rode celery -A tasks worker --loglevel=info como worker em segundo plano. O Celery aceita endereços amqp:// do jeito que estão. Com RabbitMQ, as versões recentes do Celery podem declarar filas quorum (task_default_queue_type = "quorum") — veja a documentação do Celery para a sua versão.
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)O 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()Entregue mais de uma vez
Filas e brokers entregam uma mensagem de novo quando um worker para antes de confirmá-la — durante um deploy, uma reinicialização ou uma restauração. Escreva os consumidores de forma que processar a mesma mensagem duas vezes não cause problema: guarde o ID de cada mensagem processada ou torne a própria ação repetível (por exemplo, «definir o status como pago» em vez de «adicionar um pagamento»).
Recursos e preço
| Serviço | Começa com | Memória mínima |
|---|---|---|
| NATS | 256 MB de memória · 1 núcleo de CPU · 5 GB de disco | 256 MB |
| RabbitMQ | 1 GB de memória · 1 núcleo de CPU · 10 GB de disco | 512 MB |
Cada um tem preço pela memória, CPU e disco, como qualquer serviço — veja Serviços de um projeto. Os recursos podem ser alterados depois em Configurações do serviço.
Backups e restauração
O NATS e o RabbitMQ têm backup diário; guardamos os últimos 7 dias e 4 semanas, como nos outros serviços.
- O backup copia os arquivos de dados do serviço enquanto ele roda. No RabbitMQ, o mesmo backup também guarda uma exportação das definições: usuários, virtual hosts, filas, exchanges, bindings e políticas.
- Não há restauração para um momento exato — isso existe só para PostgreSQL e MySQL. Você restaura uma das cópias diárias.
- Uma restauração para o serviço por pouco tempo, coloca os arquivos de volta e o inicia de novo. Mensagens que chegaram ou foram confirmadas perto do horário do backup podem faltar ou ser entregues de novo — mais um motivo para deixar os consumidores seguros contra repetição.
- No RabbitMQ, se os arquivos copiados não conseguirem iniciar, o serviço sobe só com as definições: as filas, os exchanges e os usuários estão lá, mas as mensagens do backup se perdem.
Manutenção e mudanças de servidor
O NATS e o RabbitMQ não têm horário de manutenção para definir. Eles não são movidos para outro servidor automaticamente; se um dia isso for necessário, o suporte combina com você.