Docker und ContainerisierungDeployment und Skalierung in 2026

TL;DR

Docker containerisiert Anwendungen und gewährleistet konsistente Umgebungen von Entwicklung bis Produktion. Es erleichtert Deployment, Skalierung und Infrastrukturverwaltung. Hier erfahren Sie, wie Sie Docker in 2026 verwenden.

Für wen ist das

• Entwickler, die Umgebungen standardisieren möchten
• DevOps-Ingenieure, die Infrastruktur verwalten
• Unternehmen, die Anwendungen skalieren möchten

Keywords (SEO)

docker, containerisierung, docker compose, kubernetes, container deployment

Was ist Docker?

Docker ist eine Containerisierungsplattform:

• Isolierte Umgebungen (Container)
• Konsistenz zwischen Umgebungen
• Leichtgewichtig (vs. virtuelle Maschinen)
• Schneller Start

Container vs. VM:

• VM: vollständiges OS, langsamer, mehr Ressourcen
• Container: geteiltes OS, schneller, weniger Ressourcen

Vorteile:

• "Funktioniert auf meinem Computer" → gelöst
• Schnellere Deployments
• Einfachere Skalierung
• Bessere Ressourcennutzung

Docker-Grundlagen

Dockerfile

Grundlegendes Beispiel:

# Base image
FROM node:18-alpine

# Working directory
WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose port
EXPOSE 3000

# Start application
CMD ["npm", "start"]

Build und Run

Image bauen:

docker build -t my-app:latest .

Container ausführen:

docker run -p 3000:3000 my-app:latest

Im Hintergrund ausführen:

docker run -d -p 3000:3000 --name my-app my-app:latest

Dockerfile Best Practices

1. Multi-Stage Builds

Image-Größe reduzieren:

# Stage 1: Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY --from=builder /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/index.js"]

2. Layer Caching

Optimale Reihenfolge:

# 1. Dependencies (ändern sich selten)
COPY package*.json ./
RUN npm ci

# 2. Anwendungscode (ändert sich oft)
COPY . .

3. .dockerignore verwenden

.dockerignore:

node_modules
npm-debug.log
.git
.env
dist
*.md

4. Minimale Base Images

Alpine Linux:

FROM node:18-alpine  # ~5MB vs. ~150MB für node:18

Distroless (noch kleiner):

FROM gcr.io/distroless/nodejs18-debian11

5. Non-Root User

Sicherheit:

RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
USER nextjs

Docker Compose

Grundkonfiguration

docker-compose.yml:

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db
      - redis

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres_data:/var/lib/postgresql/data

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

volumes:
  postgres_data:

Ausführen

Alle Services starten:

docker-compose up -d

Logs:

docker-compose logs -f app

Stoppen:

docker-compose down

Kubernetes

Grundkonzepte

Pod:

• Kleinste Einheit
• Ein oder mehrere Container
• Geteilte Ressourcen (Netzwerk, Storage)

Deployment:

• Verwaltet Pod-Replikate
• Rolling Updates
• Rollback

Service:

• Exponiert Pods als Netzwerk
• Load Balancing
• Service Discovery

Grundlegendes Deployment

deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-app:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

Service:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

Anwenden:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Skalierung

Horizontal Pod Autoscaler (HPA)

Automatische Skalierung:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Manuelle Skalierung

kubectl scale deployment my-app --replicas=5

Monitoring und Logging

Health Checks

Im Dockerfile:

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

In Kubernetes:

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 30
  periodSeconds: 10

readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 5

Logging

Docker-Logs:

docker logs my-app
docker logs -f my-app  # Follow

Kubernetes-Logs:

kubectl logs deployment/my-app
kubectl logs -f deployment/my-app

Sicherheits-Best Practices

1. Images scannen

docker scan my-app:latest

2. Minimale Berechtigungen

USER nonroot

3. Secrets Management

Nicht im Dockerfile:

# ❌ Schlecht
ENV API_KEY=secret123

Secrets verwenden:

# Kubernetes
apiVersion: v1
kind: Secret
metadata:
  name: api-secret
data:
  api-key: <base64-encoded>

4. Regelmäßige Updates

Base Images aktualisieren:

FROM node:18-alpine  # Neueste Version verwenden

CI/CD mit Docker

GitHub Actions Beispiel:

- name: Build Docker image
  run: docker build -t my-app:${{ github.sha }} .

- name: Push to registry
  run: |
    docker tag my-app:${{ github.sha }} my-registry/my-app:latest
    docker push my-registry/my-app:latest

- name: Deploy to Kubernetes
  run: |
    kubectl set image deployment/my-app app=my-registry/my-app:latest

FAQ

Ist Docker für kleine Projekte nötig?

Nicht immer, aber lohnenswert. Erleichtert Deployment, gewährleistet Umgebungskonsistenz und bereitet auf Skalierung vor.

Docker vs. Kubernetes?

Docker: Containerisierung von Anwendungen. Kubernetes: Container-Orchestrierung (für größere Systeme).

Wie oft Base Images aktualisieren?

Regelmäßig (monatlich). Verwenden Sie Tools wie Dependabot für automatische Updates.

Möchten Sie Ihre Anwendung containerisieren?

• Kontakt