Kurs NestJS · Moduł 9: Deployment i infrastruktura

Scaling i Microservices - budowanie sieci legionów

5 min czytania ·
W tej lekcji3

Dowódco legionów! Jeden fort z jednym procesem Node.js obsługuje całą prowincję, a gdy ruch rośnie, procesor dobija do stu procent i fort pada. Konsul Caesar.js nauczy Cię, jak z jednego rzymskiego fortu zbudować sieć prowincji. Scaling i microservices to techniki budowania aplikacji, które rosną razem z ruchem i złożonością biznesową.

Horizontal vs Vertical Scaling

Skalowanie pionowe to większa maszyna: więcej rdzeni i pamięci dla tego samego serwera. Skalowanie poziome to więcej instancji za load balancerem. Node.js wykonuje JavaScript w jednym wątku, więc żeby wykorzystać wszystkie rdzenie jednej maszyny, moduł cluster uruchamia kilka procesów, które dzielą port:

// cluster.mjs - kilka procesów Node.js na jednej maszynie
import cluster from 'node:cluster';
import { availableParallelism } from 'node:os';

const numCPUs = availableParallelism();

if (cluster.isPrimary) {
  console.log(`Primary ${process.pid} is running`);

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Restart worker
  });
} else {
  // Workers can share any TCP port
  import('./dist/main.js').then(() => {
    console.log(`Worker ${process.pid} started`);
  });
}

cluster.isPrimary zastąpiło przestarzałe od Node.js 16 isMaster, a availableParallelism() to zalecany dziś sposób liczenia rdzeni. Proces główny rozdziela połączenia między workery po kolei: w teście sześć żądań trafiło do sześciu różnych procesów. Workery nie dzielą pamięci, więc sesje i cache muszą mieszkać poza procesem, np. w Redisie - dokumentacja Node.js wprost ostrzega przed trzymaniem ich w obiektach w pamięci.

W kontenerach polecam jeden proces na kontener i skalowanie liczby replik, a nie cluster w środku - orkiestrator lepiej pilnuje restartów niż pętla fork().

Microservices Architecture

Mikroserwisy dzielą aplikację na małe, niezależnie wdrażane usługi, jak legiony z własnymi dowódcami. Mają swoją cenę: każda granica to połączenie sieciowe, które może zawieść, i osobne wdrożenie do pilnowania, więc małemu zespołowi często lepiej służy dobrze podzielony monolit. W NestJS klienta innego mikroserwisu rejestruje ClientsModule:

// app.module.ts - klienci mikroserwisów
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';

@Module({
  imports: [
    ClientsModule.register([
      { name: 'TRIBUTE_SERVICE', transport: Transport.TCP, options: { host: 'tributes', port: 4001 } },
      { name: 'LEGION_SERVICE', transport: Transport.TCP, options: { host: 'legions', port: 4002 } },
    ]),
  ],
  controllers: [UserController],
  providers: [UserService],
})
export class AppModule {}

Każdy klient ma nazwę, transport (tu TCP) i adres. Nazwa służy potem jako token wstrzykiwania:

// User microservice - brama HTTP, która pyta inne mikroserwisy
import { Controller, Get, Inject, Param } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
import { firstValueFrom } from 'rxjs';

@Controller('users')
export class UserController {
  constructor(
    private userService: UserService,
    @Inject('TRIBUTE_SERVICE') private tributeService: ClientProxy,
    @Inject('LEGION_SERVICE') private legionService: ClientProxy,
  ) {}

  @Get(':id/tributes')
  async getUserTributes(@Param('id') userId: string) {
    const user = await this.userService.findById(userId);
    const tributes = await firstValueFrom(
      this.tributeService.send('get_user_tributes', { userId }),
    );

    return { user, tributes };
  }
}

// Message patterns
export const USER_PATTERNS = {
  GET_USER: 'get_user',
  CREATE_USER: 'create_user',
  UPDATE_USER: 'update_user',
};

ClientProxy.send() wysyła wiadomość i czeka na odpowiedź, zwracając Observable, który firstValueFrom() z RxJS zamienia w Promise. Pierwsza wersja używała .toPromise(), przestarzałego w RxJS 7, i nie wstrzykiwała userService. Kontroler nie jest w istocie mikroserwisem użytkowników, tylko bramą HTTP, która pyta inne usługi.

Po drugiej stronie odpowiada kontroler z @MessagePattern:

// tribute.controller.ts - po stronie mikroserwisu tributów
import { Controller } from '@nestjs/common';
import { MessagePattern, Payload } from '@nestjs/microservices';

@Controller()
export class TributeController {
  @MessagePattern('get_user_tributes')
  getUserTributes(@Payload() data: { userId: string }) {
    return [{ userId: data.userId, amount: 1000, province: 'Gallia' }];
  }
}

Wzorzec get_user_tributes musi się zgadzać po obu stronach. Taki serwis startuje przez NestFactory.createMicroservice() z tym samym transportem. send() to model zapytanie-odpowiedź; do powiadomień bez odpowiedzi służą emit() i @EventPattern.

Wdrażanie bez przestojów

