⚡
NATS.io 치트시트

NATS Server 2.10+ & JetStream 최신 기준 초보자 완벽 가이드: Docker 1초 설치, Core NATS(Pub/Sub, Request-Reply, Queue Groups)와 JetStream(영속 스트림, Key-Value Store, Object Store) 핵심 멘탈 모델, 와일드카드 규칙, nats CLI 완전 정복, Go/Python/Node.js 즉시 실행 코드 및 고가용성 프로덕션 체크리스트
#nats#nats-io#jetstream#message-broker#pubsub#microservices#event-driven#golang#docker#cloud-native최종 업데이트: 2026-10-07
NATS.io 치트시트 핵심 명령어 및 실전 가이드

## 1. 필수 사전 설치 요건 & 환경 구성 (Prerequisites)

NATS.io는 CNCF(Cloud Native Computing Foundation)를 졸업한 초경량·초고속 분산 메시징 및 이벤트 스트리밍 시스템입니다. 단일 Go 바이너리로 실행되며, 메모리 사용량이 극히 적고(수십 MB 수준), 단일 서버에서도 초당 수백만 건의 메시지를 서브밀리초(Microsecond 단위) 대기시간으로 처리합니다.

초보자도 1분 안에 자신의 로컬 환경에서 직접 동작을 검증할 수 있도록 **JetStream(지속성 엔진)과 모니터링 엔드포인트가 활성화된 Docker 실행**부터 시작합니다.

---

### 🐳 1. Docker로 1초 만에 실행하기 (가장 추천)

JetStream 영속 스토리지(`-js`)와 HTTP 모니터링 포트(`-m 8222`)를 켠 상태로 공식 NATS 컨테이너를 구동합니다:

```bash
# NATS 2.10+ 최신 서버 구동 (JetStream 및 웹 모니터링 포트 활성화)
docker run -d --name nats \
  -p 4222:4222 \
  -p 8222:8222 \
  -p 6222:6222 \
  nats:latest -js -m 8222
```

- **4222 포트**: 클라이언트(Go, Python, Java, Node.js) 및 `nats` CLI 기본 통신 포트
- **8222 포트**: HTTP 기반 내장 모니터링 웹 엔드포인트 (`/varz`, `/connz`, `/jsz` 등)
- **6222 포트**: NATS 클러스터 노드 간 라우팅(Cluster Routing) 포트

#### ✅ 실행 상태 확인
웹 브라우저 또는 터미널에서 NATS 서버 상태를 즉시 확인할 수 있습니다:
```bash
# 서버 메트릭 요약 확인 (JSON 출력)
curl http://localhost:8222/varz

# JetStream 활성화 상태 확인
curl http://localhost:8222/jsz
```

---

### 💻 2. NATS CLI 도구 및 서버 로컬 설치 (선택)

NATS는 공식 CLI 유틸리티(`nats`)를 통해 토픽 발행/구독, 스트림 생성, KV 관리, 벤치마크를 손쉽게 조작할 수 있습니다.

| 운영체제 (OS) | 설치 명령어 |
| :--- | :--- |
| **macOS** | `brew install nats-io/nats-tools/nats nats-server` |
| **Linux (Ubuntu/Debian)** | `curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest \| sh`<br>`sudo mv nats /usr/local/bin/` |
| **Windows** | `choco install natscli nats-server` 또는 `scoop install nats nats-server` |
| **Go 툴체인 사용 시** | `go install github.com/nats-io/natscli/nats@latest`<br>`go install github.com/nats-io/nats-server/v2@latest` |

설치 후 로컬 연결 진단:
```bash
nats server check
# 출력 예시: OK: nats://localhost:4222 connected in 1.2ms (Server: NATS Server 2.10.x)
```

---

### 📦 3. 클라이언트 드라이버 라이브러리 설치

선호하는 프로그래밍 언어의 공식 NATS 클라이언트를 설치합니다:

```bash
# Go (공식 표준 드라이버)
go get github.com/nats-io/nats.go

# Python (비동기 asyncio 기반 공식 드라이버)
pip install nats-py

# Node.js / TypeScript (공식 드라이버)
npm install nats
```

---

## 2. 직관적인 멘탈 모델 & 아키텍처 (Mental Model)

