NATS: Mensajería Cloud-Native y Streaming con JetStream

23 de marzo de 2026

20 min de lectura

Reciente

TL;DR — Resumen Rápido

NATS ofrece mensajería cloud-native ultrarrápida y streaming durable. Aprende pub/sub, JetStream, KV store, clustering y autenticación para microservicios.

NATS es una tecnología de conectividad diseñada para aplicaciones cloud-native. Un único binario sin dependencias que maneja millones de mensajes por segundo con latencias sub-milisegundo — y añade JetStream para streaming durable, almacenamiento Key-Value y Object Store sobre la misma infraestructura.

Requisitos Previos

Docker o un host Linux con wget/curl.
El CLI de nats: curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest | sh
Familiaridad básica con conceptos de mensajería publish/subscribe.
Para Kubernetes: Helm 3 y un clúster en ejecución.

Paso 1: Instalar nats-server

Docker (más rápido)

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

nats server ping

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

Paso 2: NATS Core — Pub/Sub, Request/Reply y Grupos de Cola

NATS core es at-most-once: los mensajes se entregan solo a suscriptores activos. Es rápido porque no hay sobrecarga de persistencia.

Direccionamiento Basado en Sujetos

Los sujetos son cadenas jerárquicas delimitadas por puntos:

Token	Coincide con	Ejemplo
`*`	Un solo token	`orders.*.placed` coincide con `orders.eu.placed`
`>`	Todos los tokens restantes	`orders.>` coincide con `orders.eu.placed`, `orders.us.updated`

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

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

Grupos de Cola — Balanceo de Carga

Agregue múltiples suscriptores al mismo grupo de cola y NATS entrega cada mensaje a exactamente uno:

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

Patrón Request/Reply

# Servicio (lado respuesta)
nats reply "inventario.verificar" '{"disponible": true, "cantidad": 42}'

# Cliente (lado solicitud)
nats request "inventario.verificar" '{"sku":"WIDGET-A"}'

Paso 3: JetStream — Streaming Durable

JetStream almacena mensajes en streams. Un stream captura mensajes que coinciden con uno o más sujetos y los retiene según una política de retención.

Crear un Stream

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

Backends de almacenamiento:

Backend	Caso de uso
`file`	Persistencia entre reinicios, grandes conjuntos de datos
`memory`	Latencia ultra-baja, cargas de trabajo tipo caché

Políticas de retención:

Política	Comportamiento
`limits`	Retiene hasta alcanzar límites de tamaño/edad/cantidad
`interest`	Retiene mientras exista al menos un consumidor
`workqueue`	Elimina cada mensaje tras ser reconocido por un consumidor

Consumidores Push vs Pull

# Consumidor push durable
nats consumer add PEDIDOS fulfillment \
  --deliver-subject fulfillment.worker \
  --ack explicit \
  --durable fulfillment

# Consumidor pull durable
nats consumer add PEDIDOS facturacion \
  --pull --ack explicit --durable facturacion

# Obtener lote de 10 mensajes
nats consumer next PEDIDOS facturacion --count 10

Entrega Exactly-Once — Deduplicación

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

# Configurar ventana de deduplicación
nats stream edit PEDIDOS --dupe-window 5m

Dead Letter — Max Deliver

Cuando un consumidor agota los reintentos de max_deliver, el mensaje va a un sujeto de aviso ($JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>):

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

Paso 4: Key-Value Store

El KV respaldado por JetStream ofrece get/put/delete con historial, TTL y semántica de vigilancia:

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

Paso 5: Object Store

Para activos binarios grandes distribuidos entre nodos:

nats object add ARTEFACTOS --replicas 3
nats object put ARTEFACTOS ./modelo-v2.bin
nats object get ARTEFACTOS modelo-v2.bin ./modelo-descargado.bin

Paso 6: Autenticación y Autorización

Token (más simple)

nats-server --auth mitokenSecreto
nats pub sujeto msg --server nats://mitokenSecreto@localhost:4222

JWT Descentralizado con `nsc`

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

Paso 7: Clustering y Leaf Nodes

Configuración de Clúster de 3 Nodos

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 para Conectividad en el Borde

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

Paso 8: Monitoreo

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

Métricas de Prometheus

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

Agregue http://surveyor:7777/metrics como objetivo de scrape de Prometheus. Importe el dashboard de Grafana NATS (ID 14725).

NATS vs Alternativas

Característica	NATS+JetStream	Kafka	RabbitMQ	Redis Pub/Sub	Pulsar	MQTT
Latencia	Sub-ms	ms bajo	ms bajo	Sub-ms	ms bajo	Sub-ms
Rendimiento	Muy alto	Muy alto	Alto	Alto	Muy alto	Medio
Persistencia	JetStream	Sí	Sí	No	Sí	Opcional
Exactly-once	Ventana dedup	Transacciones	No	No	Sí	No
Request/Reply nativo	Sí	No	No	No	No	No
KV Store	Integrado	No	No	Externo	No	No
Complejidad operativa	Baja	Alta	Media	Baja	Alta	Baja
Borde/IoT	Leaf nodes	No	Limitado	No	No	Sí

