Eventi e code: Valkey, NATS e RabbitMQ.
Job in background, eventi e messaggi tra i servizi di un'applicazione: quando scegliere Valkey, NATS o RabbitMQ, le variabili di connessione, esempi per Laravel, Node.js e Python, risorse, backup e limiti.
Quando un sito passa un lavoro a un worker — inviare un'email, ridimensionare un'immagine, addebitare un ordine — o quando un servizio comunica agli altri che è successo qualcosa, il messaggio passa per una coda o un message broker. Un progetto può averne tre, ognuno aggiunto come servizio: Panoramica → Servizi → Aggiungi un servizio.
| Servizio | Sceglilo per |
|---|---|
| Valkey | semplici code di job (code di Laravel e Horizon, BullMQ, Celery, RQ) ed eventi negli Stream — quando lo usi già per cache e sessioni |
| NATS | messaggistica leggera tra servizi: eventi, richiesta e risposta, e stream persistenti con JetStream |
| RabbitMQ | un message broker classico: instradamento tramite exchange, conferme, nuovi tentativi e dead-lettering, quorum queue |
Se non sei sicuro, parti con Valkey per i job in background: la maggior parte dei framework lo supporta di serie. Scegli RabbitMQ quando i messaggi devono essere instradati tra molte code e nessuno può andare perso, e NATS quando i servizi si scambiano molti piccoli messaggi o si chiedono risposte a vicenda.
Valkey: code di job e Stream
Valkey è uno store compatibile con Redis — lo stesso servizio gestito descritto in Database. Il primo Valkey dell'applicazione fornisce a ogni servizio di codice REDIS_URL, REDIS_HOST, REDIS_PORT e REDIS_PASSWORD; ogni Valkey fornisce anche la propria RIVERVO_<NAME>_URL.
Tre modi per inviare messaggi tramite Valkey:
- Code di job — le code di Laravel con il driver
redise Horizon, BullMQ, Celery, RQ. La libreria conserva i job in Valkey; un worker li prende uno alla volta e riprova quelli che falliscono. - Stream con consumer group —
XADDaggiunge un evento a uno stream, i consumer di un gruppo lo leggono conXREADGROUPe lo confermano conXACK. Gli eventi vengono conservati: un consumer che si era fermato riprende da dove aveva lasciato, un evento non confermato può essere preso di nuovo e un nuovo gruppo può leggere lo stream dall'inizio. - Pub/Sub —
PUBLISHeSUBSCRIBEconsegnano un messaggio solo ai subscriber collegati in quel momento. Il messaggio non viene conservato: un subscriber che si sta riavviando o non è ancora collegato lo perde. Usa Pub/Sub solo dove un messaggio perso non fa danni (ad esempio un segnale di «aggiornamento»), e gli Stream o una coda per tutto il resto.
Valkey viene salvato ogni giorno come gli altri database; è anche raggiungibile dall'esterno quando apri l'accesso. Vedi Database.
NATS
NATS è un sistema di messaggistica leggero e veloce, con JetStream attivo:
- Publish e subscribe — un servizio pubblica su un subject come
orders.createde ogni subscriber di quel subject riceve il messaggio. Senza JetStream è un invio «fire-and-forget», come il Pub/Sub descritto sopra. - Richiesta e risposta — un servizio chiede, un altro risponde. Quando più istanze rispondono come queue group, NATS distribuisce le richieste tra loro.
- JetStream — stream persistenti: i messaggi vengono conservati sul disco del servizio, un consumer ricorda cosa ha letto e ogni messaggio viene consegnato almeno una volta finché non viene confermato.
- Key-value e object store basati su JetStream — per piccole impostazioni condivise, lock o file tra servizi.
Variabili. Il primo NATS dell'applicazione fornisce a ogni servizio di codice:
NATS_URL=nats://<user>:<password>@<service name>:4222
Ogni servizio NATS fornisce anche RIVERVO_<NAME>_URL con un indirizzo dello stesso formato — NAME è il nome del servizio in maiuscolo, con i trattini trasformati in _: un servizio chiamato events fornisce RIVERVO_EVENTS_URL.
JetStream conserva i suoi stream sul disco del servizio; gli stream tenuti in memoria possono usare circa un quarto della memoria del servizio.
RabbitMQ
RabbitMQ 4.1 è un message broker classico: i producer pubblicano sugli exchange, gli exchange instradano i messaggi verso le code in base alle routing key, i consumer confermano ogni messaggio, e un messaggio rifiutato o scaduto può finire in un exchange di dead-letter. Per le code i cui messaggi devono sopravvivere a un riavvio, usa le quorum queue (l'argomento x-queue-type: quorum) e pubblica i messaggi come persistenti.
Variabili. Il primo RabbitMQ dell'applicazione fornisce a ogni servizio di codice:
| Variabile | Valore |
|---|---|
AMQP_URL | amqp://<user>:<password>@<service name>:5672/%2f |
RABBITMQ_HOST | il nome del servizio |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | utente e password |
RABBITMQ_VHOST | / |
%2f alla fine di AMQP_URL è il virtual host predefinito /, scritto come lo richiedono gli indirizzi di connessione. Ogni servizio RabbitMQ fornisce anche la propria RIVERVO_<NAME>_URL con un indirizzo dello stesso formato.
API di gestione. L'API HTTP di gestione è in ascolto sulla porta 15672 all'interno della rete privata dell'applicazione: i servizi dell'applicazione la raggiungono su http://<service name>:15672 con lo stesso utente e la stessa password, ad esempio:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Non c'è una pagina di gestione su internet. La pagina del servizio nel pannello mostra un breve elenco in sola lettura delle sue code: messaggi pronti, non confermati e consumer.
Solo interni
NATS e RabbitMQ non hanno un indirizzo pubblico e non sono raggiungibili dall'esterno dell'applicazione — dal tuo computer, da un altro server o da un'altra applicazione. A differenza di PostgreSQL, MySQL e Valkey, per loro non è previsto l'accesso dall'esterno. I servizi che pubblicano e consumano messaggi funzionano come servizi della stessa applicazione: servizi web, worker in background e job pianificati.
Un secondo servizio dello stesso tipo
Solo il primo Valkey, NATS e RabbitMQ dell'applicazione ricevono i nomi consueti (REDIS_*, NATS_URL, AMQP_URL e RABBITMQ_*). Il successivo dello stesso tipo aggiunge solo la propria RIVERVO_<NAME>_URL; leggi quella variabile nel tuo codice, oppure imposta i nomi consueti con i suoi valori nella scheda Variabili. Le variabili arrivano a un servizio con il suo deploy successivo — vedi Variabili d'ambiente.
Laravel
Valkey. Imposta nella scheda Variabili:
QUEUE_CONNECTION=redisEsegui php artisan queue:work — oppure php artisan horizon con Horizon — come worker in background. Vedi Laravel.
RabbitMQ. Laravel non ha un driver RabbitMQ integrato, e Rivervo non modifica QUEUE_CONNECTION da solo. Per usare RabbitMQ per le code di Laravel:
- Installa il pacchetto:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Aggiungi la connessione
rabbitmqaconfig/queue.phpcome indicato nel README del pacchetto per la tua versione. LeggeRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDeRABBITMQ_VHOST, che l'applicazione ha già:
'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', '/'),
],
],
],- Imposta
QUEUE_CONNECTION=rabbitmqnella scheda Variabili e fai il deploy. Il worker restaphp artisan queue:work.
NATS. Non esiste un driver ufficiale per le code di Laravel con NATS. Usa un client NATS per PHP nel tuo codice — ad esempio basis-company/nats — e passagli host, porta, utente e password presi da NATS_URL. Prima di costruirci sopra, verifica che il client supporti le funzioni che ti servono (JetStream, key-value).
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 richiede maxRetriesPerRequest: null sulla connessione usata dai suoi worker.
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 voce letta ma non confermata resta in sospeso nel gruppo; XAUTOCLAIM la passa a un altro consumer.
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()
}Richiesta e risposta: un servizio risponde con nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), un altro chiede 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
}
})Ogni servizio che dichiara la coda deve dichiararla con gli stessi argomenti.
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):
...Esegui celery -A tasks worker --loglevel=info come worker in background. Celery accetta gli indirizzi amqp:// così come sono. Con RabbitMQ, le versioni recenti di Celery possono dichiarare quorum queue (task_default_queue_type = "quorum") — consulta la documentazione di Celery per la tua versione.
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)Il 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()Consegnato più di una volta
Code e broker consegnano di nuovo un messaggio quando un worker si ferma prima di averlo confermato — durante un deploy, un riavvio o un ripristino. Scrivi i consumer in modo che elaborare due volte lo stesso messaggio non faccia danni: conserva l'ID di ogni messaggio elaborato, oppure rendi l'azione stessa ripetibile (ad esempio «imposta lo stato su pagato» invece di «aggiungi un pagamento»).
Risorse e prezzo
| Servizio | Parte con | Memoria minima |
|---|---|---|
| NATS | 256 MB di memoria · 1 core di CPU · 5 GB di disco | 256 MB |
| RabbitMQ | 1 GB di memoria · 1 core di CPU · 10 GB di disco | 512 MB |
Ognuno ha un prezzo in base a memoria, CPU e disco come qualsiasi servizio — vedi Servizi di un progetto. Le risorse si possono cambiare in seguito in Impostazioni del servizio.
Backup e ripristino
NATS e RabbitMQ vengono salvati ogni giorno; conserviamo gli ultimi 7 giorni e 4 settimane, come per gli altri servizi.
- Il backup copia i file di dati del servizio mentre è in esecuzione. Per RabbitMQ lo stesso backup contiene anche un'esportazione delle sue definizioni: utenti, virtual host, code, exchange, binding e policy.
- Non è possibile ripristinare a un momento preciso — questo vale solo per PostgreSQL e MySQL. Ripristini una delle copie giornaliere.
- Un ripristino ferma il servizio per poco tempo, rimette a posto i file e lo riavvia. I messaggi arrivati o confermati intorno al momento del backup possono mancare o essere consegnati di nuovo — un motivo in più per rendere i consumer sicuri da ripetere.
- Per RabbitMQ, se i file copiati non riescono ad avviarsi, il servizio parte con le sole definizioni: code, exchange e utenti ci sono, ma i messaggi del backup vanno persi.
Manutenzione e spostamenti
NATS e RabbitMQ non hanno una finestra di manutenzione da impostare. Non vengono spostati automaticamente su un altro server; se mai fosse necessario, l'assistenza lo organizza insieme a te.