Kurs NestJS · Moduł 8: Cache i wydajność
Performance Optimization - zwiększanie prędkości kohorty
W tej lekcji6
Wieczorem, gdy kohorty zdają raporty, fort zwalnia: odpowiedź, która rano trwa 80 ms, po zmroku ciągnie się sekundami. Konsul Caesar.js chce przyspieszenia, ale nikt nie wie, co spowalnia - baza, procesor czy pamięć. Pierwsza zasada inżyniera legionowego brzmi więc: najpierw zmierz, potem optymalizuj.
Czym jest optymalizacja wydajności?
Wyobraź sobie aplikację jako obóz legionu:
- siła legionistów (CPU) - musi wystarczyć na wszystkie zadania,
- magazyny (pamięć) - muszą być dobrze zarządzane,
- tabularium (baza danych) - musi być uporządkowane,
- kohorty (procesy) - muszą sprawnie współpracować,
- drogi i posłańcy (operacje I/O) - muszą być przejezdne.
Optymalizacja to sztuka harmonijnego dostrojenia wszystkich tych elementów.
Cztery sygnały
Zanim cokolwiek zmienisz, ustal, co mierzysz. Książka Google o SRE wymienia cztery złote sygnały, w tej kolejności:
- latencja - czas odpowiedzi, podawany jako percentyle p95 i p99,
- ruch - przepustowość, na przykład żądania na sekundę,
- błędy - odsetek nieudanych żądań,
- nasycenie - zużycie zasobów, czyli CPU i pamięci.
p95 równe 200 ms znaczy, że 95% żądań kończy się szybciej niż w 200 ms. Średnia ukrywa pechowców z ogona: użytkownik czekający 10 sekund ginie w niej wśród tysiąca szybkich odpowiedzi.
Cztery próby obciążenia
Sygnały odczytujesz podczas testów obciążeniowych, od najlżejszego do najcięższego:
- smoke test - minimalne obciążenie, sprawdza, czy system w ogóle działa,
- load test - oczekiwany, typowy ruch,
- stress test - obciążenie powyżej oczekiwanego, szukające punktu krytycznego,
- spike test - nagły, krótki i ogromny skok ruchu.
Tak dzieli je dokumentacja narzędzia k6; samo strzelanie żądaniami poznasz w lekcji o profilowaniu.
Profiling - diagnoza problemów
Wewnątrz aplikacji czas mierzy moduł perf_hooks z Node.js: performance.mark() stawia znacznik na osi czasu, performance.measure() liczy odstęp między dwoma znacznikami, a PerformanceObserver dostaje każdy nowy pomiar. Na tym zbudujemy serwis profilujący:
// performance-profiler.service.ts
import { Injectable } from '@nestjs/common';
import { performance, PerformanceObserver } from 'node:perf_hooks';
@Injectable()
export class PerformanceProfilerService {
private measurements = new Map<string, number[]>();
private observer: PerformanceObserver;
constructor() {
this.setupPerformanceObserver();
}
private setupPerformanceObserver(): void {
this.observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
if (entry.entryType === 'measure') {
this.recordMeasurement(entry.name, entry.duration);
}
});
});
this.observer.observe({ entryTypes: ['measure'] });
}
private recordMeasurement(name: string, duration: number): void {
if (!this.measurements.has(name)) {
this.measurements.set(name, []);
}
const measurements = this.measurements.get(name)!;
measurements.push(duration);
// Zachowaj tylko ostatnie 100 pomiarów
if (measurements.length > 100) {
measurements.shift();
}
// Loguj wolne operacje
if (duration > 1000) {
console.warn(`Wolna operacja: ${name} - ${duration.toFixed(2)}ms`);
}
}Obserwator przekazuje pomiary do recordMeasurement(), który trzyma ostatnie 100 wyników każdej operacji i ostrzega o dłuższych niż sekunda.
Najwygodniej mierzy się dekoratorem - statyczną metodą, która owija oryginalną metodę pomiarem:
// Dekorator do mierzenia czasu wykonania
static Measure(operationName?: string) {
return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
const measureName = operationName || `${target.constructor.name}.${propertyName}`;
let callId = 0;
descriptor.value = async function (...args: any[]) {
const id = ++callId; // osobne znaczniki dla równoległych wywołań
const startMark = `${measureName}-start-${id}`;
const endMark = `${measureName}-end-${id}`;
performance.mark(startMark);
try {
const result = await originalMethod.apply(this, args);
performance.mark(endMark);
performance.measure(measureName, startMark, endMark);
return result;
} catch (error) {
performance.mark(endMark);
performance.measure(`${measureName}-error`, startMark, endMark);
throw error;
} finally {
// Znaczniki zostają w globalnej osi czasu, dopóki ich nie usuniemy
performance.clearMarks(startMark);
performance.clearMarks(endMark);
performance.clearMeasures(measureName);
performance.clearMeasures(`${measureName}-error`);
}
};
};
}Pierwsza wersja budowała nazwy znaczników z Date.now(), więc dwa wywołania w tej samej milisekundzie nadpisywały sobie znaczniki; licznik callId to naprawia. Blok finally sprząta, bo znaczniki bez clearMarks() rosłyby w serwerze działającym tygodniami jak wyciek pamięci. Obserwator dostał już pomiar, więc nic nie tracimy.
Pomiar ręczny przydaje się, gdy mierzysz tylko fragment metody:
startMeasurement(name: string): void {
performance.mark(`${name}-start`);
}
endMeasurement(name: string): number {
const endMark = `${name}-end`;
performance.mark(endMark);
// measure() zwraca świeży pomiar - nie szukamy go w historii
const measurement = performance.measure(name, `${name}-start`, endMark);
performance.clearMarks(`${name}-start`);
performance.clearMarks(endMark);
performance.clearMeasures(name);
return measurement.duration;
}Wcześniej serwis szukał pomiaru przez getEntriesByName(name)[0], a to zwraca najstarszy pomiar o tej nazwie - od drugiego wywołania wynik był w kółko ten sam.
Z zebranych liczb robimy statystyki:
getStatistics(operationName: string) {
const measurements = this.measurements.get(operationName) || [];
if (measurements.length === 0) return null;
const sorted = [...measurements].sort((a, b) => a - b);
const avg = measurements.reduce((a, b) => a + b, 0) / measurements.length;
return {
count: measurements.length,
average: avg.toFixed(2),
median: sorted[Math.floor(sorted.length / 2)].toFixed(2),
min: sorted[0].toFixed(2),
max: sorted[sorted.length - 1].toFixed(2),
p95: sorted[Math.ceil(sorted.length * 0.95) - 1].toFixed(2),
};
}
getAllStatistics() {
const stats = {};
this.measurements.forEach((_, name) => {
stats[name] = this.getStatistics(name);
});
return stats;
}
}p95 liczymy metodą najbliższej rangi: przy 100 pomiarach to 95. wynik po posortowaniu.
W serwisie dekorator stoi nad metodą, a pomiar ręczny otacza wybrany fragment:
// Użycie w serwisie
@Injectable()
export class TributeService {
constructor(private profiler: PerformanceProfilerService) {}
@PerformanceProfilerService.Measure('tribute-search')
async findTributes(criteria: any) {
// Złożone wyszukiwanie tributów
await this.complexDatabaseQuery(criteria);
return [];
}
async manualMeasurement() {
this.profiler.startMeasurement('manual-operation');
// Jakaś operacja
await this.doSomething();
const duration = this.profiler.endMeasurement('manual-operation');
console.log(`Operacja zajęła: ${duration}ms`);
}
private async complexDatabaseQuery(criteria: any) {
await new Promise((r) => setTimeout(r, 20)); // zaślepka zapytania
}
private async doSomething() {
await new Promise((r) => setTimeout(r, 30)); // zaślepka pracy
}
}Dekorator nie zmienia treści findTributes - metoda dalej tylko wyszukuje, a pomiar dzieje się obok.
Database Query Optimization
Najczęstszym winowajcą jest baza. Klasyczny problem N+1 wygląda niewinnie:
// query-optimizer.service.ts
@Injectable()
export class QueryOptimizerService {
constructor(
@InjectRepository(Tribute) private tributeRepo: Repository<Tribute>,
) {}
// Zamiast N+1 queries
async getBadTributesWithOwners(): Promise<any[]> {
const tributes = await this.tributeRepo.find();
// To generuje N zapytań dodatkowych!
const tributesWithOwners = [];
for (const tribute of tributes) {
const owner = await this.getOwner(tribute.ownerId);
tributesWithOwners.push({ ...tribute, owner });
}
return tributesWithOwners;
}Jedno zapytanie po listę i po jednym na każdego właściciela: w teście na PostgreSQL 120 tributów kosztowało 121 zapytań.
Rozwiązaniem jest JOIN, który TypeORM zbuduje z opcji relations:
// Optymalna wersja z JOIN
async getOptimizedTributesWithOwners(): Promise<any[]> {
// Jedno zapytanie z JOIN
return await this.tributeRepo.find({
relations: { owner: true },
select: {
id: true,
name: true,
value: true,
owner: {
id: true,
name: true,
rank: true,
},
},
});
}Ten sam wynik przyszedł jednym zapytaniem, a select pobrał tylko potrzebne kolumny. TypeORM 1.x usunął tablicową składnię relations: ['owner'] - obowiązuje obiekt.
Duże zbiory przetwarzamy partiami, zamiast ładować wszystko do pamięci:
// Batch processing dla dużych zbiorów
async processTributesInBatches(batchSize: number = 100): Promise<void> {
let offset = 0;
let batch;
do {
batch = await this.tributeRepo.find({
skip: offset,
take: batchSize,
order: { id: 'ASC' },
});
if (batch.length > 0) {
await this.processTributeBatch(batch);
offset += batchSize;
// Oddaj na chwilę event loop innym żądaniom
await this.delay(10);
}
} while (batch.length === batchSize);
}Pauza oddaje event loop innym żądaniom; pierwsza wersja twierdziła, że „daje czas garbage collectorowi”, ale GC działa, kiedy sam uzna za stosowne. Z każdą partią rośnie skip, a baza i tak przechodzi pominięte wiersze, więc przy milionach rekordów lepszy jest kursor:
// Paginacja z cursor dla bardzo dużych zbiorów
async getTributesWithCursor(cursor?: number, limit: number = 50) {
const qb = this.tributeRepo.createQueryBuilder('tribute');
if (cursor) {
qb.where('tribute.id > :cursor', { cursor });
}
const tributes = await qb
.orderBy('tribute.id', 'ASC')
.limit(limit + 1) // +1 żeby sprawdzić czy są kolejne
.getMany();
const hasNext = tributes.length > limit;
const items = hasNext ? tributes.slice(0, -1) : tributes;
const nextCursor = hasNext ? tributes[tributes.length - 2].id : null;
return {
items,
nextCursor,
hasNext,
};
}Kursor to id ostatniego zwróconego wiersza, a WHERE id > :cursor korzysta z indeksu klucza głównego, więc setna strona jest tak szybka jak pierwsza. Jeden dodatkowy wiersz mówi, czy istnieje następna strona, bez osobnego COUNT.
Filtry też decydują o szybkości:
// Optymalizacja z indeksami
async searchTributesOptimized(filters: any) {
const qb = this.tributeRepo.createQueryBuilder('tribute');
// Używaj indeksowanych kolumn w WHERE
if (filters.type) {
qb.andWhere('tribute.type = :type', { type: filters.type });
}
if (filters.minValue) {
qb.andWhere('tribute.value >= :minValue', { minValue: filters.minValue });
}
// Użyj indeksu na created_at
if (filters.dateRange) {
qb.andWhere('tribute.createdAt BETWEEN :start AND :end', {
start: filters.dateRange.start,
end: filters.dateRange.end,
});
}
return await qb
.orderBy('tribute.value', 'DESC') // Indeks na value
.limit(filters.limit || 100)
.getMany();
}
private async delay(ms: number): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms));
}
private async processTributeBatch(tributes: Tribute[]): Promise<void> {
// Przetwarzanie batch'a
console.log(`Przetwarzam ${tributes.length} tributów...`);
}
}Warunki na indeksowanych kolumnach pozwalają bazie od razu przeskoczyć do właściwych wierszy. limit() jest tu bezpieczny, bo zapytanie nie ma JOIN-ów; przy nich używaj take().
Warstwy szybkości
Najszybsze żądanie to takie, które w ogóle nie dotrze do fortu. Od warstwy najbliższej użytkownikowi:
- cache przeglądarki - sterowany nagłówkami
Cache-Control, - CDN, czyli edge cache - kopie treści na serwerach blisko użytkowników, co skraca drogę i latencję,
- cache aplikacji - Redis z poprzednich lekcji,
- cache zapytań po stronie bazy danych.
Polecam Ci jedną kolejność pracy: zmierz, popraw największy problem, zmierz ponownie - bez drugiego pomiaru nie wiesz, czy pomogłeś. W kolejnych lekcjach zajmiemy się indeksami, rozkładaniem ruchu i pamięcią.
Pamiętaj: szybka kohorta nie biega szybciej, tylko nie dźwiga zbędnego ciężaru - najpierw go zważ, potem zrzuć.
Kod do tej lekcji: src/performance-optimization.ts
// Performance Optimization - Zwiekszanie Predkosci Kohorty
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
// 1. Interceptor mierzacy czas odpowiedzi
@Injectable()
export class PerformanceInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
const start = Date.now();
const req = context.switchToHttp().getRequest();
return next.handle().pipe(
tap(() => {
const duration = Date.now() - start;
const method = req.method;
const url = req.url;
console.log(`[${method}] ${url} - ${duration}ms`);
if (duration > 1000) {
console.warn(`SLOW REQUEST: ${url} took ${duration}ms`);
}
}),
);
}
}
// 2. Lazy loading modulow
// @Module({
// imports: [
// LazyModuleLoader, // NestJS lazy loading
// ],
// })
// class AppModule {}
//
// // W serwisie:
// const { ProvinceModule } = await import('./province.module');
// const moduleRef = await this.lazyModuleLoader.load(
// () => ProvinceModule
// );
// const service = moduleRef.get(ProvinceService);
// 3. Pagination - nie laduj wszystkiego naraz
@Injectable()
class PaginationService {
async findPaginated<T>(
query: any,
page: number = 1,
limit: number = 20
): Promise<{
data: T[];
total: number;
page: number;
lastPage: number;
}> {
const skip = (page - 1) * limit;
// const [data, total] = await repo.findAndCount({
// skip, take: limit,
// order: { createdAt: 'DESC' },
// });
const total = 100; // symulacja
const data = [] as T[];
return {
data,
total,
page,
lastPage: Math.ceil(total / limit),
};
}
}
// 4. Connection pooling
const databaseConfig = {
type: 'postgres',
host: 'localhost',
port: 5432,
// Pool configuration
extra: {
max: 20, // Max polaczen w puli
min: 5, // Min polaczen
idle: 10000, // Timeout bezczynnosci (ms)
acquire: 30000, // Timeout uzyskania polaczenia
},
};
// 5. Kompresja odpowiedzi
// import * as compression from 'compression';
// app.use(compression());
// Zmniejsza rozmiar odpowiedzi o 60-80%!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Stress testing w kontekście wydajności oznacza:
2. Edge caching w CDN oznacza:
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj etapy testowania obciążeniowego od najlżejszego:
- Klikanie w kolejności
Ułóż kluczowe metryki wydajności w kolejności czterech złotych sygnałów Google SRE: