Kurs NestJS · Moduł 9: Deployment i infrastruktura

Deployment - wyprowadzenie fortu na pole bitwy

5 min czytania ·
W tej lekcji6

Obóz ćwiczebny wybacza wszystko. Wał jest niski, bo i tak nikt nie szturmuje, prowiant przywożą codziennie, a jak coś się zawali, stawia się to od nowa po obiedzie. Fort na granicy nie wybacza niczego - i to nie dlatego, że zbudowano go inaczej, tylko dlatego, że nikt tam nie stoi obok, żeby poprawić.

Deployment to ta chwila przeprowadzki. Aplikacja, którą uruchamiałeś poleceniem yarn start:dev, ma zacząć działać sama, przez wiele dni, dla ludzi, których nie znasz. Ta lekcja jest o czterech rzeczach, które trzeba zrobić, zanim to się stanie.

nest build - kompilacja

W trybie deweloperskim NestJS tłumaczy TypeScript na bieżąco, przy każdym zapisie pliku. Na produkcji tłumaczymy raz, z góry:

{
  "scripts": {
    "build": "nest build",
    "start:dev": "nest start --watch",
    "start:prod": "node dist/main"
  }
}

Polecenie nest build kompiluje TypeScript do JavaScriptu w katalogu dist/ - i tylko tyle. Nie generuje dokumentacji Swagger (tę dodaje się osobno, dekoratorami i SwaggerModule), nie instaluje zależności z package.json (od tego jest yarn install), nie uruchamia trybu watch (to start:dev z flagą --watch).

Po kompilacji uruchamiasz node dist/main - zwykły Node.js na zwykłym pliku .js. Na serwerze produkcyjnym TypeScript nie jest już potrzebny, bo nie ma czego tłumaczyć.

NODE_ENV - jeden napis, wiele skutków

NODE_ENV to zmienna środowiskowa, którą czytają niemal wszystkie biblioteki ekosystemu Node.js. Ustawienie NODE_ENV=production włącza optymalizacje produkcyjne i wyłącza szczegółowe logowanie.

To jedyne, co robi. Nie uruchamia testów automatycznych - te uruchamia yarn test. Nie włącza trybu hot-reload; przeciwnie, hot-reload to sprawa środowiska deweloperskiego. Nie generuje dokumentacji API. Zmiana jednego napisu nie dodaje aplikacji funkcji - ona tylko przestawia to, co już w niej jest, z trybu „pomagaj programiście" na tryb „obsługuj ruch".

Skutki bywają zaskakująco duże: biblioteki pomijają kosztowne sprawdzenia, cache szablonów zostaje włączony, a stos wywołań przestaje trafiać do odpowiedzi błędu - bo użytkownikowi jest niepotrzebny, a atakującemu bardzo przydatny.

Zmienne środowiskowe - to, co różni fort od obozu

NODE_ENV jest tylko jedną z nich. Adres bazy danych, sekret do podpisywania tokenów, klucz do bramki płatności - to wszystko zmienne środowiskowe: wartości, które podaje się aplikacji z zewnątrz, zamiast wpisywać do kodu.

NODE_ENV=production
PORT=3000
DATABASE_URL=postgres://legion:haslo@db.limes.internal:5432/tributes
JWT_SECRET=zmien-mnie-przed-wymarszem

Powód jest praktyczny: ten sam zbudowany dist/ musi działać na twoim komputerze, na środowisku testowym i na produkcji. Różni je wyłącznie zestaw zmiennych. Gdyby adres bazy siedział w kodzie, każde środowisko wymagałoby osobnej kompilacji - a wtedy to, co przetestowałeś, nie byłoby tym, co uruchamiasz.

Dlatego konfiguracja zmiennych to pierwszy krok przygotowania, przed jakąkolwiek kompilacją.

Produkcyjny main.ts

Plik main.ts startuje aplikację. W wersji deweloperskiej ma zwykle dwie linijki; w produkcyjnej dokłada się do niego cztery rzeczy, w tej kolejności:

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.use(helmet());
  app.use(compression());
  app.enableCors({ origin: 'https://legion.imperium.rome' });

  app.useGlobalPipes(new ValidationPipe({ whitelist: true }));

  const port = process.env.PORT || 3000;
  await app.listen(port);
}

Kolejność nie jest przypadkowa: const app = await NestFactory.create(AppModule) musi być pierwsze, bo dopiero wtedy istnieje obiekt aplikacji; app.use(helmet()) i pozostałe middleware ustawia się przed obsługą ruchu; app.useGlobalPipes(new ValidationPipe()) rejestruje walidację; await app.listen(port) otwiera port i od tej chwili aplikacja przyjmuje żądania. Cokolwiek dopiszesz po listen, wykona się już przy działającym serwerze.

Każdy z tych czterech elementów odpowiada za co innego:

  • helmet ustawia nagłówki HTTP bezpieczeństwa - Content-Security-Policy (CSP), X-Frame-Options, Strict-Transport-Security i kilkanaście innych. Nie szyfruje bazy danych, nie kompresuje plików statycznych i nie zarządza sesjami użytkowników; to hełm dla odpowiedzi, nie dla danych.
  • compression pakuje odpowiedzi algorytmem gzip, zanim wyjdą na sieć. Kilkusetkilobajtowy JSON potrafi zejść do kilkudziesięciu kilobajtów.
  • enableCors rozstrzyga, ze których stron przeglądarka może wołać twoje API. Na produkcji podaje się konkretny adres, nie gwiazdkę.
  • ValidationPipe to znany ci już strażnik danych wejściowych, tu włączony globalnie.

Cztery kroki

