Skip to content

Einführung in Container

Container sind eine Methode zur Isolierung von Anwendungen und ihren Abhängigkeiten in einer portablen, reproduzierbaren Einheit. Sie ermöglichen es, Software konsistent in verschiedenen Umgebungen zu betreiben – vom Entwicklungsrechner über die Testumgebung bis hin zur Produktionsinfrastruktur.

Was ist ein Container?

Ein Container kapselt eine Anwendung samt aller benötigten Bibliotheken, Konfigurationsdateien und Laufzeitabhängigkeiten in einem einzigen, ausführbaren Paket. Im Gegensatz zu klassischen virtuellen Maschinen teilen sich Container den Kernel des Host-Betriebssystems. Dadurch starten sie erheblich schneller und verbrauchen deutlich weniger Ressourcen.

┌─────────────────────────────────────┐
│           Host-System               │
│                                     │
│  ┌──────────┐  ┌──────────┐         │
│  │Container │  │Container │  ...    │
│  │  App A   │  │  App B   │         │
│  │  + Libs  │  │  + Libs  │         │
│  └──────────┘  └──────────┘         │
│                                     │
│         Gemeinsamer Kernel          │
└─────────────────────────────────────┘

Der wesentliche Unterschied zur VM: Kein separates Gast-Betriebssystem, kein Hypervisor-Overhead.

Zentrale Konzepte

Begriff Bedeutung
Image Unveränderliche Vorlage, aus der Container erzeugt werden. Enthält das Dateisystem und Metadaten.
Container Laufende Instanz eines Images. Isoliert vom Host und anderen Containern.
Dockerfile / Containerfile Skript, das beschreibt, wie ein Image gebaut wird.
Volume Persistenter Speicher, der unabhängig vom Container-Lebenszyklus existiert.
Registry Zentrales Repository für Images (z. B. Docker Hub, GitHub Container Registry).
Network Virtuelles Netzwerk zur Kommunikation zwischen Containern.

Vorteile gegenüber klassischen VMs

Portabilität – Ein Container läuft identisch auf jedem System mit kompatibler Container-Runtime. Umgebungsunterschiede zwischen Entwicklung und Produktion entfallen.

Effizienz – Container teilen den Host-Kernel. Start dauert Millisekunden statt Minuten, Speicherbedarf liegt im MB- statt GB-Bereich.

Reproduzierbarkeit – Das Image beschreibt den Zustand exakt und versionierbar. Deployments sind deterministisch.

Isolation – Prozesse, Dateisystem und Netzwerk sind voneinander getrennt, ohne den Overhead einer vollständigen VM.

Typische Anwendungsfälle

  • Isolierte Entwicklungsumgebungen ohne lokale Installationen
  • Reproduzierbare Build- und Testumgebungen in CI/CD-Pipelines
  • Betrieb von Webservern, Datenbanken und Microservices
  • Lokales Testen von Infrastruktur (z. B. mit Docker Compose)
  • Grundlage für Kubernetes-basierte Orchestrierung

Container-Runtimes

Container sind kein Docker-exklusives Konzept. Die zugrundeliegenden Standards werden von der Open Container Initiative (OCI) definiert. Verschiedene Runtimes implementieren diese Spezifikation:

Runtime Besonderheit
Docker De-facto Standard, großes Ökosystem
Podman Daemonlos, rootless, RHEL-nativ
containerd Lightweight-Runtime, Basis für Kubernetes
nerdctl Docker-kompatible CLI für containerd

Orchestrierung mit Kubernetes

Einzelne Container laufen gut auf einem Host – sobald jedoch viele Container über mehrere Maschinen hinweg betrieben werden sollen, braucht es Orchestrierung. Kubernetes (kurz: K8s) ist der De-facto-Standard dafür.

Was Kubernetes leistet

  • Scheduling – Entscheidet automatisch, auf welchem Node ein Container läuft
  • Self-Healing – Neustart bei Absturz, Ersatz bei Node-Ausfall
  • Skalierung – Automatisches Hoch- und Herunterskalieren nach Last
  • Rolling Updates – Deployments ohne Downtime
  • Service Discovery & Load Balancing – Internes DNS und Traffic-Verteilung

Kubernetes-Konzepte im Überblick

Begriff Bedeutung
Pod Kleinste deploybare Einheit; enthält einen oder mehrere Container
Deployment Beschreibt den gewünschten Zustand einer Anwendung (Replicas, Image, etc.)
Service Stabiler Netzwerk-Endpunkt für eine Gruppe von Pods
Namespace Logische Trennung von Ressourcen innerhalb eines Clusters
ConfigMap / Secret Konfiguration und sensible Daten getrennt vom Image
Ingress HTTP(S)-Routing von außen in den Cluster
Node Physische oder virtuelle Maschine im Cluster

Verhältnis zu Container-Runtimes

Kubernetes selbst baut keine Container – es orchestriert sie. Als Runtime-Schnittstelle nutzt K8s die Container Runtime Interface (CRI). Unterstützte Runtimes:

Kubernetes → CRI → containerd → runc → Container
Kubernetes → CRI → CRI-O     → runc → Container

Docker wurde ab Kubernetes 1.24 als direkte Runtime entfernt. Im Hintergrund läuft aber weiterhin containerd, sodass Docker-Images weiterhin funktionieren.

Kubernetes lokal ausprobieren

Für lokale Entwicklung und Tests gibt es schlanke Distributionen:

Tool Beschreibung
minikube Klassisch, viele Addons, etwas schwergewichtig
kind (K8s in Docker) Cluster-Nodes als Docker-Container, ideal für CI
k3s / k3d Leichtgewichtige K8s-Distribution, sehr schnell
Podman Desktop Integrierter K8s-Support via Kind 
# Beispiel: Deployment mit kubectl
kubectl create deployment webserver --image=nginx
kubectl expose deployment webserver --port=80 --type=NodePort
kubectl scale deployment webserver --replicas=3
kubectl rollout status deployment/webserver

Wann Kubernetes sinnvoll ist

Kubernetes bringt erhebliche Komplexität mit sich und ist nicht für jeden Anwendungsfall nötig:

Kubernetes lohnt sich, wenn… - mehrere Services zusammenspielen und skaliert werden müssen - Hochverfügbarkeit und automatisches Failover gefordert sind - ein Team an einer gemeinsamen Infrastruktur arbeitet - eine Cloud-native Strategie verfolgt wird (AWS EKS, GKE, AKS)

Kubernetes ist überdimensioniert, wenn… - ein einzelner Service auf einem Server betrieben wird - Docker Compose den Bedarf vollständig abdeckt - das Team keine Kapazitäten für K8s-Betrieb hat

Grundlegende Befehle

Die folgenden Befehle funktionieren sowohl mit docker als auch mit podman:

# Image herunterladen
docker pull nginx

# Container starten
docker run -d -p 8080:80 --name webserver nginx

# Laufende Container anzeigen
docker ps

# Logs anzeigen
docker logs webserver

# Container stoppen und entfernen
docker stop webserver
docker rm webserver

# Image aus Dockerfile bauen
docker build -t mein-image:1.0 .

Nächste Schritte

  • Docker vs. Podman – Unterschiede, Sicherheitsmodell und Entscheidungshilfe → podman-vs-docker.md
  • Docker Compose – Mehrere Container als Stack definieren und gemeinsam betreiben
  • Kubernetes Grundlagen – Cluster-Architektur, kubectl und erste Deployments
  • Helm – Paketmanager für Kubernetes-Applikationen