Kurs Next.js · Moduł 9: Integracje i zaawansowane funkcje
Next.js i Docker - Konteneryzacja Aplikacji
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
- Konsystentność środowiska - aplikacja działa identycznie na każdym systemie
- Izolacja - każda aplikacja ma swoje dedykowane środowisko
- Przenośność - łatwe przenoszenie między środowiskami
- Skalowalność - proste skalowanie poziome
- 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 /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 /app/public ./public
# Kopiowanie zbudowanej aplikacji
COPY /app/.next/standalone ./
COPY /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
.coverageKonfiguracja 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 = nextConfigDocker 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 /app/.next/standalone ./
COPY /app/.next/static ./.next/static
COPY /app/public ./public
USER nextjs
EXPOSE 3000
ENV PORT 3000
ENV HOSTNAME "0.0.0.0"
HEALTHCHECK \
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-keyDocker 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 /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 /app/public ./public
COPY /app/.next/standalone ./
COPY /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 /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 /app/.next/standalone ./
COPY /app/.next/static ./.next/static
# Ustawienie użytkownika
USER nextjs
# Healthcheck dla monitorowania
HEALTHCHECK \
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 loggerHealth 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 produkcyjnySkalowanie 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: LoadBalancerNajlepsze 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 curl2. Używanie .dockerignore
# .dockerignore
node_modules
.git
.gitignore
README.md
Dockerfile
.dockerignore
npm-debug.log
coverage
.nyc_output3. Zarządzanie secretami
# Użycie Docker secrets zamiast zmiennych środowiskowych
docker service create \
--name nextjs-app \
--secret db_password \
--secret api_key \
myapp/nextjs:latest4. 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
Problem z npm ci w Alpine Linux
# Rozwiązanie: dodanie python i make RUN apk add --no-cache python3 make g++Problemy z Next.js Image Optimization
// next.config.js module.exports = { images: { unoptimized: true, // Dla środowisk bez sharp }, }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. Co NIE jest bezpośrednią korzyścią konteneryzacji Next.js w Docker?
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.