Cała droga na produkcję układa się w kolejność, której nie da się poprzestawiać:

  1. Skonfiguruj zmienne środowiskowe - bo od nich zależy, do jakiej bazy aplikacja się połączy.
  2. Dodaj helmet, compression i CORS - bo to zmiany w kodzie, a kod zaraz zamrozimy.
  3. Uruchom nest build - powstaje katalog dist/, od tej chwili niezmienny.
  4. Uruchom node dist/main w produkcji - startuje to, co zbudowałeś, z tymi zmiennymi, które zastanie.

Zamiana kroków drugiego i trzeciego to najczęstszy błąd tej listy: zbudowany dist/ nie zna zmian, które dopisałeś po kompilacji. Aplikacja wstanie, nie zgłosi żadnego błędu i będzie działać bez nagłówków bezpieczeństwa.

Podsumowanie

Fort rusza na granicę:

  • nest build kompiluje TypeScript do JavaScriptu w katalogu dist/ - nie generuje Swaggera, nie instaluje zależności, nie uruchamia trybu watch,
  • na produkcji uruchamiasz node dist/main; TypeScript nie jest tam już potrzebny,
  • NODE_ENV=production włącza optymalizacje produkcyjne i wyłącza szczegółowe logowanie - nie uruchamia testów, nie włącza hot-reloadu, nie generuje dokumentacji,
  • zmienne środowiskowe pozwalają uruchomić ten sam zbudowany katalog na każdym środowisku - dlatego konfiguruje się je jako pierwsze,
  • kolejność w main.ts: const app = await NestFactory.create(AppModule) → app.use(helmet()) → app.useGlobalPipes(new ValidationPipe()) → await app.listen(port),
  • helmet ustawia nagłówki HTTP bezpieczeństwa (CSP, X-Frame-Options i inne) - nie szyfruje bazy, nie kompresuje plików statycznych, nie zarządza sesjami,
  • compression pakuje odpowiedzi gzipem, enableCors wskazuje dozwolone źródła żądań,
  • cztery kroki przygotowania: zmienne środowiskowe → helmet, compression, CORS → nest build → node dist/main.

W następnej lekcji zamkniemy fort w kontenerze, żeby jego wnętrze wyglądało tak samo na każdej maszynie. A na razie zapamiętaj: produkcja nie jest trudniejszą wersją środowiska deweloperskiego. Jest tą samą aplikacją bez nikogo, kto poprawi.

Kod do tej lekcji: src/deployment-intro.ts
// Deployment - Wyprowadzenie Fortu na Pelne Imperium
import { NestFactory } from '@nestjs/core';
import { ValidationPipe, Logger } from '@nestjs/common';

// 1. Konfiguracja produkcyjna main.ts
async function bootstrap() {
  const logger = new Logger('Bootstrap');

  // Tworzymy aplikacje z ograniczonym logowaniem
  const app = await NestFactory.create(AppModule, {
    logger: ['error', 'warn', 'log'],
  });

  // Bezpieczenstwo - Helmet
  // app.use(helmet());

  // Kompresja odpowiedzi - zmniejsza rozmiar o 60-80%
  // app.use(compression());

  // CORS - kontrola dostepu
  app.enableCors({
    origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
    credentials: true,
  });

  // Globalna walidacja
  app.useGlobalPipes(new ValidationPipe({
    whitelist: true,           // Usun nieznane pola
    forbidNonWhitelisted: true, // Blad przy nieznanych polach
    transform: true,           // Automatyczna transformacja typow
  }));

  // Prefix API
  app.setGlobalPrefix('api/v1');

  // Graceful Shutdown - zamknij polaczenia przed wylaczeniem
  app.enableShutdownHooks();

  const port = process.env.PORT || 3000;
  await app.listen(port, '0.0.0.0');

  logger.log(`Application running on port ${port}`);
  logger.log(`Environment: ${process.env.NODE_ENV}`);
}

// 2. Roznice miedzy srodowiskami
// Development:  hot-reload, debug, verbose logging
// Staging:      produkcja-like, test data
// Production:   zoptymalizowane, ograniczone logi, bezpieczenstwo

// 3. Skrypty w package.json
const scripts = {
  'start:dev': 'nest start --watch',
  'start:debug': 'nest start --debug --watch',
  'build': 'nest build',
  'start:prod': 'node dist/main',
  'test': 'jest',
  'test:cov': 'jest --coverage',
  'test:e2e': 'jest --config ./test/jest-e2e.json',
  'lint': 'eslint "{src,test}/**/*.ts" --fix',
};

// 4. Checklist przed deploymentem
const checklist = [
  'Testy przeszly (unit + e2e)',
  'Zmienne srodowiskowe ustawione',
  'Baza danych zmigrowana',
  'Sekrety bezpieczne (nie w kodzie!)',
  'CORS skonfigurowany',
  'Health check endpoint gotowy',
  'Monitoring wlaczony',
  'Backup strategy gotowa',
];

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. Komenda nest build w NestJS:

  2. 2. Ustawienie NODE_ENV=production w aplikacji NestJS:

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Skonfiguruj main.ts z helmet, compression, CORS i ValidationPipe dla produkcji

  • Układanie w pionie

    Uporządkuj kroki przygotowania aplikacji NestJS do produkcji:

  • Klikanie w kolejności

    Ułóż elementy konfiguracji main.ts w poprawnej kolejności:

  1. PytanieBuild aplikacji produkcyjnej
  2. PytanieNODE_ENV=production
  3. Zadanie z kodemPraktyka: Konfiguracja produkcyjna
  4. PytanieBezpieczeństwo Helmet
  5. Ułóż w kolejnościPrzygotowanie do produkcji
  6. Kliknij w kolejnościInicjalizacja produkcyjna

Przydatne artykuły