🐳 Was ist Docker?

📖 Definition

Docker ist eine Plattform, die Anwendungen in isolierten Umgebungen namens Container ausführt. Container bündeln eine Anwendung mit allen benötigten Abhängigkeiten, sodass sie überall identisch ausgeführt werden können. Es löst das "Auf meinem Rechner funktioniert es..."-Problem und macht Entwicklung, Tests und Deployment einfach und konsistent.

🎯 Verstehen durch Analogien

Versandcontainer

Docker kann man mit Frachtcontainern vergleichen:

Traditioneller Versand (VM)
├─ Unterschiedliche Verpackung pro Artikel
├─ Verschiedene Größen/Gewichte
├─ Unterschiedliche Transportmethoden
└─ Ineffizient, komplex

Container-Versand (Docker)
├─ Standardisierte Container
├─ Kann beliebige Artikel aufnehmen
├─ Schiff, LKW, Bahn - überall gleich transportierbar
└─ Effizient, einfach

Docker Container = Standardisiertes Softwarepaket

Wohnung vs. Einfamilienhaus

Virtual Machine (VM) = Einfamilienhaus
├─ Jedes Haus braucht komplette Infrastruktur
├─ Grundstück, Gebäude, Strom, Wasser alles separat
├─ Hohe Kosten
└─ Langsamer Start

Docker Container = Wohnung
├─ Gemeinsame Infrastruktur (Grundstück, Gebäude)
├─ Jede Wohnung unabhängig
├─ Effizient
└─ Schneller Einzug

⚙️ Funktionsweise

1. Docker-Architektur

┌─────────────────────────────────────┐
│       Docker Client (CLI)           │
│  docker run, docker build, usw.     │
└───────────────┬─────────────────────┘
                │ API-Aufrufe
┌───────────────▼─────────────────────┐
│         Docker Daemon               │
│    Container-/Image-Verwaltung      │
└───────────────┬─────────────────────┘
                │
┌───────────────▼─────────────────────┐
│    Container (laufende Apps)        │
│  ┌─────┐ ┌─────┐ ┌─────┐            │
│  │App 1│ │App 2│ │App 3│            │
│  └─────┘ └─────┘ └─────┘            │
└─────────────────────────────────────┘
                │
┌───────────────▼─────────────────────┐
│       Host OS (Linux Kernel)        │
└─────────────────────────────────────┘

2. Image vs Container

Image = Bauplan, Klasse
├─ Nur lesbar
├─ Aus Schichten aufgebaut
├─ Wiederverwendbar
└─ Beispiel: ubuntu, node, nginx

Container = Laufende Instanz, Objekt
├─ Aus Image erstellt
├─ Ausführbar
├─ Isolierte Umgebung
└─ Mehrere Instanzen möglich

Beziehung:
Image → Container 1
     → Container 2
     → Container 3

3. Dockerfile → Image → Container

1. Dockerfile schreiben (Rezept)
   ├─ FROM node:18
   ├─ COPY package.json .
   ├─ RUN npm install
   └─ CMD ["npm", "start"]

2. Image bauen (Kochen)
   docker build -t my-app .

3. Container ausführen (Servieren)
   docker run -p 3000:3000 my-app

💡 Praxisbeispiele

Dockerfile schreiben

# Node.js Anwendung Dockerfile

# Basis-Image
FROM node:18-alpine

# Arbeitsverzeichnis festlegen
WORKDIR /app

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

# Abhängigkeiten installieren
RUN npm ci --only=production

# Quellcode kopieren
COPY . .

# Port freigeben
EXPOSE 3000

# Umgebungsvariable
ENV NODE_ENV=production

# Befehl beim Container-Start
CMD ["node", "server.js"]

Image bauen und ausführen

# 1. Image bauen
docker build -t my-node-app:1.0 .
# -t: Tag (Name:Version)
# .: Dockerfile im aktuellen Verzeichnis

# 2. Image prüfen
docker images
# REPOSITORY      TAG       IMAGE ID       CREATED
# my-node-app     1.0       abc123         2 minutes ago

# 3. Container ausführen
docker run -d \
  --name my-app \
  -p 3000:3000 \
  -e NODE_ENV=production \
  my-node-app:1.0

# -d: Hintergrund-Ausführung
# --name: Container-Name
# -p: Port-Mapping (Host:Container)
# -e: Umgebungsvariable

# 4. Laufende Container prüfen
docker ps

# 5. Logs anzeigen
docker logs my-app

# 6. In Container zugreifen
docker exec -it my-app sh

# 7. Container stoppen
docker stop my-app

# 8. Container löschen
docker rm my-app

# 9. Image löschen
docker rmi my-node-app:1.0

Docker Compose (Mehrere Container verwalten)

# docker-compose.yml

version: '3.8'

services:
  # Webanwendung
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=database
    depends_on:
      - database
      - redis
    volumes:
      - ./logs:/app/logs

  # Datenbank
  database:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=secret
      - MYSQL_DATABASE=myapp
    volumes:
      - db-data:/var/lib/mysql
    ports:
      - "3306:3306"

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

  # Nginx (Reverse Proxy)
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - web

