Kurs NestJS · Moduł 8: Cache i wydajność
PROJEKT - system optymalizacji wydajności
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:
- Zmierz - ile trwa żądanie, ile zajmuje pamięć, ile zapytań idzie do bazy.
- Znajdź wąskie gardło - jedno, to najkosztowniejsze.
- Zastosuj najtańszą poprawkę, która je usuwa.
- 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:
- Endpoint
/metricszheapUsed,heapTotal,rssiuptime. - Cache w Redisie przez
CacheModule.registerzestore: redisStore, z unieważnianiem przy zapisie. - Indeksy na kolumnach filtrowanych oraz
selectitakew zapytaniach listujących. - Kompresję odpowiedzi i ograniczanie liczby żądań na endpointach zapisu.
- 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: