NATS : Messagerie Cloud-Native et Streaming avec JetStream

23 mars 2026

20 min de lecture

Récent

TL;DR — Résumé Rapide

NATS offre messagerie cloud-native ultra-rapide et streaming durable. Maîtrisez pub/sub, JetStream, KV store, clustering et authentification pour microservices.

NATS est une technologie de connectivité conçue pour les applications cloud-native. Un binaire unique sans dépendances qui traite des millions de messages par seconde avec des latences sub-milliseconde — et ajoute JetStream pour le streaming durable, le stockage Key-Value et l’Object Store sur la même infrastructure.

Prérequis

Docker ou un hôte Linux avec wget/curl.
Le CLI nats : curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest | sh
Familiarité de base avec les concepts de messagerie publish/subscribe.
Pour Kubernetes : Helm 3 et un cluster opérationnel.

Étape 1 : Installer nats-server

Docker (plus rapide)

docker run -d --name nats \
  -p 4222:4222 -p 8222:8222 \
  nats:latest -js -m 8222

nats server ping

Binaire (Linux)

curl -L https://github.com/nats-io/nats-server/releases/latest/download/nats-server-v2.10.14-linux-amd64.zip -o nats.zip
unzip nats.zip && sudo mv nats-server /usr/local/bin/
nats-server --jetstream --http_port 8222

Kubernetes (Helm)

helm repo add nats https://nats-io.github.io/k8s/helm/charts/
helm install nats nats/nats \
  --set config.jetstream.enabled=true \
  --set config.cluster.enabled=true \
  --set replicaCount=3

Étape 2 : NATS Core — Pub/Sub, Request/Reply et Groupes de Files

NATS core est at-most-once : les messages ne sont livrés qu’aux abonnés actifs. Il est rapide car il n’y a pas de surcharge de persistance.

Adressage Basé sur les Sujets

Les sujets sont des chaînes hiérarchiques délimitées par des points :

Token	Correspond à	Exemple
`*`	Un seul token	`orders.*.placed` correspond à `orders.eu.placed`
`>`	Tous les tokens restants	`orders.>` correspond à `orders.eu.placed`, `orders.us.updated`

# Terminal 1 — s'abonner
nats sub "orders.>"

# Terminal 2 — publier
nats pub orders.us.placed '{"id":"1001","montant":99.00}'

Groupes de Files — Équilibrage de Charge

nats sub --queue traiteurs "orders.>"   # terminal 1
nats sub --queue traiteurs "orders.>"   # terminal 2
nats pub orders.us.placed '{"id":"1003"}'

Pattern Request/Reply

# Service (côté réponse)
nats reply "stock.verifier" '{"disponible": true, "qte": 42}'

# Client (côté requête)
nats request "stock.verifier" '{"sku":"WIDGET-A"}'

Étape 3 : JetStream — Streaming Durable

JetStream stocke les messages dans des streams. Un stream capture les messages correspondant à un ou plusieurs sujets et les conserve selon une politique de rétention.

Créer un Stream

nats stream add COMMANDES \
  --subjects "orders.>" \
  --storage file \
  --retention limits \
  --max-msgs 1000000 \
  --max-age 7d \
  --replicas 3

Backends de stockage :

Backend	Cas d’utilisation
`file`	Persistance entre redémarrages, grands ensembles de données
`memory`	Latence ultra-faible, charges de travail de type cache

Politiques de rétention :

Politique	Comportement
`limits`	Conserve jusqu’aux limites de taille/âge/quantité
`interest`	Conserve tant qu’au moins un consumer existe
`workqueue`	Supprime chaque message après acquittement par un consumer

Consumers Push vs Pull

# Consumer push durable
nats consumer add COMMANDES fulfillment \
  --deliver-subject fulfillment.worker \
  --ack explicit --durable fulfillment

# Consumer pull durable
nats consumer add COMMANDES facturation \
  --pull --ack explicit --durable facturation

# Récupérer un lot de 10 messages
nats consumer next COMMANDES facturation --count 10

Livraison Exactly-Once — Déduplication

nats pub orders.us.placed \
  --header "Nats-Msg-Id: txn-abc-123" \
  '{"id":"1004","montant":200}'

nats stream edit COMMANDES --dupe-window 5m

Dead Letter — Max Deliver

nats stream add DLQ \
  --subjects "\$JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.COMMANDES.*" \
  --storage file --retention limits

Étape 4 : Key-Value Store