Wiele instancji pozwala aktualizować aplikację bez przerwy. Blue-green deployment utrzymuje dwa identyczne środowiska i przełącza ruch ze starego na nowe - daje zero przestojów i natychmiastowy rollback przez przełączenie z powrotem, kosztem podwójnej infrastruktury. Wdrożenie bez przestojów przebiega tak:

  1. przygotuj nową wersję w równoległym środowisku,
  2. uruchom health checki i smoke testy,
  3. przełącz ruch na nową wersję,
  4. wyłącz starą wersję po weryfikacji.

Canary deployment stopniowo kieruje ruch do nowej wersji, zaczynając od małego procentu użytkowników:

  1. wdróż nową wersję dla małego procentu użytkowników,
  2. monitoruj metryki i błędy,
  3. stopniowo zwiększaj ruch,
  4. zrób pełny rollout albo rollback.

W Kubernetesie o tym, czy instancja dostaje ruch, decydują sondy:

# deployment.yaml - fragment: strategia wdrożenia i sondy zdrowia
spec:
  replicas: 4
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # najwyżej 1 dodatkowy pod w trakcie wdrożenia
      maxUnavailable: 0  # stary pod znika dopiero, gdy nowy jest gotowy
  template:
    spec:
      containers:
        - name: api
          image: registry.imperium.rome/api:2.4.0
          readinessProbe:        # czy przyjmować ruch?
            httpGet:
              path: /health/ready
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 10
            timeoutSeconds: 2
            successThreshold: 2  # dwa udane sprawdzenia z rzędu
            failureThreshold: 3  # trzy nieudane = pod wypada z ruchu
          livenessProbe:         # czy proces żyje?
            httpGet:
              path: /health/live
              port: 3000
            periodSeconds: 10
            failureThreshold: 3  # trzy nieudane = restart kontenera

Sonda readiness usuwa pod z ruchu, gdy nie jest gotowy, a liveness restartuje kontener, który przestał odpowiadać. successThreshold większy niż 1 wolno ustawić tylko dla readiness; domyślnie periodSeconds to 10, a failureThreshold - 3. maxUnavailable: 0 sprawia, że rolling update nigdy nie zmniejsza liczby gotowych podów.

W ostatniej lekcji modułu zbudujemy blue-green, rolling update i feature flagi w kodzie.

Pamiętaj: siła Imperium nie leżała w jednym wielkim forcie, tylko w sieci legionów, które mogły się wzajemnie zastąpić -, buduj aplikację tak samo.

Kod do tej lekcji: src/scaling.ts
// Scaling i Microservices - Budowanie Legionu Kohort

// 1. Vertical vs Horizontal Scaling
// Vertical: wiekszy serwer (wiecej CPU/RAM)
// Horizontal: wiecej instancji (load balancing)

// 2. NestJS Microservices
import { Controller } from '@nestjs/common';
// import { MessagePattern, EventPattern } from '@nestjs/microservices';

// Microservice - TributeService
// @Controller()
// class TributeController {
//   // Request-Response pattern
//   @MessagePattern({ cmd: 'get_tribute' })
//   getTribute(data: { provinceId: string }) {
//     return { province: data.provinceId, amount: 1000 };
//   }
//
//   // Event pattern (fire and forget)
//   @EventPattern('tribute_collected')
//   handleTributeCollected(data: { province: string; amount: number }) {
//     console.log(`Tribute collected from ${data.province}`);
//   }
// }

// 3. Komunikacja miedzy serwisami
// TCP Transport (domyslny):
// const app = await NestFactory.createMicroservice(AppModule, {
//   transport: Transport.TCP,
//   options: { host: '0.0.0.0', port: 3001 },
// });

// Redis Transport:
// const app = await NestFactory.createMicroservice(AppModule, {
//   transport: Transport.REDIS,
//   options: { host: 'localhost', port: 6379 },
// });

// 4. Docker Compose dla microservices
const dockerCompose = `
services:
  api-gateway:
    build: ./gateway
    ports: ['3000:3000']
    depends_on: [tribute-service, legion-service]

  tribute-service:
    build: ./tribute-service
    ports: ['3001:3001']

  legion-service:
    build: ./legion-service
    ports: ['3002:3002']

  redis:
    image: redis:7-alpine
    ports: ['6379:6379']

  mongodb:
    image: mongo:7
    ports: ['27017:27017']
    volumes: [mongo-data:/data/db]

volumes:
  mongo-data:
`;

// 5. Wzorce architektury
// - API Gateway: jeden punkt wejscia
// - Service Discovery: automatyczne wykrywanie serwisow
// - Circuit Breaker: ochrona przed kaskadowymi awariami
// - Saga Pattern: transakcje rozproszone
// - CQRS: oddzielenie odczytu od zapisu

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. Blue-green deployment strategy oferuje:

  2. 2. Canary deployment polega na:

Zadania praktyczne w grze

  • Edytor kodu

    Napisz konfigurację deployment z readiness probe i liveness probe

  • Układanie w pionie

    Ułóż kroki procesu canary deployment:

  • Układanie w pionie

    Uporządkuj kroki zero-downtime deployment:

  1. PytanieBlue-green deployment
  2. PytanieCanary deployment
  3. Zadanie z kodemPraktyka: Deployment strategy config
  4. Ułóż w kolejnościCanary deployment flow
  5. Ułóż w kolejnościZero-downtime deployment

Przydatne artykuły