Kurs NestJS · Moduł 8: Cache i wydajność

PROJEKT - system optymalizacji wydajności

5 min czytania ·
W tej lekcji6

Ten moduł pokazał kilka narzędzi: cache w pamięci procesu i w Redisie, indeksy w bazie, kompresję odpowiedzi, ograniczanie liczby żądań. Projekt jest miejscem, w którym trzeba zdecydować, którego użyć - a to zupełnie inna umiejętność niż znajomość składni.

Zbudujesz API zarządzania legionem, które radzi sobie z ruchem większym, niż wytrzymałaby wersja naiwna, i potrafi pokazać, dlaczego sobie radzi.

Jedna zasada przed wszystkimi innymi

Optymalizacja bez pomiaru to zgadywanie. Brzmi banalnie, a jest najczęściej łamaną regułą w tej dziedzinie: dodaje się cache tam, gdzie akurat przyszło do głowy, i odnotowuje poprawę, której nikt nie zmierzył.

Porządek pracy jest zawsze ten sam:

  1. Zmierz - ile trwa żądanie, ile zajmuje pamięć, ile zapytań idzie do bazy.
  2. Znajdź wąskie gardło - jedno, to najkosztowniejsze.
  3. Zastosuj najtańszą poprawkę, która je usuwa.
  4. Zmierz ponownie - i sprawdź, czy poprawka zadziałała, a nie tylko przesunęła problem.

Dlatego projekt zaczyna się od pomiaru, nie od cache'a.

Krok 1 - endpoint z metrykami

Pierwszą rzeczą, jaką wystawisz, jest podgląd stanu procesu:

@Controller('metrics')
export class MetricsController {
  @Get()
  getMetrics() {
    const memory = process.memoryUsage();

    return {
      heapUsed: memory.heapUsed,
      heapTotal: memory.heapTotal,
      rss: memory.rss,
      uptime: process.uptime(),
    };
  }
}

process.memoryUsage() zwraca kilka liczb i warto wiedzieć, czym się różnią. heapUsed to pamięć faktycznie zajęta przez obiekty twojej aplikacji - ta rośnie, gdy trzymasz w cache'u za dużo. heapTotal to pamięć, którą silnik V8 zarezerwował na stertę; jest zawsze większa i zmienia się skokowo. rss (Resident Set Size) to całość pamięci procesu widziana przez system operacyjny - sterta, stos, kod i bufory razem.

Najważniejsza jest różnica między heapUsed a rss. Gdy rośnie sam heapUsed, gromadzisz obiekty - zwykle w jakimś cache'u bez limitu. Gdy rośnie rss, a heapUsed stoi, wyciek jest poza stertą: bufory, otwarte połączenia, biblioteki natywne.

process.uptime() podaje, ile sekund działa proces. Sam w sobie mało mówi, ale w zestawieniu z resztą owszem: zużycie pamięci rosnące liniowo z czasem działania to wyciek, a nie obciążenie.

Krok 2 - cache w Redisie

Cache w pamięci procesu, który poznałeś wcześniej, ma jedną wadę: każda instancja aplikacji ma własny. Przy dwóch instancjach ten sam odczyt trafia do bazy dwa razy, a unieważnienie w jednej nie dociera do drugiej. Redis to naprawia:

CacheModule.register({
  store: redisStore,
  host: 'localhost',
  port: 6379,
  ttl: 300000 })

Kolejność zapisu jest stała: CacheModule.register({ otwiera konfigurację, store: redisStore, podmienia magazyn z pamięci procesu na Redisa, host: 'localhost', i port: 6379, wskazują, gdzie ten Redis stoi, a ttl: 300000 }) ustala domyślny czas życia wpisu i domyka.

Kluczowy jest store. Bez niego CacheModule działa dalej, tylko w pamięci procesu - i to jest podstępne, bo lokalnie wszystko wygląda dobrze, a problem pojawia się dopiero po uruchomieniu drugiej instancji na produkcji.

Zwróć uwagę, że host i port stoją tu bezpośrednio w obiekcie konfiguracji. W nowszych wersjach cache-manager zagnieżdża się je w osobnym polu połączenia - sprawdź wersję w swoim package.json, zanim skopiujesz cudzy przykład.

Krok 3 - baza danych

Cache przyspiesza powtarzalne odczyty. Zapytania, których nie da się zbuforować, trzeba naprawić u źródła:

@Entity('legionaries')
@Index(['cohortId', 'isActive'])
export class Legionary {
  @Column()
  cohortId: number;

  @Column({ default: true })
  isActive: boolean;
}

// w repozytorium
findActiveByCohort(cohortId: number) {
  return this.repo.find({
    where: { cohortId, isActive: true },
    select: ['id', 'name', 'rank'],
    take: 50,
  });
}

Trzy poprawki naraz, każda o innym działaniu. Indeks złożony na kolumnach, po których naprawdę filtrujesz, zamienia przegląd całej tabeli w skok do konkretnych wierszy. select pobiera tylko potrzebne kolumny - bez niego ściągasz z bazy pola, których nikt nie użyje, wraz z całą ich objętością. take ogranicza liczbę wierszy; endpoint bez limitu działa świetnie do dnia, w którym ktoś ma ich sto tysięcy.

