Commencer

Événements et files d'attente : Valkey, NATS et RabbitMQ.

Tâches en arrière-plan, événements et messages entre les services d'une application : quand choisir Valkey, NATS ou RabbitMQ, les variables de connexion, des exemples pour Laravel, Node.js et Python, les ressources, les sauvegardes et les limites.

11 MIN DE LECTURE

Quand un site confie du travail à un worker (envoyer un e-mail, redimensionner une image, encaisser une commande) ou qu'un service signale aux autres qu'il s'est passé quelque chose, le message passe par une file d'attente ou un broker de messages. Un projet peut en avoir trois, chacun ajouté comme un service : Vue d'ensemble → Services → Ajouter un service.

ServiceÀ choisir pour
Valkeydes files de tâches simples (files Laravel et Horizon, BullMQ, Celery, RQ) et des événements dans des Streams, quand vous l'utilisez déjà pour le cache et les sessions
NATSune messagerie légère entre services : événements, requête-réponse et flux durables avec JetStream
RabbitMQun broker de messages classique : routage via des exchanges, accusés de réception, nouvelles tentatives et dead-lettering, files quorum

En cas de doute, commencez par Valkey pour les tâches en arrière-plan : la plupart des frameworks le prennent en charge nativement. Choisissez RabbitMQ quand les messages doivent être routés entre de nombreuses files sans qu'aucun ne se perde, et NATS quand les services échangent beaucoup de petits messages ou s'interrogent mutuellement.

Valkey : files de tâches et Streams

Valkey est un stockage compatible Redis : le même service managé que dans Bases de données. Le premier Valkey de l'application fournit à chaque service de code REDIS_URL, REDIS_HOST, REDIS_PORT et REDIS_PASSWORD ; chaque Valkey fournit aussi sa propre variable RIVERVO_<NAME>_URL.

Trois façons d'y faire passer des messages :

  • Files de tâches : files Laravel avec le driver redis et Horizon, BullMQ, Celery, RQ. La bibliothèque conserve les tâches dans Valkey ; un worker les prend une par une et relance celles qui échouent.
  • Streams avec groupes de consommateurs : XADD ajoute un événement à un stream, les consommateurs d'un groupe le lisent avec XREADGROUP et le confirment avec XACK. Les événements sont conservés : un consommateur qui a été arrêté reprend là où il s'était arrêté, un événement non confirmé peut être repris, et un nouveau groupe peut lire le stream depuis le début.
  • Pub/Sub : PUBLISH et SUBSCRIBE ne délivrent un message qu'aux abonnés connectés à ce moment-là. Le message n'est pas conservé : un abonné en cours de redémarrage ou pas encore connecté le manque. Réservez Pub/Sub aux cas où un message perdu ne pose aucun problème (par exemple un signal « rafraîchir »), et utilisez des Streams ou une file pour tout le reste.

Valkey est sauvegardé chaque jour comme les autres bases de données ; il est aussi joignable depuis l'extérieur si vous ouvrez l'accès. Voir Bases de données.

NATS

NATS est un système de messagerie léger et rapide, avec JetStream activé :

  • Publication et abonnement : un service publie sur un sujet comme orders.created, et chaque abonné à ce sujet reçoit le message. Sans JetStream, c'est du « fire-and-forget », comme le Pub/Sub ci-dessus.
  • Requête-réponse : un service demande, un autre répond. Quand plusieurs instances répondent en tant que groupe de file, NATS répartit les requêtes entre elles.
  • JetStream : des flux durables. Les messages sont stockés sur le disque du service, un consommateur retient ce qu'il a lu, et chaque message est délivré au moins une fois jusqu'à ce qu'il soit acquitté.
  • Stockage clé-valeur et stockage d'objets construits sur JetStream : pour de petits réglages partagés, des verrous ou des fichiers entre services.

Variables. Le premier NATS de l'application fournit à chaque service de code :

NATS_URL=nats://<user>:<password>@<service name>:4222

Chaque service NATS fournit aussi RIVERVO_<NAME>_URL avec une adresse de la même forme : NAME est le nom du service en majuscules, les tirets étant remplacés par _. Un service nommé events fournit RIVERVO_EVENTS_URL.

JetStream conserve ses flux sur le disque du service ; les flux gardés en mémoire peuvent utiliser environ un quart de la mémoire du service.

RabbitMQ

