Wzorce Docker i kontenerów

Opanuj konteneryzację z Cursor i Claude Code. Ten przewodnik obejmuje buildy wieloetapowe, optymalizację kontenerów, orkiestrację Docker Compose, najlepsze praktyki bezpieczeństwa oraz przepływy pracy gotowe do produkcji z pomocą AI.

Szybka konfiguracja

1. Inicjalizacja projektu Docker

   Cursor

   # Tworzenie zoptymalizowanego Dockerfile
   Agent: "Stwórz wieloetapową konfigurację Docker dla tej aplikacji Node.js z:
   - Etapem build dla zależności
   - Etapem produkcyjnym z minimalną powierzchnią ataku
   - Użytkownikiem non-root
   - Health checks"

   Claude Code

   # Generowanie konfiguracji Docker
   claude "Stwórz konfigurację Docker z:
   - Buildem wieloetapowym dla aplikacji Python
   - Optymalizacją cachowania warstw
   - Integracją skanowania bezpieczeństwa
   - docker-compose.yml dla rozwoju lokalnego
   - Optymalizacjami produkcyjnymi"

2. Instalacja serwera MCP Docker (opcjonalne)

   # Claude Code
   # Uwaga: Brak bezpośredniego URL MCP - użyj Docker Hub MCP Server
   claude mcp add docker-hub -- npx -y docker-mcp
   
   # Dostęp do katalogu Docker MCP na: https://hub.docker.com/mcp

3. Konfiguracja reguł AI

   # .cursorrules lub CLAUDE.md
   Najlepsze praktyki Docker:
   - Używaj konkretnych wersji obrazów bazowych (nie :latest)
   - Minimalizuj warstwy i rozmiar obrazu
   - Uruchamiaj jako użytkownik non-root
   - Używaj .dockerignore
   - Implementuj health checks
   - Przestrzegaj najlepszych praktyk bezpieczeństwa
   - Efektywnie wykorzystuj cache buildów

Buildy wieloetapowe

Aplikacja Node.js

Cursor

# Prompt AI
Agent: "Stwórz zoptymalizowany wieloetapowy Dockerfile dla Node.js z:
- Cachowaniem zależności
- Optymalizacją buildu produkcyjnego
- Zabezpieczeniami
- Minimalnym obrazem końcowym"

# Wygenerowany Dockerfile
# Etap build
FROM node:20-alpine AS builder

# Instalacja zależności buildowych
RUN apk add --no-cache python3 make g++

WORKDIR /app

# Cache zależności
COPY package*.json ./
RUN npm ci --only=production && \
    cp -R node_modules prod_node_modules && \
    npm ci

# Build aplikacji
COPY . .
RUN npm run build

# Etap produkcyjny
FROM node:20-alpine AS production

# Instalacja dumb-init dla właściwej obsługi sygnałów
RUN apk add --no-cache dumb-init

# Utworzenie użytkownika non-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

WORKDIR /app

# Kopiowanie zależności produkcyjnych
COPY --from=builder --chown=nodejs:nodejs /app/prod_node_modules ./node_modules

# Kopiowanie zbudowanej aplikacji
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
COPY --from=builder --chown=nodejs:nodejs /app/package*.json ./

# Przełączenie na użytkownika non-root
USER nodejs

# Udostępnienie portu
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js

# Użycie dumb-init do prawidłowej obsługi sygnałów
ENTRYPOINT ["dumb-init", "--"]
CMD ["node", "dist/index.js"]

Claude Code

# Generowanie buildu wieloetapowego
claude "Stwórz wieloetapowy build Docker dla aplikacji Node.js, który:
1. Efektywnie cachuje zależności npm
2. Uruchamia skanowanie bezpieczeństwa zależności
3. Minimalizuje rozmiar końcowego obrazu
4. Implementuje obraz bazowy distroless
5. Dodaje właściwą obsługę sygnałów"

Aplikacja Python