NATS는 크게 **Core NATS(순수 메모리 기반 인메모리 통신)**와 **JetStream(Raft 기반 영속성 및 분산 스트리밍 엔진)** 두 가지 계층으로 나뉩니다.

```
┌────────────────────────────────────────────────────────────────────────┐
│                          NATS SERVER (포트 4222)                       │
│                                                                        │
│  [ Core NATS 계층 ] - 초고속 메모리 통신 (At-Most-Once / Fire & Forget)│
│    1. Publish / Subscribe : 1:N 브로드캐스트 (구독자 없으면 즉시 폐기)   │
│    2. Request / Reply     : 1:1 동기 RPC 패턴 (_INBOX.<임시ID> 기반)   │
│    3. Queue Groups        : 1:N 분산 부하 분산 (동일 큐그룹 중 1개만 소비)│
│                                                                        │
│  [ JetStream 계층 ] - 디스크/메모리 영속화 (At-Least-Once / Exactly-Once) │
│    1. Streams             : 토픽 메시지 순차 로그 저장 (Write-Ahead-Log)│
│    2. Consumers           : Durable/Ephemeral 오프셋 추적 & ACK/재시도  │
│    3. Key-Value Store     : 분산 키-값 저장소 (스트림 기반 추상화)     │
│    4. Object Store        : 대용량 파일 청크 분산 저장소               │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │
               ┌────────────────────┴────────────────────┐
               ▼                                         ▼
   [ Publisher / Client ]                    [ Subscriber / Consumer ]
   nats.publish("orders.created", data)      nats.subscribe("orders.*")
```

### Core NATS vs JetStream 핵심 차이 비교

| 구분 | Core NATS | JetStream |
| :--- | :--- | :--- |
| **메시지 전달 보장** | **At-most-once (최대 1회)**<br>수신자가 없으면 즉시 메시지 소멸 | **At-least-once (최소 1회)** 또는 **Exactly-once**<br>디스크에 저장 후 ACK 확인 시까지 재시도 |
| **저장소 (Storage)** | 메모리 없음 (Zero-allocation 버퍼) | 파일(File) 또는 인메모리(Memory) WAL |
| **소비자 오프셋** | 없음 (실시간 수신 전용) | 컨슈머(Consumer)별 오프셋 및 시퀀스 번호 추적 |
| **주요 활용 사례** | 실시간 메트릭 수집, 채팅, 내부 RPC, 알림 | 결제 이벤트, 주문 트랜잭션, 감사 로그, 작업 큐 |
| **대기 시간 (Latency)** | 수십 마이크로초 (Microseconds, 극초저지연) | 수백 마이크로초 ~ 1밀리초 내외 |

---

## 3. 단계별 점진적 실습 (Step-by-Step Walkthrough)

### 📌 [초보자 1단계] 헬로월드: CLI로 경험하는 Pub/Sub & Subject 와일드카드

NATS는 URL 경로와 유사하게 점(`.`)을 구분자로 사용하는 **Subject(주제)** 기반 라우팅을 지원합니다.

#### 1) Subject 명명 규칙 & 와일드카드
- **구분자**: `.` (점, 토큰 구분)
- `*` (Single Token): 정확히 **1개의 토큰**에 매칭
  - `sensor.*.temperature` ➔ `sensor.kitchen.temperature` (매칭 O)
  - `sensor.kitchen.room1.temperature` (매칭 X)
- `>` (Multi Token / Wildcard): **1개 이상의 모든 하위 토큰**에 매칭 (반드시 맨 끝에 위치)
  - `orders.>` ➔ `orders.created`, `orders.us.express.delivered` 모두 매칭

#### 2) CLI로 실시간 수신 및 발행 실습
서로 다른 두 개의 터미널을 열고 아래 명령어를 순서대로 실행합니다:

**[터미널 1: 구독자(Subscriber)]**
```bash
# notifications로 시작하는 모든 알림 수신 대기
nats sub "notifications.*"
```

**[터미널 2: 발행자(Publisher)]**
```bash
# 메시지 발행
nats pub "notifications.email" '{"user": "alice", "title": "로그인 알림"}'
nats pub "notifications.sms" '{"user": "bob", "phone": "010-1234-5678"}'
```