volumes:
  db-data:

# Docker Compose Befehle

# Alle Services starten
docker-compose up -d

# Logs anzeigen
docker-compose logs -f web

# Bestimmten Service neu starten
docker-compose restart web

# Services skalieren
docker-compose up -d --scale web=3

# Alle Services stoppen und löschen
docker-compose down

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

Praxisbeispiel: React + Node.js + MongoDB

# frontend/Dockerfile
FROM node:18-alpine AS build

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

# Statische Dateien mit Nginx bereitstellen
FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# backend/Dockerfile
FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .

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

# docker-compose.yml
version: '3.8'

services:
  frontend:
    build:
      context: ./frontend
    ports:
      - "80:80"
    depends_on:
      - backend

  backend:
    build:
      context: ./backend
    ports:
      - "5000:5000"
    environment:
      - MONGO_URL=mongodb://mongodb:27017/myapp
    depends_on:
      - mongodb

  mongodb:
    image: mongo:6
    volumes:
      - mongo-data:/data/db
    ports:
      - "27017:27017"

volumes:
  mongo-data:

Daten-Volume-Verwaltung

# Volume erstellen
docker volume create my-data

# Volume-Liste
docker volume ls

# Volume an Container mounten
docker run -v my-data:/app/data my-app

# Host-Verzeichnis mounten (nützlich bei Entwicklung)
docker run -v $(pwd):/app my-app

# Read-only Mount
docker run -v $(pwd):/app:ro my-app

# Volume löschen
docker volume rm my-data

# Alle ungenutzten Volumes löschen
docker volume prune

.dockerignore Datei

# .dockerignore

# Git
.git
.gitignore

# Node
node_modules
npm-debug.log

# Umgebungskonfiguration
.env
.env.local

# Build-Artefakte
dist
build

# IDE
.vscode
.idea

# Tests
coverage
*.test.js

# Dokumentation
README.md
docs/

🤔 Häufig gestellte Fragen

F1. Docker vs Virtual Machine?

Virtual Machine (VM)
┌─────────────────┐ ┌─────────────────┐
│   App A         │ │   App B         │
│   Libs          │ │   Libs          │
│   Guest OS      │ │   Guest OS      │
│   (Linux)       │ │   (Ubuntu)      │
└─────────────────┘ └─────────────────┘
┌─────────────────────────────────────┐
│        Hypervisor (VMware etc.)     │
└─────────────────────────────────────┘
┌─────────────────────────────────────┐
│         Host OS                     │
└─────────────────────────────────────┘

Docker Container
┌───────┐ ┌───────┐ ┌───────┐
│ App A │ │ App B │ │ App C │
│ Libs  │ │ Libs  │ │ Libs  │
└───────┘ └───────┘ └───────┘
┌─────────────────────────────┐
│    Docker Engine            │
└─────────────────────────────┘
┌─────────────────────────────┐
│    Host OS (Linux Kernel)   │
└─────────────────────────────┘

Vergleich:
           VM              Docker
Größe      GB              MB
Start      Minuten         Sekunden
Isolation  Komplett        Prozess-Ebene
Leistung   Hoher Overhead  Fast nativ
Portabilität Niedrig      Hoch

F2. Was sind Docker Image-Schichten?

FROM node:18          # Schicht 1: Basis-Image
WORKDIR /app          # Schicht 2: Arbeitsverzeichnis
COPY package.json .   # Schicht 3: package.json
RUN npm install       # Schicht 4: Abhängigkeiten installieren
COPY . .              # Schicht 5: Quellcode
CMD ["node", "app.js"]# Schicht 6: Startbefehl

# Schichten-Caching
# - Unveränderte Schichten werden wiederverwendet
# - Beschleunigt Build-Prozess

# ✅ Gutes Beispiel: Häufig geänderte Dinge später
COPY package.json .
RUN npm install       # Gecacht (wenn package.json unverändert)
COPY . .              # Nur Code geändert

# ❌ Schlechtes Beispiel: Häufig geänderte Dinge zuerst
COPY . .              # Bei Code-Änderung
RUN npm install       # npm install erneut ausführen!

F3. Was ist Container-Orchestrierung?

Einzelner Server
┌─────────────────────┐
│  ┌───┐ ┌───┐ ┌───┐ │
│  │C1 │ │C2 │ │C3 │ │
│  └───┘ └───┘ └───┘ │
└─────────────────────┘

Orchestrierung (Kubernetes)
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Server1 │ │ Server2 │ │ Server3 │
│ ┌───┐   │ │ ┌───┐   │ │ ┌───┐   │
│ │C1 │   │ │ │C2 │   │ │ │C3 │   │
│ └───┘   │ │ └───┘   │ │ └───┘   │
└─────────┘ └─────────┘ └─────────┘

Funktionen:
- Automatisches Deployment
- Skalierung (automatische Vergrößerung/Verkleinerung)
- Load Balancing
- Automatische Wiederherstellung (Container neu starten wenn tot)
- Rolling Updates

