SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor

NATS, RabbitMQ ou Kafka sur un seul VPS ?

Comparez les garanties de livraison, le coût mémoire et disque, les redémarrages et le suivi des backlogs. Découvrez quand Postgres suffit sur un seul serveur.

La réponse courte pour un seul serveur

Une message queue sur un seul VPS est un choix qui concerne les garanties de livraison, pas la vitesse. Sur une machine unique, le broker est rarement le goulot d’étranglement, car votre code applicatif, votre base de données et votre disque unique atteignent leurs limites avant lui. Choisissez l’outil dont le comportement en cas de panne vous convient, puis mesurez la machine dont vous disposez réellement.

Voici quatre options, dans l’ordre où la plupart des lecteurs devraient les envisager.

  • Utilisez la base de données que vous exploitez déjà. Postgres avec SELECT ... FOR UPDATE SKIP LOCKED constitue une job queue fonctionnelle et n’ajoute aucun nouveau processus à monitorer.
  • Utilisez RabbitMQ lorsque chaque message représente une unité de travail qui doit être acquittée, réessayée un nombre limité de fois, puis placée quelque part où un humain peut l’examiner.
  • Utilisez NATS lorsque les messages sont des événements auxquels plusieurs composants de votre système réagissent. Activez JetStream pour les événements qui doivent survivre à un redémarrage.
  • Utilisez Kafka lorsqu’un outil en aval ne parle que le protocole Kafka. Sur un seul serveur, c’est presque la seule raison qui le justifie encore.

La suite de ce guide explique le raisonnement : le coût de chaque option en mémoire et sur disque pour un petit VPS, son comportement lorsque la machine redémarre, ainsi que la commande exacte qui permet d’afficher un backlog avant que vos utilisateurs ne le ressentent.

Ce que signifie réellement une garantie de livraison

Au plus une fois signifie que le broker remet le message, puis l’oublie. Si aucun consumer n’est connecté ou si un consumer s’arrête en cours de traitement, le message est perdu et rien ne le signale.

Au moins une fois signifie que le consumer envoie un accusé de réception (un ack) une fois le traitement terminé. Tant que cet ack n’est pas arrivé, le broker conserve le message et le remettra. La redelivery impose que vos handlers soient idempotents : traiter deux fois le même message ne doit pas débiter la carte deux fois. Une garantie de traitement exactement une fois, de bout en bout, n’est pas fournie par un broker. Elle repose sur une clé unique dans votre propre base de données.

Le replay est une propriété distincte. Une queue supprime un message dès qu’il est acquitté. Un log le conserve pendant une période de rétention, afin qu’un nouveau consumer puisse commencer au début et lire tout l’historique. Kafka et NATS JetStream sont des logs. RabbitMQ fournit des queues et des streams rejouables ; ce guide utilise des quorum queues. Cette différence influence davantage les architectures que le débit.

Le dead lettering concerne les messages qui échouent de manière répétée. Sans ce mécanisme, un message toxique boucle indéfiniment. La boucle ressemble alors à un worker occupé plutôt qu’à un worker défaillant.

Commencez par Postgres et laissez le broker faire ses preuves

La plupart des workloads associés à une seule application représentent quelques milliers de jobs en arrière-plan par jour. Une table suffit.

CREATE TABLE job (
  id        bigserial   PRIMARY KEY,
  payload   jsonb       NOT NULL,
  run_after timestamptz NOT NULL DEFAULT now(),
  attempts  int         NOT NULL DEFAULT 0
);
CREATE INDEX job_ready_idx ON job (run_after, id);

Un worker récupère un job dans le cadre d’une transaction.

BEGIN;
SELECT id, payload
  FROM job
 WHERE run_after <= now()
 ORDER BY id
   FOR UPDATE SKIP LOCKED
 LIMIT 1;
-- run the work, then remove the row
DELETE FROM job WHERE id = $1;
COMMIT;

FOR UPDATE SKIP LOCKED constitue l’élément essentiel. Il verrouille la ligne renvoyée et ignore toute ligne déjà verrouillée par une autre transaction. Deux workers ne récupèrent donc jamais le même job. Si un worker plante, Postgres annule sa transaction, libère le verrou et rend la ligne visible pour le worker suivant. Vous obtenez une livraison au moins une fois, des retries en incrémentant attempts, ainsi qu’une table de dead letters, le tout avec la durabilité que vous payez déjà. Le backlog se consulte avec une seule requête : SELECT count(*) FROM job WHERE run_after <= now();

Ses limites. Chaque récupération et chaque suppression constituent une écriture. Un débit élevé de jobs laisse donc des versions obsolètes de lignes, et une queue table est le cas classique où le bloat dépasse les capacités d’autovacuum. Les jobs longs aggravent le problème, car une transaction maintenue ouverte pendant toute la durée du traitement retarde également l’horizon de vacuum pour toute la base de données. Le polling ajoute de la latence, et LISTEN avec NOTIFY supprime le polling, mais pas les écritures. Lorsque la table des jobs devient la table la plus sollicitée, ou lorsqu’un second service a besoin des mêmes événements, déplacez le traitement ailleurs. Ce choix dépend aussi du déploiement de la base de données. Déterminez donc si la base de données s’exécute dans Docker ou sur l’hôte avant d’ajouter un broker à côté.

Redis est l’autre composant que vous exécutez peut-être déjà. Redis Streams fournit des consumer groups avec XADD et XREADGROUP, une pending list par groupe, ainsi que XAUTOCLAIM pour reprendre le travail d’un consumer qui a cessé de fonctionner. C’est léger et rapide. La limite à connaître sur une seule machine : avec le réglage appendfsync everysec courant, une coupure de courant peut entraîner la perte d’environ une seconde d’écritures. Cela convient à l’invalidation de cache, mais pas aux paiements. Si votre application est un processus unique reposant sur SQLite en production sur un VPS, le même modèle de récupération et de suppression fonctionne. SQLite n’a toutefois pas d’équivalent de SKIP LOCKED, et chaque worker se sérialise sur l’unique write lock.

Routage des subjects avec NATS core, sans mémoire

docker run -d --name nats \
  -p 4222:4222 -p 127.0.0.1:8222:8222 \
  nats:2.15 -m 8222

En octobre 2026, la branche actuelle du serveur est la 2.15. -m 8222 active le port de monitoring HTTP. Celui-ci est désactivé par défaut et ne fournit aucune authentification. Liez-le donc à localhost, comme indiqué plus haut.

Core NATS fournit une livraison au plus une fois et ne stocke rien. Un publisher envoie un message sur un subject tel que orders.created, et chaque subscriber dont le filtre correspond en reçoit une copie. Si aucun subscriber n’est abonné, le message est supprimé et le publisher ne reçoit aucune erreur, car son travail se termine lorsque le serveur accepte les octets. Un queue group, composé de plusieurs subscribers partageant le même nom de groupe, permet au serveur de sélectionner un membre par message. Cela répartit le travail sans stocker de queue.

L’empreinte se compose de l’état des subscriptions et d’un write buffer pour chaque connexion. Elle dépend donc du nombre de connexions, et non du volume de messages. Rien ne s’accumule sur disque. Le comportement au redémarrage en découle : les messages en cours de transmission sont perdus, les clients se reconnectent seuls et aucune étape de récupération n’est nécessaire.

Il n’y a aucun backlog à surveiller. Surveillez plutôt les pertes. Lorsqu’un subscriber lit son socket plus lentement que le serveur n’y écrit, le buffer du serveur pour ce client se remplit. Si le client n’a pas rattrapé son retard à l’expiration du write deadline, le serveur ferme toute la connexion et incrémente un compteur.

curl -s http://localhost:8222/varz | jq '.slow_consumers, .connections, .in_msgs, .out_msgs'

Une valeur slow_consumers qui continue d’augmenter indique que des messages sont supprimés. Déclenchez donc une alerte sur cette valeur au lieu de la consulter une seule fois. Core NATS convient aux messages dont la valeur expire rapidement : une métrique, une mise à jour de présence ou une invalidation de cache que l’événement suivant remplacera de toute façon.

NATS JetStream : streams persistants et relecture dans le même processus

JetStream n’est pas un produit distinct. C’est un sous-système intégré au même binaire, activé par une seule option.

