Learn NATS - CLI & Client Libraries

#Introduction

Episode 5 gave you the communication patterns; episode 6 gives you the toolkit that will accompany you throughout your NATS career. Two main tools: the nats CLI for administration and debugging, and client libraries for writing real applications.

We'll map out the important CLI commands, then write complete programs in Go, Python, and Node.js. This episode is practical — make sure your NATS server is still running.

#nats CLI: Your Daily Admin Tool

#Core NATS Commands

Three basic commands you already know:

nats pub orders.created "pesanan-1"
nats sub orders.>
nats request auth.login '{"user":"arman"}'

nats pub, nats sub, and nats request cover most of your testing needs. Add the --help flag to every subcommand to see its full options.

#JetStream Management Commands

When JetStream is active, the CLI provides dedicated subcommands:

nats stream ls
nats consumer ls ORDERS
nats account info

nats stream ls lists all streams, nats consumer ls ORDERS lists consumers on a given stream, and nats account info shows an account summary including JetStream quotas. All three are the gateway to the observability in episode 18.

#Global Connection Options

Every CLI command accepts consistent connection options:

nats sub orders.> -s nats://localhost:4222
nats pub orders.created "hi" --creds my.creds
nats stream ls --server nats://localhost:4222

The -s nats://localhost:4222 flag specifies the server, and --creds my.creds uses JWT credentials. Making a habit of these flags lets you move easily between development and production servers.

#Client Libraries: Building Applications

#A Common Pattern Across Languages

All NATS client libraries follow the same pattern: connect, publish, subscribe, request. Let's compare the three main languages side by side.

#Go with nats.go

Go is the language closest to NATS — both were born from the same ecosystem:

package main
 
import (
    "log"
    "time"
 
    "github.com/nats-io/nats.go"
)
 
func main() {
    nc, err := nats.Connect("nats://localhost:4222")
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Close()
 
    nc.Subscribe("notif.email", func(m *nats.Msg) {
        log.Printf("terima: %s", string(m.Data))
    })
 
    nc.Publish("notif.email", []byte("selamat datang"))
    resp, err := nc.Request("auth.login", []byte("arman"), time.Second)
    if err == nil {
        log.Printf("reply: %s", string(resp.Data))
    }
    select {}
}

nc.Request("auth.login", []byte("arman"), time.Second) combines request and timeout in a single call. This connect-subscribe-publish-request pattern is the foundation of all Go programs.

#Python with nats-py

The Python client is fully asynchronous and uses asyncio:

Complete nats-py program

import asyncio
import nats
 
async def main():
    nc = await nats.connect("nats://localhost:4222")
 
    async def handler(msg):
        print("terima:", msg.data.decode())
 
    await nc.subscribe("notif.email", cb=handler)
    await nc.publish("notif.email", b"selamat datang")
    reply = await nc.request("auth.login", b"arman", timeout=1)
    print("reply:", reply.data)
 
    await nc.close()
 
asyncio.run(main())

await nc.request("auth.login", b"arman", timeout=1) in Python is the equivalent of nc.Request in Go. Because it's async, all calls use await — a pattern worth remembering when writing handlers.

#Node.js with nats.js

The Node.js client is also async and Promise-based:

Complete nats.js program

import { connect, StringCodec } from "nats";
 
const nc = await connect({ servers: "nats://localhost:4222" });
const sc = StringCodec();
 
nc.subscribe("notif.email", (err, msg) => {
  console.log("terima:", sc.decode(msg.data));
});
 
nc.publish("notif.email", sc.encode("selamat datang"));
 
const reply = await nc.request("auth.login", sc.encode("arman"), { timeout: 1000 });
console.log("reply:", sc.decode(reply.data));

await nc.request("auth.login", sc.encode("arman"), { timeout: 1000 }) in Node.js uses a timeout option in milliseconds. All three languages have parallel APIs — once you understand one, the others are just a matter of adjusting syntax.

#Choosing a Language for Production

#Selection Criteria

There's no single answer; each language has its strengths:

• Go: best performance, closest to the NATS ecosystem, suited for high-performance services.
• Python: fast to develop, ideal for data pipelines and experiments.
• Node.js: the natural choice for full-stack frontend teams and I/O-heavy applications.

need performance & mature ecosystem  -> Go
quick prototyping & data pipeline    -> Python
team is Node.js, I/O-heavy           -> Node.js

The need performance & mature ecosystem → Go rule isn't dogma — but it's the direction the community chooses most often. What matters most: understand the client library patterns, because all three are consistent.

#Conclusion

Episode 6 equipped you fully: the nats CLI for daily operations (pub, sub, request, stream, consumer, account) with consistent connection options, plus complete client programs in Go, Python, and Node.js that follow the identical connect, publish, subscribe, and request pattern.

Key takeaways:

• The nats CLI covers Core NATS testing and JetStream management.
• The -s, --creds, and --timeout flags are consistent across all subcommands.
• All client libraries follow the connect, publish, subscribe, request pattern.
• Go uses synchronous calls; Python and Node.js use await.
• Node.js requires codecs like StringCodec for non-binary data.
• Master one language, transferring to another is just a matter of syntax.

In episode 7 next, we'll discuss JetStream: introduction — the concept of a stream as a persistent log, retention, storage, and durability, how to enable JetStream with the -js flag or a configuration block, and the flow from publishing into a stream and from a stream to a consumer. This is where NATS starts to gain long-term memory.