NestJS hỗ trợ microservice như thế nào?

Question

Accepted Answer

NestJS có **hỗ trợ microservice tích hợp sẵn** — nó có thể chạy như một microservice giao tiếp qua nhiều **transport** khác nhau (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) thay vì HTTP, dùng một mô hình lập trình dựa trên message nhất quán. Cùng cấu trúc NestJS (module, service, DI) áp dụng; chỉ transport và message pattern thay đổi.

## Tạo một microservice

```ts
// một microservice lắng nghe trên một transport thay vì HTTP
const app = await NestFactory.createMicroservice(AppModule, {
  transport: Transport.TCP,             // hoặc REDIS, NATS, RMQ, KAFKA, GRPC
  options: { host: "0.0.0.0", port: 3001 },
});
await app.listen();
```

## Message pattern vs event pattern

```ts
@Controller()
export class MathController {
  // REQUEST-RESPONSE: phản hồi một message và TRẢ VỀ kết quả (kiểu RPC)
  @MessagePattern({ cmd: "sum" })
  sum(data: number[]): number {
    return data.reduce((a, b) => a + b, 0);   // bên gọi chờ kết quả này
  }

// EVENT-BASED: phản ứng với một event, KHÔNG mong đợi response (fire-and-forget)
  @EventPattern("order_created")
  handleOrderCreated(data: OrderDto) {
    this.processOrder(data);                   // chỉ phản ứng; không trả về gì
  }
}
```

Hai phong cách giao tiếp: **`@MessagePattern`** cho request-response (bên gọi chờ một kết quả, như RPC) và **`@EventPattern`** cho event (fire-and-forget, tách rời — bên publish không chờ).

## Gọi một microservice khác (client)

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

async getSum() {
    // send() → request-response (trả về một Observable của kết quả)
    return this.client.send({ cmd: "sum" }, [1, 2, 3]);
    // emit() → phát một event (không response)
    this.client.emit("order_created", orderData);
  }
}
```

Một `ClientProxy` (được cấu hình qua `ClientsModule`) gửi message/event tới các service khác — `send()` cho request-response, `emit()` cho event.

## Ứng dụng hybrid

```ts
// một ứng dụng có thể phục vụ HTTP VÀ kết nối các transport microservice đồng thời
const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: {...} });
await app.startAllMicroservices();
await app.listen(3000);   // cả HTTP
```

## Lựa chọn transport quan trọng

```text
TCP   → giao tiếp service-to-service trực tiếp đơn giản
Redis/NATS → message pub/sub nhẹ
RabbitMQ/Kafka → message queue/stream vững chắc (bền vững, retry, tách rời)
gRPC  → RPC hiệu năng cao, kiểu mạnh (protobuf)
→ Message broker async (RMQ/Kafka) cho tách rời & khả năng phục hồi; gRPC cho tốc độ+kiểu.
```

## Tại sao điều này quan trọng

Hỗ trợ microservice tích hợp của NestJS có ý nghĩa vì nó cho phép bạn xây dựng các hệ thống phân tán dùng *cùng* cấu trúc NestJS quen thuộc (module, provider, DI, decorator) trong khi hoán đổi HTTP lấy các transport dựa trên message — một lợi thế lớn về năng suất và sự nhất quán.

Hiểu nó là quan trọng để kiến trúc các hệ thống có khả năng mở rộng: **khác biệt giữa message-pattern (request-response) và event-pattern (fire-and-forget)** ánh xạ trực tiếp tới lựa chọn giao tiếp cơ bản của microservice — các lời gọi đồng bộ kiểu RPC so với các event bất đồng bộ, tách rời (cái sau, qua message broker, cung cấp khả năng phục hồi và sự lỏng lẻo làm cho microservice vững chắc).

Biết cách tạo microservice, định nghĩa các handler message/event, gọi các service khác qua `ClientProxy`, xây dựng các ứng dụng hybrid HTTP+microservice, và chọn transport (pub/sub nhẹ vs queue bền vững như Kafka/RabbitMQ vs gRPC hiệu năng cao) là kiến thức cấp senior giá trị để thiết kế các back-end phân tán.

Mặc dù microservice thêm độ phức tạp thực sự (và không phải lúc nào cũng là lựa chọn đúng so với monolith), NestJS làm cho việc triển khai sạch sẽ và nhất quán, khiến đây trở thành một chủ đề kiến trúc quan trọng để xây dựng các hệ thống NestJS phân tán, quy mô lớn.