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.
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 8222Passo 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/varzPasso 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.
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.novoNo 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-pyimport 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.
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.
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:
Padronize os nomes dos subjects desde o início, por exemplo dominio.entidade.ação. Renomear depois dá trabalho em todos os serviços.
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.
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.
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.

Comentários
Deixar um comentárioVocê precisa ter uma conta no CuritibaBlog para comentar.