Belajar NATS - CLI & Client Libraries

#Pendahuluan

Episode 5 memberi kalian pola komunikasi; episode 6 ini memberi kalian perangkat kerja yang akan menemani sepanjang karier memakai NATS. Dua alat utama: nats CLI untuk administrasi dan debugging, serta client libraries untuk menulis aplikasi sungguhan.

Kita akan memetakan perintah-perintah penting CLI, lalu menulis program lengkap di Go, Python, dan Node.js. Episode ini praktis — pastikan server NATS kalian masih berjalan.

#nats CLI: Perangkat Admin Harian

#Perintah Inti Core NATS

Tiga perintah dasar yang sudah kalian kenal:

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

nats pub, nats sub, dan nats request menutupi sebagian besar kebutuhan pengujian. Tambahkan flag --help di setiap sub-perintah untuk melihat opsi lengkapnya.

#Perintah Manajemen JetStream

Saat JetStream aktif, CLI menyediakan sub-perintah khusus:

nats stream ls
nats consumer ls ORDERS
nats account info

nats stream ls mendaftar semua stream, nats consumer ls ORDERS mendaftar consumer pada stream tertentu, dan nats account info menampilkan ringkasan akun termasuk kuota JetStream. Ketiganya adalah pintu masuk observability di episode 18.

#Opsi Koneksi Global

Semua perintah CLI menerima opsi koneksi yang konsisten:

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

Flag -s nats://localhost:4222 menentukan server, --creds my.creds memakai kredensial JWT. Kebiasaan memakai flag ini memudahkan kalian berpindah antar server development dan production.

#Client Library: Membangun Aplikasi

#Pola Umum di Semua Bahasa

Semua client library NATS mengikuti pola yang sama: connect, publish, subscribe, request. Mari bandingkan tiga bahasa utama secara langsung.

#Go dengan nats.go

Go adalah bahasa yang paling erat dengan NATS — keduanya lahir dari ekosistem yang sama:

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) menggabungkan request dan timeout dalam satu panggilan. Pola connect-subscribe-publish-request ini adalah fondasi semua program Go.

#Python dengan nats-py

Client Python bersifat asinkron penuh dan memakai asyncio:

Program lengkap nats-py

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) di Python setara dengan nc.Request di Go. Karena asinkron, semua panggilan memakai await — pola yang wajib diingat saat menulis handler.

#Node.js dengan nats.js

Client Node.js juga asinkron berbasis Promise:

Program lengkap nats.js

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 }) di Node.js memakai opsi timeout dalam milidetik. Ketiga bahasa memiliki API yang paralel — sekali memahami satu, sisanya tinggal menyesuaikan sintaks.

#Memilih Bahasa untuk Produksi

#Kriteria Pemilihan

Tidak ada jawaban tunggal; setiap bahasa punya kekuatan:

• Go: performa terbaik, paling erat dengan ekosistem NATS, cocok untuk service berperforma tinggi.
• Python: cepat dikembangkan, ideal untuk pipeline data dan eksperimen.
• Node.js: pilihan natural untuk tim frontend-fullstack dan aplikasi I/O-heavy.

butuh performa & ekosistem matang   -> Go
cepat prototipe & data pipeline     -> Python
tim sudah Node.js, I/O-heavy        -> Node.js

Aturan butuh performa & ekosistem matang → Go bukan dogma — tapi arah yang paling sering dipilih komunitas. Yang terpenting: pahami pola client library, karena ketiganya konsisten.

#Penutup

Episode 6 memperlengkapi kalian secara penuh: nats CLI untuk operasi harian (pub, sub, request, stream, consumer, account) dengan opsi koneksi konsisten, plus program lengkap client di Go, Python, dan Node.js yang mengikuti pola connect, publish, subscribe, dan request yang identik.

Inti yang harus dibawa pulang:

• nats CLI menutupi pengujian Core NATS dan manajemen JetStream.
• Flag -s, --creds, dan --timeout konsisten di semua sub-perintah.
• Semua client library mengikuti pola connect, publish, subscribe, request.
• Go memakai panggilan sinkron; Python dan Node.js memakai await.
• Node.js memerlukan codec seperti StringCodec untuk data non-binary.
• Kuasai satu bahasa, transfer ke bahasa lain tinggal soal sintaks.

Di episode 7 selanjutnya kita akan membahas JetStream: pendahuluan — konsep stream sebagai log persisten, retention, storage, dan durability, cara mengaktifkan JetStream dengan flag -js atau blok konfigurasi, serta alur publish menuju stream dan dari stream menuju consumer. Di sinilah NATS mulai menyimpan memori jangka panjang.