Kurs NestJS · Moduł 9: Deployment i infrastruktura
Scaling i Microservices - budowanie sieci legionów
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:
- przygotuj nową wersję w równoległym środowisku,
- uruchom health checki i smoke testy,
- przełącz ruch na nową wersję,
- wyłącz starą wersję po weryfikacji.
Canary deployment stopniowo kieruje ruch do nowej wersji, zaczynając od małego procentu użytkowników:
- wdróż nową wersję dla małego procentu użytkowników,
- monitoruj metryki i błędy,
- stopniowo zwiększaj ruch,
- 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 konteneraSonda 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. Blue-green deployment strategy oferuje:
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: