Kurs NestJS · Moduł 12: Konteneryzacja i CI/CD
Dockerfile dla NestJS - Budowa Obozu
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-alpineAlpine 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 /appCOPY - 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 buildCMD - 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 /app/dist ./dist
COPY /app/node_modules ./node_modules
COPY /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
.ideaDzię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/healthPamię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. Co definiuje instrukcja FROM w Dockerfile?
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:
Zadania po tej lekcji
- PytaniePowtórzenie: Instrukcja FROM w Dockerfile
- PytaniePowtórzenie: Cel multi-stage build
- Zadanie z kodemPowtórzenie: Multi-stage build w praktyce
- Kliknij w kolejnościPowtórzenie: Kolejność instrukcji Dockerfile
- PytaniePowtórzenie: Rola pliku .dockerignore
- Zadanie z kodemPowtórzenie: Konfiguracja .dockerignore
- Ułóż w kolejnościPowtórzenie: Komenda budowania obrazu Docker