NATS: Cloud-Native Messaging und Streaming mit JetStream

23. März 2026

20 Min. Lesezeit

Aktuell

TL;DR — Kurzzusammenfassung

NATS liefert ultraschnelles Cloud-Native-Messaging und dauerhaftes Streaming. Lernen Sie Pub/Sub, JetStream, KV-Store, Clustering und Auth in der Praxis.

NATS ist eine Verbindungstechnologie für cloud-native Anwendungen. Ein einzelnes Binary ohne Abhängigkeiten, das Millionen von Nachrichten pro Sekunde mit Sub-Millisekunden-Latenz verarbeitet — und JetStream für dauerhaftes Streaming, Key-Value-Speicherung und Object Store auf derselben Infrastruktur hinzufügt.

Voraussetzungen

Docker oder ein Linux-Host mit wget/curl.
Das nats-CLI: curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest | sh
Grundkenntnisse über Publish/Subscribe-Messaging-Konzepte.
Für Kubernetes: Helm 3 und ein laufendes Cluster.

Schritt 1: nats-server installieren

Docker (schnellste Methode)

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

nats server ping

Binary (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

Schritt 2: Core NATS — Pub/Sub, Request/Reply und Queue-Gruppen

Core NATS ist At-most-once: Nachrichten werden nur an aktive Abonnenten zugestellt. Es ist schnell, weil kein Persistenz-Overhead vorhanden ist.

Subjekt-basierte Adressierung

Subjekte sind hierarchische, durch Punkte getrennte Zeichenketten:

Token	Entspricht	Beispiel
`*`	Einzelnes Token	`orders.*.placed` entspricht `orders.eu.placed`
`>`	Alle verbleibenden Token	`orders.>` entspricht `orders.eu.placed`, `orders.us.updated`

# Terminal 1 — abonnieren
nats sub "orders.>"

# Terminal 2 — veröffentlichen
nats pub orders.us.placed '{"id":"1001","betrag":99.00}'

Queue-Gruppen — Lastverteilung

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

Request/Reply-Muster

# Dienst (Antwortseite)
nats reply "lager.pruefen" '{"verfuegbar": true, "menge": 42}'

# Client (Anforderungsseite)
nats request "lager.pruefen" '{"sku":"WIDGET-A"}'

Schritt 3: JetStream — Dauerhaftes Streaming

JetStream speichert Nachrichten in Streams. Ein Stream erfasst Nachrichten, die einem oder mehreren Subjekten entsprechen, und behält sie gemäß einer Aufbewahrungsrichtlinie.

Einen Stream erstellen

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

Speicher-Backends:

Backend	Anwendungsfall
`file`	Persistenz über Neustarts hinaus, große Datensätze
`memory`	Ultra-niedrige Latenz, cache-ähnliche Workloads

Aufbewahrungsrichtlinien:

Richtlinie	Verhalten
`limits`	Beibehaltung bis Größen-/Alters-/Mengenlimits erreicht
`interest`	Beibehaltung solange mindestens ein Consumer existiert
`workqueue`	Löscht jede Nachricht nach Bestätigung durch einen Consumer

Push- vs. Pull-Consumer

# Dauerhafter Push-Consumer
nats consumer add BESTELLUNGEN fulfillment \
  --deliver-subject fulfillment.worker \
  --ack explicit --durable fulfillment

# Dauerhafter Pull-Consumer
nats consumer add BESTELLUNGEN rechnungsstellung \
  --pull --ack explicit --durable rechnungsstellung

# Batch von 10 Nachrichten abrufen
nats consumer next BESTELLUNGEN rechnungsstellung --count 10

Exactly-Once-Zustellung — Deduplizierung

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

nats stream edit BESTELLUNGEN --dupe-window 5m

Dead Letter — Max Deliver

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

Schritt 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

Schritt 5: Object Store

nats object add ARTEFAKTE --replicas 3
nats object put ARTEFAKTE ./modell-v2.bin
nats object get ARTEFAKTE modell-v2.bin ./heruntergeladenes-modell.bin

Schritt 6: Authentifizierung und Autorisierung

Token (einfachste Methode)

nats-server --auth meinGeheimerToken
nats pub subjekt msg --server nats://meinGeheimerToken@localhost:4222

Dezentralisiertes JWT mit `nsc`

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

Schritt 7: Clustering und Leaf-Nodes

3-Knoten-Cluster-Konfiguration

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 für Edge-Konnektivität

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

Schritt 8: Monitoring

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

Prometheus-Metriken

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

Fügen Sie http://surveyor:7777/metrics als Prometheus-Scrape-Ziel hinzu. Importieren Sie das NATS-Grafana-Dashboard (ID 14725).

NATS vs. Alternativen

Merkmal	NATS+JetStream	Kafka	RabbitMQ	Redis Pub/Sub	Pulsar	MQTT
Latenz	Sub-ms	Niedrige ms	Niedrige ms	Sub-ms	Niedrige ms	Sub-ms
Durchsatz	Sehr hoch	Sehr hoch	Hoch	Hoch	Sehr hoch	Mittel
Persistenz	JetStream	Ja	Ja	Nein	Ja	Optional
Exactly-once	Dedup-Fenster	Transaktionen	Nein	Nein	Ja	Nein
Request/Reply nativ	Ja	Nein	Nein	Nein	Nein	Nein
KV Store	Integriert	Nein	Nein	Extern	Nein	Nein
Operative Komplexität	Gering	Hoch	Mittel	Gering	Hoch	Gering
Edge/IoT	Leaf-Nodes	Nein	Begrenzt	Nein	Nein	Ja

Praktisches Microservices-Beispiel

# 1. Bestellungs-Stream erstellen
nats stream add BESTELLUNGEN --subjects "orders.>" --storage file --replicas 1

# 2. Lagerdienst beantwortet Prüfungen
nats reply "lager.pruefen" '{"verfuegbar":true}'

# 3. Bestellung zur dauerhaften Verarbeitung veröffentlichen
nats pub orders.us.placed \
  --header "Nats-Msg-Id: $(uuidgen)" \
  '{"id":"2001","sku":"WIDGET-A","menge":5}'

# 4. Fulfillment-Worker zieht vom JetStream-Consumer
nats consumer add BESTELLUNGEN fulfillment --pull --ack explicit --durable fulfillment
nats consumer next BESTELLUNGEN fulfillment --count 5

# 5. Status im KV speichern
nats kv put BESTELLUNGEN "2001" '{"status":"erfuellt","ts":"2026-03-23T10:00:00Z"}'

Fallstricke und Grenzfälle

JetStream ist standardmäßig nicht aktiviert. Übergeben Sie immer --jetstream oder konfigurieren Sie jetstream: {}.
Replikate erfordern eine ungerade Anzahl von Knoten. Ein 2-Knoten-JetStream-Cluster kann nach einem Ausfall keinen Meta-Leader wählen.
interest-Aufbewahrung ohne Consumer löscht Nachrichten sofort. Erstellen Sie den Consumer vor dem Veröffentlichen.
Pull-Consumer benötigen explizite Acks. Setzen Sie max_deliver auf einen endlichen Wert.
Monitoring-Port 8222 ist standardmäßig nicht authentifiziert. Sichern Sie ihn mit einer Firewall.

Zusammenfassung

NATS Core = At-most-once Pub/Sub, Request/Reply, Queue-Gruppen — keine Konfiguration, Sub-ms-Latenz.
JetStream fügt Persistenz, At-least-once/Exactly-once-Zustellung, Consumer, KV und Object Store hinzu.
Verwenden Sie Pull-Consumer für Worker-Queues; Push für Event-Fans.
3-Knoten-Cluster sind das Minimum für JetStream HA; Leaf-Nodes erweitern auf den Edge.
Überwachen Sie mit dem HTTP-Endpunkt /varz, nats-surveyor und Grafana.

Guide & Instructions

Estimated Time: 20m

Tools Needed:

NATS
nats CLI
Docker

nats-server und nats CLI installieren

Laden Sie das NATS-Docker-Image oder das nats-server-Binary herunter. Installieren Sie das nats CLI-Tool zum Veröffentlichen, Abonnieren und Verwalten von JetStream-Streams und Consumern.

Core-NATS Pub/Sub ausführen

Starten Sie nats-server, abonnieren Sie ein Subjekt mit dem CLI und veröffentlichen Sie Nachrichten. Beobachten Sie At-most-once-Zustellung, Wildcards (* und >) und Queue-Gruppen für Lastverteilung.

JetStream aktivieren und einen Stream erstellen

Starten Sie nats-server mit --jetstream. Erstellen Sie einen Stream, der Subjekte mit dem gewählten Speicher-Backend und einer Aufbewahrungsrichtlinie erfasst.

Consumer erstellen und Nachrichten bestätigen

Fügen Sie dauerhafte Pull- oder Push-Consumer zum Stream hinzu. Konfigurieren Sie Ack-Richtlinien, max_deliver und aktivieren Sie Nachrichtendeduplication für Exactly-once-Semantik.

Key-Value und Object Store verwenden

Erstellen Sie einen JetStream-gestützten KV-Bucket mit nats kv-Befehlen. Verwenden Sie den Object Store für große Binärdateien, die im Cluster repliziert werden.

Ein 3-Knoten-Cluster bereitstellen

Konfigurieren Sie cluster.routes in jeder nats-server.conf, die auf Peer-Knoten zeigen. Überprüfen Sie mit nats server report und verbinden Sie Leaf-Nodes am Edge für Hub-Spoke-Topologien.

Frequently Asked Questions

Was ist der Unterschied zwischen NATS Core und JetStream?

NATS Core bietet At-most-once Pub/Sub ohne Persistenz — Nachrichten gehen verloren, wenn kein Abonnent aktiv ist. JetStream fügt Persistenz, At-least-once- und Exactly-once-Zustellung, Consumer-Bestätigungen, Replay und Speicherung auf Datei oder im Speicher hinzu.

Wie vergleicht sich NATS mit Kafka für Microservices-Messaging?

NATS ist einfacher, leichter und viel schneller für Request/Reply-Muster mit niedriger Latenz. Kafka glänzt beim hochdurchsatzfähigen, geordneten Log-Streaming mit langer Aufbewahrung. JetStream deckt die meisten Persistenzanforderungen ab und bewahrt dabei die operative Einfachheit von NATS.

Was ist ein JetStream-Consumer und wann Pull vs. Push verwenden?

Ein Consumer ist ein dauerhafter oder ephemerer Cursor über einen Stream. Push-Consumer liefern Nachrichten automatisch; Pull-Consumer verlangen, dass der Client Batches anfordert, was Gegendruck-Kontrolle ermöglicht. Verwenden Sie Pull für Worker-Queues, bei denen die Verarbeitungsgeschwindigkeit variiert.

Wie betreibe ich ein minimales NATS-Cluster für hohe Verfügbarkeit?

Stellen Sie mindestens 3 nats-server-Knoten bereit, konfigurieren Sie Route-URLs, die jeden Knoten auf seine Peers zeigen, und legen Sie einen Cluster-Namen fest. NATS verwendet Gossip für die Mitgliedschaft und Raft für die Meta-Leader-Wahl von JetStream. Drei Knoten tolerieren einen Ausfall.