**[터미널 1의 출력 결과 (실시간 수신)]**
```text
[#1] Received on "notifications.email":
{"user": "alice", "title": "로그인 알림"}

[#2] Received on "notifications.sms":
{"user": "bob", "phone": "010-1234-5678"}
```

---

### 📌 [2단계] Request-Reply (동기식 RPC) & Queue Groups (부하 분산)

#### 1) Request-Reply 패턴 (인박스 기반 RPC)
발행자가 메시지를 보낼 때 임시 생성된 응답 주소(`_INBOX.xxx`)를 함께 전송하며, 수신자가 해당 인박스로 답장을 보내는 1:1 동기 패턴입니다.

**[터미널 1: 응답 서버 (Responder)]**
```bash
# service.user.info 요청이 오면 JSON 답장 전송
nats reply "service.user.info" '{"status": 200, "name": "Lucky", "role": "ADMIN"}'
```

**[터미널 2: 요청자 (Requester)]**
```bash
# 요청을 보내고 응답 수신 대기 (기본 0.5초 타임아웃)
nats req "service.user.info" '{"userId": 1001}'
```

**[터미널 2 출력 결과]**
```text
17:42:01.321 >>> {"userId": 1001}
17:42:01.323 <<< {"status": 200, "name": "Lucky", "role": "ADMIN"}
Received in 2.1ms
```

---

#### 2) Queue Groups (동일 큐 그룹 내 작업자 간 부하 분산)
일반 Pub/Sub는 모든 구독자에게 메시지를 복제(Broadcast)하지만, `--queue` 플래그를 지정하면 **동일 그룹에 속한 워커들 중 단 하나만 메시지를 할당**받아 처리합니다 (Worker Pool / 로드밸런싱).

```bash
# 터미널 A (Worker 1)
nats sub "jobs.image.resize" --queue "workers"

# 터미널 B (Worker 2)
nats sub "jobs.image.resize" --queue "workers"

# 터미널 C (발행자) - 여러 건 전송
nats pub "jobs.image.resize" "이미지 작업 #1"
nats pub "jobs.image.resize" "이미지 작업 #2"
nats pub "jobs.image.resize" "이미지 작업 #3"
```
➔ 작업 #1은 Worker 1, 작업 #2는 Worker 2 등으로 공평하게 분배됩니다.

---

### 📌 [3단계] JetStream 영속 스트림 & Key-Value Store 실무 응용

메시지가 유실되면 안 되는 핵심 비즈니스 로직(결제, 주문)에는 JetStream을 사용합니다.

#### 1) 영속 스트림(Stream) 생성
```bash
# ORDERS 스트림 생성: orders.* 주제의 메시지를 파일에 영속 보관
nats stream add ORDERS \
  --subjects "orders.*" \
  --storage file \
  --retention limits \
  --max-msgs 100000 \
  --max-age 7d \
  --discard old \
  --dupe-window 2m
```

#### 2) 스트림에 메시지 발행 & 중복 방지 (Idempotency)
`Nats-Msg-Id` 헤더를 전달하면 중복 윈도우(`dupe-window`) 내 동일 ID의 메시지 중복 발행을 NATS가 자동으로 차단합니다:
```bash
# 주문 생성 메시지 발행 (메시지 ID 헤더 지정)
nats pub orders.created '{"orderId": "ORD-2026", "amount": 54000}' -H "Nats-Msg-Id: ORDER_REQ_001"

# 동일한 ID로 재발행 시 중복 감지되어 스토리지에 1건만 기록됨
nats pub orders.created '{"orderId": "ORD-2026", "amount": 54000}' -H "Nats-Msg-Id: ORDER_REQ_001"
```

#### 3) 지속성 컨슈머(Durable Consumer) 생성 및 메시지 가져오기 (Pull)
```bash
# ORDERS 스트림에 ORDER_WORKER 컨슈머 등록 (명시적 수동 ACK 요구)
nats consumer add ORDERS ORDER_WORKER \
  --pull \
  --ack explicit \
  --deliver all \
  --replay instant

# 다음 대기 중인 메시지 1건 가져오기 및 ACK 처리
nats consumer next ORDERS ORDER_WORKER
```

---

#### 4) NATS Key-Value (KV) Store 활용
JetStream 스트림을 기반으로 초고속 분산 K/V 데이터베이스를 기본 제공합니다:

```bash
# 1. 'app-config' 버킷 생성 (히스토리 최대 5개 보관)
nats kv add app-config --history 5

# 2. 키/값 저장
nats kv put app-config db_host "postgres.cluster.local"
nats kv put app-config max_connections "50"

# 3. 키 조회
nats kv get app-config db_host

# 4. 실시간 변경 감지 (Watch 모드 - 설정 핫 리로딩에 유용)
nats kv watch app-config
```

---

## 4. 복사해서 바로 실행 가능한 코드 (Self-contained & Runnable)

### 🐹 1. Go (공식 nats.go 표준 예제)

다음 코드는 **Core NATS Pub/Sub**, **Request-Reply**, **JetStream 스트림 생성 및 발행/소비**를 한 번에 검증할 수 있는 완전한 단일 파일입니다.

```go
// main.go
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/nats-io/nats.go"
	"github.com/nats-io/nats.go/jetstream"
)

func main() {
	// 1. NATS 서버 연결
	nc, err := nats.Connect("nats://127.0.0.1:4222", nats.Timeout(3*time.Second))
	if err != nil {
		log.Fatalf("NATS 연결 실패: %v", err)
	}
	defer nc.Close()
	fmt.Println("✅ [Core NATS] 서버 연결 성공!")

	// 2. Core NATS: 비동기 구독 (Pub/Sub)
	sub, err := nc.Subscribe("service.logs", func(m *nats.Msg) {
		fmt.Printf("📩 [Subscriber] 수신: %s\n", string(m.Data))
	})
	if err != nil {
		log.Fatal(err)
	}
	defer sub.Unsubscribe()

	// 3. 메시지 발행
	_ = nc.Publish("service.logs", []byte("서버 헬스체크 정상"))
	_ = nc.Flush()

	// 4. Core NATS: Request-Reply (1:1 RPC)
	nc.Subscribe("user.lookup", func(m *nats.Msg) {
		// 요청 수신 후 응답 반환
		m.Respond([]byte(`{"status": "OK", "user": "lucky"}`))
	})
	_ = nc.Flush()

	// 요청 보내기 (1초 대기)
	replyMsg, err := nc.Request("user.lookup", []byte(`{"id": 42}`), 1*time.Second)
	if err == nil {
		fmt.Printf("🔄 [Request-Reply] 응답 수신: %s\n", string(replyMsg.Data))
	}

	// 5. JetStream 컨텍스트 생성 (영속 스트리밍)
	ctx := context.Background()
	js, err := jetstream.New(nc)
	if err != nil {
		log.Fatalf("JetStream 초기화 실패: %v", err)
	}

	// 스트림 정의 및 생성 (존재하지 않을 때만 생성)
	streamName := "EVENTS"
	stream, err := js.CreateOrUpdateStream(ctx, jetstream.StreamConfig{
		Name:      streamName,
		Subjects:  []string{"events.*"},
		Storage:   jetstream.FileStorage,
		Retention: jetstream.LimitsPolicy,
	})
	if err != nil {
		log.Fatalf("스트림 생성 실패: %v", err)
	}
	fmt.Printf("🚀 [JetStream] 스트림 '%s' 활성화 완료\n", stream.CachedInfo().Config.Name)

	// JetStream 메시지 발행
	ack, err := js.Publish(ctx, "events.login", []byte(`{"event": "USER_LOGIN", "timestamp": "2026-10-07"}`))
	if err != nil {
		log.Fatalf("발행 실패: %v", err)
	}
	fmt.Printf("📦 [JetStream] 발행 완료 (Stream: %s, Seq: %d)\n", ack.Stream, ack.Sequence)

	time.Sleep(500 * time.Millisecond)
	fmt.Println("🎉 NATS 모든 동작 테스트 완료!")
}
```

#### 실행 방법 및 출력:
```bash
go mod init nats-test
go get github.com/nats-io/nats.go
go run main.go
```
```text
✅ [Core NATS] 서버 연결 성공!
📩 [Subscriber] 수신: 서버 헬스체크 정상
🔄 [Request-Reply] 응답 수신: {"status": "OK", "user": "lucky"}
🚀 [JetStream] 스트림 'EVENTS' 활성화 완료
📦 [JetStream] 발행 완료 (Stream: EVENTS, Seq: 1)
🎉 NATS 모든 동작 테스트 완료!
```

