Belajar NATS - Setup & First Connect

#Pendahuluan

Episode 2 memberi kalian peta konsep. Episode 3 ini adalah titik di mana teori mulai hidup: kalian akan benar-benar menjalankan server NATS, terhubung ke sana, dan mengirim pesan pertama. Tidak ada yang lebih memuaskan daripada melihat pesan melintas antar terminal.

Kita akan membahas tiga cara menjalankan server, menyusun konfigurasi minimal berbasis file, memakai CLI untuk publish dan subscribe, lalu menghubungkan client library pertama. Mari mulai.

#Menjalankan nats-server

#Mode Langsung dari Binary

Cara termudah adalah menjalankan binary langsung. Di terminal pertama:

nats-server -p 4222 -m 8222

Flag -p 4222 menentukan port client, -m 8222 mengaktifkan port monitoring. Server akan menampilkan baris Listening for client connections on 0.0.0.0:4222 dan memblokir terminal.

#Mode Docker

Jika memakai Docker, perintahnya hampir sama. Container nats:2.14 sudah memiliki monitoring aktif di port 8222:

docker run -d --name nats -p 4222:4222 -p 8222:8222 nats:2.14

Container nats:2.14 berjalan di latar belakang dengan nama nats. Cek log untuk memastikan server hidup:

docker logs nats | head -n 10

#Konfigurasi Minimal Berbasis File

Untuk pengaturan yang lebih terstruktur, gunakan file konfigurasi. Buat file nats.conf:

port: 4222
monitor_port: 8222
server_name: server-utama
 
jetstream {
  store_dir: /data/jetstream
}

Lalu jalankan server dengan file tersebut:

nats-server -c nats.conf

Blok jetstream di atas mengaktifkan JetStream sejak awal dengan direktori penyimpanan /data/jetstream. Kalian akan sering memakai file konfigurasi di episode 12 sampai 15.

#Verifikasi Dasar dengan CLI

#Publish dan Subscribe

Di terminal kedua, pasang subscriber dulu:

nats sub hello.world

Di terminal ketiga, kirim pesan:

nats pub hello.world "Halo dari CLI"

Perintah nats pub hello.world "Halo dari CLI" mengirim pesan, dan terminal subscriber menampilkan Halo dari CLI beserta metadata seperti timestamp dan reply subject. Jika tidak ada subscriber saat publish, pesan di Core NATS akan hilang — wajar, dan itulah perilaku yang dirancang.

#Cek Kesehatan Server

Untuk memastikan server dalam kondisi baik:

nats server check

Output menunjukkan baris ok dengan informasi server, versi, dan cluster. Perintah nats server check ini akan menjadi andalan kalian setiap kali ingin memastikan server merespons.

#Menghubungkan Client Library Pertama

#Client Python

Client library adalah jembatan antara aplikasi dan server. Contoh dengan nats-py:

Connect dan subscribe dengan nats-py

import asyncio
import nats
 
async def main():
    nc = await nats.connect("nats://localhost:4222")
 
    async def on_message(msg):
        print(f"Subject {msg.subject}: {msg.data.decode()}")
 
    await nc.subscribe("hello.world", cb=on_message)
    await nc.publish("hello.world", b"Hello dari Python")
    await asyncio.sleep(1)
    await nc.close()
 
asyncio.run(main())

await nats.connect("nats://localhost:4222") membuka koneksi, nc.publish("hello.world", b"Hello dari Python") mengirim pesan, dan callback on_message mencetak pesan yang diterima. Jalankan dengan python main.py dan lihat pesan berhasil melintas.

#Client Go

Di Go, nats.go menawarkan API sinkron dan async:

package main
 
import (
    "log"
    "github.com/nats-io/nats.go"
)
 
func main() {
    nc, err := nats.Connect("nats://localhost:4222")
    if err != nil {
        log.Fatal(err)
    }
    defer nc.Close()
 
    _, err = nc.Subscribe("hello.world", func(m *nats.Msg) {
        log.Printf("Subject %s: %s", m.Subject, string(m.Data))
    })
    if err != nil {
        log.Fatal(err)
    }
 
    nc.Publish("hello.world", []byte("Hello dari Go"))
    select {}
}

nc.Connect("nats://localhost:4222") di Go membuka koneksi, dan nc.Subscribe("hello.world", handler) mendaftarkan callback yang dipanggil setiap ada pesan masuk.

#Verifikasi Koneksi Secara Lengkap

Sebagai penutup praktik episode ini, pastikan alur lengkap bekerja:

nats-server -p 4222 -m 8222 &
nats server check
nats pub ping.pong "pong"
nats sub ping.pong

Jika nats server check mengembalikan ok dan pesan ping-pong diterima subscriber, kalian resmi terhubung ke NATS. Server, CLI, dan client library sudah saling memahami — langkah berikutnya tinggal memperdalam pola komunikasi.

#Penutup

Episode 3 membawa kalian dari nol ke koneksi pertama: menjalankan nats-server langsung atau via Docker, menyusun konfigurasi minimal dengan blok jetstream, memakai nats pub, nats sub, dan nats server check, serta menghubungkan client Python dan Go pertama.

Inti yang harus dibawa pulang:

• Server bisa dijalankan dengan flag, Docker, atau file konfigurasi -c nats.conf.
• Port 4222 untuk client, 8222 untuk monitoring.
• Pasang subscriber sebelum publish; pesan tanpa subscriber hilang di Core NATS.
• nats server check adalah pemeriksaan kesehatan tercepat.
• Client Python dan Go memakai pola connect, subscribe, dan publish yang konsisten.

Di episode 4 selanjutnya kita akan membahas subjects & wildcards — hierarki subject orders.created.eu, best practice penamaan berbasis event-driven, serta perbedaan * dan > beserta implikasinya terhadap permission dan subscription. Di sinilah seni routing NATS mulai dikuasai.