docker run -d --name nats \
  -p 4222:4222 -p 127.0.0.1:8222:8222 \
  -v nats-data:/data \
  nats:2.15 -js -sd /data -m 8222

-sd /data définit le répertoire de stockage. Si vous omettez cette option, JetStream stocke ses données sous /tmp, avec une persistance à la hauteur de ce que ce chemin laisse entendre. Créez un stream avec la CLI, fournie dans l’image nats-box.

docker run --rm -it --network host natsio/nats-box:latest \
  nats stream add ORDERS \
    --subjects 'orders.>' \
    --storage file \
    --retention limits \
    --max-age 72h \
    --max-bytes=1073741824 \
    --discard old \
    --defaults

Chaque limite a son utilité sur un petit serveur. Le stockage sur disque survit au crash du processus du broker, mais l’intervalle fsync par défaut de deux minutes signifie qu’un crash de l’OS ou une coupure de courant peut faire perdre des messages acquittés ; les streams en mémoire perdent leurs données à l’arrêt du processus. --max-bytes=1073741824 limite le stream à 1 GiB, exprimé en octets, et --discard old supprime les messages les plus anciens lorsque la limite est atteinte au lieu de refuser les nouvelles écritures. Si vous ne définissez pas cette limite, un publisher défaillant peut remplir le disque ; la base de données s’arrête alors elle aussi, car elle utilise le même disque.

Un consumer durable conserve sa position dans le stream et la conserve après un redémarrage. Définissez --max-deliver sur le consumer afin qu’un message qui échoue systématiquement cesse d’être redélivré indéfiniment. Lorsqu’un message a épuisé son nombre de livraisons, JetStream publie un advisory sur $JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>. Un abonnement à ce sujet permet de construire le circuit dead letter que RabbitMQ fournit directement. Cette logique doit être implémentée par vos soins.

Pour consulter le backlog, exécutez nats stream report afin d’obtenir le nombre de messages stockés, puis nats consumer report ORDERS pour voir les acquittements en attente et les messages non traités par consumer. C’est le nombre de messages non traités qu’il faut surveiller. La consommation disque se vérifie avec du -sh sur le répertoire de stockage et augmente jusqu’à ce qu’une limite de rétention la réduise.

RabbitMQ : acquitter chaque message, isoler les échecs

docker run -d --name rabbitmq \
  -p 5672:5672 -p 127.0.0.1:15672:15672 \
  -v rabbitmq-data:/var/lib/rabbitmq \
  rabbitmq:4-management

Au 1 novembre 2026, la série actuelle est la 4.4 et la dernière release est la 4.4.0. Le port 5672 correspond à AMQP (advanced message queuing protocol) et le port 15672 à l’interface de gestion. Laissez l’interface sur localhost et utilisez-la via un tunnel SSH.

Déclarez les queues avec l’argument x-queue-type défini sur quorum ; la valeur par défaut reste classic. Les quorum queues sont toujours durables et écrivent les données sur disque avant toute autre opération. Sur un seul nœud, vous obtenez donc un comportement clair, au lieu d’une matrice d’options durables et transitoires. Définissez la cible dead letter avec une policy.

docker exec rabbitmq rabbitmqctl set_policy DLX ".*" \
  '{"dead-letter-exchange":"my-dlx", "dead-letter-routing-key":"my-routing-key"}' \
  --apply-to queues --priority 7

Déclarez my-dlx et liez-lui une dead letter queue durable avec my-routing-key ; la policy ne les crée pas.

Un message est envoyé en dead letter pour quatre raisons : un consumer le rejette avec basic.reject ou basic.nack et requeue est défini sur false, son TTL (time to live) par message expire, la queue dépasse une limite de longueur ou il dépasse la limite de livraisons d’une quorum queue. Cette limite est définie par défaut sur 20 depuis RabbitMQ 4.0. Depuis RabbitMQ 4.3, les nacks explicites avec requeue n’incrémentent pas delivery-count et peuvent donc boucler indéfiniment. Utilisez basic.reject avec requeue pour les échecs qui doivent être comptabilisés dans la limite. Le dépassement de cette limite envoie le message en dead letter uniquement si un DLX est configuré ; sinon, le message est supprimé.