---

### 🐍 2. Python (비동기 nats-py 예제)

```python
# test_nats.py
import asyncio
import json
import nats

async def main():
    # 1. NATS 서버 비동기 연결
    nc = await nats.connect("nats://127.0.0.1:4222")
    print("✅ [Python] NATS 연결 성공!")

    # 2. 메시지 수신 콜백 핸들러 등록
    async def message_handler(msg):
        data = json.loads(msg.data.decode())
        print(f"📩 [Python 수신] 주제: {msg.subject}, 데이터: {data}")

    # 3. 와일드카드 구독
    sub = await nc.subscribe("orders.*", cb=message_handler)

    # 4. 메시지 발행
    payload = {"order_id": "ORD-999", "status": "PAID", "items": 3}
    await nc.publish("orders.checkout", json.dumps(payload).encode())

    # 5. Request-Reply 테스트
    async def reply_handler(msg):
        await msg.respond(b'{"result": "PONG"}')

    await nc.subscribe("service.ping", cb=reply_handler)
    response = await nc.request("service.ping", b'PING', timeout=1.0)
    print(f"🔄 [Python RPC] 응답: {response.data.decode()}")

    # 잠시 대기 후 정리
    await asyncio.sleep(0.5)
    await sub.unsubscribe()
    await nc.drain()
    print("🎉 [Python] 테스트 종료 완료")

if __name__ == '__main__':
    asyncio.run(main())
```

---

### 🟩 3. Node.js / TypeScript (공식 nats 패키지)

```typescript
// app.ts
import { connect, StringCodec } from "nats";

async function run() {
  const sc = StringCodec();
  // 1. 서버 연결
  const nc = await connect({ servers: "nats://127.0.0.1:4222" });
  console.log(`✅ [Node.js] NATS 연결됨: ${nc.getServer()}`);

  // 2. 비동기 이터레이터 방식 구독 (Core NATS)
  const sub = nc.subscribe("telemetry.>");
  (async () => {
    for await (const m of sub) {
      console.log(`📩 [Node.js 수신] [${m.subject}]: ${sc.decode(m.data)}`);
    }
  })();

  // 3. 메시지 발행
  nc.publish("telemetry.server.cpu", sc.encode(JSON.stringify({ usage: "42%" })));
  nc.publish("telemetry.server.memory", sc.encode(JSON.stringify({ free_mb: 2048 })));

  // 4. Request-Reply
  nc.subscribe("math.add", {
    callback: (_err, msg) => {
      const numbers: number[] = JSON.parse(sc.decode(msg.data));
      const sum = numbers.reduce((a, b) => a + b, 0);
      msg.respond(sc.encode(JSON.stringify({ sum })));
    },
  });

  const rep = await nc.request("math.add", sc.encode(JSON.stringify([10, 20, 30])), { timeout: 1000 });
  console.log(`➕ [Node.js RPC] 합계 결과: ${sc.decode(rep.data)}`);

  // 연결 종료 대기
  await nc.drain();
}

run().catch(console.error);
```

---

## 5. nats CLI 핵심 명령어 종합 치트시트

### 1) 기본 Core NATS 메시징
```bash
# 메시지 실시간 구독 (헤더 표시, 타임스탬프)
nats sub "sensors.*" --headers

# 메시지 발행 (헤더 포함)
nats pub "sensors.temp" "24.5" -H "Device-ID: DEV-01"

# 1:1 동기 요청 (타임아웃 2초)
nats req "auth.verify" '{"token": "xyz"}' --timeout 2s

# 큐 그룹 분산 구독
nats sub "tasks.process" --queue "workers"
```

### 2) JetStream 스트림 관리
```bash
# 스트림 목록 확인
nats stream ls

# 스트림 상세 정보 조회 (메시지 수, 용량, 컨슈머 목록)
nats stream info ORDERS

# 특정 스트림의 저장된 메시지 브라우징 (조회)
nats stream view ORDERS

# 스트림 내 모든 메시지 안전하게 비우기 (Purge)
nats stream purge ORDERS

# 스트림 삭제
nats stream rm ORDERS --force
```

