Kurs NestJS · Moduł 8: Cache i wydajność
Load Balancing - rozłożenie obciążenia legionu
W tej lekcji5
Dowódco legionów! Konsul Caesar.js zauważył, że jeden fort wykonuje całą pracę, podczas gdy inne stoją bezczynnie w garnizonie. Gdy nadchodzi fala meldunków, ten jeden fort pada, a razem z nim cała aplikacja. Czas nauczyć się load balancingu - sztuki rozkładania obciążenia między wszystkie oddziały armii.
Czym jest load balancing w świecie legionariuszy?
Wyobraź sobie armię rzymskich legionów:
- jeden fort obsługuje wszystkich klientów = przeciążenie,
- oddziały stoją bezczynnie = marnotrawstwo zasobów,
- nierównomierne obciążenie = niektóre forty padają pod ciężarem zadań,
- brak redundancji = gdy główny fort upadnie, cała armia staje.
Load balancer to mądry legat, który rozdziela zadania między forty. W praktyce tę rolę pełni zwykle gotowy serwer przed aplikacją, jak Nginx, HAProxy albo balancer chmury, który często przejmuje też HTTPS i kompresję odpowiedzi. Gdy nikt przed aplikacją nie kompresuje, w NestJS robi to middleware app.use(compression()), zmniejszając rozmiar wysyłanych odpowiedzi HTTP - wrócimy do niego w lekcji o optymalizacji odpowiedzi. Poniżej budujemy balancer w samym NestJS, żeby zobaczyć, jak działają algorytmy.
Strona instancji: endpoint /health
Balancer musi wiedzieć, które forty żyją. Każda instancja wystawia więc prosty endpoint zdrowia:
// health.controller.ts - na każdej instancji
import { Controller, Get } from '@nestjs/common';
@Controller('health')
export class HealthController {
@Get()
check() {
const memory = process.memoryUsage();
return {
status: 'ok',
uptime: Math.round(process.uptime()),
heapUsedMB: Math.round(memory.heapUsed / 1024 / 1024),
rssMB: Math.round(memory.rss / 1024 / 1024),
};
}
}process.uptime() podaje sekundy od startu procesu, a process.memoryUsage() zużycie pamięci. Czas odpowiedzi mierzy sam balancer: jeśli /health odpowiada wolno albo wcale, fort wypada z rotacji.
Application Load Balancing
Serwis balancera trzyma listę serwerów opisanych interfejsem ServerInstance: adres, waga, bieżące obciążenie i stan zdrowia:
// load-balancer.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { Cron } from '@nestjs/schedule';
interface ServerInstance {
id: string;
host: string;
port: number;
weight: number;
currentLoad: number;
isHealthy: boolean;
lastHealthCheck: Date;
}
@Injectable()
export class LoadBalancerService implements OnModuleInit {
private servers: ServerInstance[] = [];
private currentIndex = 0;
constructor(private configService: ConfigService) {
this.initializeServers();
}
async onModuleInit() {
await this.startHealthChecks(); // pierwszy przegląd od razu po starcie
}
private initializeServers(): void {
// LEGION_SERVERS to JSON z listą serwerów, np. [{"host":"...","port":3000,"weight":10}]
const fromEnv = this.configService.get<string>('LEGION_SERVERS');
const serverConfigs = fromEnv ? JSON.parse(fromEnv) : [
{ host: 'cohort-1.legion.local', port: 3000, weight: 10 },
{ host: 'cohort-2.legion.local', port: 3000, weight: 15 },
{ host: 'cohort-3.legion.local', port: 3000, weight: 8 },
];
this.servers = serverConfigs.map((config, index) => ({
id: `cohort-${index + 1}`,
...config,
currentLoad: 0,
isHealthy: true,
lastHealthCheck: new Date(),
}));
}Listę czytamy ze zmiennej LEGION_SERVERS, a zmienne środowiskowe są tekstem, więc najpierw JSON.parse(). Pierwszy przegląd zdrowia rusza w onModuleInit(); pierwotna wersja odpalała go w konstruktorze, który nie może na nic czekać.
Dwa najprostsze algorytmy wyboru:
// Round Robin - kolejno każdy fort
getNextServerRoundRobin(): ServerInstance | null {
const healthyServers = this.servers.filter(s => s.isHealthy);
if (healthyServers.length === 0) return null;
const server = healthyServers[this.currentIndex % healthyServers.length];
this.currentIndex++;
console.log(`Wybrano fort: ${server.id} (Round Robin)`);
return server;
}
// Weighted random - losowanie z wagami: silniejsza kohorta częściej
getNextServerWeighted(): ServerInstance | null {
const healthyServers = this.servers.filter(s => s.isHealthy);
if (healthyServers.length === 0) return null;
const totalWeight = healthyServers.reduce((sum, s) => sum + s.weight, 0);
let randomWeight = Math.random() * totalWeight;
for (const server of healthyServers) {
randomWeight -= server.weight;
if (randomWeight <= 0) {
console.log(`Wybrano fort: ${server.id} (Weighted)`);
return server;
}
}
return healthyServers[0];
}Round Robin bierze forty po kolei. Druga metoda to losowanie z wagami, a nie „Weighted Round Robin”, jak twierdził stary komentarz: w teście na 2500 losowań wagi 10 i 15 dały 986 i 1514 wyborów.
Dwa kolejne patrzą na obciążenie:
// Least Connections - najmniej obciążony fort
getNextServerLeastConnections(): ServerInstance | null {
const healthyServers = this.servers.filter(s => s.isHealthy);
if (healthyServers.length === 0) return null;
const leastLoaded = healthyServers.reduce((min, server) =>
server.currentLoad < min.currentLoad ? server : min
);
console.log(`Wybrano fort: ${leastLoaded.id} (Least Connections: ${leastLoaded.currentLoad})`);
return leastLoaded;
}
// Resource-based - na podstawie zasobów systemowych
async getNextServerResourceBased(): Promise<ServerInstance | null> {
const healthyServers = this.servers.filter(s => s.isHealthy);
if (healthyServers.length === 0) return null;
// Pobierz metryki zasobów dla każdej kohorty
const serversWithMetrics = await Promise.all(
healthyServers.map(async (server) => {
const metrics = await this.getServerMetrics(server);
return {
...server,
cpuUsage: metrics.cpu,
memoryUsage: metrics.memory,
responseTime: metrics.avgResponseTime,
score: this.calculateServerScore(metrics),
};
})
);
// Wybierz fort z najniższym score (najmniej obciążony)
const bestServer = serversWithMetrics.reduce((best, server) =>
server.score < best.score ? server : best
);
console.log(`Wybrano fort: ${bestServer.id} (Resource-based, score: ${bestServer.score})`);
return bestServer;
}Least Connections wybiera fort z najmniejszą liczbą trwających żądań. Wariant zasobowy pyta każdy serwer o metryki przy każdym żądaniu, co kosztuje - w produkcji metryki odświeża się w tle i trzyma w pamięci.
Punktacja, liczniki i pobieranie metryk:
private calculateServerScore(metrics: any): number {
// Prosta formuła: wyższa wartość = gorszy serwer
return (
metrics.cpu * 0.4 + // 40% wagi dla CPU
metrics.memory * 0.3 + // 30% wagi dla pamięci
metrics.avgResponseTime * 0.2 + // 20% wagi dla czasu odpowiedzi
metrics.activeConnections * 0.1 // 10% wagi dla połączeń
);
}
async incrementLoad(serverId: string): Promise<void> {
const server = this.servers.find(s => s.id === serverId);
if (server) {
server.currentLoad++;
}
}
async decrementLoad(serverId: string): Promise<void> {
const server = this.servers.find(s => s.id === serverId);
if (server && server.currentLoad > 0) {
server.currentLoad--;
}
}
private async getServerMetrics(server: ServerInstance): Promise<any> {
try {
// HTTP call do endpointu z metrykami, najwyżej 2 sekundy
const response = await fetch(`http://${server.host}:${server.port}/health/metrics`, {
signal: AbortSignal.timeout(2000),
});
return await response.json();
} catch (error) {
// Brak odpowiedzi = najgorsze możliwe metryki, fort wybierzemy na końcu
return {
cpu: 100,
memory: 100,
avgResponseTime: 10000,
activeConnections: 1000,
};
}
}Wynik miesza procenty z milisekundami, więc czas odpowiedzi łatwo zdominuje resztę - przed ważeniem warto sprowadzić metryki do wspólnej skali. Przy braku odpowiedzi zwracamy najgorsze możliwe metryki; pierwsza wersja losowała je, więc martwy fort mógł wygrać. AbortSignal.timeout(2000) przerywa zbyt długie wywołanie, bo natywny fetch z Node.js nie zna opcji timeout.
Przegląd zdrowia powtarza się co 30 sekund:
@Cron('*/30 * * * * *') // Co 30 sekund
private async startHealthChecks(): Promise<void> {
for (const server of this.servers) {
try {
const response = await fetch(`http://${server.host}:${server.port}/health`, {
signal: AbortSignal.timeout(5000),
});
server.isHealthy = response.ok;
server.lastHealthCheck = new Date();
if (!server.isHealthy) {
console.warn(`Kohorta ${server.id} nie odpowiada!`);
}
} catch (error) {
server.isHealthy = false;
server.lastHealthCheck = new Date();
console.error(`Kohorta ${server.id} nieosiągalna:`, error.message);
}
}
}
getLegionStatus() {
return {
totalServers: this.servers.length,
healthyServers: this.servers.filter(s => s.isHealthy).length,
totalLoad: this.servers.reduce((sum, s) => sum + s.currentLoad, 0),
servers: this.servers.map(s => ({
id: s.id,
host: s.host,
isHealthy: s.isHealthy,
currentLoad: s.currentLoad,
weight: s.weight,
lastHealthCheck: s.lastHealthCheck,
})),
};
}
}Dekorator @Cron pochodzi z @nestjs/schedule i działa dopiero po zaimportowaniu ScheduleModule.forRoot(). Wzorzec ma sześć pól, pierwsze to sekundy, więc */30 * * * * * znaczy co 30 sekund.
Proxy Load Balancer Implementation
Kontroler przyjmuje każde żądanie pod /api/proxy i przekazuje je do wybranego fortu przez http-proxy-middleware:
// proxy-load-balancer.controller.ts
import { All, Controller, Req, Res } from '@nestjs/common';
import type { Request, Response } from 'express';
import { createProxyMiddleware, fixRequestBody } from 'http-proxy-middleware';
import { LoadBalancerService } from './load-balancer.service';
@Controller('/api/proxy')
export class ProxyLoadBalancerController {
constructor(private loadBalancer: LoadBalancerService) {}
@All('*path')
async proxyRequest(@Req() req: Request, @Res() res: Response): Promise<void> {
// Wybierz serwer za pomocą load balancera
const targetServer = await this.loadBalancer.getNextServerResourceBased();
if (!targetServer) {
res.status(503).json({
error: 'Wszystkie kohorty legionu są niedostępne!',
code: 'LEGION_UNAVAILABLE'
});
return;
}
// Zwiększ licznik obciążenia
await this.loadBalancer.incrementLoad(targetServer.id);
// Utwórz proxy do wybranego serwera
const proxy = createProxyMiddleware<Request, Response>({
target: `http://${targetServer.host}:${targetServer.port}`,
changeOrigin: true,
pathRewrite: {
'^/api/proxy': '', // Usuń prefix
},
on: {
proxyReq: (proxyReq, req) => {
// Dodaj informacje o load balancerze
proxyReq.setHeader('X-Proxy-Server', targetServer.id);
proxyReq.setHeader('X-Load-Balancer', 'legionariusze-legion-lb');
console.log(`Przekierowanie ${req.method} ${req.url} do ${targetServer.id}`);
// NestJS przeczytał już body - odtwórz je na końcu, po nagłówkach
fixRequestBody(proxyReq, req);
},
proxyRes: async (proxyRes) => {
// Zmniejsz licznik obciążenia po zakończeniu
await this.loadBalancer.decrementLoad(targetServer.id);
console.log(`Odpowiedź z ${targetServer.id}: ${proxyRes.statusCode}`);
},
error: async (err) => {
await this.loadBalancer.decrementLoad(targetServer.id);
console.error(`Błąd proxy do ${targetServer.id}:`, err.message);
if (!res.headersSent) {
res.status(502).json({
error: 'Błąd komunikacji z fortem',
server: targetServer.id,
details: err.message
});
}
},
},
});
proxy(req, res);
}
}Kod jest dostosowany do http-proxy-middleware 4: zdarzenia podaje się w obiekcie on, a stare opcje onProxyReq i spółka już nie działają. fixRequestBody jest konieczne, bo NestJS przeczytał już ciało żądania - bez niego POST w teście wisiał bez odpowiedzi. Woła się je na końcu, bo zapisuje ciało, a po nim nagłówków ustawić nie można. '*path' to nazwany wildcard wymagany od Express 5, a typy Express importujemy przez import type, czego TypeScript wymaga przy włączonych isolatedModules i emitDecoratorMetadata.
Tworzenie nowego proxy przy każdym żądaniu jest rozrzutne; opcja router pozwala jednemu proxy wybierać cel dla każdego żądania.
Circuit Breaker Pattern
Każdy serwer dostaje własny bezpiecznik, trzymany w mapie:
// circuit-breaker.service.ts
@Injectable()
export class CircuitBreakerService {
private breakers = new Map<string, CircuitBreaker>();
getOrCreateBreaker(serverId: string): CircuitBreaker {
if (!this.breakers.has(serverId)) {
this.breakers.set(serverId, new CircuitBreaker({
serverId,
failureThreshold: 5, // 5 błędów
recoveryTimeout: 30000, // 30 sekund
monitoringPeriod: 10000, // 10 sekund
}));
}
return this.breakers.get(serverId)!;
}
async executeWithBreaker<T>(
serverId: string,
operation: () => Promise<T>
): Promise<T> {
const breaker = this.getOrCreateBreaker(serverId);
return await breaker.execute(operation);
}
getBreakerStatus(serverId: string) {
const breaker = this.breakers.get(serverId);
return breaker ? breaker.getStatus() : null;
}
getAllBreakersStatus() {
const status = {};
this.breakers.forEach((breaker, serverId) => {
status[serverId] = breaker.getStatus();
});
return status;
}
}getOrCreateBreaker() zakłada bezpiecznik przy pierwszym użyciu, a executeWithBreaker() przepuszcza przez niego operację, więc awaria jednego fortu nie odcina pozostałych. Sam bezpiecznik liczy błędy danego serwera:
class CircuitBreaker {
private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
private failures = 0;
private lastFailureTime?: Date;
private successCount = 0;
constructor(private config: {
serverId: string;
failureThreshold: number;
recoveryTimeout: number;
monitoringPeriod: number;
}) {}
async execute<T>(operation: () => Promise<T>): Promise<T> {
if (this.state === 'OPEN') {
if (this.shouldAttemptReset()) {
this.state = 'HALF_OPEN';
console.log(`Circuit breaker dla ${this.config.serverId}: próba resetu`);
} else {
throw new Error(`Circuit breaker OPEN dla serwera ${this.config.serverId}`);
}
}
try {
const result = await operation();
this.onSuccess();
return result;
} catch (error) {
this.onFailure();
throw error;
}
}
private onSuccess(): void {
this.failures = 0;
this.successCount++;
if (this.state === 'HALF_OPEN') {
this.state = 'CLOSED';
console.log(`Circuit breaker dla ${this.config.serverId}: przywrócony`);
}
}
private onFailure(): void {
this.failures++;
this.lastFailureTime = new Date();
if (this.failures >= this.config.failureThreshold) {
this.state = 'OPEN';
console.log(`Circuit breaker dla ${this.config.serverId}: OTWORZONY`);
}
}
private shouldAttemptReset(): boolean {
if (!this.lastFailureTime) return false;
const timeSinceLastFailure = Date.now() - this.lastFailureTime.getTime();
return timeSinceLastFailure >= this.config.recoveryTimeout;
}
getStatus() {
return {
serverId: this.config.serverId,
state: this.state,
failures: this.failures,
successCount: this.successCount,
lastFailureTime: this.lastFailureTime,
};
}
}Po pięciu błędach z rzędu obwód się otwiera, a sukces zeruje licznik. monitoringPeriod czeka na okno czasowe, którego ta wersja jeszcze nie liczy.
Polecam Ci podział ról: ruchem niech steruje Nginx albo balancer chmury, a aplikacja niech uczciwie odpowiada na /health. W następnej lekcji zajrzymy do magazynów pamięci.
Pamiętaj: dobry legat nie wysyła wszystkich meldunków do jednego fortu - rozkłada je według sił i omija forty, które milczą.
Kod do tej lekcji: src/load-balancing.ts
// Load Balancing - Rozlozenie Obciazenia Legionu
// 1. Nginx jako load balancer (konfiguracja)
const nginxConfig = `
upstream roman_legion {
# Round Robin (domyslny) - po kolei
server app1:3000;
server app2:3000;
server app3:3000;
# Least Connections - do najmniej obciazzonego
# least_conn;
# IP Hash - ten sam klient -> ten sam serwer
# ip_hash;
# Weighted - serwery o roznej mocy
# server app1:3000 weight=3;
# server app2:3000 weight=2;
# server app3:3000 weight=1;
}
server {
listen 80;
server_name roman-empire.com;
location / {
proxy_pass http://roman_legion;
proxy_set_header Host \$host;
proxy_set_header X-Real-IP \$remote_addr;
}
}
`;
// 2. PM2 - cluster mode w Node.js
const pm2Config = {
apps: [{
name: 'roman-empire-api',
script: 'dist/main.js',
instances: 'max', // Uzyj wszystkich CPU
exec_mode: 'cluster',
env_production: {
NODE_ENV: 'production',
PORT: 3000,
},
}],
};
// 3. Kubernetes Horizontal Pod Autoscaler
const hpaYaml = `
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: roman-api-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: roman-api
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
`;
// 4. Health Check dla Load Balancera
import { Controller, Get } from '@nestjs/common';
@Controller('health')
export class HealthController {
@Get()
check() {
return {
status: 'healthy',
uptime: process.uptime(),
pid: process.pid,
memory: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
};
}
@Get('ready')
ready() {
return { status: 'ready' };
}
}
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. Moduł compression w NestJS (app.use(compression())) powoduje:
Zadania praktyczne w grze
- Edytor kodu
Stwórz /health endpoint z informacją o uptime, memory i response time