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

Load Balancing - rozłożenie obciążenia legionu

10 min czytania ·
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. 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

  1. PytanieOptymalizacja kompresji
  2. Zadanie z kodemPraktyka: Health check endpoint

Przydatne artykuły