Kurs Next.js · Moduł 9: Integracje i zaawansowane funkcje

Next.js i Docker - Konteneryzacja Aplikacji

9 min czytania ·
W tej lekcji14

Tak jak starożytni budowniczowie wykorzystywali standardowe formy do tworzenia identycznych cegieł budowlanych, współczesny Docker pozwala nam tworzyć standardowe, przenośne kontenery dla naszych aplikacji Next.js. W tej lekcji nauczymy się, jak "zapakować" naszą aplikację w kontener Docker, który będzie działał jednakowo na każdym środowisku - od lokalnej maszyny programisty po serwery produkcyjne.

Czym jest Docker i dlaczego jest przydatny dla Next.js?

Docker to platforma do konteneryzacji aplikacji, która pozwala na pakowanie aplikacji wraz z wszystkimi jej zależnościami w lekkie, przenośne kontenery. Dla aplikacji Next.js Docker oferuje wiele korzyści:

Zalety używania Docker z Next.js

  1. Konsystentność środowiska - aplikacja działa identycznie na każdym systemie
  2. Izolacja - każda aplikacja ma swoje dedykowane środowisko
  3. Przenośność - łatwe przenoszenie między środowiskami
  4. Skalowalność - proste skalowanie poziome
  5. Wersjonowanie - możliwość zarządzania wersjami środowisk

Podstawy Docker dla Next.js

Struktura plików Docker

Zacznijmy od utworzenia podstawowych plików Docker w naszym projekcie Next.js:

# Dockerfile
# Etap 1: Instalacja zależności
FROM node:18-alpine AS deps

WORKDIR /app

# Kopiowanie plików package
COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* ./

# Instalacja zależności w zależności od lockfile
RUN \
  if [ -f yarn.lock ]; then yarn --frozen-lockfile; \
  elif [ -f package-lock.json ]; then npm ci; \
  elif [ -f pnpm-lock.yaml ]; then yarn global add pnpm && pnpm i --frozen-lockfile; \
  else echo "Lockfile not found." && exit 1; \
  fi

# Etap 2: Budowanie aplikacji
FROM node:18-alpine AS builder

WORKDIR /app

# Kopiowanie zależności z poprzedniego etapu
COPY --from=deps /app/node_modules ./node_modules

# Kopiowanie kodu źródłowego
COPY . .

# Budowanie aplikacji Next.js
RUN npm run build

# Etap 3: Środowisko produkcyjne
FROM node:18-alpine AS runner

WORKDIR /app

# Dodanie użytkownika nieadministracyjnego
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

# Kopiowanie plików publicznych
COPY --from=builder /app/public ./public

# Kopiowanie zbudowanej aplikacji
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT 3000
ENV HOSTNAME "0.0.0.0"

CMD ["node", "server.js"]

Plik .dockerignore

Podobnie jak .gitignore, plik .dockerignore określa, które pliki mają być ignorowane podczas budowania obrazu Docker:

# .dockerignore
Dockerfile
.dockerignore
node_modules
npm-debug.log
README.md
.env
.git
.gitignore
.next
.nyc_output
coverage
.coverage

Konfiguracja Next.js dla Docker

Standalone Output

Aby zoptymalizować rozmiar obrazu Docker, Next.js oferuje opcję standalone output:

// next.config.js
/** @type {import('next').NextConfig} */
const nextConfig = {
  output: 'standalone',
  experimental: {
    // Optymalizacje dla Docker
    outputFileTracingRoot: path.join(__dirname, '../../'),
  },
  // Konfiguracja dla zmiennych środowiskowych
  env: {
    CUSTOM_KEY: process.env.CUSTOM_KEY,
  },
  // Optymalizacja obrazów
  images: {
    domains: ['example.com'],
    unoptimized: process.env.NODE_ENV === 'development',
  },
}

module.exports = nextConfig

Docker Compose dla środowisk deweloperskich

Podstawowa konfiguracja Docker Compose

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: development
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
    volumes:
      - .:/app
      - /app/node_modules
      - /app/.next
    command: npm run dev

  database:
    image: postgres:15
    environment:
      POSTGRES_DB: nextjs_app
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

Dockerfile dla środowiska deweloperskiego

# Dockerfile.dev
FROM node:18-alpine

WORKDIR /app

# Instalacja zależności globalnych
RUN npm install -g nodemon

# Kopiowanie plików package
COPY package*.json ./

# Instalacja zależności
RUN npm ci

# Kopiowanie kodu źródłowego
COPY . .

EXPOSE 3000

CMD ["npm", "run", "dev"]