### 3) JetStream 컨슈머 관리
```bash
# 특정 스트림의 컨슈머 목록 조회
nats consumer ls ORDERS

# 컨슈머 상태 및 밀린 메시지 수(Lag) 확인
nats consumer info ORDERS ORDER_WORKER

# Pull 컨슈머로부터 다음 메시지 수신 및 확인
nats consumer next ORDERS ORDER_WORKER --ack
```

### 4) 성능 측정 (내장 벤치마크)
별도의 부하 도구 설치 없이 초당 처리량을 즉시 측정할 수 있습니다:
```bash
# 100만 건 메시지 Pub/Sub 벤치마크 (메시지 크기 128B)
nats bench "benchmark.test" --pub 1 --sub 1 --msgs 1000000 --size 128
```
➔ 초당 1,500,000+ msgs/sec 처리량과 p99 지연 시간 통계가 즉시 출력됩니다.

---

## 6. 실무 주의사항 & 프로덕션 장애 예방 체크리스트

### ⚠️ 1. 초보자가 가장 많이 겪는 실수 Top 4
1. **구독자가 없을 때 Core NATS 메시지 유실**:
   - `nc.Publish()`는 기본적으로 **Fire-and-forget**입니다. 해당 시점에 토픽을 청취 중인 활성 구독자가 없다면 메시지는 버려집니다.
   - ➔ 주문, 결제 등 영속성이 필요한 업무에는 반드시 **JetStream Stream**을 생성하여 발행해야 합니다.
2. **도커 실행 시 `-js` 플래그 누락**:
   - `nats:latest` 컨테이너 구동 시 `-js` 옵션을 주지 않으면 JetStream API 호출 시 `nats: JetStream not enabled for account` 에러가 발생합니다.
3. **Queue Group과 JetStream Consumer의 혼동**:
   - **Queue Group**: 인메모리 실시간 로드밸런싱 (작업자 다운 시 처리 중이던 메시지 복구 불가).
   - **JetStream Durable Pull Consumer**: 수동 ACK(`ack explicit`) 기반으로 작업자가 다운되어 ACK를 못 주면 타임아웃(`AckWait`) 후 다른 작업자에게 자동 재전송(At-least-once 보장).
4. **Subject에 공백 또는 잘못된 특수문자 사용**:
   - Subject는 오직 영문자, 숫자, 하이픈(`-`), 언더스코어(`_`), 점(`.`)만 사용하는 것이 표준 권장사항입니다. 공백이나 슬래시(`/`)는 사용하지 마세요.

---

### 🛡️ 2. 프로덕션 운영 체크리스트

- [ ] **고가용성 클러스터링 (High Availability)**:
  - JetStream은 **3대 또는 5대의 홀수 노드**로 클러스터를 구성해야 Raft 합의 쿼럼(Quorum)을 유지하며 리더 장애 시 무중단 자동 페일오버가 가능합니다.
- [ ] **스토리지 용량 한도 (`max_bytes`, `discard`)**:
  - 디스크 고갈을 방지하기 위해 스트림마다 `max_bytes` 한도와 `discard: old`(오래된 메시지 순차 삭제) 정책을 설정해야 합니다.
- [ ] **메트릭 모니터링**:
  - `http://<nats-ip>:8222/varz`: 메모리 사용량, CPU, 연결 클라이언트 수
  - `http://<nats-ip>:8222/jsz`: JetStream 계정별 스트림 및 컨슈머 수, 디스크 사용량
  - 공식 프로메테우스 익스포터(`nats-exporter`)를 파드/호스트에 배포하여 Grafana 대시보드와 연동 권장
- [ ] **TLS 암호화 및 계정/권한 분리 (NKeys / JWT)**:
  - 프로덕션에서는 평문 통신 대신 TLS 1.3을 활성화하고, 탈중앙화된 NKeys(ED25519) 및 JWT 토큰 기반 인증으로 Subject별 발행/구독 권한을 화이트리스트로 제한해야 합니다.
- [ ] **Leaf Node (엣지 컴퓨팅 연동)**:
  - 공장 설비, IoT 게이트웨이, 리모트 지사 서버에 독립된 NATS Leaf Node를 설치하고 본사 중앙 NATS 클러스터로 브리지 연결하면 네트워크 단절 시에도 로컬 버퍼링 후 복구 시 자동 동기화됩니다.
💬
NATS.io 치트시트

의견 및 질문

댓글 수정

댓글 삭제
