Kurs NestJS · Moduł 12: Konteneryzacja i CI/CD

Dockerfile dla NestJS - Budowa Obozu

3 min czytania ·
W tej lekcji5

Legioniście, czas nauczyć się pisać instrukcje budowy obozu - czyli Dockerfile! Dockerfile to plik tekstowy zawierający sekwencję komend, które Docker wykonuje aby zbudować obraz. Każda komenda tworzy nową warstwę (stratum) w obrazie.

Podstawowe instrukcje Dockerfile

Dockerfile składa się z instrukcji, z których każda pełni określoną rolę:

FROM - Fundament obozu

Instrukcja FROM wybiera bazowy obraz, na którym budujemy. Dla aplikacji NestJS używamy obrazu Node.js:

# Używamy oficjalnego obrazu Node.js w wersji Alpine (lekki!)
FROM node:20-alpine

Alpine Linux to minimalistyczna dystrybucja - waży ~5MB zamiast ~900MB pełnego Ubuntu. To jak lekki obóz polowy zamiast pełnej fortecy - szybki do postawienia i przeniesienia.

WORKDIR - Wyznaczenie placu budowy

Instrukcja WORKDIR ustawia katalog roboczy wewnątrz kontenera:

# Ustawiamy katalog roboczy
WORKDIR /app

COPY - Transport materiałów

COPY kopiuje pliki z naszego komputera do kontenera:

# Kopiujemy pliki package.json i yarn.lock
COPY package.json yarn.lock ./

# Kopiujemy resztę kodu źródłowego
COPY . .

RUN - Wykonanie prac budowlanych

RUN wykonuje komendy podczas budowy obrazu:

# Instalacja zależności
RUN yarn install --frozen-lockfile

# Budowanie aplikacji
RUN yarn build

CMD - Rozkaz startowy

CMD definiuje komendę uruchamianą przy starcie kontenera:

# Uruchomienie aplikacji
CMD ["node", "dist/main"]

Prosty Dockerfile dla NestJS

FROM node:20-alpine

WORKDIR /app

COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile

COPY . .
RUN yarn build

EXPOSE 4000

CMD ["node", "dist/main"]

Multi-stage Build - Zaawansowana strategia budowy

Prosty Dockerfile ma problem - końcowy obraz zawiera narzędzia developerskie, pliki źródłowe TypeScript, devDependencies. To jak zostawienie rusztowań po zakończeniu budowy fortecy.

Multi-stage build pozwala używać wielu etapów budowy, gdzie finalny obraz zawiera tylko to, co potrzebne do uruchomienia:

# =========================
# ETAP 1: Builder (Inżynierowie legionowi)
# =========================
FROM node:20-alpine AS builder

WORKDIR /app

# Kopiujemy pliki zależności
COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile

# Kopiujemy kod źródłowy i budujemy
COPY . .
RUN yarn build

# Instalujemy tylko produkcyjne zależności
RUN yarn install --frozen-lockfile --production

# =========================
# ETAP 2: Production (Gotowy obóz)
# =========================
FROM node:20-alpine AS production

WORKDIR /app

# Kopiujemy TYLKO zbudowany kod i produkcyjne zależności
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./package.json

# Tworzymy użytkownika bez uprawnień root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nestjs -u 1001

USER nestjs

EXPOSE 4000

CMD ["node", "dist/main"]

Porównanie rozmiarów

const porownanie = {
  singleStage: {
    rozmiar: '~800 MB',
    zawiera: ['node_modules (dev + prod)', 'src/', 'test/', '.git'],
    bezpieczenstwo: 'root user'
  },
  multiStage: {
    rozmiar: '~200 MB',
    zawiera: ['dist/', 'node_modules (prod only)', 'package.json'],
    bezpieczenstwo: 'non-root user (nestjs)'
  }
};

Plik .dockerignore

Tak jak .gitignore zapobiega dodawaniu plików do repozytorium, .dockerignore zapobiega kopiowaniu niepotrzebnych plików do obrazu:

