Inizia ora

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.

10 MIN DI LETTURA

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.

ServizioSceglilo per
Valkeysemplici code di job (code di Laravel e Horizon, BullMQ, Celery, RQ) ed eventi negli Stream — quando lo usi già per cache e sessioni
NATSmessaggistica leggera tra servizi: eventi, richiesta e risposta, e stream persistenti con JetStream
RabbitMQun 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 redis e 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 — XADD aggiunge un evento a uno stream, i consumer di un gruppo lo leggono con XREADGROUP e lo confermano con XACK. 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 — PUBLISH e SUBSCRIBE consegnano 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.created e 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:

VariabileValore
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTil nome del servizio
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDutente 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=redis

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

  1. Installa il pacchetto: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Aggiungi la connessione rabbitmq a config/queue.php come indicato nel README del pacchetto per la tua versione. Legge RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD e RABBITMQ_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', '/'),
        ],
    ],
],
  1. Imposta QUEUE_CONNECTION=rabbitmq nella scheda Variabili e fai il deploy. Il worker resta php 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

ServizioParte conMemoria minima
NATS256 MB di memoria · 1 core di CPU · 5 GB di disco256 MB
RabbitMQ1 GB di memoria · 1 core di CPU · 10 GB di disco512 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.

Hai ancora dubbi?

Scrivici in chat: l'AI risponde subito e un tecnico si unisce quando serve, a qualsiasi ora.

Contatta l'assistenza