Bagaimanakah NestJS menyokong microservices?

Question

Accepted Answer

NestJS mempunyai **sokongan microservices terbina** — ia boleh berjalan sebagai satu microservice yang berkomunikasi melalui pelbagai **transport** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) dan bukannya HTTP, menggunakan satu model pengaturcaraan berasaskan mesej yang konsisten. Struktur NestJS yang sama (modules, services, DI) terpakai; hanya transport dan corak mesej yang berubah.

## Mencipta satu 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 patterns lwn event patterns

```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
  }
}
```

Dua gaya komunikasi: **`@MessagePattern`** untuk request-response (pemanggil menunggu satu hasil, seperti RPC) dan **`@EventPattern`** untuk events (fire-and-forget, longgar gandingan — penerbit tidak menunggu).

## Memanggil microservice lain (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);
  }
}
```

Satu `ClientProxy` (dikonfigurasi melalui `ClientsModule`) menghantar mesej/events kepada perkhidmatan lain — `send()` untuk request-response, `emit()` untuk events.

## Aplikasi hibrid

```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
```

## Pilihan transport penting

```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.
```

## Mengapa ia penting

Sokongan microservices terbina NestJS adalah ketara kerana ia membolehkan anda membina sistem teragih menggunakan struktur NestJS yang *sama* dan biasa (modules, providers, DI, decorators) sambil menukar HTTP dengan transport berasaskan mesej — satu kelebihan produktiviti dan konsistensi yang besar.

Memahaminya adalah penting untuk merancang seni bina sistem yang boleh diskala: **perbezaan antara message-pattern (request-response) lwn event-pattern (fire-and-forget)** terpeta secara langsung kepada pilihan komunikasi microservices yang asas — panggilan gaya RPC segerak berbanding events yang tak segerak dan longgar gandingan (yang terakhir, melalui message brokers, memberikan ketahanan dan gandingan longgar yang menjadikan microservices teguh).

Mengetahui cara mencipta microservices, mentakrifkan handler mesej/event, memanggil perkhidmatan lain melalui `ClientProxy`, membina aplikasi hibrid HTTP+microservice, dan memilih transport (pub/sub ringan lwn queue tahan lama seperti Kafka/RabbitMQ lwn gRPC berprestasi tinggi) ialah pengetahuan peringkat senior yang berharga untuk mereka bentuk back-end teragih.

Walaupun microservices menambah kerumitan sebenar (dan bukan sentiasa pilihan yang betul berbanding satu monolit), NestJS menjadikan implementasinya bersih dan konsisten, menjadikan ini satu topik seni bina yang penting untuk membina sistem NestJS yang berskala besar dan teragih.