Multi-stage Dockerfile dla produkcji

Optymalizowany Dockerfile

# Dockerfile.prod
# Etap budowania
FROM node:18-alpine AS build

WORKDIR /app

# Instalacja zależności
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

# Kopiowanie i budowanie aplikacji
COPY . .
RUN npm run build

# Etap produkcyjny
FROM node:18-alpine AS production

WORKDIR /app

# Tworzenie użytkownika
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

# Kopiowanie tylko niezbędnych plików
COPY --from=build --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=build --chown=nextjs:nodejs /app/.next/static ./.next/static
COPY --from=build --chown=nextjs:nodejs /app/public ./public

USER nextjs

EXPOSE 3000

ENV PORT 3000
ENV HOSTNAME "0.0.0.0"

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/api/health || exit 1

CMD ["node", "server.js"]

Zarządzanie zmiennymi środowiskowymi

Plik environment

# .env.docker
NODE_ENV=production
NEXT_PUBLIC_API_URL=https://api.example.com
DATABASE_URL=postgresql://user:password@database:5432/nextjs_app
REDIS_URL=redis://redis:6379
JWT_SECRET=your-secret-key

Docker Compose z plikami środowiskowymi

# docker-compose.prod.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.prod
    ports:
      - "3000:3000"
    env_file:
      - .env.docker
    depends_on:
      - database
      - redis
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - app
    restart: unless-stopped

  database:
    image: postgres:15
    env_file:
      - .env.docker
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    restart: unless-stopped

volumes:
  postgres_data:

Optymalizacja obrazów Docker

Zmniejszanie rozmiaru obrazu

# Dockerfile.optimized
FROM node:18-alpine AS base

# Instalacja tylko niezbędnych pakietów
RUN apk add --no-cache libc6-compat

FROM base AS deps
WORKDIR /app

# Kopiowanie plików zależności
COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* ./

# Instalacja zależności
RUN \
  if [ -f yarn.lock ]; then yarn --frozen-lockfile; \
  elif [ -f package-lock.json ]; then npm ci; \
  elif [ -f pnpm-lock.yaml ]; then yarn global add pnpm && pnpm i; \
  else echo "Lockfile not found." && exit 1; \
  fi

FROM base AS builder
WORKDIR /app

COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Budowanie z optymalizacjami
ENV NEXT_TELEMETRY_DISABLED 1
RUN npm run build

FROM base AS runner
WORKDIR /app

ENV NODE_ENV production
ENV NEXT_TELEMETRY_DISABLED 1

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT 3000

CMD ["node", "server.js"]

Bezpieczeństwo w kontenerach Docker

Dobre praktyki bezpieczeństwa

# Dockerfile.secure
FROM node:18-alpine AS base

# Aktualizacja pakietów systemowych
RUN apk update && apk upgrade

# Instalacja narzędzi bezpieczeństwa
RUN apk add --no-cache dumb-init

# Użycie użytkownika nieadministracyjnego
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

FROM base AS deps
WORKDIR /app

# Kopiowanie tylko niezbędnych plików
COPY package*.json ./

# Instalacja z audytem bezpieczeństwa
RUN npm ci --only=production && npm audit fix

FROM base AS builder
WORKDIR /app

COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Skanowanie bezpieczeństwa przed budowaniem
RUN npm audit

# Budowanie aplikacji
RUN npm run build

FROM base AS runner
WORKDIR /app

ENV NODE_ENV=production

# Kopiowanie z odpowiednimi uprawnieniami
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

# Ustawienie użytkownika
USER nextjs

# Healthcheck dla monitorowania
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/api/health || exit 1

EXPOSE 3000

# Użycie dumb-init dla lepszego zarządzania procesami
ENTRYPOINT ["dumb-init", "--"]
CMD ["node", "server.js"]

Monitoring i logowanie

Konfiguracja logowania

// utils/logger.js
import winston from 'winston'

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: { service: 'nextjs-app' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
})

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }))
}

export default logger

Health Check endpoint

// pages/api/health.js
export default function handler(req, res) {
  const healthcheck = {
    uptime: process.uptime(),
    message: 'OK',
    timestamp: Date.now(),
    environment: process.env.NODE_ENV,
    version: process.env.npm_package_version,
  }

  try {
    // Sprawdzenie połączeń z bazą danych, Redis, itp.
    res.status(200).json(healthcheck)
  } catch (error) {
    healthcheck.message = error.message
    res.status(503).json(healthcheck)
  }
}

CI/CD z Docker

GitHub Actions z Docker

