Belajar NestJS - API Gateway & Microservices

#Pendahuluan

Saat aplikasi tumbuh, membangun satu monolit besar menjadi sulit dirawat. Microservices memecah aplikasi menjadi service-service kecil yang berkomunikasi lewat jaringan. NestJS memiliki dukungan microservices yang matang sejak awal.

Episode 14 membahas arsitektur microservices NestJS: konsep, transport layer, gateway, dan aspek keamanan antar service.

#Arsitektur Microservices NestJS

#Konsep Dasar

Microservices memisahkan aplikasi menjadi beberapa service independen — misalnya user-service, order-service, dan payment-service. Setiap service punya database sendiri dan berkomunikasi lewat network. NestJS mendukung pola ini lewat module @nestjs/microservices.

#Pattern Message dan Event

Service microservices NestJS berkomunikasi dengan dua pola:

• Request-response: klien mengirim request dan menunggu respons.
• Event-based: service mengirim event tanpa menunggu respons (fire-and-forget).

Microservice dengan @MessagePattern

import { Controller } from "@nestjs/common";
import { MessagePattern, Payload } from "@nestjs/microservices";
 
@Controller()
export class UserController {
  @MessagePattern("user.find")
  find(@Payload() data: { id: number }): string {
    return `User dengan id ${data.id}`;
  }
}

@MessagePattern("user.find") mendaftarkan handler yang merespons message bernama user.find.

#Transport Layers

#Memilih Transport

NestJS mendukung beberapa transport layer untuk komunikasi antar service:

• TCP: transport default, sederhana dan cepat.
• Redis: memakai publish-subscribe Redis.
• NATS: message broker ringan dan berperforma tinggi.
• RabbitMQ: message broker enterprise dengan routing yang kuat.
• Kafka: platform streaming terdistribusi untuk event-driven berskala besar.

#Konfigurasi Transport

Bootstrap service dengan transport yang dipilih:

Bootstrap microservice TCP

import { NestFactory } from "@nestjs/core";
import { MicroserviceOptions, Transport } from "@nestjs/microservices";
import { UserModule } from "./user.module";
 
async function bootstrap(): Promise<void> {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    UserModule,
    {
      transport: Transport.TCP,
      options: { host: "0.0.0.0", port: 3001 },
    },
  );
  await app.listen();
}
 
void bootstrap();

Service ini mendengarkan koneksi TCP di port 3001.

#Transport Redis

Bootstrap microservice Redis

const app = await NestFactory.createMicroservice<MicroserviceOptions>(
  UserModule,
  {
    transport: Transport.REDIS,
    options: { host: "localhost", port: 6379 },
  },
);

Dengan Redis, message dikirim lewat channel pub-sub. Opsi lain seperti NATS, RabbitMQ, dan Kafka memakai konfigurasi yang serupa dengan opsi masing-masing.

#Gateway Patterns dan API Composition

#Membuat API Gateway

Gateway adalah pintu masuk tunggal yang meneruskan request ke service yang tepat:

API gateway memakai ClientProxy

import { Controller, Get, Inject } from "@nestjs/common";
import { ClientProxy } from "@nestjs/microservices";
 
@Controller("users")
export class GatewayController {
  constructor(
    @Inject("USER_SERVICE") private readonly userClient: ClientProxy,
  ) {}
 
  @Get(":id")
  find(@Param("id") id: number): Promise<unknown> {
    return this.userClient.send("user.find", { id }).toPromise();
  }
}

Gateway menerima request HTTP lalu meneruskan sebagai message ke service. Ini disebut API composition — gateway mengoordinasikan beberapa service untuk satu respons.

#Mengatur ClientsModule

Untuk memakai ClientProxy, daftarkan klien di module:

Mendaftarkan klien service

import { Module } from "@nestjs/common";
import { ClientsModule, Transport } from "@nestjs/microservices";
 
@Module({
  imports: [
    ClientsModule.register([
      {
        name: "USER_SERVICE",
        transport: Transport.TCP,
        options: { port: 3001 },
      },
    ]),
  ],
})
export class GatewayModule {}

#Autentikasi dan Validasi Antar Service

#Service-to-Service Authentication

Ketika service berkomunikasi, pastikan keduanya saling terpercaya. Pola umum: kirim token service (bukan token user) atau gunakan mTLS. NestJS memungkinkan memakai interceptor untuk menambahkan token sebelum mengirim message:

Interceptor menambahkan token service

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from "@nestjs/common";
import { Observable } from "rxjs";
 
@Injectable()
export class ServiceAuthInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    const request = context.switchToHttp().getRequest();
    request.headers["x-service-token"] = process.env.SERVICE_TOKEN;
    return next.handle();
  }
}

#Validasi Message

Sama seperti HTTP, message antar service harus divalidasi. Gunakan ValidationPipe pada handler microservices dan DTO untuk payload message. Ini mencegah data rusak atau berbahaya mengalir antar service.

#Penutup

Episode 14 membuka dunia microservices NestJS: konsep message dan event pattern, transport layer, gateway, serta autentikasi dan validasi antar service.

Inti yang harus dibawa pulang:

• Microservices memecah aplikasi menjadi service independen yang terhubung via network.
• @MessagePattern mendaftarkan handler untuk request-response.
• Transport tersedia: TCP, Redis, NATS, RabbitMQ, dan Kafka.
• API gateway meneruskan request ke service memakai ClientProxy.
• Service-to-service auth memakai token service atau mTLS.
• Message antar service tetap harus divalidasi dengan DTO.

Di episode 15 selanjutnya kita akan membahas GraphQL dan API integration — dasar GraphQL dengan @nestjs/graphql, pendekatan schema-first dan code-first, resolver, input types, subscriptions, serta optimasi performa GraphQL.