La mémoire est souvent source de surprises avec RabbitMQ sur un petit VPS. Le high watermark par défaut est fixé à 0.6 de la RAM disponible. Lorsque le nœud le dépasse, RabbitMQ bloque toute connexion qui publie des messages. Votre application ne reçoit pas d’erreur. Elle effectue une publication qui ne retourne jamais, ce qui ressemble à un blocage dans votre code. Le journal de démarrage affiche la valeur calculée par le nœud :

Memory high watermark set to 1024 MiB (1073741824 bytes) of 8192 MiB (8589934592 bytes) total

L’alarme de disque bloque les publishers de la même manière lorsque l’espace libre passe sous 50 MB par défaut. Les quorum queues ajoutent leur propre consommation : la documentation prévoit au moins 32 bytes de métadonnées en mémoire par message, soit environ 1 MB pour 30,000 messages, et recommande au moins trois fois la taille effective du write-ahead log en RAM. La limite du WAL est de 512 MiB par défaut. Cette recommandation demande donc à elle seule 1.5 GiB. Sur un serveur de 2 GB, réduisez-la dans rabbitmq.conf au lieu de supposer que la valeur par défaut conviendra.

raft.wal_max_size_bytes = 64000000
vm_memory_high_watermark.relative = 0.5

Le backlog se mesure avec deux nombres. Leur combinaison indique le type d’échec rencontré.

docker exec rabbitmq rabbitmqctl list_queues name messages messages_ready messages_unacknowledged

messages_ready correspond aux messages qui attendent un consumer. messages_unacknowledged correspond aux messages livrés mais jamais acquittés. Une hausse du nombre de messages non acquittés avec un nombre de messages prêts stable signifie que vos workers ont pris les tâches et ont cessé de les terminer. Il s’agit d’un problème différent d’une queue simplement en retard.

Kafka sur une seule machine, et quand cela ne se justifie plus

KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"
bin/kafka-storage.sh format --standalone -t $KAFKA_CLUSTER_ID -c config/server.properties
bin/kafka-server-start.sh config/server.properties

Voici le quickstart de Kafka 4.4.0, à jour au 1 novembre 2026, exécuté en mode KRaft (Kafka Raft, le controller intégré qui a remplacé ZooKeeper dans Kafka 4.0). L’équivalent avec un conteneur est apache/kafka:4.4.0.

Le script de démarrage définit export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" si vous ne l’avez pas déjà défini. Le broker réserve donc un heap Java de 1 GB avant même de stocker un seul message. Il attend également de la RAM libre supplémentaire pour le page cache qu’il lit. Sur un VPS de 2 GB, votre application se retrouve donc en concurrence avec la JVM pour la mémoire restante.

La rétention constitue la surprise suivante. log.retention.hours vaut 168 par défaut, soit sept jours, et log.retention.bytes vaut -1 par défaut, ce qui signifie qu’il n’y a aucune limite de taille. Kafka conserve les messages pendant toute cette période, même si aucun consumer ne les a encore tous lus. C’est la fonctionnalité recherchée, mais sur un petit disque, c’est aussi la cause de la panne. Définissez donc une limite en octets par topic avant de le découvrir. Cette limite s’applique à chaque partition. Multipliez-la donc par le nombre de partitions pour estimer l’espace disque nécessaire.

Passons maintenant au point essentiel. Un broker unique signifie un replication factor de 1. acks=all attend donc uniquement ce broker, et non un fsync. Avec le flushing par défaut, les données acquittées peuvent encore se trouver dans le page cache du système. Vous obtenez la durabilité d’une seule machine, avec les coûts d’exploitation d’un broker JVM et d’un controller. Les partitions permettent aussi à plusieurs consumers d’un même groupe de se répartir le travail sur un broker unique. La réplication, la rack awareness et les autres fonctionnalités destinées aux clusters restent inutilisées. JetStream fournit le même replay durable sur la même machine, pour une fraction de la mémoire. Deux raisons justifient encore Kafka dans ce cas : un outil en aval ne parle que le protocole Kafka (par exemple la capture de changements avec Debezium ou le chargement vers un outil d’analytics), ou vous reproduisez une topologie de production à petite échelle. Prévoir d’évoluer vers un cluster implique de prévoir l’achat de machines supplémentaires. En attendant, le compromis est le même que pour exécuter k3s sur un seul nœud : vous payez la complexité d’un cluster pour la fiabilité d’un seul nœud.

