NATS: Mensagens Cloud-Native e Streaming com JetStream

23 de março de 2026

20 min de leitura

Recente

TL;DR — Resumo Rápido

NATS oferece mensagens cloud-native ultra-rápidas e streaming durável. Aprenda pub/sub, JetStream, KV store, clustering e autenticação para microsserviços.

NATS é uma tecnologia de conectividade criada para aplicações cloud-native. Um único binário sem dependências que processa milhões de mensagens por segundo com latências sub-milissegundo — e acrescenta JetStream para streaming durável, armazenamento Key-Value e Object Store na mesma infraestrutura.

Pré-requisitos

Docker ou um host Linux com wget/curl.
O CLI nats: curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest | sh
Familiaridade básica com conceitos de mensagens publish/subscribe.
Para Kubernetes: Helm 3 e um cluster em execução.

Passo 1: Instalar o nats-server

Docker (mais rápido)

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

nats server ping

Binário (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

Passo 2: NATS Core — Pub/Sub, Request/Reply e Grupos de Fila

NATS core é at-most-once: mensagens são entregues apenas a assinantes ativos. É rápido porque não há overhead de persistência.

Endereçamento Baseado em Assuntos

Assuntos são strings hierárquicas delimitadas por pontos:

Token	Corresponde a	Exemplo
`*`	Um único token	`orders.*.placed` corresponde a `orders.eu.placed`
`>`	Todos os tokens restantes	`orders.>` corresponde a `orders.eu.placed`, `orders.us.updated`

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

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

Grupos de Fila — Balanceamento de Carga

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

Padrão Request/Reply

# Serviço (lado resposta)
nats reply "estoque.verificar" '{"disponivel": true, "qtd": 42}'

# Cliente (lado requisição)
nats request "estoque.verificar" '{"sku":"WIDGET-A"}'

Passo 3: JetStream — Streaming Durável

JetStream armazena mensagens em streams. Um stream captura mensagens correspondentes a um ou mais assuntos e as retém conforme uma política de retenção.

Criar um Stream

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

Backends de armazenamento:

Backend	Caso de uso
`file`	Persistência entre reinicializações, grandes conjuntos de dados
`memory`	Latência ultra-baixa, cargas de trabalho tipo cache

Políticas de retenção:

Política	Comportamento
`limits`	Retém até atingir limites de tamanho/idade/quantidade
`interest`	Retém enquanto existir pelo menos um consumidor
`workqueue`	Exclui cada mensagem após confirmação por um consumidor

Consumidores Push vs Pull

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

# Consumidor pull durável
nats consumer add PEDIDOS faturamento \
  --pull --ack explicit --durable faturamento

# Obter lote de 10 mensagens
nats consumer next PEDIDOS faturamento --count 10

Entrega Exactly-Once — Deduplicação

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

nats stream edit PEDIDOS --dupe-window 5m

Dead Letter — Max Deliver

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

Passo 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

Passo 5: Object Store

nats object add ARTEFATOS --replicas 3
nats object put ARTEFATOS ./modelo-v2.bin
nats object get ARTEFATOS modelo-v2.bin ./modelo-baixado.bin

Passo 6: Autenticação e Autorização

Token (mais simples)

nats-server --auth meuTokenSecreto
nats pub assunto msg --server nats://meuTokenSecreto@localhost:4222

JWT Descentralizado com `nsc`

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

Passo 7: Clustering e Leaf Nodes

Configuração de Cluster de 3 Nós

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 Conectividade na Borda

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

Passo 8: Monitoramento

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

Métricas Prometheus

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

Adicione http://surveyor:7777/metrics como alvo de scrape do Prometheus. Importe o dashboard Grafana NATS (ID 14725).

NATS vs Alternativas

Característica	NATS+JetStream	Kafka	RabbitMQ	Redis Pub/Sub	Pulsar	MQTT
Latência	Sub-ms	ms baixo	ms baixo	Sub-ms	ms baixo	Sub-ms
Throughput	Muito alto	Muito alto	Alto	Alto	Muito alto	Médio
Persistência	JetStream	Sim	Sim	Não	Sim	Opcional
Exactly-once	Janela dedup	Transações	Não	Não	Sim	Não
Request/Reply nativo	Sim	Não	Não	Não	Não	Não
KV Store	Integrado	Não	Não	Externo	Não	Não
Complexidade operacional	Baixa	Alta	Média	Baixa	Alta	Baixa
Borda/IoT	Leaf nodes	Não	Limitado	Não	Não	Sim

Exemplo Prático de Microsserviços

# 1. Criar stream de pedidos
nats stream add PEDIDOS --subjects "orders.>" --storage file --replicas 1

# 2. Serviço de estoque responde verificações
nats reply "estoque.verificar" '{"disponivel":true}'

# 3. Publicar pedido para processamento durável
nats pub orders.us.placed \
  --header "Nats-Msg-Id: $(uuidgen)" \
  '{"id":"2001","sku":"WIDGET-A","qtd":5}'

# 4. Trabalhador de fulfillment extrai do consumidor JetStream
nats consumer add PEDIDOS fulfillment --pull --ack explicit --durable fulfillment
nats consumer next PEDIDOS fulfillment --count 5

# 5. Armazenar estado no KV
nats kv put PEDIDOS "2001" '{"status":"cumprido","ts":"2026-03-23T10:00:00Z"}'

Armadilhas e Casos Extremos

JetStream não está habilitado por padrão. Sempre passe --jetstream ou configure jetstream: {}.
Réplicas exigem número ímpar de nós. Um cluster de 2 nós não consegue eleger meta-líder após uma falha.
Retenção interest sem consumidores exclui mensagens imediatamente. Crie o consumidor antes de publicar.
Consumidores pull precisam de acks explícitos. Configure max_deliver com valor finito.
A porta de monitoramento 8222 não é autenticada por padrão. Proteja com firewall.

Resumo

NATS core = pub/sub at-most-once, request/reply, grupos de fila — sem configuração, latência sub-ms.
JetStream adiciona persistência, entrega at-least-once/exactly-once, consumidores, KV e Object Store.
Use consumidores pull para filas de trabalhadores; push para leques de eventos.
Clusters de 3 nós são o mínimo para HA do JetStream; leaf nodes estendem à borda.
Monitore com o endpoint HTTP /varz, nats-surveyor e Grafana.

Guide & Instructions

Estimated Time: 20m

Tools Needed:

NATS
nats CLI
Docker

Instalar nats-server e nats CLI

Baixe a imagem Docker do NATS ou o binário nats-server. Instale a ferramenta nats CLI para publicar, assinar e gerenciar streams e consumidores do JetStream.

Executar pub/sub com NATS core

Inicie o nats-server, assine um assunto com o CLI e publique mensagens. Observe a entrega at-most-once, curingas (* e >) e grupos de fila para balanceamento de carga.

Habilitar JetStream e criar um stream

Inicie nats-server com --jetstream. Crie um stream capturando assuntos com backend de armazenamento escolhido e política de retenção.

Criar consumidores e confirmar mensagens

Adicione consumidores duráveis pull ou push ao stream. Configure políticas de ack, max_deliver e habilite deduplicação de mensagens para semântica exactly-once.

Usar Key-Value e Object Store

Crie um bucket KV respaldado por JetStream com comandos nats kv. Use o Object Store para grandes ativos binários replicados no cluster.

Implantar um cluster de 3 nós

Configure cluster.routes em cada nats-server.conf apontando para os nós pares. Verifique com nats server report e conecte leaf nodes na borda para topologias hub-spoke.

Frequently Asked Questions

Qual é a diferença entre NATS core e JetStream?

NATS core oferece pub/sub at-most-once sem persistência — mensagens são descartadas se não houver assinante ativo. JetStream adiciona persistência, entrega at-least-once e exactly-once, confirmações de consumidores, replay e armazenamento em disco ou memória.

Como o NATS se compara ao Kafka para mensagens em microsserviços?

NATS é mais simples, leve e muito mais rápido para padrões request/reply de baixa latência. Kafka se destaca em streaming de logs ordenados com alta retenção. JetStream supre a maioria das necessidades de persistência mantendo a simplicidade operacional do NATS.

O que é um consumidor JetStream e quando usar pull vs push?

Um consumidor é um cursor durável ou efêmero sobre um stream. Consumidores push entregam mensagens automaticamente; pull exige que o cliente solicite lotes, dando controle de contrapressão. Use pull para filas de trabalhadores onde a velocidade de processamento varia.

Como executo um cluster NATS mínimo para alta disponibilidade?

Implante pelo menos 3 nós nats-server, configure URLs de rota apontando cada nó para seus pares e defina um nome de cluster. NATS usa gossip para associação e Raft para eleição do meta-líder do JetStream. Três nós toleram uma falha.