NestJS รองรับ microservices อย่างไร?

Question

Accepted Answer

NestJS มี **การรองรับ microservices มาในตัว** สามารถรันเป็น microservice ที่สื่อสารผ่าน **transport** หลากหลายรูปแบบ (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) แทน HTTP โดยใช้โมเดลการเขียนโปรแกรมแบบ message ที่สอดคล้องกัน โครงสร้าง NestJS เดิม (module, service, DI) ยังคงใช้ได้ มีเพียง transport และ message pattern ที่เปลี่ยนไป

## การสร้าง microservice

```ts
// a microservice listens on a transport instead of HTTP
const app = await NestFactory.createMicroservice(AppModule, {
  transport: Transport.TCP,             // or REDIS, NATS, RMQ, KAFKA, GRPC
  options: { host: "0.0.0.0", port: 3001 },
});
await app.listen();
```

## message pattern เทียบกับ event pattern

```ts
@Controller()
export class MathController {
  // REQUEST-RESPONSE: respond to a message and RETURN a result (RPC-style)
  @MessagePattern({ cmd: "sum" })
  sum(data: number[]): number {
    return data.reduce((a, b) => a + b, 0);   // the caller awaits this result
  }

// EVENT-BASED: react to an event, NO response expected (fire-and-forget)
  @EventPattern("order_created")
  handleOrderCreated(data: OrderDto) {
    this.processOrder(data);                   // just react; nothing returned
  }
}
```

รูปแบบการสื่อสารสองแบบ: **`@MessagePattern`** สำหรับ request-response (ตัวเรียกรอผลลัพธ์ เหมือน RPC) และ **`@EventPattern`** สำหรับ event (fire-and-forget, decoupled โดยผู้ publish ไม่รอ)

## การเรียก microservice อื่น (ฝั่ง client)

```ts
@Injectable()
export class AppService {
  constructor(@Inject("MATH_SERVICE") private client: ClientProxy) {}

async getSum() {
    // send() → request-response (returns an Observable of the result)
    return this.client.send({ cmd: "sum" }, [1, 2, 3]);
    // emit() → fire an event (no response)
    this.client.emit("order_created", orderData);
  }
}
```

`ClientProxy` (ตั้งค่าผ่าน `ClientsModule`) ส่ง message/event ไปยัง service อื่น โดย `send()` สำหรับ request-response และ `emit()` สำหรับ event

## แอปพลิเคชันแบบไฮบริด

```ts
// an app can serve HTTP AND connect microservice transports simultaneously
const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: {...} });
await app.startAllMicroservices();
await app.listen(3000);   // HTTP too
```

## การเลือก transport มีความสำคัญ

```text
TCP   → simple direct service-to-service
Redis/NATS → lightweight pub/sub messaging
RabbitMQ/Kafka → robust message queues/streams (durability, retries, decoupling)
gRPC  → high-performance, strongly-typed RPC (protobuf)
→ Async message brokers (RMQ/Kafka) give decoupling & resilience; gRPC gives speed+typing.
```

## ทำไมจึงสำคัญ

การรองรับ microservices ที่มีมาในตัวของ NestJS มีความสำคัญ เพราะมันให้คุณสร้างระบบกระจาย (distributed system) โดยใช้โครงสร้าง NestJS ที่*คุ้นเคยแบบเดียวกัน* (module, provider, DI, decorator) ในขณะที่สลับ HTTP เป็น transport แบบ message ซึ่งเป็นข้อได้เปรียบสำคัญด้าน productivity และความสอดคล้อง

การเข้าใจมันสำคัญสำหรับการออกแบบสถาปัตยกรรมระบบที่ scale ได้: **ความแตกต่างระหว่าง message-pattern (request-response) กับ event-pattern (fire-and-forget)** สอดคล้องโดยตรงกับทางเลือกการสื่อสารพื้นฐานของ microservices คือ การเรียกแบบ RPC ที่ synchronous เทียบกับ event ที่ asynchronous และ decoupled (แบบหลังผ่าน message broker มอบความยืดหยุ่นและการ coupling ที่หลวมซึ่งทำให้ microservices แข็งแกร่ง)

การรู้วิธีสร้าง microservice, นิยาม message/event handler, เรียก service อื่นผ่าน `ClientProxy`, สร้างแอปแบบไฮบริด HTTP+microservice และเลือก transport (pub/sub ที่เบาเทียบกับ queue ที่ทนทานอย่าง Kafka/RabbitMQ เทียบกับ gRPC ที่ประสิทธิภาพสูง) เป็นความรู้ระดับ senior ที่มีค่าสำหรับการออกแบบ back-end แบบกระจาย

แม้ microservices จะเพิ่มความซับซ้อนจริง (และไม่ได้เป็นทางเลือกที่ถูกต้องเสมอไปเมื่อเทียบกับ monolith) แต่ NestJS ทำให้การ implement สะอาดและสอดคล้องกัน ทำให้นี่เป็นหัวข้อเชิงสถาปัตยกรรมที่สำคัญสำหรับการสร้างระบบ NestJS แบบกระจายขนาดใหญ่