O que é o NATS Server

O NATS é um sistema de mensageria open source, leve e rápido, feito para conectar serviços, aplicativos e dispositivos. O servidor é um único binário escrito em Go, chamado nats-server.

O projeto foi criado por Derek Collison e hoje faz parte da CNCF (Cloud Native Computing Foundation). O código usa a licença Apache 2.0, então você pode usar em produção sem pagar nada.

Ele resolve um problema comum: como vários serviços conversam entre si sem ficar chamando um ao outro por HTTP, cada um precisando saber o endereço do outro. No NATS, quem envia só pública numa palavra-chave (o subject) e quem se interessa assina essa palavra-chave.

O repositório apareceu em alta no GitHub Trending nesta semana, o que mostra como mensageria simples voltou a chamar atenção de quem monta microsserviços e sistemas com agentes de IA.

Como funciona

A ideia central é o publish/subscribe. Um serviço pública uma mensagem no subject pedidos.novo. Qualquer serviço que assinou pedidos.novo recebe a mensagem na hora.

Os subjects são hierárquicos, separados por ponto. Dá para assinar com curingas: pedidos.* pega um nível e pedidos.> pega todos os níveis abaixo.

O NATS também faz request/reply (um serviço pergunta e outro responde) e queue groups, que distribuem as mensagens entre várias instâncias do mesmo serviço, como um balanceador de carga embutido.

O núcleo do NATS entrega mensagens na memória, com foco em velocidade. Quando você precisa de persistência, entra o JetStream, a camada que guarda mensagens em disco e permite reler o histórico.

💡
Dica

Pense no subject como um endereço de rádio. Quem pública não sabe quem escuta, e isso deixa os serviços desacoplados.

Principais recursos

O NATS junta, num servidor só, vários padrões de comunicação que normalmente exigiriam ferramentas diferentes. Veja os principais:

  • Pub/Sub: um para muitos, por subject.
  • Request/Reply: chamadas entre serviços sem precisar de endereço fixo.
  • Queue groups: divide o trabalho entre instâncias.
  • JetStream: persistência, replay de mensagens e entrega com confirmação.
  • Key/Value e Object Store: armazenamento simples construído sobre o JetStream.
  • Clusters: vários servidores formam um cluster e podem se conectar a outros por leaf nodes.

Outro diferencial é o tamanho. O servidor é um binário pequeno, sobe em segundos e consome pouca memória, o que ajuda em ambientes com recursos limitados.

Existem clientes oficiais para várias linguagens, incluindo Go, Python, JavaScript e Java, então a adoção não prende você a uma stack só.

Como começar: instalação passo a passo

O caminho mais rápido é o Docker. Você só precisa ter o Docker instalado e a porta padrão do cliente livre na sua máquina.

Passo 1: suba o servidor com o JetStream habilitado.

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

Passo 2: confira se o servidor está respondendo. A porta 4222 é a dos clientes e a 8222 expõe o monitoramento HTTP.

curl http://localhost:8222/varz

Passo 3: instale a CLI oficial, chamada nats, para testar sem escrever código. Ela está disponível pelos binários na página de releases do GitHub e por gerenciadores de pacote como o Homebrew.

Se preferir sem Docker, baixe o binário nats-server da página de releases e rode direto no terminal.

⚠️
Atenção

Em produção, não deixe a porta 4222 aberta para a internet. Mantenha o servidor em rede privada e configure autenticação.

Exemplo prático

Vamos simular um cenário simples: um serviço de pedidos avisa o serviço de e-mail sempre que um pedido novo chega. Abra dois terminais com a CLI do NATS apontando para o servidor local.

No primeiro terminal, assine o subject:

nats sub pedidos.novo

No segundo terminal, publique uma mensagem:

nats pub pedidos.novo 'pedido 123 do cliente Maria'

O primeiro terminal mostra a mensagem imediatamente. Agora o mesmo exemplo em Python, com o cliente oficial nats-py:

pip install nats-py
import asyncio
import nats

