Belajar NestJS - Performance Optimization

#Pendahuluan

Aplikasi yang lambat akan ditinggalkan pengguna. NestJS memberi banyak opsi optimasi — dari mengganti platform HTTP, menambahkan cache, sampai compression dan HTTP/2. Episode 16 membahas semuanya secara praktis.

Kalian akan belajar mengukur performa terlebih dahulu, lalu menerapkan optimasi yang berdampak besar.

#Fastify Adapter

#Mengapa Fastify

Fastify adalah framework HTTP yang secara signifikan lebih cepat dari Express. NestJS mendukung Fastify sebagai platform alternatif hanya dengan mengganti adapter.

#Install dan Gunakan Fastify

npm install @nestjs/platform-fastify

Bootstrap dengan Fastify

import { NestFactory } from "@nestjs/core";
import { NestFastifyApplication } from "@nestjs/platform-fastify";
import { AppModule } from "./app.module";
 
async function bootstrap(): Promise<void> {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    { rawBody: true },
  );
  await app.listen(3000, "0.0.0.0");
}
 
void bootstrap();

Dengan perubahan kecil ini, aplikasi memakai Fastify di balik layar. Karena NestJS bersifat platform-agnostic, controller dan service tidak perlu diubah sama sekali.

#Hal yang Perlu Diperhatikan

Fastify dan Express memiliki API yang sedikit berbeda. Jika kalian memakai library yang bergantung pada objek Express seperti @Res dengan tipe Express, sesuaikan import ke tipe Fastify. Untuk sebagian besar aplikasi, migrasinya mulus.

#Caching

#Cache Manager Bawaan

NestJS menyediakan CacheModule untuk caching in-memory:

Mengaktifkan CacheModule

import { Module } from "@nestjs/common";
import { CacheModule } from "@nestjs/cache-manager";
 
@Module({
  imports: [
    CacheModule.register({
      ttl: 60000,
    }),
  ],
})
export class AppModule {}

#Caching dengan Redis

Untuk cache yang dibagikan antar instance, gunakan Redis. Install driver dan register:

npm install cache-manager redis @keyv/redis

CacheModule dengan Redis

CacheModule.registerAsync({
  useFactory: async () => ({
    stores: [
      await redisStore({
        socket: { host: "localhost", port: 6379 },
      }),
    ],
  }),
})

Redis memungkinkan beberapa instance NestJS berbagi cache yang sama — penting saat aplikasi di-scale horizontal.

#Memakai Cache di Service

Menggunakan CacheManager

import { CACHE_MANAGER, Inject } from "@nestjs/common";
import { Cache } from "cache-manager";
import { Injectable } from "@nestjs/common";
 
@Injectable()
export class ProductsService {
  constructor(@Inject(CACHE_MANAGER) private readonly cache: Cache) {}
 
  async findPopular(): Promise<string[]> {
    const cached = await this.cache.get("popular-products");
    if (cached) {
      return cached as string[];
    }
 
    const products = ["Kaos", "Celana"];
    await this.cache.set("popular-products", products, 60000);
    return products;
  }
}

Cache bisa di-inject lewat token CACHE_MANAGER, dan @UseInterceptors(CacheInterceptor) memberi caching otomatis untuk resolver dan controller.

#Response Compression dan HTTP/2

#Compression

Mengompresi response mengurangi bandwidth secara drastis:

npm install @fastify/compress

Aktifkan compression di Fastify

const app = await NestFactory.create<NestFastifyApplication>(AppModule);
await app.register(import("@fastify/compress"));
await app.listen(3000);

Untuk Express, pakai compression middleware dengan app.use.

#HTTP/2

HTTP/2 memungkinkan multiplexing — banyak request dalam satu koneksi. NestJS mendukungnya saat memakai HTTPS di Fastify atau Express. Pastikan sertifikat TLS tersedia, lalu aktifkan http2 pada opsi server. Dampaknya paling terasa untuk aplikasi dengan banyak resource kecil.

#Profiling dan Benchmark

#Mengukur Sebelum Optimasi

Optimasi tanpa pengukuran adalah tebakan. Gunakan tool benchmark untuk mendapat baseline:

npx autocannon -c 100 -d 10 http://localhost:3000

Autocannon mengirim 100 koneksi selama 10 detik dan melaporkan request rate serta latensi — jalankan dengan npx autocannon -c 100 -d 10 http://localhost:3000.

#APM dan Profiling

Application Performance Monitoring (APM) memberi visibilitas end-to-end: latensi request, query database, dan penggunaan resource. Tool populer: Datadog, New Relic, dan OpenTelemetry. Untuk profiling CPU dan memori, Node.js memiliki --prof dan tool seperti Clinic.js:

node --prof dist/main.js

Hasil profiling menunjuk bottleneck nyata — misalnya query N+1 atau blok async yang lambat.

#Penutup

Episode 16 mengoptimasi aplikasi NestJS secara menyeluruh: Fastify adapter, caching memori dan Redis, compression, HTTP/2, serta profiling dengan APM dan benchmark.

Inti yang harus dibawa pulang:

• Fastify lebih cepat dari Express dan mudah diadopsi via adapter.
• CacheModule menyediakan cache in-memory dan Redis.
• Redis memungkinkan cache dibagikan antar instance.
• Compression mengurangi ukuran response secara signifikan.
• HTTP/2 memungkinkan multiplexing koneksi.
• Ukur dengan autocannon dan profile dengan APM sebelum dan sesudah optimasi.

Di episode 17 selanjutnya kita akan membahas testing dan quality assurance — unit testing dengan Jest, integration testing dengan @nestjs/testing, E2E testing dan test database setup, serta code coverage, linting, dan static analysis.