Le backlog de Kafka correspond au consumer lag.

bin/kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group my-group

Lisez la colonne LAG. Elle correspond à LOG-END-OFFSET moins CURRENT-OFFSET pour chaque partition. Un lag qui augmente sur une partition alors que les autres restent stables indique une clé mal répartie. Tous les messages ayant la même clé sont placés dans la même partition, et un seul consumer les traite.

Redémarrage du serveur

Core NATS perd tout ce qui est en cours et redémarre immédiatement, car il n’y a rien à récupérer. JetStream recharge les streams et la position des consumers depuis le répertoire de stockage. Les consumers reprennent donc à l’offset où ils s’étaient arrêtés. RabbitMQ récupère les quorum queues depuis le disque, quel que soit le mode de livraison des messages. Les queues classic transitoires et les messages non persistants des queues classic sont perdus. Depuis RabbitMQ 4.3, les queues classic non durables et non exclusives ne peuvent pas être déclarées par défaut. Kafka rejoue ses segments de log au démarrage. Après un arrêt non propre, cette analyse de récupération peut durer plusieurs minutes sur un petit disque avant que le broker accepte une connexion.

Deux réglages méritent d’être effectués une fois pour toutes. Attribuez une restart policy au conteneur (restart: unless-stopped) ou activez l’unité systemd. Le broker redémarrera ainsi après le reboot provoqué par une mise à niveau du kernel, sans intervention manuelle. Gérez ensuite l’ordre de démarrage. Un broker qui devient prêt vingt secondes après l’application refusera les premières connexions. Certaines bibliothèques clientes se terminent au lieu de réessayer. Faites dépendre l’application du broker avec les healthchecks Compose qui empêchent le démarrage d’un service dépendant tant que le broker n’est pas prêt.

Coût sur votre propre VPS, mesuré plutôt que repris d’une documentation

Les débits publiés sont mesurés sur du matériel que vous ne possédez pas, généralement un serveur multicœur équipé de NVMe local. Considérez-les comme une limite supérieure et mesurez les performances de votre serveur.

