Bagaimana NestJS mendukung microservices?

Question

IT Interview Practice · Accepted Answer

NestJS memiliki **dukungan microservices bawaan** — dapat berjalan sebagai microservice yang berkomunikasi melalui berbagai **transport** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) alih-alih HTTP, menggunakan model pemrograman berbasis pesan yang konsisten. Struktur NestJS yang sama (modules, services, DI) berlaku; hanya transport dan message pattern yang berubah.

## Membuat 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 vs 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
  }
}
```

Dua gaya komunikasi: **`@MessagePattern`** untuk request-response (pemanggil menunggu hasil, seperti RPC) dan **`@EventPattern`** untuk event (fire-and-forget, decoupled — publisher 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);
  }
}
```

`ClientProxy` (dikonfigurasi via `ClientsModule`) mengirim pesan/event ke layanan lain — `send()` untuk request-response, `emit()` untuk event.

## Aplikasi hybrid

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

Dukungan microservices bawaan NestJS signifikan karena memungkinkan Anda membangun sistem terdistribusi menggunakan struktur NestJS yang *sama* (modules, providers, DI, decorators) sambil mengganti HTTP dengan transport berbasis pesan — keuntungan produktivitas dan konsistensi yang besar.

Memahamianya penting untuk merancang sistem yang scalable: **perbedaan message-pattern (request-response) vs event-pattern (fire-and-forget)** memetakan langsung ke pilihan komunikasi microservices fundamental — panggilan RPC-style synchronous versus event asynchronous yang decoupled (yang terakhir, via message broker, memberikan resilience dan loose coupling yang membuat microservices robust).

Mengetahui cara membuat microservices, mendefinisikan message/event handlers, memanggil layanan lain via `ClientProxy`, membangun aplikasi hybrid HTTP+microservice, dan memilih transport (pub/sub ringan vs durable queue seperti Kafka/RabbitMQ vs gRPC berkinerja tinggi) adalah pengetahuan level senior yang berharga untuk mendesain distributed back-ends.

Meskipun microservices menambah kompleksitas nyata (dan tidak selalu pilihan yang tepat dibanding monolith), NestJS membuat implementasinya clean dan konsisten, menjadikan ini topik arsitektur penting untuk membangun sistem NestJS terdistribusi skala besar.

Membuat microservice

Message pattern vs event pattern

Memanggil microservice lain (client)

Aplikasi hybrid

Pilihan transport penting

Mengapa ini penting

Pertanyaan terkait