Zanim dodasz indeks, sprawdź plan zapytania przez EXPLAIN. Indeks na kolumnie, po której nikt nie filtruje, nie przyspiesza odczytu, a spowalnia każdy zapis.

Krok 4 - warstwa wyjściowa

Na koniec dwie rzeczy działające na brzegu aplikacji:

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.use(compression());

  await app.listen(3000);
}

compression() pakuje odpowiedzi gzipem - przy listach w formacie JSON to zwykle kilkukrotne zmniejszenie transferu, kosztem odrobiny procesora. Rate limiting z ThrottlerModule działa z drugiej strony: nie przyspiesza obsługi, tylko ogranicza liczbę żądań, które w ogóle przyjmujesz.

Te dwa mechanizmy warto rozumieć jako parę przeciwieństw. Kompresja i cache sprawiają, że jedno żądanie kosztuje mniej. Ograniczanie liczby żądań sprawia, że żądań jest mniej. Gdy system się dławi, zawsze masz do wyboru te dwie drogi - i zwykle potrzebujesz obu.

Co oddajesz

Projekt jest gotowy, gdy zawiera:

  1. Endpoint /metrics z heapUsed, heapTotal, rss i uptime.
  2. Cache w Redisie przez CacheModule.register ze store: redisStore, z unieważnianiem przy zapisie.
  3. Indeksy na kolumnach filtrowanych oraz select i take w zapytaniach listujących.
  4. Kompresję odpowiedzi i ograniczanie liczby żądań na endpointach zapisu.
  5. Pomiar przed i po - liczby dla co najmniej jednego endpointu, z opisem, co się zmieniło.

Piąty punkt jest najważniejszy i najczęściej pomijany. Bez niego oddajesz zbiór technik, a nie optymalizację - bo optymalizacja to różnica między dwoma pomiarami a nie lista zastosowanych narzędzi.

Prześlij link do repozytorium, gdy skończysz.

Kod do tej lekcji: src/performance-project.ts
// PROJEKT: System Optymalizacji Wydajnosci Legionu
import { Injectable, Inject, Module, Logger } from '@nestjs/common';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';

// === KOMPLETNY SYSTEM WYDAJNOSCI ===

// 1. Cache Service z metrykami
@Injectable()
export class LegionCacheService {
  private hits = 0;
  private misses = 0;

  constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}

  async getOrFetch<T>(
    key: string,
    fetcher: () => Promise<T>,
    ttl = 300
  ): Promise<T> {
    const cached = await this.cache.get<T>(key);
    if (cached) {
      this.hits++;
      return cached;
    }
    this.misses++;
    const data = await fetcher();
    await this.cache.set(key, data, ttl * 1000);
    return data;
  }

  getCacheStats() {
    const total = this.hits + this.misses;
    return {
      hits: this.hits,
      misses: this.misses,
      hitRate: total > 0
        ? `${((this.hits / total) * 100).toFixed(1)}%`
        : 'N/A',
    };
  }
}

// 2. Performance Monitor
@Injectable()
export class PerformanceMonitor {
  private readonly logger = new Logger('PerformanceMonitor');
  private requestTimes: number[] = [];

  recordRequest(durationMs: number) {
    this.requestTimes.push(durationMs);
    if (this.requestTimes.length > 1000) {
      this.requestTimes = this.requestTimes.slice(-1000);
    }
  }

  getMetrics() {
    if (this.requestTimes.length === 0) {
      return { avg: 0, p95: 0, p99: 0, max: 0 };
    }

    const sorted = [...this.requestTimes].sort((a, b) => a - b);
    const len = sorted.length;

    return {
      avg: Math.round(
        sorted.reduce((a, b) => a + b, 0) / len
      ),
      p95: sorted[Math.floor(len * 0.95)],
      p99: sorted[Math.floor(len * 0.99)],
      max: sorted[len - 1],
      totalRequests: len,
    };
  }

  getSystemMetrics() {
    const mem = process.memoryUsage();
    return {
      uptime: Math.round(process.uptime()),
      memory: {
        heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
        heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
        rss: Math.round(mem.rss / 1024 / 1024),
      },
      cpu: process.cpuUsage(),
      pid: process.pid,
    };
  }
}

// 3. Health Check agregujacy wszystkie metryki
@Injectable()
export class LegionHealthService {
  constructor(
    private cacheService: LegionCacheService,
    private perfMonitor: PerformanceMonitor,
  ) {}

  getHealthReport() {
    const perf = this.perfMonitor.getMetrics();
    const system = this.perfMonitor.getSystemMetrics();
    const cache = this.cacheService.getCacheStats();

    return {
      status: perf.p95 < 500 ? 'healthy' : 'degraded',
      performance: perf,
      system,
      cache,
      timestamp: new Date().toISOString(),
    };
  }
}

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz endpoint /metrics zwracający heapUsed, heapTotal, rss i uptime

  • Układanie w pionie

    Ułóż poprawną konfigurację CacheModule z Redis store:

  1. Zadanie z kodemPraktyka: Monitoring pamięci
  2. Ułóż w kolejnościKonfiguracja CacheModule z Redis

Przydatne artykuły