async def main():
    nc = await nats.connect('nats://localhost:4222')

    async def tratar(msg):
        print('Recebido:', msg.data.decode())

    await nc.subscribe('pedidos.novo', cb=tratar)
    await nc.publish('pedidos.novo', b'pedido 124')
    await asyncio.sleep(1)
    await nc.drain()

asyncio.run(main())

Pronto: você tem dois pontos conversando por mensagens, sem nenhum dos dois conhecer o endereço do outro.

Comparação com alternativas

As alternativas mais conhecidas são o RabbitMQ, o Apache Kafka e o Redis (com Pub/Sub e Streams). Cada um tem seu lugar.

O RabbitMQ é forte quando você precisa de roteamento sofisticado com exchanges e filas. O Kafka é a escolha clássica para logs de eventos em volume muito alto e reprocessamento. O Redis serve bem quando você já o usa e quer algo rápido sem subir outro serviço.

O NATS se destaca pela simplicidade operacional: um binário, configuração curta e baixa latência. Com o JetStream ele cobre boa parte dos casos que antes pediam Kafka ou RabbitMQ, embora o ecossistema de conectores do Kafka seja bem maior.

🚀
Pro tip

Comece pelo NATS core e só ative o JetStream nos subjects que realmente precisam de persistência. Assim você mantém a velocidade onde ela importa.

Pontos positivos e limitações

Pontos positivos: instalação trivial, baixo consumo de recursos, boa documentação, clientes para muitas linguagens e um modelo de subjects fácil de entender.

Limitações: o NATS core não persiste mensagens, então quem estiver desconectado na hora perde o que foi publicado. Para resolver isso você precisa do JetStream, que adiciona conceitos novos como streams e consumers.

Outra limitação é o ecossistema. Há menos ferramentas prontas de integração do que no Kafka, e a comunidade brasileira ainda tem pouco material em português.

🔴
Cuidado

Sem autenticação e TLS, qualquer cliente que alcance o servidor consegue publicar e assinar em qualquer subject. Configure usuários, permissões e TLS antes de expor o serviço a outras redes.

Casos de uso reais

Time de microsserviços: uma equipe que mantém vários serviços em Go e Python troca chamadas HTTP diretas por eventos no NATS, reduzindo o acoplamento entre eles.

Dispositivos IoT: sensores publicam leituras em subjects como fabrica.linha1.temperatura, e um painel assina tudo com um curinga. O servidor leve roda bem até em hardware modesto.

Sistemas com agentes de IA: vários agentes trocam tarefas e resultados por subjects, e os queue groups distribuem o trabalho entre workers.

Startup com pouca infraestrutura: quem não tem time de plataforma para operar um cluster Kafka ganha um broker simples de manter, com persistência pelo JetStream.

Dicas e boas práticas

Quem já usa o NATS há mais tempo costuma seguir algumas regras simples. Veja as principais:

💡
Dica

Padronize os nomes dos subjects desde o início, por exemplo dominio.entidade.ação. Renomear depois dá trabalho em todos os serviços.

⚠️
Atenção

Use drain() ao encerrar uma conexão em vez de fechar de uma vez. Isso processa as mensagens que ainda estão em trânsito.

🚀
Pro tip

Use o endpoint de monitoramento na porta 8222 para acompanhar conexões e mensagens, e conecte esses dados ao Prometheus se você já usa esse stack.

🔴
Cuidado

Erro comum de iniciante: assumir que o NATS core garante entrega. Se a mensagem não pode ser perdida, use JetStream com confirmação.

Também vale começar com um servidor único em desenvolvimento e só migrar para cluster quando houver necessidade real de alta disponibilidade.

Vale a pena?

Para quem sim: times que querem mensageria simples, rápida e fácil de operar, especialmente em arquiteturas de microsserviços, IoT e sistemas distribuídos com muitos pequenos serviços.

Para quem não: se você precisa de um ecossistema enorme de conectores, de processamento de streams complexo já integrado ou se sua equipe já domina bem o Kafka, a troca pode não compensar.

O próximo passo é direto: suba o container com o comando da seção de instalação, rode o exemplo de pub/sub e depois teste o JetStream com um stream simples. Em meia hora você sabe se o NATS cabe no seu projeto.