Was ist Docker und wofür wird es verwendet?

Docker: Container für schnelle, portable Anwendungen

Docker hat die Softwarebereitstellung revolutioniert, indem es Anwendungen und ihre Abhängigkeiten in Container kapselt. Container starten extrem schnell, sind ressourcenschonend und laufen in identischer Form auf Entwickler-Laptops, CI/CD-Pipelines und Produktionsumgebungen.

Was ist Docker?

Docker ist eine Plattform zum Paketieren, Verteilen und Ausführen von Anwendungen als Container. Ein Container enthält alles, was eine Anwendung benötigt (Runtime, Libraries, Konfigurationen), und läuft isoliert vom Host-System. Im Gegensatz zu virtuellen Maschinen teilen sich Container den Kernel des Host-Systems – das macht sie leichtgewichtig und schnell.

Kernkonzepte

• Image: Unveränderliches Template mit App und Abhängigkeiten (Versionierbar, in Layers aufgebaut).
• Container: Laufzeitinstanz eines Images (flüchtig, start/stop/restart in Sekunden).
• Dockerfile: Bauplan, der beschreibt, wie ein Image entsteht (Befehle wie FROM, RUN, COPY, CMD).
• Registry: Ablage/Distribution von Images (z. B. Docker Hub, GHCR, GitLab Registry, AWS ECR, Azure ACR, Google Artifact Registry).
• Layer & Copy-on-Write: Images bestehen aus Schichten; Container schreiben nur Delta-Daten (spart Platz und beschleunigt Builds).
• Volumes: Persistente Datenhaltung außerhalb des Container-Filesystems.
• Networks: Isolation und Vernetzung von Containern (Bridge, Host, Overlay).

Wie funktioniert Docker technisch?

Docker nutzt Linux-Technologien wie Namespaces (Isolation von Prozessen, Netzwerken, PIDs, Mounts) und cgroups (Ressourcenbegrenzung für CPU/RAM/IO). Overlay-/UnionFS ermöglicht das Layering von Images. Build- und Laufzeit werden heute häufig durch containerd und BuildKit unterstützt.

Wofür wird Docker verwendet?

• Lokale Entwicklung: Einheitliche Dev-Umgebung, keine „funktioniert-nur-auf-meinem-Rechner“-Probleme.
• CI/CD: Reproduzierbare Builds, automatische Tests, Security-Scanning und Release-Pipelines.
• Microservices: Saubere Trennung von Services (API, Frontend, Datenbank, Cache) mit eigenen Lifecycle- und Skalierungsstrategien.
• Testing & Debugging: Schnelles Spin-up von Abhängigkeiten (z. B. PostgreSQL, Redis, Kafka) für Integrationstests.
• Datenanalyse & ML: Portables Packaging von Python/R-Stacks inkl. CUDA-Treibern für GPU-Workloads (auf passender Infrastruktur).
• Edge/IoT: Konsistente Auslieferung von Software auf verteilte Geräte.

Vorteile von Docker

• Portabilität: Gleiches Image von Laptop bis Cloud.
• Schnelligkeit: Container starten in Sekunden; inkrementelle Builds.
• Ressourceneffizienz: Weniger Overhead als VMs, höhere Dichte.
• Reproduzierbarkeit: Deterministische Builds, versionskontrollierte Dockerfiles.
• Skalierbarkeit: Leichtes Hoch- und Herunterskalieren; ideal für Orchestrierung.

Docker vs. Virtuelle Maschinen (VMs)

• Kernel: Container teilen den Host-Kernel; VMs haben eigenen Kernel.
• Overhead: Container sind leichter und schneller; VMs isolieren stärker und eignen sich für heterogene Betriebssysteme.
• Use Case: Container für Microservices, CI/CD, schnelle Deployments; VMs für starke Mandantentrennung, Legacy-OS oder volle Isolation.

Docker-Ökosystem und Tools

• Docker Engine & CLI: Basis zum Bauen, Runnen und Managen von Containern.
• Docker Desktop: Komfortpaket für macOS/Windows mit GUI, Kubernetes-Option und Dev-Tools.
• BuildKit: Moderne Build-Engine (schneller, Cache, parallele Builds, Secrets, SSH-Forwarding).
• Docker Compose: Mehrere Services via docker-compose.yml definieren und gemeinsam starten (ideal für lokale Dev und Tests).
• Orchestrierung:
  • Docker Swarm: Einfache, integrierte Orchestrierung.
  • Kubernetes: De-facto-Standard für Produktion; Docker-Images laufen auch dort (über containerd/CRI-O). Compose unterstützt Dev-Workflows, K8s orchestriert in Produktion.

Typische Workflows & Kommandos

• Build: docker build -t myapp:1.0 .
• Run: docker run -p 8080:80 myapp:1.0
• Compose: docker compose up -d
• Inspect/Logs: docker ps, docker logs -f <container>
• Volumes/Networks: docker volume ls, docker network ls
• Cleanup: docker system prune

Best Practices

• Kleine Images: Basis-Images wie alpine, Multi-Stage-Builds, unnötige Tools entfernen.
• Reproduzierbarkeit: Exakte Versionen pinnen, --no-cache gezielt nutzen, .dockerignore pflegen.
• Sicherheit: Least-Privilege (non-root-User), Secrets nicht ins Image, Signieren/Scannen (SBOM, Snyk/Trivy), regelmäßige Updates.
• Performance: Layer-Cache optimieren (Reihenfolge im Dockerfile), BuildKit aktivieren, persistenten Storage über Volumes.
• Observability: Strukturierte Logs, Healthchecks, Metriken und Tracing einbinden.

Sicherheit

• Isolation: Namespaces/cgroups bieten Prozessisolation; für höhere Anforderungen zusätzliche Maßnahmen (seccomp, AppArmor/SELinux, rootless).
• Secrets Management: Keine Secrets im Image/ENV; stattdessen Secret-Stores (Docker Secrets, Vault, K8s Secrets).
• Supply Chain Security: Signierte Images (Notary/Cosign), SBOMs, regelmäßiges Vulnerability-Scanning.

Häufige Herausforderungen

• Stateful Services: Persistenz über Volumes/Managed Databases planen.
• Netzwerk & DNS: Service-Namen per Compose/K8s intern auflösen, Ports sauber mappen.
• Kosten & Sprawl: Unbenutzte Images/Container aufräumen, CI-Caching kontrollieren.
• Windows/macOS: Datei-I/O und Filesharing können langsamer sein; Sync-Optionen und Cache-Strategien prüfen.

Alternativen & verwandte Technologien

• Podman (rootless), containerd, CRI-O, Buildah, nerdctl – kompatible Werkzeuge im Container-Ökosystem.

Docker in CI/CD und Produktion

• Immutable Releases: Gleiches Image vom Build bis Prod.
• Rollouts: Blue/Green, Canary, Rolling Updates (mit Swarm/Kubernetes).
• Policies: Tagging-Konventionen, Promotions über Stages (dev → staging → prod), Image-Scanning im Pipeline-Gate.

Fazit

Docker ermöglicht schnelle, portable und reproduzierbare Softwarebereitstellung. Von lokalen Dev-Setups über automatisierte CI/CD-Pipelines bis zu hochskalierenden Microservices in der Cloud – Container vereinfachen Prozesse, reduzieren Fehlerquellen und beschleunigen Releases. Mit soliden Sicherheits- und Build-Praktiken entfaltet Docker sein volles Potenzial in Entwicklung und Produktion.