docker stats --no-stream
free -m
sudo du -sh /var/lib/docker/volumes/*/_data

Exécutez ces tests avec le broker au repos, puis recommencez avec votre trafic réel. L’écart entre les deux mesures détermine si le broker peut fonctionner à côté de votre application. Pour obtenir un ordre de grandeur minimal du débit, utilisez le générateur de charge fourni par chaque projet plutôt que les chiffres publiés sur un blog : nats bench pub test --msgs 100000 --clients 2 pour NATS, bin/kafka-producer-perf-test.sh pour Kafka et PerfTest pour RabbitMQ. Exécuter le générateur sur le même VPS mesure le broker et le générateur ensemble. Cela convient tant que vous le précisez lorsque vous publiez le résultat.

Une limite s’applique à tous ces logiciels. Le stockage durable dépend à terme du disque, mais l’accusé de réception n’attend pas toujours fsync : la configuration par défaut de Kafka désactive fsync côté application, et l’intervalle de synchronisation par défaut de JetStream est de deux minutes. Sur un VPS utilisant un stockage connecté par le réseau, mesurez le débit du disque et la latence des opérations de flush en parallèle des paramètres de durabilité que vous choisissez.

Trois charges de travail et la file de messages adaptée à chacune

  1. Tâches en arrière-plan pour une application web, par exemple l’envoi d’e-mails, le redimensionnement d’images ou l’envoi de webhooks. Commencez avec Postgres et SKIP LOCKED. Passez à RabbitMQ avec des quorum queues lorsque vous avez besoin d’accusés de réception par message, d’une limite de livraisons et d’une dead letter queue que vous pouvez inspecter sans développer vous-même cette logique, ou lorsque la table des tâches est devenue la table la plus sollicitée de la base de données.
  2. Événements auxquels plusieurs services internes réagissent, lorsqu’un message perdu est rapidement remplacé par un message plus récent. Utilisez Core NATS, avec des subjects comme mécanisme de routage et des queue groups lorsque vous devez répartir le travail. Ajoutez un stream JetStream pour l’ensemble restreint de subjects qui doivent survivre à un redémarrage, et laissez le reste en mémoire.
  3. Journal d’événements que les consommateurs lisent depuis le début, pour constituer une piste d’audit, reconstruire un read model ou alimenter ultérieurement des outils d’analytics. Utilisez JetStream avec un stockage sur disque et une limite explicite en octets. Choisissez Kafka uniquement lorsqu’un outil en aval exige le protocole Kafka, et acceptez le heap de la JVM comme coût de cette compatibilité.

Sur un serveur unique, le mauvais choix ne coûte pas en débit. Il coûte au moment de la récupération à trois heures du matin, lorsque vous devez savoir si les messages existent encore. Choisissez en fonction de cela.

FAQ

Puis-je exécuter Kafka sur un VPS de 2 GB ?

Il démarre, mais les ressources seront limitées. bin/kafka-server-start.sh définit KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" lorsque vous ne l’avez pas remplacé. La JVM réserve donc 1 GB avant de stocker le moindre message. Kafka utilise également la mémoire libre restante pour le page cache. Si vous ajoutez votre application et votre base de données sur le même serveur, vous utiliserez le swap. Vous aurez aussi un facteur de réplication de 1, c’est-à-dire une seule copie sans replica redondant. acks=all n’exige pas de fsync. Les données acquittées peuvent donc encore se trouver dans le page cache du système d’exploitation. NATS JetStream fournit une relecture durable sur le même matériel avec beaucoup moins de mémoire.

Ai-je besoin d’une message queue si j’exécute déjà Postgres ?

Souvent, non. Une table job lue avec SELECT ... FOR UPDATE SKIP LOCKED dans une transaction fournit une livraison « au moins une fois », des workers concurrents sûrs, des retries et une dead letter table, sans service supplémentaire à monitorer et avec les backups que vous effectuez déjà. Certains signaux indiquent toutefois qu’il faut utiliser un service séparé : la table de queue devient votre charge d’écriture la plus importante et autovacuum prend du retard, des jobs de longue durée maintiennent des transactions ouvertes et bloquent vacuum pour toute la base de données, ou un second service doit consommer les mêmes événements indépendamment.

Dois-je utiliser NATS JetStream ou RabbitMQ pour les jobs en arrière-plan ?

RabbitMQ si vous voulez un acquittement par message, une limite de livraison et un routage vers une dead letter queue intégrés. Les quorum queues sont toujours durables, et la limite de livraison est définie par défaut à 20 depuis RabbitMQ 4.0. Depuis la version 4.3, les nacks explicites avec requeue ne sont pas comptabilisés dans cette limite. Utilisez basic.reject avec requeue pour comptabiliser les échecs et configurez un DLX pour conserver les messages ayant atteint la limite. Utilisez JetStream si les mêmes événements doivent également être relus ultérieurement par d’autres consumers, car un stream conserve les messages après leur acquittement, contrairement à une queue. Avec JetStream, définissez --max-deliver et construisez vous-même le dead letter path à partir de l’advisory $JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>.

Comment savoir jusqu’où mes consumers ont pris du retard ?

Chaque broker dispose d’une commande dédiée. Pour RabbitMQ, rabbitmqctl list_queues name messages messages_ready messages_unacknowledged distingue le travail en attente d’un consumer du travail livré mais jamais acquitté. Pour JetStream, nats consumer report <stream> affiche les messages non traités et les acquittements en attente pour chaque consumer. Pour Kafka, kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group <group> affiche une colonne LAG pour chaque partition. Core NATS n’a aucun backlog à consulter, car il ne stocke rien. Surveillez plutôt le compteur slow_consumers sur http://localhost:8222/varz : il compte les connexions que le serveur a fermées parce qu’elles avaient pris du retard, ce qui entraîne une perte de messages.

Cet article vous a-t-il été utile ?

#nats#rabbitmq#kafka#message-queue#architecture