RabbitMQ 4.1 est un broker de messages classique : les producteurs publient vers des exchanges, les exchanges routent les messages vers des files selon des clés de routage, les consommateurs acquittent chaque message, et un message rejeté ou expiré peut partir vers un exchange de dead-letter. Pour les files dont les messages doivent survivre à un redémarrage, utilisez des files quorum (l'argument x-queue-type: quorum) et publiez les messages en mode persistant.

Variables. Le premier RabbitMQ de l'application fournit à chaque service de code :

VariableValeur
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTle nom du service
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDl'utilisateur et le mot de passe
RABBITMQ_VHOST/

Le %2f à la fin de AMQP_URL correspond à l'hôte virtuel par défaut /, écrit comme l'exigent les adresses de connexion. Chaque service RabbitMQ fournit aussi sa propre variable RIVERVO_<NAME>_URL avec une adresse de la même forme.

API de gestion. L'API HTTP de gestion écoute sur le port 15672 au sein du réseau privé de l'application : les services de l'application y accèdent à l'adresse http://<service name>:15672 avec le même utilisateur et le même mot de passe, par exemple :

curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"

Il n'y a pas d'interface de gestion accessible depuis Internet. La page du service dans le panel affiche une courte liste de ses files, en lecture seule : messages prêts, non acquittés et consommateurs.

Interne uniquement

NATS et RabbitMQ n'ont pas d'adresse publique et ne sont pas joignables depuis l'extérieur de l'application, que ce soit depuis votre ordinateur, un autre serveur ou une autre application. Contrairement à PostgreSQL, MySQL et Valkey, l'accès depuis l'extérieur n'est pas proposé pour eux. Les services qui publient et consomment les messages tournent comme services de la même application : services web, workers en arrière-plan et tâches planifiées.

Deuxième service du même type

Seuls le premier Valkey, le premier NATS et le premier RabbitMQ de l'application reçoivent les noms habituels (REDIS_*, NATS_URL, AMQP_URL et RABBITMQ_*). Le suivant du même type n'ajoute que sa propre variable RIVERVO_<NAME>_URL ; lisez cette variable dans votre code, ou renseignez les noms habituels avec ses valeurs dans l'onglet Variables. Les variables parviennent à un service à son prochain déploiement : voir Variables d'environnement.

Laravel

Valkey. Dans l'onglet Variables, définissez :

QUEUE_CONNECTION=redis

Lancez php artisan queue:work (ou php artisan horizon avec Horizon) comme worker en arrière-plan. Voir Laravel.

RabbitMQ. Laravel n'intègre pas de driver RabbitMQ, et Rivervo ne modifie pas QUEUE_CONNECTION de lui-même. Pour utiliser RabbitMQ avec les files Laravel :

  1. Installez le paquet : composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Ajoutez la connexion rabbitmq dans config/queue.php, comme l'indique le README du paquet pour votre version. Elle lit RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD et RABBITMQ_VHOST, dont l'application dispose déjà :
'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. Définissez QUEUE_CONNECTION=rabbitmq dans l'onglet Variables et déployez. Le worker reste php artisan queue:work.

NATS. Il n'existe pas de driver de file officiel pour NATS dans Laravel. Utilisez un client NATS pour PHP dans votre propre code, par exemple basis-company/nats, et transmettez-lui l'hôte, le port, l'utilisateur et le mot de passe issus de NATS_URL. Vérifiez que le client prend en charge les fonctions dont vous avez besoin (JetStream, clé-valeur) avant de bâtir dessus.

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 exige maxRetriesPerRequest: null sur la connexion qu'utilisent ses 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)
    }
  }
}

Une entrée lue mais non acquittée reste en attente dans le groupe ; XAUTOCLAIM la confie à un autre consommateur.

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()
}

Requête-réponse : un service répond avec nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), un autre interroge avec 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
  }
})

Chaque service qui déclare la file doit la déclarer avec les mêmes arguments.

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):
    ...

Lancez celery -A tasks worker --loglevel=info comme worker en arrière-plan. Celery accepte les adresses amqp:// telles quelles. Avec RabbitMQ, les versions récentes de Celery peuvent déclarer des files quorum (task_default_queue_type = "quorum") : consultez la documentation de Celery pour votre version.

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)

Le 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()

Messages délivrés plusieurs fois

Les files et les brokers délivrent à nouveau un message quand un worker s'arrête avant de l'avoir confirmé : pendant un déploiement, un redémarrage ou une restauration. Écrivez vos consommateurs de sorte que traiter deux fois le même message soit sans conséquence : conservez l'identifiant de chaque message traité, ou rendez l'action elle-même rejouable (par exemple « passer le statut à payé » plutôt que « ajouter un paiement »).

Ressources et prix

ServiceDémarre avecMémoire minimale
NATS256 Mo de mémoire · 1 cœur de CPU · 5 Go de disque256 Mo
RabbitMQ1 Go de mémoire · 1 cœur de CPU · 10 Go de disque512 Mo

Chacun est facturé selon sa mémoire, son CPU et son disque, comme n'importe quel service : voir Services d'un projet. Les ressources peuvent être modifiées plus tard dans les Paramètres du service.

Sauvegardes et restauration

NATS et RabbitMQ sont sauvegardés chaque jour ; nous conservons les 7 derniers jours et les 4 dernières semaines, comme pour les autres services.

  • La sauvegarde copie les fichiers de données du service pendant qu'il tourne. Pour RabbitMQ, la même sauvegarde contient aussi un export de ses définitions : utilisateurs, hôtes virtuels, files, exchanges, bindings et politiques.
  • Il n'y a pas de restauration à un instant précis : elle est réservée à PostgreSQL et MySQL. Vous restaurez l'une des copies quotidiennes.
  • Une restauration arrête brièvement le service, remet les fichiers en place et le redémarre. Les messages arrivés ou acquittés autour du moment de la sauvegarde peuvent manquer ou être délivrés à nouveau : une raison de plus pour rendre vos consommateurs rejouables sans risque.
  • Pour RabbitMQ, si les fichiers copiés ne peuvent pas démarrer, le service démarre avec les seules définitions : les files, les exchanges et les utilisateurs sont présents, mais les messages de la sauvegarde sont perdus.

Maintenance et déplacements

NATS et RabbitMQ n'ont pas de créneau de maintenance à définir. Ils ne sont pas déplacés automatiquement vers un autre serveur ; si cela devait un jour être nécessaire, l'assistance l'organise avec vous.

Toujours bloqué ?

Écrivez-nous dans le chat — l'AI répond immédiatement et un ingénieur intervient si besoin, à toute heure.

Contacter l'assistance