Ejemplo Práctico de Microservicios

# 1. Crear stream de pedidos (persistencia JetStream)
nats stream add PEDIDOS --subjects "orders.>" --storage file --replicas 1

# 2. Servicio de inventario responde verificaciones (NATS request/reply)
nats reply "inventario.verificar" '{"disponible":true}'

# 3. Publicar pedido a JetStream para procesamiento durable
nats pub orders.us.placed \
  --header "Nats-Msg-Id: $(uuidgen)" \
  '{"id":"2001","sku":"WIDGET-A","cantidad":5}'

# 4. Trabajador de fulfillment extrae de consumidor JetStream
nats consumer add PEDIDOS fulfillment --pull --ack explicit --durable fulfillment
nats consumer next PEDIDOS fulfillment --count 5

# 5. Almacenar estado en KV
nats kv put PEDIDOS "2001" '{"estado":"cumplido","ts":"2026-03-23T10:00:00Z"}'

Errores Comunes y Casos Límite

JetStream no está habilitado por defecto. Siempre pase --jetstream o configure jetstream: {}.
Las réplicas requieren un número impar de nodos. Un clúster de 2 nodos no puede elegir meta-líder tras un fallo.
La retención interest sin consumidores elimina mensajes inmediatamente. Cree el consumidor antes de publicar.
Los consumidores pull necesitan acks explícitos. Configure max_deliver con un valor finito y monitoree el sujeto de aviso.
El puerto de monitoreo 8222 es no autenticado por defecto. Protéjalo con firewall.

Resumen

NATS core = pub/sub at-most-once, request/reply, grupos de cola — sin configuración, latencia sub-ms.
JetStream agrega persistencia, entrega at-least-once/exactly-once, consumidores, KV y Object Store.
Use consumidores pull para colas de trabajadores; push para abanicos de eventos.
Clústeres de 3 nodos son el mínimo para HA de JetStream; los leaf nodes extienden al borde.
Monitoree con el endpoint HTTP /varz, nats-surveyor y Grafana.

Guide & Instructions

Estimated Time: 20m

Tools Needed:

NATS
nats CLI
Docker

Instalar nats-server y nats CLI

Descargue la imagen Docker de NATS o el binario nats-server. Instale la herramienta nats CLI para publicar, suscribirse y gestionar streams y consumidores de JetStream.

Ejecutar pub/sub con NATS core

Inicie nats-server, suscríbase a un sujeto con el CLI y publique mensajes. Observe la entrega at-most-once, los comodines (* y >) y los grupos de cola para balanceo de carga.

Habilitar JetStream y crear un stream

Inicie nats-server con --jetstream. Cree un stream que capture sujetos con el backend de almacenamiento elegido (archivo o memoria) y una política de retención.

Crear consumidores y acusar recibo de mensajes

Agregue consumidores durables pull o push al stream. Configure políticas de ack, max_deliver y habilite la deduplicación de mensajes para semántica exactly-once.

Usar Key-Value y Object Store

Cree un bucket KV respaldado por JetStream con comandos nats kv para configuración. Use Object Store para activos binarios grandes replicados en el clúster.

Desplegar un clúster de 3 nodos

Configure cluster.routes en cada nats-server.conf apuntando a los nodos pares. Verifique con nats server report y conecte leaf nodes en el borde para topologías hub-spoke.

Frequently Asked Questions

¿Cuál es la diferencia entre NATS core y JetStream?

NATS core ofrece pub/sub at-most-once sin persistencia — los mensajes se pierden si no hay suscriptor activo. JetStream agrega persistencia, entrega at-least-once y exactly-once, acuses de recibo, replay y almacenamiento en disco o memoria.

¿Cómo se compara NATS con Kafka para mensajería de microservicios?

NATS es más simple, ligero y mucho más rápido para patrones request/reply de baja latencia. Kafka sobresale en streaming de logs ordenados con alta retención. JetStream cubre la mayor parte de las necesidades de persistencia manteniendo la simplicidad operativa de NATS.

¿Qué es un consumidor JetStream y cuándo usar pull vs push?

Un consumidor es un cursor durable o efímero sobre un stream. Los consumidores push entregan mensajes automáticamente; los pull requieren que el cliente solicite lotes, permitiendo control de contrapresión. Use pull para colas de trabajadores donde la velocidad de procesamiento varía.

¿Cómo ejecuto un clúster NATS mínimo para alta disponibilidad?

Despliegue al menos 3 nodos nats-server, configure las URLs de ruta apuntando cada nodo a sus pares y establezca un nombre de clúster. NATS usa un protocolo gossip para membresía y Raft para la elección de meta-líder de JetStream. Tres nodos toleran un fallo.