Docker Containerization Masterclass | Cloud & DevOps Tutorial

🐳 Was ist Docker?

Docker ist eine Containerisierungsplattform, die es ermöglicht, Anwendungen und deren Abhängigkeiten in leichtgewichtige, portable Container zu verpacken. Diese Container laufen konsistent auf jeder Umgebung - von der Entwicklung bis zur Produktion.

📦 Portabilität

Container laufen überall gleich

⚡ Effizienz

Weniger Ressourcenverbrauch als VMs

🔄 Skalierung

Schnelle Horizontal-Skalierung

🔧 Docker Installation

Windows Installation

# Docker Desktop für Windows herunterladen
# https://www.docker.com/products/docker-desktop

# Installation verifizieren
docker --version
docker-compose --version

Linux Installation (Ubuntu)

# Docker Repository hinzufügen
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Docker installieren
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# User zu Docker-Gruppe hinzufügen
sudo usermod -aG docker $USER

📦 Docker Images erstellen

Erstes Dockerfile

# Dockerfile für eine Node.js Anwendung
FROM node:18-alpine

# Arbeitsverzeichnis setzen
WORKDIR /app

# Package.json kopieren
COPY package*.json ./

# Dependencies installieren
RUN npm ci --only=production

# Anwendungscode kopieren
COPY . .

# Port freigeben
EXPOSE 3000

# Startkommando definieren
CMD ["npm", "start"]

💡 Best Practice Tipps

• Alpine Images verwenden - Kleiner und sicherer
• Layer-Caching optimieren - Dependencies zuerst kopieren
• .dockerignore nutzen - Unnötige Dateien ausschließen
• Non-root User - Sicherheit durch eingeschränkte Rechte

🏗️ Multi-Stage Builds

React App mit Multi-Stage Build

# Build Stage
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

# Production Stage
FROM nginx:alpine AS production

# Built assets kopieren
COPY --from=builder /app/dist /usr/share/nginx/html

# Custom nginx config
COPY nginx.conf /etc/nginx/nginx.conf

EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

✅ Vorteile von Multi-Stage Builds

Kleinere Images

Nur Production-Artifacts im finalen Image

Bessere Sicherheit

Build-Tools nicht in Production

🐙 Docker Compose

Full-Stack Anwendung mit Compose

version: '3.8'

services:
  # Frontend Service
  frontend:
    build: 
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "3000:80"
    depends_on:
      - backend
    environment:
      - REACT_APP_API_URL=http://backend:5000

  # Backend Service
  backend:
    build: 
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    depends_on:
      - database
    environment:
      - DATABASE_URL=postgresql://user:password@database:5432/mydb
      - JWT_SECRET=your-secret-key
    volumes:
      - ./uploads:/app/uploads

  # Database Service
  database:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  # Redis Cache
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

Compose Kommandos

# Services starten
docker-compose up -d

# Services mit Build
docker-compose up --build

# Logs anzeigen
docker-compose logs -f

# Services stoppen
docker-compose down

# Mit Volumes löschen
docker-compose down -v

🔒 Container Security

⚠️ Security Risks

• Vulnerable Base Images
• Root User in Container
• Exposed Secrets
• Ungeschützte Container Ports
• Privilege Escalation

✅ Security Best Practices

• Minimal Base Images (Alpine)
• Non-root User verwenden
• Secrets Management
• Regular Security Scans
• Container Runtime Security

Sicheres Dockerfile

FROM node:18-alpine

# Non-root user erstellen
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

# Dependencies installieren
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force

# Code kopieren und Ownership setzen
COPY --chown=nextjs:nodejs . .

# User wechseln
USER nextjs

EXPOSE 3000
CMD ["npm", "start"]

🚀 Production Best Practices

📊 Monitoring

• Container Metrics
• Health Checks
• Log Aggregation
• Performance Monitoring

🔄 Deployment

• Rolling Updates
• Blue-Green Deployment
• Canary Releases
• Rollback Strategien

⚡ Performance

• Resource Limits
• Image Optimization
• Layer Caching
• Registry Optimization

Health Checks implementieren

# Dockerfile Health Check
FROM node:18-alpine

WORKDIR /app
COPY . .
RUN npm install

# Health Check hinzufügen
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3   CMD curl -f http://localhost:3000/health || exit 1

EXPOSE 3000
CMD ["npm", "start"]

🎯 Zusammenfassung

Docker Containerization ist ein fundamentaler Baustein moderner DevOps-Praktiken. Mit den richtigen Techniken und Best Practices können Sie:

Erreichte Ziele

✅ Konsistente Deployment-Umgebungen
✅ Effiziente Ressourcennutzung
✅ Skalierbare Microservices-Architektur
✅ Vereinfachte CI/CD-Pipelines

Nächste Schritte

🔄 Kubernetes für Orchestrierung
🔍 Container Monitoring Setup
🛡️ Advanced Security Hardening
📊 Performance Optimization

📋 Inhaltsverzeichnis

Docker ContainerizationMasterclass