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.