nats kv add CONFIG --history 10 --ttl 24h
nats kv put CONFIG db_url "postgres://prod-db:5432/app"
nats kv get CONFIG db_url
nats kv watch CONFIG

Étape 5 : Object Store

nats object add ARTEFACTS --replicas 3
nats object put ARTEFACTS ./modele-v2.bin
nats object get ARTEFACTS modele-v2.bin ./modele-telecharge.bin

Étape 6 : Authentification et Autorisation

Token (le plus simple)

nats-server --auth monTokenSecret
nats pub sujet msg --server nats://monTokenSecret@localhost:4222

JWT Décentralisé avec `nsc`

nsc add operator MonOrg
nsc add account AppA
nsc add user -a AppA alice
nsc generate creds -a AppA -n alice > alice.creds
nats pub sujet msg --creds alice.creds

Étape 7 : Clustering et Leaf Nodes

Configuration d’un Cluster de 3 Nœuds

port: 4222
server_name: n1
jetstream: { store_dir: /data/nats }

cluster {
  name: prod
  port: 6222
  routes: [
    nats-route://nats-2:6222
    nats-route://nats-3:6222
  ]
}

nats server report jetstream
nats server list

Leaf Nodes pour la Connectivité en Périphérie

port: 4222
leafnodes {
  remotes: [{ url: "nats://hub-cluster:7422" }]
}

Étape 8 : Surveillance

curl http://localhost:8222/varz | jq .
curl http://localhost:8222/connz | jq .

Métriques Prometheus

docker run -d --name surveyor \
  -p 7777:7777 \
  natsio/nats-surveyor:latest \
  --servers nats://nats:4222 --port 7777

Ajoutez http://surveyor:7777/metrics comme cible de scrape Prometheus. Importez le dashboard Grafana NATS (ID 14725).

NATS vs Alternatives

Fonctionnalité	NATS+JetStream	Kafka	RabbitMQ	Redis Pub/Sub	Pulsar	MQTT
Latence	Sub-ms	ms faible	ms faible	Sub-ms	ms faible	Sub-ms
Débit	Très élevé	Très élevé	Élevé	Élevé	Très élevé	Moyen
Persistance	JetStream	Oui	Oui	Non	Oui	Optionnelle
Exactly-once	Fenêtre dedup	Transactions	Non	Non	Oui	Non
Request/Reply natif	Oui	Non	Non	Non	Non	Non
KV Store	Intégré	Non	Non	Externe	Non	Non
Complexité opérationnelle	Faible	Élevée	Moyenne	Faible	Élevée	Faible
Périphérie/IoT	Leaf nodes	Non	Limité	Non	Non	Oui

Exemple Pratique de Microservices

# 1. Créer le stream de commandes
nats stream add COMMANDES --subjects "orders.>" --storage file --replicas 1

# 2. Service de stock répond aux vérifications
nats reply "stock.verifier" '{"disponible":true}'

# 3. Publier une commande pour traitement durable
nats pub orders.us.placed \
  --header "Nats-Msg-Id: $(uuidgen)" \
  '{"id":"2001","sku":"WIDGET-A","qte":5}'

# 4. Worker de fulfillment extrait du consumer JetStream
nats consumer add COMMANDES fulfillment --pull --ack explicit --durable fulfillment
nats consumer next COMMANDES fulfillment --count 5

# 5. Stocker l'état dans le KV
nats kv put COMMANDES "2001" '{"statut":"accompli","ts":"2026-03-23T10:00:00Z"}'

Pièges et Cas Limites

JetStream n’est pas activé par défaut. Passez toujours --jetstream ou configurez jetstream: {}.
Les réplicas nécessitent un nombre impair de nœuds. Un cluster de 2 nœuds ne peut pas élire un méta-leader après une panne.
La rétention interest sans consumers supprime immédiatement les messages. Créez le consumer avant de publier.
Les consumers pull nécessitent des acks explicites. Configurez max_deliver avec une valeur finie.
Le port de surveillance 8222 est non authentifié par défaut. Protégez-le avec un pare-feu.

Résumé

NATS core = pub/sub at-most-once, request/reply, groupes de files — sans configuration, latence sub-ms.
JetStream ajoute persistance, livraison at-least-once/exactly-once, consumers, KV et Object Store.
Utilisez des consumers pull pour les files de workers ; push pour les fans d’événements.
Les clusters de 3 nœuds sont le minimum pour la HA JetStream ; les leaf nodes étendent à la périphérie.
Surveillez avec le point de terminaison HTTP /varz, nats-surveyor et Grafana.