# Prompt AI: "Stwórz zoptymalizowany build Python Docker z Poetry"

# Etap build
FROM python:3.12-slim AS builder

# Instalacja zależności buildowych
RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Instalacja Poetry
ENV POETRY_VERSION=1.7.1
RUN curl -sSL https://install.python-poetry.org | python3 -

# Ustawienie katalogu roboczego
WORKDIR /app

# Kopiowanie plików zależności
COPY pyproject.toml poetry.lock ./

# Instalacja zależności
RUN ~/.local/bin/poetry config virtualenvs.create false && \
    ~/.local/bin/poetry install --no-interaction --no-ansi --only main

# Kopiowanie aplikacji
COPY . .

# Etap produkcyjny
FROM python:3.12-slim AS production

# Instalacja zależności runtime
RUN apt-get update && apt-get install -y \
    libpq5 \
    && rm -rf /var/lib/apt/lists/*

# Utworzenie użytkownika non-root
RUN useradd -m -u 1001 -s /bin/bash app

# Kopiowanie pakietów Python z buildera
COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin

# Ustawienie katalogu roboczego
WORKDIR /app

# Kopiowanie plików aplikacji
COPY --from=builder --chown=app:app /app .

# Przełączenie na użytkownika non-root
USER app

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD python -c "import requests; requests.get('http://localhost:8000/health')"

# Uruchomienie aplikacji
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "app:application"]

Optymalizacja kontenerów

Redukcja rozmiaru obrazu

Cursor

# Prompt AI
Ask: "Zoptymalizuj ten Dockerfile pod kątem rozmiaru:
- Użyj Alpine lub distroless jako bazy
- Usuń niepotrzebne pliki
- Połącz komendy RUN
- Użyj flag --no-cache
- Wyczyść cache menedżera pakietów"

# Zoptymalizowana aplikacja Go
# Etap build
FROM golang:1.21-alpine AS builder

RUN apk add --no-cache git ca-certificates

WORKDIR /app

# Cache zależności
COPY go.mod go.sum ./
RUN go mod download

# Build binarki
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build \
    -ldflags="-w -s" \
    -o server ./cmd/server

# Etap końcowy - distroless
FROM gcr.io/distroless/static:nonroot

# Kopiowanie binarki
COPY --from=builder /app/server /server

# Kopiowanie certyfikatów dla HTTPS
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/

# Uruchomienie jako non-root
USER nonroot:nonroot

EXPOSE 8080

ENTRYPOINT ["/server"]

Claude Code

# Analiza i optymalizacja istniejącego Dockerfile
claude "Przeanalizuj ten Dockerfile i zoptymalizuj pod kątem:
1. Minimalnego rozmiaru obrazu
2. Luk w zabezpieczeniach
3. Wydajności czasu buildu
4. Cachowania warstw
5. Efektywności runtime"

Wydajność buildu

1.4

# Prompt AI: "Optymalizuj wydajność buildu Docker z cachowaniem"

FROM node:20-alpine AS builder

# Montowanie cache dla menedżerów pakietów
RUN --mount=type=cache,target=/root/.npm \
    npm config set cache /root/.npm

WORKDIR /app

# Kopiuj tylko pliki pakietów najpierw
COPY package*.json ./

# Instalacja zależności z montowaniem cache
RUN --mount=type=cache,target=/root/.npm \
    npm ci

# Kopiuj pliki źródłowe (zmiany nie unieważniają cache npm)
COPY . .

# Build z montowaniem cache
RUN --mount=type=cache,target=/app/.next/cache \
    npm run build

# Etap produkcyjny
FROM node:20-alpine

WORKDIR /app

# Kopiowanie zbudowanej aplikacji
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public

EXPOSE 3000

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

Wzorce Docker Compose

Stack mikroserwisów

Cursor

# Prompt AI
Agent: "Stwórz Docker Compose dla mikroserwisów z:
- API gateway
- Wieloma serwisami backendowymi
- PostgreSQL i Redis
- Service discovery
- Health checks
- Nadpisaniami developerskimi"

# docker-compose.yml
version: '3.9'

services:
  # API Gateway
  gateway:
    build:
      context: ./gateway
      target: ${BUILD_TARGET:-production}
    ports:
      - "8080:8080"
    environment:
      - SERVICE_DISCOVERY_URL=http://consul:8500
      - LOG_LEVEL=${LOG_LEVEL:-info}
    depends_on:
      consul:
        condition: service_healthy
      auth-service:
        condition: service_healthy
      product-service:
        condition: service_healthy
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health"]
      interval: 30s
      timeout: 3s
      retries: 3

  # Serwis Auth
  auth-service:
    build:
      context: ./services/auth
      cache_from:
        - ${REGISTRY}/auth-service:cache
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/auth_db
      - REDIS_URL=redis://redis:6379
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    deploy:
      replicas: 2
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/health"]
      interval: 30s
      timeout: 3s
      retries: 3

  # Serwis Product
  product-service:
    build:
      context: ./services/product
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/product_db
      - CACHE_URL=redis://redis:6379
      - S3_BUCKET=${S3_BUCKET}
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    volumes:
      - product-images:/app/uploads
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3002/health"]
      interval: 30s
      timeout: 3s
      retries: 3

  # PostgreSQL
  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=${DB_PASSWORD:-postgres}
      - POSTGRES_MULTIPLE_DATABASES=auth_db,product_db
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./scripts/init-db.sh:/docker-entrypoint-initdb.d/init-db.sh
    networks:
      - app-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis
  redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD:-redis}
    volumes:
      - redis-data:/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Service Discovery
  consul:
    image: consul:1.17
    command: agent -server -bootstrap -ui -client=0.0.0.0
    ports:
      - "8500:8500"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "consul", "members"]
      interval: 10s
      timeout: 5s
      retries: 5

networks:
  app-network:
    driver: bridge

volumes:
  postgres-data:
  redis-data:
  product-images:

Claude Code

# Generowanie kompletnego stacku
claude "Stwórz konfigurację Docker Compose dla:
1. Architektury mikroserwisów
2. Kolejki wiadomości (RabbitMQ/Kafka)
3. Stacku monitorowania (Prometheus/Grafana)
4. Agregacji logów (ELK)
5. Konfiguracji development vs production"

Środowisko developerskie

docker-compose.dev.yml

# Prompt AI: "Stwórz Docker Compose developerski z hot reload"

version: '3.9'

services:
  # Frontend z hot reload
  frontend:
    build:
      context: ./frontend
      target: development
    volumes:
      - ./frontend:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - REACT_APP_API_URL=http://localhost:8080
    ports:
      - "3000:3000"
    command: npm run dev

  # Backend z trybem watch
  backend:
    build:
      context: ./backend
      target: development
    volumes:
      - ./backend:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - DEBUG=app:*
    ports:
      - "8080:8080"
      - "9229:9229" # Debugger Node.js
    command: npm run dev:debug

  # Baza danych z inicjalizacją
  postgres:
    ports:
      - "5432:5432"
    volumes:
      - ./db/init:/docker-entrypoint-initdb.d
      - ./db/seeds:/seeds

  # Mailhog do testowania emaili
  mailhog:
    image: mailhog/mailhog
    ports:
      - "1025:1025" # SMTP
      - "8025:8025" # Web UI
    networks:
      - app-network

  # Adminer do zarządzania bazą danych
  adminer:
    image: adminer
    ports:
      - "8081:8080"
    networks:
      - app-network

Najlepsze praktyki bezpieczeństwa

Zabezpieczanie kontenerów

Cursor

# Prompt AI
Agent: "Zabezpiecz ten kontener Docker poprzez:
- Skanowanie bezpieczeństwa
- Minimalną powierzchnię ataku
- System plików tylko do odczytu
- Usunięcie capabilities
- Polityki bezpieczeństwa"

# Przykład zabezpieczonego kontenera
FROM node:20-alpine AS production

# Instalacja aktualizacji bezpieczeństwa
RUN apk update && apk upgrade && rm -rf /var/cache/apk/*

# Utworzenie użytkownika non-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

# Konfiguracja katalogu aplikacji z właściwymi uprawnieniami
WORKDIR /app
RUN chown nodejs:nodejs /app

# Kopiowanie plików aplikacji
COPY --chown=nodejs:nodejs package*.json ./
RUN npm ci --only=production && npm cache clean --force
COPY --chown=nodejs:nodejs . .

# Konfiguracje bezpieczeństwa
USER nodejs

# Usunięcie wszystkich capabilities
RUN apk add --no-cache libcap && \
    setcap -r /usr/local/bin/node || true

# System plików tylko do odczytu
RUN chmod -R a-w /app

# Etykiety bezpieczeństwa
LABEL security.scan="enabled" \
      security.updates="auto"

# Health check z timeout
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js || exit 1

# Uruchomienie z ograniczonymi zasobami
CMD ["node", "--max-old-space-size=512", "index.js"]

Claude Code

# Audit bezpieczeństwa
claude "Zbadaj ten Dockerfile pod kątem problemów bezpieczeństwa i napraw:
1. Luki CVE
2. Ryzyko eskalacji uprawnień
3. Ujawnienie sekretów
4. Powierzchnię ataku sieciowego
5. Limity zasobów"

Zarządzanie sekretami

docker-compose.secrets.yml

# Prompt AI: "Implementuj bezpieczną obsługę sekretów w Docker"

version: '3.9'

services:
  app:
    build: .
    secrets:
      - db_password
      - api_key
      - jwt_secret
    environment:
      - DB_PASSWORD_FILE=/run/secrets/db_password
      - API_KEY_FILE=/run/secrets/api_key
      - JWT_SECRET_FILE=/run/secrets/jwt_secret
    # Użyj skryptu init do ładowania sekretów
    entrypoint: ["/app/docker-entrypoint.sh"]
    command: ["node", "index.js"]

secrets:
  db_password:
    file: ./secrets/db_password.txt
  api_key:
    file: ./secrets/api_key.txt
  jwt_secret:
    file: ./secrets/jwt_secret.txt

# docker-entrypoint.sh
#!/bin/sh
set -e

# Ładowanie sekretów z plików do zmiennych środowiskowych
if [ -f "$DB_PASSWORD_FILE" ]; then
    export DB_PASSWORD=$(cat "$DB_PASSWORD_FILE")
fi

if [ -f "$API_KEY_FILE" ]; then
    export API_KEY=$(cat "$API_KEY_FILE")
fi

if [ -f "$JWT_SECRET_FILE" ]; then
    export JWT_SECRET=$(cat "$JWT_SECRET_FILE")
fi

# Wykonanie głównej komendy
exec "$@"

Development Containers

VS Code Dev Container

.devcontainer/devcontainer.json

// Prompt AI: "Stwórz devcontainer dla rozwoju full-stack"

{
  "name": "Full Stack Dev Container",
  "dockerComposeFile": "docker-compose.yml",
  "service": "dev",
  "workspaceFolder": "/workspace",

  "features": {
    "ghcr.io/devcontainers/features/common-utils:2": {},
    "ghcr.io/devcontainers/features/git:1": {},
    "ghcr.io/devcontainers/features/node:1": {
      "version": "20"
    },
    "ghcr.io/devcontainers/features/docker-in-docker:2": {}
  },

  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "ms-azuretools.vscode-docker",
        "github.copilot",
        "continue.continue"
      ],
      "settings": {
        "terminal.integrated.defaultProfile.linux": "zsh",
        "editor.formatOnSave": true,
        "editor.defaultFormatter": "esbenp.prettier-vscode"
      }
    }
  },

  "forwardPorts": [3000, 8080, 5432],

  "postCreateCommand": "npm install && npm run db:migrate",

  "remoteUser": "vscode"
}

Integracja CI/CD

GitHub Actions

Cursor

# Prompt AI
Agent: "Stwórz workflow GitHub Actions dla Docker:
- Build i test
- Skanowanie bezpieczeństwa
- Push do registry
- Wdrożenie na staging
- Optymalizacja cache"

# .github/workflows/docker-ci.yml
name: Docker CI/CD

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

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
      security-events: write

    steps:
      - name: Checkout kodu
        uses: actions/checkout@v4

      - name: Konfiguracja Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Logowanie do registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Wyciąganie metadanych
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=sha

      - name: Build i push obrazu Docker
        uses: docker/build-push-action@v5
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
          build-args: |
            VERSION=${{ github.sha }}

      - name: Uruchomienie skanera Trivy
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}
          format: 'sarif'
          output: 'trivy-results.sarif'

      - name: Upload wyników Trivy
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: 'trivy-results.sarif'

      - name: Uruchomienie testów integracyjnych
        run: |
          docker compose -f docker-compose.test.yml up --abort-on-container-exit
          docker compose -f docker-compose.test.yml down -v

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

    steps:
      - name: Wdrożenie na staging
        uses: digitalocean/action-doctl@v2
        with:
          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}
        run: |
          doctl kubernetes cluster kubeconfig save staging-cluster
          kubectl set image deployment/app app=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}
          kubectl rollout status deployment/app

Claude Code

# Generowanie pipeline CI/CD
claude "Stwórz kompletny pipeline Docker CI/CD z:
1. Buildami wieloarchitekturowymi
2. Skanowaniem luk
3. Generowaniem SBOM
4. Automatycznym testowaniem
5. Wdrożeniem progresywnym"

Najlepsze praktyki

Wytyczne rozwoju Docker

1. Cachowanie warstw - Porządkuj komendy Dockerfile od najmniej do najbardziej zmieniających się
2. Buildy wieloetapowe - Oddziel zależności buildowe od runtime
3. Bezpieczeństwo na pierwszym miejscu - Uruchamiaj jako non-root, skanuj luki
4. Rozmiar ma znaczenie - Używaj minimalnych obrazów bazowych, usuwaj niepotrzebne pliki
5. Health checks - Zawsze implementuj endpointy health check
6. Sekrety - Nigdy nie hardcoduj sekretów, używaj właściwego zarządzania sekretami

Typowe wzorce

Debugowanie

# AI: "Dodaj możliwości debugowania do kontenera produkcyjnego"
FROM app:production AS debug

# Instalacja narzędzi debugowania
USER root
RUN apk add --no-cache \
    curl \
    wget \
    netcat-openbsd \
    bind-tools \
    strace

USER nodejs

# Włączenie debugowania Node.js
ENV NODE_OPTIONS="--inspect=0.0.0.0:9229"
EXPOSE 9229

Testowanie

# AI: "Stwórz kontener do uruchamiania testów"
FROM app:builder AS test

# Instalacja zależności testowych
RUN npm ci --include=dev

# Kopiowanie plików testowych
COPY --chown=nodejs:nodejs tests ./tests

# Uruchomienie testów
CMD ["npm", "test"]

Rozwiązywanie problemów

Typowe problemy

# Prompt AI: "Debuguj problemy z buildem Docker"

# Analiza wydajności buildu
docker build --progress=plain --no-cache .

# Debugowanie rozmiarów warstw
docker history --human --format "table {{.CreatedBy}}\t{{.Size}}" image:tag

# Inspekcja cache buildu
docker buildx du --verbose

# Skanowanie bezpieczeństwa
docker scout cves image:tag

# Użycie zasobów
docker stats --no-stream

Następne kroki

Wzorce Kubernetes Wdrażaj kontenery na dużą skalę z orkiestracją Kubernetes

Pipeline CI/CD Automatyzuj przepływy pracy kontenerów z zaawansowanym CI/CD