node_modules
dist
.git
.gitignore
*.md
.env
.env.*
test
coverage
.vscode
.idea

Dzięki .dockerignore komenda COPY . . nie skopiuje tych plików, co przyspiesza budowę i zmniejsza rozmiar obrazu.

Budowanie i uruchamianie

# Buduj obraz
docker build -t roman-imperium-api:1.0 .

# Uruchom kontener
docker run -d -p 4000:4000 --name imperium-api roman-imperium-api:1.0

# Sprawdź logi
docker logs imperium-api

# Sprawdź działanie
curl http://localhost:4000/health

Pamiętaj, legioniście - multi-stage build to najlepsza praktyka dla produkcji. Budujemy ciężko, ale wdrażamy lekko!

Kod do tej lekcji: src/dockerfile-example.ts
// Dockerfile - Instrukcje budowy obozu legionowego
console.log("=== DOCKERFILE DLA NestJS ===\n");

// Instrukcje Dockerfile
interface DockerInstruction {
  command: string;
  purpose: string;
  example: string;
}

const instructions: DockerInstruction[] = [
  {
    command: 'FROM',
    purpose: 'Bazowy obraz (fundament obozu)',
    example: 'FROM node:20-alpine',
  },
  {
    command: 'WORKDIR',
    purpose: 'Katalog roboczy (plac budowy)',
    example: 'WORKDIR /app',
  },
  {
    command: 'COPY',
    purpose: 'Kopiowanie plikow (transport materialow)',
    example: 'COPY package.json yarn.lock ./',
  },
  {
    command: 'RUN',
    purpose: 'Wykonanie komendy (prace budowlane)',
    example: 'RUN yarn install --frozen-lockfile',
  },
  {
    command: 'EXPOSE',
    purpose: 'Deklaracja portu (brama obozu)',
    example: 'EXPOSE 4000',
  },
  {
    command: 'CMD',
    purpose: 'Komenda startowa (rozkaz na start)',
    example: 'CMD ["node", "dist/main"]',
  },
];

console.log("Instrukcje Dockerfile:\n");
instructions.forEach(i => {
  console.log(`${i.command}: ${i.purpose}`);
  console.log(`  Przyklad: ${i.example}\n`);
});

// Multi-stage build comparison
console.log("=== MULTI-STAGE BUILD ===\n");
console.log("Single-stage: ~800 MB (dev + prod dependencies)");
console.log("Multi-stage:  ~200 MB (only production)\n");

console.log("Etap 1 (builder): instalacja, build, kompilacja");
console.log("Etap 2 (production): COPY --from=builder tylko dist/");
console.log("\nKorzysc: mniejszy obraz, brak dev-dependencies, non-root user");

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. Co definiuje instrukcja FROM w Dockerfile?

  2. 2. Jaka jest główna korzyść z multi-stage build w Docker?

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

Zadania praktyczne w grze

  • Edytor kodu

    Zdefiniuj dwa etapy Dockerfile: builder (budowanie) i production (uruchomienie)

  • Klikanie w kolejności

    Ułóż instrukcje Dockerfile w prawidłowej kolejności:

  • Edytor kodu

    Zaznacz, które pliki/foldery powinny być ignorowane przez Docker (node_modules, dist, .git, .env, src, test, package.json, coverage)

  • Układanie w poziomie

    Ułóż elementy komendy budowania obrazu Docker w prawidłowej kolejności:

  1. PytaniePowtórzenie: Instrukcja FROM w Dockerfile
  2. PytaniePowtórzenie: Cel multi-stage build
  3. Zadanie z kodemPowtórzenie: Multi-stage build w praktyce
  4. Kliknij w kolejnościPowtórzenie: Kolejność instrukcji Dockerfile
  5. PytaniePowtórzenie: Rola pliku .dockerignore
  6. Zadanie z kodemPowtórzenie: Konfiguracja .dockerignore
  7. Ułóż w kolejnościPowtórzenie: Komenda budowania obrazu Docker

Przydatne artykuły