Docker Container

KAPITEL 08 · CLOUD & INFRASTRUKTUR

Docker Container

Die Revolution der Software-Bereitstellung – Containerisierung ermöglicht portable, skalierbare und konsistente Anwendungen. Lernen Sie Docker von den Grundlagen bis zu Best Practices für moderne Infrastruktur.

Container Dockerfile Volumes Networking

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernen Sie alles über Docker Container:

  • Was ist Docker? Containerisierung und ihre Vorteile
  • Container vs. VMs: Unterschiede und Einsatzgebiete
  • Docker-Komponenten: Images, Container, Volumes, Networks
  • Docker-Befehle: Die wichtigsten CLI-Kommandos
  • Dockerfile: Images erstellen und anpassen
  • Best Practices: Performance, Sicherheit, Organisation
  • FAQ: Häufige Fragen und Troubleshooting

1. Was ist Docker?

Definition

Docker ist eine Open-Source-Plattform zur Containerisierung von Anwendungen. Ein Container ist eine leichtgewichtige, isolierte Laufzeitumgebung, die eine Anwendung mit allen benötigten Abhängigkeiten (Bibliotheken, Konfiguration, Tools) paketiert.

Docker löst das klassische Problem: "Bei mir funktioniert es!" – Container laufen überall gleich, unabhängig vom Host-System. Entwickelt auf einem Laptop, deployed in der Cloud, getestet in CI/CD – immer dasselbe Ergebnis.

Die drei Hauptvorteile: Portabilität (läuft überall), Konsistenz (gleiche Umgebung) und Effizienz (weniger Ressourcen als VMs).

Warum Docker so erfolgreich ist

  • Schnell: Container starten in Sekunden (vs. Minuten bei VMs)
  • Leichtgewichtig: Teilen sich den Host-Kernel, kein Gast-OS nötig
  • Skalierbar: Einfaches Replizieren und Orchestrieren
  • Versioniert: Images sind versionierbar wie Code
  • Ökosystem: Docker Hub mit Millionen vorgefertigter Images

2. Container vs. Virtuelle Maschinen

Container und VMs lösen ähnliche Probleme, aber auf unterschiedliche Weise.

Architektur-Vergleich

Container

  • OS: Teilen sich Host-Kernel
  • Größe: MB (nicht GB)
  • Startzeit: Sekunden
  • Isolation: Prozess-Level
  • Performance: Nahezu nativ
  • Dichte: 100+ Container pro Host

Virtuelle Maschinen

  • OS: Vollständiges Gast-OS
  • Größe: GB (nicht MB)
  • Startzeit: Minuten
  • Isolation: Hardware-Level
  • Performance: Overhead durch Hypervisor
  • Dichte: 10-20 VMs pro Host

Wann Container, wann VMs?

Container für: Microservices, CI/CD, moderne Web-Apps, skalierbare Services

VMs für: Legacy-Systeme, unterschiedliche OS, starke Isolation, Compliance-Anforderungen

Häufige Kombination: VMs als Host-System, Container für die Anwendungen (z.B. Kubernetes auf VMs)

3. Docker-Komponenten

Docker besteht aus vier Hauptkomponenten, die zusammenarbeiten.

Images

Vorlagen für Container – read-only, versioniert, layer-basiert.

  • Read-only Template
  • Aus Layern aufgebaut
  • Versionierbar (Tags)
  • Docker Hub Registry

Container

Laufende Instanzen von Images – isoliert, mit eigenem Dateisystem.

  • Laufende Image-Instanz
  • Eigenes Dateisystem
  • Isolierter Prozessraum
  • Start/Stop/Remove

Volumes

Persistente Datenspeicherung – über Container-Lebenszyklus hinaus.

  • Persistente Daten
  • Zwischen Containern teilbar
  • Host-Dateisystem-Mounts
  • Backup-freundlich

Networks

Netzwerk-Isolation und Kommunikation zwischen Containern.

  • Bridge (Standard)
  • Host (direkter Zugriff)
  • Overlay (Multi-Host)
  • None (keine Netzwerk)

4. Wichtige Docker-Befehle

Die wichtigsten CLI-Kommandos für die tägliche Arbeit mit Docker.

Image ziehen
docker pull nginx:latest

Lädt ein Image von Docker Hub herunter.

Container starten
docker run -d -p 80:80 --name web nginx

Startet einen Container im Hintergrund mit Port-Mapping.

Container auflisten
docker ps -a

Zeigt alle Container (laufend und gestoppt).

Container stoppen
docker stop web

Stoppt einen laufenden Container.

Container entfernen
docker rm web

Entfernt einen gestoppten Container.

Images auflisten
docker images

Zeigt alle lokalen Images.

Shell im Container
docker exec -it web /bin/bash

Öffnet eine interaktive Shell im laufenden Container.

Logs anzeigen
docker logs -f web

Zeigt Container-Logs (live mit -f).

Aufräumen
docker system prune -a

Entfernt ungenutzte Container, Images, Volumes.

5. Dockerfile – Eigene Images erstellen

Ein Dockerfile ist eine Textdatei mit Anweisungen zum Erstellen eines Docker-Images.

Dockerfile-Beispiel

Dockerfile # Basis-Image verwenden FROM node:18-alpine # Arbeitsverzeichnis setzen WORKDIR /app # Abhängigkeiten kopieren und installieren COPY package*.json ./ RUN npm install # Anwendungscode kopieren COPY . . # Port freigeben EXPOSE 3000 # Startbefehl CMD ["npm", "start"]

Image bauen und starten

Bash # Image bauen docker build -t my-app:1.0 . # Container starten docker run -d -p 3000:3000 --name my-app my-app:1.0

Wichtige Dockerfile-Anweisungen

FROM

Basis-Image festlegen (z.B. ubuntu:20.04, node:18-alpine)

RUN

Befehl während des Build-Prozesses ausführen (z.B. apt-get install)

COPY

Dateien vom Host in das Image kopieren

WORKDIR

Arbeitsverzeichnis im Container setzen

EXPOSE

Ports dokumentieren, die der Container nutzt

CMD

Standard-Befehl beim Container-Start

ENTRYPOINT

Fester Einstiegspunkt (kann mit CMD ergänzt werden)

ENV

Umgebungsvariablen setzen

6. Docker Best Practices

Bewährte Methoden für effiziente, sichere und wartbare Docker-Images.

Performance

  • Kleine Basis-Images nutzen (Alpine Linux)
  • Multi-Stage Builds für kleinere Images
  • Layer-Caching optimieren (häufig ändernde Dateien zuletzt)
  • Unnötige Pakete entfernen
  • .dockerignore verwenden

Sicherheit

  • Nicht als Root laufen (USER-Anweisung)
  • Offizielle Images bevorzugen
  • Regelmäßige Updates (docker pull)
  • Secrets nicht im Image speichern
  • Read-only Filesystem wo möglich

Organisation

  • Semantische Versionierung (1.0.0)
  • Tags für verschiedene Umgebungen (dev, staging, prod)
  • Dokumentation im Dockerfile (Kommentare)
  • Labels für Metadaten
  • Private Registry für interne Images

Wartung

  • Health Checks implementieren
  • Logs strukturiert ausgeben (JSON)
  • Graceful Shutdown unterstützen
  • Regelmäßige Sicherheits-Scans (Trivy, Clair)
  • Automatische Updates in CI/CD

Multi-Stage Build Beispiel

Dockerfile # Build-Stage FROM node:18 AS builder WORKDIR /app COPY package*.json ./ RUN npm install COPY . . RUN npm run build # Production-Stage FROM node:18-alpine WORKDIR /app COPY --from=builder /app/dist ./dist COPY package*.json ./ RUN npm install --production CMD ["node", "dist/index.js"]

Ergebnis: Kleines Production-Image ohne Build-Tools und Quellcode.

7. FAQ – Häufige Fragen & Antworten

Häufige Fragen zu Docker

Was ist der Unterschied zwischen docker run und docker start?

docker run: Erstellt einen neuen Container aus einem Image und startet ihn. Kombiniert docker create + docker start.

docker start: Startet einen bereits existierenden, gestoppten Container. Erstellt keinen neuen Container.

Beispiel:

  • docker run nginx → Erstellt und startet neuen Container
  • docker stop web → Stoppt Container
  • docker start web → Startet denselben Container erneut
Wie persistiere ich Daten in Docker?

Container sind standardmäßig ephemer – Daten werden beim Löschen des Containers verloren. Lösungen:

  • Volumes: Von Docker verwaltete persistente Speicher (empfohlen)
  • Bind Mounts: Direkter Zugriff auf Host-Dateisystem
  • tmpfs: Temporärer Speicher im RAM

Beispiel:

Bash docker run -v my-volume:/data nginx
Wie kommunizieren Container miteinander?

Docker bietet mehrere Netzwerk-Modi:

  • Bridge (Standard): Container im gleichen Netzwerk können sich über Namen erreichen
  • Host: Container nutzt direkt das Host-Netzwerk
  • Overlay: Für Multi-Host-Setups (Swarm, Kubernetes)
  • None: Keine Netzwerkverbindung

Beispiel:

Bash docker network create my-network docker run --network my-network --name db postgres docker run --network my-network --name app my-app

Der app-Container kann jetzt db über den Namen "db" erreichen.

Warum ist mein Docker-Image so groß?

Häufige Ursachen und Lösungen:

  • Großes Basis-Image: Ubuntu (~100MB) statt Alpine (~5MB) verwenden
  • Unnötige Layer: RUN-Befehle zusammenfassen (&& verwenden)
  • Build-Tools im Image: Multi-Stage Builds nutzen
  • Cache nicht genutzt: Häufig ändernde Dateien zuletzt kopieren
  • Kein .dockerignore: node_modules, .git etc. ausschließen

Tipp: docker image history <image> zeigt die Layer-Größen.

Wie sichere ich Docker-Container ab?

Wichtige Sicherheitsmaßnahmen:

  • Nicht als Root: USER-Anweisung im Dockerfile verwenden
  • Offizielle Images: Nur vertrauenswürdige Quellen nutzen
  • Regelmäßige Updates: docker pull für aktuelle Patches
  • Read-only: --read-only Flag wo möglich
  • Resource Limits: --memory, --cpus begrenzen
  • Security Scans: Trivy, Clair für Schwachstellen
  • Secrets: Docker Secrets oder externe Vault-Lösungen
Was ist Docker Compose und wann nutze ich es?

Docker Compose ist ein Tool zur Definition und Ausführung von Multi-Container-Anwendungen über eine YAML-Datei.

Wann nutzen?

  • Anwendungen mit mehreren Services (Web + DB + Cache)
  • Lokale Entwicklungsumgebungen
  • CI/CD-Pipelines
  • Einfache Deployment-Szenarien

Beispiel:

docker-compose.yml version: '3.8' services: web: image: nginx ports: - "80:80" db: image: postgres environment: POSTGRES_PASSWORD: secret
Bash docker-compose up -d
Wie debugge ich einen Container, der nicht startet?

Systematische Fehlersuche:

  • Logs prüfen: docker logs <container>
  • Exit-Code: docker inspect <container> | grep ExitCode
  • Interaktiv starten: docker run -it <image> /bin/sh
  • Resource Limits: docker stats prüfen
  • Netzwerk: docker network inspect
  • Events: docker events für Echtzeit-Logs

Tipp: docker run --entrypoint /bin/sh <image> überschreibt den ENTRYPOINT für Debugging.

Was ist der Unterschied zwischen CMD und ENTRYPOINT?

CMD: Standard-Befehl, der beim Container-Start ausgeführt wird. Kann durch docker run <image> <command> überschrieben werden.

ENTRYPOINT: Fester Einstiegspunkt, der immer ausgeführt wird. Argumente von docker run werden angehängt.

Kombination: ENTRYPOINT für den Hauptbefehl, CMD für Standard-Argumente.

Dockerfile ENTRYPOINT ["python"] CMD ["app.py"]

docker run my-app → Führt python app.py aus
docker run my-app script.py → Führt python script.py aus

Zusammenfassung

Die wichtigsten Punkte

  • Docker: Containerisierung für portable, konsistente Anwendungen
  • Container vs. VMs: Container sind leichtgewichtiger, schneller, teilen Host-Kernel
  • Komponenten: Images (Vorlagen), Container (Instanzen), Volumes (Daten), Networks
  • Befehle: pull, run, ps, stop, rm, exec, logs, system prune
  • Dockerfile: FROM, RUN, COPY, WORKDIR, EXPOSE, CMD, ENTRYPOINT
  • Best Practices: Kleine Images, Multi-Stage Builds, Security, Versionierung
  • Docker Compose: Multi-Container-Orchestrierung über YAML
  • Einsatz: Microservices, CI/CD, Entwicklung, Testing, Production

Nächste Schritte

Docker ist die Grundlage für moderne Infrastruktur. Als nächstes lernen Sie:

  • Docker Compose: Multi-Container-Anwendungen definieren
  • Kubernetes: Container-Orchestrierung für Production
  • Docker Swarm: Native Docker-Orchestrierung
  • Container-Registries: Docker Hub, AWS ECR, GitLab Registry

Weiterführende Themen

Docker Compose

Multi-Container-Anwendungen mit YAML definieren und orchestrieren.

Zu Docker Compose
Container Orchestration

Kubernetes, Docker Swarm – Skalierung und Hochverfügbarkeit.

Zu Orchestration
Cloud Security

Sicherheit in Cloud- und Container-Umgebungen.

Zu Cloud Security
Virtualisierung

VMs, Hypervisor, KVM – die Grundlage für Container.

Zu Virtualisierung