# .github/workflows/docker.yml
name: Docker Build and Deploy

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2

    - name: Login to Docker Hub
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKERHUB_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}

    - name: Build and push
      uses: docker/build-push-action@v4
      with:
        context: .
        file: ./Dockerfile
        platforms: linux/amd64,linux/arm64
        push: true
        tags: \
          myapp/nextjs:latest
          myapp/nextjs:${{ github.sha }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
    - name: Deploy to production
      run: |
        echo "Deploying to production server"
        # Tutaj kod wdrażania na serwer produkcyjny

Skalowanie i orkiestracja

Kubernetes Deployment

# k8s/deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nextjs-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nextjs-app
  template:
    metadata:
      labels:
        app: nextjs-app
    spec:
      containers:
      - name: nextjs-app
        image: myapp/nextjs:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /api/health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /api/health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: nextjs-service
spec:
  selector:
    app: nextjs-app
  ports:
  - port: 80
    targetPort: 3000
  type: LoadBalancer

Najlepsze praktyki

1. Optymalizacja warstw

# Dobre - grupowanie poleceń
RUN apk update && \
    apk add --no-cache git curl && \
    rm -rf /var/cache/apk/*

# Złe - osobne warstwy
RUN apk update
RUN apk add --no-cache git
RUN apk add --no-cache curl

2. Używanie .dockerignore

# .dockerignore
node_modules
.git
.gitignore
README.md
Dockerfile
.dockerignore
npm-debug.log
coverage
.nyc_output

3. Zarządzanie secretami

# Użycie Docker secrets zamiast zmiennych środowiskowych
docker service create \
  --name nextjs-app \
  --secret db_password \
  --secret api_key \
  myapp/nextjs:latest

4. Monitoring i alerting

// middleware/monitoring.js
import prometheus from 'prom-client'

const httpDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status'],
  buckets: [0.1, 0.5, 1, 2, 5]
})

export function monitoringMiddleware(req, res, next) {
  const start = Date.now()

  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000
    httpDuration
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .observe(duration)
  })

  next()
}

Troubleshooting

Typowe problemy i rozwiązania

  1. Problem z npm ci w Alpine Linux

    # Rozwiązanie: dodanie python i make
    RUN apk add --no-cache python3 make g++
  2. Problemy z Next.js Image Optimization

    // next.config.js
    module.exports = {
      images: {
        unoptimized: true, // Dla środowisk bez sharp
      },
    }
  3. Problemy z pamięcią

    # Ograniczenie pamięci Node.js
    ENV NODE_OPTIONS="--max-old-space-size=1024"

Podsumowanie

Docker z Next.js to potężne połączenie, które umożliwia:

  • Konsystentne środowiska na wszystkich etapach rozwoju
  • Łatwe skalowanie aplikacji w chmurze
  • Bezpieczne wdrażanie z izolacją procesów
  • Efektywne zarządzanie zależnościami i wersjami

Podobnie jak starożytni budowniczowie tworzyli trwałe struktury przy pomocy standardowych elementów, Docker pozwala nam budować niezawodne, skalowalne aplikacje Next.js, które działają jednakowo w każdym środowisku.

W następnych lekcjach poznamy zaawansowane techniki orkiestracji kontenerów oraz strategie wdrażania aplikacji Next.js w środowiskach chmurowych.

Hasła z dokumentacji w tej lekcji

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 NIE jest bezpośrednią korzyścią konteneryzacji Next.js w Docker?

  2. 2. Która praktyka jest NIEPRAWIDŁOWA przy produkcyjnym deployment Next.js w Docker?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kroki konteneryzacji aplikacji Next.js z Docker

  • Klikanie w kolejności

    Uporządkuj kroki Docker orchestration.

  • Układanie w pionie

    Ułóż poprawną kolejność podstawowych dyrektyw w Dockerfile dla aplikacji Next.js:

  • Edytor kodu

    Napisz wieloetapowy (multi-stage) Dockerfile dla Next.js: zainstaluj zależności i zbuduj aplikację w etapie opartym na obrazie node, do etapu końcowego skopiuj tylko wynik builda (COPY --from) i wystartuj aplikację przez CMD.

  1. PytanieDocker benefits dla Next.js
  2. PytanieProduction deployment
  3. Ułóż w kolejnościProces konteneryzacji z Docker
  4. Kliknij w kolejnościDocker Compose i orchestration
  5. Ułóż w kolejnościKolejność dyrektyw w Dockerfile
  6. Zadanie z kodemDockerfile dla Next.js

Przydatne artykuły