Articles Connexes

Guide & Instructions

Estimated Time: 20m

Tools Needed:

NATS
nats CLI
Docker

Installer nats-server et nats CLI

Téléchargez l'image Docker NATS ou le binaire nats-server. Installez l'outil nats CLI pour publier, s'abonner et gérer les streams et consumers JetStream.

Exécuter pub/sub avec NATS core

Démarrez nats-server, abonnez-vous à un sujet avec le CLI et publiez des messages. Observez la livraison at-most-once, les jokers (* et >) et les groupes de files pour l'équilibrage de charge.

Activer JetStream et créer un stream

Démarrez nats-server avec --jetstream. Créez un stream capturant des sujets avec le backend de stockage choisi et une politique de rétention.

Créer des consumers et accuser réception des messages

Ajoutez des consumers durables pull ou push au stream. Configurez les politiques d'ack, max_deliver et activez la déduplication pour la sémantique exactly-once.

Utiliser Key-Value et Object Store

Créez un bucket KV soutenu par JetStream avec les commandes nats kv. Utilisez l'Object Store pour les grands actifs binaires répliqués dans le cluster.

Déployer un cluster de 3 nœuds

Configurez cluster.routes dans chaque nats-server.conf pointant vers les nœuds pairs. Vérifiez avec nats server report et connectez des leaf nodes en périphérie pour les topologies hub-spoke.

Frequently Asked Questions

Quelle est la différence entre NATS core et JetStream ?

NATS core offre un pub/sub at-most-once sans persistance — les messages sont perdus si aucun abonné n'est actif. JetStream ajoute la persistance, la livraison at-least-once et exactly-once, les accusés de réception, le replay et le stockage sur disque ou en mémoire.

Comment NATS se compare-t-il à Kafka pour la messagerie de microservices ?

NATS est plus simple, léger et beaucoup plus rapide pour les patterns request/reply à faible latence. Kafka excelle dans le streaming de logs ordonnés à haute rétention. JetStream couvre la plupart des besoins de persistance tout en conservant la simplicité opérationnelle de NATS.

Qu'est-ce qu'un consumer JetStream et quand utiliser pull vs push ?

Un consumer est un curseur durable ou éphémère sur un stream. Les consumers push livrent automatiquement les messages ; les pull demandent au client de récupérer des lots, permettant le contrôle de la contrepression. Utilisez pull pour les files de workers où la vitesse de traitement varie.

Comment déployer un cluster NATS minimal pour la haute disponibilité ?

Déployez au moins 3 nœuds nats-server, configurez les URLs de route pointant chaque nœud vers ses pairs et définissez un nom de cluster. NATS utilise le gossip pour l'appartenance et Raft pour l'élection du méta-leader JetStream. Trois nœuds tolèrent une panne.

Prérequis

Étape 1 : Installer nats-server

Docker (plus rapide)

Binaire (Linux)

Kubernetes (Helm)

Étape 2 : NATS Core — Pub/Sub, Request/Reply et Groupes de Files

Adressage Basé sur les Sujets

Groupes de Files — Équilibrage de Charge

Pattern Request/Reply

Étape 3 : JetStream — Streaming Durable

Créer un Stream

Consumers Push vs Pull

Livraison Exactly-Once — Déduplication

Dead Letter — Max Deliver

Étape 4 : Key-Value Store

Étape 5 : Object Store

Étape 6 : Authentification et Autorisation

Token (le plus simple)

JWT Décentralisé avec nsc

Étape 7 : Clustering et Leaf Nodes

Configuration d’un Cluster de 3 Nœuds

Leaf Nodes pour la Connectivité en Périphérie

Étape 8 : Surveillance

Métriques Prometheus

NATS vs Alternatives

Exemple Pratique de Microservices

Pièges et Cas Limites

Résumé

Articles Connexes

Guide & Instructions

Installer nats-server et nats CLI

Exécuter pub/sub avec NATS core

Activer JetStream et créer un stream

Créer des consumers et accuser réception des messages

Utiliser Key-Value et Object Store

Déployer un cluster de 3 nœuds

Frequently Asked Questions

Articles Connexes

bandwhich : Voyez Quels Processus Utilisent Votre Bande Passante

Caddy comme Proxy Inverse : Guide Complet avec HTTPS Automatique

HashiCorp Consul : Guide Service Discovery et Service Mesh

JWT Décentralisé avec `nsc`