Tools:
- Kubernetes (am beliebtesten)
- Docker Swarm
- Amazon ECS

F4. Wie nutzt man Docker in der Entwicklungsumgebung?

# Szenario: Jedes Teammitglied hat unterschiedliche Umgebung

# Teammitglied A: macOS, Node 16
# Teammitglied B: Windows, Node 18
# Teammitglied C: Linux, Node 14

# Problem: "Auf meinem Rechner funktioniert es..."

# Lösung: Umgebung mit Docker vereinheitlichen

# docker-compose.yml
version: '3.8'
services:
  app:
    image: node:18
    volumes:
      - .:/app
    working_dir: /app
    command: npm run dev
    ports:
      - "3000:3000"

# Alle Teammitglieder haben identische Umgebung
docker-compose up

# Vorteile:
# 1. Node.js-Installation nicht erforderlich
# 2. Version vereinheitlicht
# 3. Abhängigkeiten isoliert
# 4. Umgebungskonfiguration geteilt

F5. Wie sicher ist Docker?

# ✅ Sicherheits-Best Practices

# 1. Minimales Basis-Image
FROM node:18-alpine  # ✅ Klein und sicher
FROM node:18         # ❌ Viele unnötige Tools

# 2. Als Nicht-Root-Benutzer ausführen
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001
USER nodejs  # ✅ Minimale Berechtigungen

# 3. Sensible Informationen ausschließen
# In .dockerignore hinzufügen
.env
*.key
secrets/

# 4. Multi-Stage Build (unnötige Tools entfernen)
FROM node:18 AS builder
WORKDIR /app
COPY . .
RUN npm run build

FROM node:18-alpine  # Kleines Image
COPY --from=builder /app/dist ./dist
CMD ["node", "dist/main.js"]

# 5. Image scannen
docker scan my-image

# 6. Read-only Root-Dateisystem
docker run --read-only my-app

# 7. Ressourcen-Limits
docker run --memory="512m" --cpus="1" my-app

🎓 Nächste Schritte

Wenn Sie Docker verstanden haben, lernen Sie als nächstes:

Was ist Git? (noch zu schreiben) - Versionskontrolle und Deployment
Was ist Node.js? (noch zu schreiben) - Node-Apps mit Docker deployen
Was ist TDD? - Tests in Docker ausführen

Ausprobieren

# 1. Docker-Installation prüfen
docker --version

# 2. Hello World
docker run hello-world

# 3. Nginx ausführen
docker run -d -p 8080:80 nginx
# http://localhost:8080 aufrufen

# 4. Container prüfen
docker ps

# 5. Stoppen und löschen
docker stop <container-id>
docker rm <container-id>

# 6. Eigene App containerisieren
# - Dockerfile schreiben
# - docker build
# - docker run

Nützliche Befehle

# Image-Verwaltung
docker pull nginx              # Image herunterladen
docker images                  # Image-Liste
docker rmi nginx               # Image löschen

# Container-Verwaltung
docker run                     # Container ausführen
docker ps                      # Laufende Container
docker ps -a                   # Alle Container
docker stop <id>               # Container stoppen
docker start <id>              # Container starten
docker restart <id>            # Container neu starten
docker rm <id>                 # Container löschen

# Logs und Debugging
docker logs <id>               # Logs anzeigen
docker logs -f <id>            # Echtzeit-Logs
docker exec -it <id> sh        # In Container zugreifen
docker inspect <id>            # Detaillierte Informationen

# Aufräumen
docker system prune            # Ungenutzte Ressourcen löschen
docker system prune -a         # Alle ungenutzten Ressourcen
docker volume prune            # Ungenutzte Volumes löschen

🎬 Zusammenfassung

Docker ist ein unverzichtbares Tool moderner Entwicklung:

Container: Isolierte Ausführungsumgebung
Image: Anwendungspaket
Portabilität: Läuft überall identisch
Effizienz: Leichtgewichtig und schnell

Lösen Sie das "Auf meinem Rechner funktioniert es..."-Problem mit Docker! 🐳✨

📖 Definition​

🎯 Verstehen durch Analogien​

Versandcontainer​

Wohnung vs. Einfamilienhaus​

⚙️ Funktionsweise​

1. Docker-Architektur​

2. Image vs Container​

3. Dockerfile → Image → Container​

💡 Praxisbeispiele​

Dockerfile schreiben​

Image bauen und ausführen​

Docker Compose (Mehrere Container verwalten)​

Praxisbeispiel: React + Node.js + MongoDB​

Daten-Volume-Verwaltung​

.dockerignore Datei​

🤔 Häufig gestellte Fragen​

F1. Docker vs Virtual Machine?​

F2. Was sind Docker Image-Schichten?​

F3. Was ist Container-Orchestrierung?​

F4. Wie nutzt man Docker in der Entwicklungsumgebung?​

F5. Wie sicher ist Docker?​

🎓 Nächste Schritte​

Ausprobieren​

Nützliche Befehle​

🎬 Zusammenfassung​