Container-Tools – Docker, Kubernetes, Podman & mehr

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernen Sie die wichtigsten Container-Tools kennen:

Container-Grundlagen: Was sind Container und warum sind sie wichtig?
Die wichtigsten Tools: Docker, Kubernetes, Podman, Portainer, Helm, etc.
Vergleichstabelle: Alle Tools auf einen Blick
Interaktive Generatoren: Dockerfile & Compose-Generator
Ressourcen-Rechner: CPU, RAM und Storage für Container planen
Cheat Sheets: Die wichtigsten Befehle für Docker, K8s, Compose
Best Practices: Security, Performance, Size, Network
FAQ: Häufige Fragen und Antworten

1. Was sind Container?

Definition

Container-Tools sind Software-Werkzeuge zur Erstellung, Verwaltung, Orchestrierung und Überwachung von Containern – leichtgewichtige, portable Ausführungsumgebungen, die Anwendungen mit allen Abhängigkeiten paketieren.

Container-Tools decken den gesamten Lifecycle ab: vom Build (Docker, Buildah) über die Registry (Docker Hub, Harbor) und Orchestrierung (Kubernetes) bis zu Security (Trivy, Falco) und Monitoring (Prometheus, Grafana).

Warum wichtig? Container revolutionierten die Software-Entwicklung durch Portabilität („läuft überall"), Isolation, Ressourceneffizienz (shared Kernel) und Skalierbarkeit.

Container vs. Virtuelle Maschinen

Container sind leichtgewichtige, portable Ausführungseinheiten, die eine Anwendung mit allen ihren Abhängigkeiten (Bibliotheken, Konfigurationsdateien, etc.) paketieren. Im Gegensatz zu VMs teilen sich Container den Host-Kernel und sind daher deutlich ressourcenschonender.

Container: Start in Millisekunden, MB-Größe, teilen Kernel
VMs: Start in Minuten, GB-Größe, eigener Kernel
Vorteile: Portabilität, Skalierbarkeit, Reproduzierbarkeit, Effizienz

2. Die wichtigsten Container-Tools

Ein Überblick über die wichtigsten Tools im Container-Ökosystem – von der Runtime bis zum Orchestrierungssystem.

01

Docker

Der Container-Standard

Die populärste Container-Plattform. Ermöglicht das Bauen, Teilen und Ausführen von Containern.

Dockerfile zum Bauen von Images
Docker Hub als Registry
Docker CLI für alle Operationen
Riesige Community & Ecosystem

Runtime CLI Open Source

02

Docker Compose

Multi-Container-Orchestrierung

Definiert und betreibt Multi-Container-Docker-Anwendungen über YAML-Dateien.

YAML-basierte Konfiguration
Ein Befehl startet alle Services
Ideal für Entwicklung & Testing
Networking & Volumes integriert

Orchestrierung Dev-Tool YAML

03

Kubernetes (K8s)

Enterprise-Orchestrierung

Das führende Open-Source-System zur Automatisierung von Deployment, Skalierung und Management containerisierter Anwendungen.

Auto-Scaling & Self-Healing
Service Discovery & Load Balancing
Rollouts & Rollbacks
Multi-Cloud-fähig

Orchestrierung Enterprise Production

04

Podman

Daemonless Container Engine

Red Hats Alternative zu Docker. Läuft ohne Daemon und unterstützt rootless Container.

Kein Daemon nötig
Rootless Container (sicherer)
Docker-kompatible CLI
Pod-Konzept (ähnlich K8s)

Runtime Security Red Hat

05

Portainer

Web-GUI für Container

Leichtgewichtige Management-UI für Docker, Swarm, Kubernetes und ACI. Ideal für Einsteiger.

Browser-basierte Verwaltung
Container, Images, Volumes, Networks
App-Templates
Multi-User & RBAC

GUI Management Einsteiger

06

Helm

Package Manager für K8s

Der "apt-get" für Kubernetes. Vereinfacht das Deployment komplexer Anwendungen mit Charts.

Helm Charts als Pakete
Templating mit Go-Templates
Versionierung von Releases
Artifact Hub als Repository

K8s Package Templating

07

Docker Swarm

Natives Docker-Clustering

Dockers eingebautes Orchestrierungstool. Einfacher als K8s, aber weniger Features.

In Docker integriert
Einfache Einrichtung
Service Discovery
Rolling Updates

Orchestrierung Einfach Docker-nativ

08

Rancher

Kubernetes-Management-Plattform

Enterprise-Plattform zur Verwaltung mehrerer Kubernetes-Cluster über eine zentrale UI.

Multi-Cluster-Management
Integrierte CI/CD (Fleet)
User-Authentifizierung
Catalog für Helm-Charts

Enterprise Multi-Cluster GUI

09

containerd

Industrie-Standard Runtime

Die zugrundeliegende Container-Runtime, die von Docker, K8s und anderen genutzt wird.

CNCF-Graduated-Projekt
Von Docker abgespalten
Standard in K8s
Leichtgewichtig & performant

Runtime CNCF Low-Level

10

LXC / LXD

System-Container

Linux-Container, die komplette Betriebssysteme ausführen – ein Hybrid zwischen VM und Container.

System-Container (vollständiges OS)
LXD als Management-Tool
Sehr performant
Ideal für Legacy-Apps

System-Container Linux Canonical

3. Tool-Vergleich

Alle wichtigen Container-Tools auf einen Blick – für die schnelle Entscheidung.

Tool	Typ	Daemon	Rootless	GUI	Hauptanwendung
Docker	Runtime	Ja	Nein (Standard)	Nein	Entwicklung, Single-Host
Docker Compose	Orchestrierung	Ja (via Docker)	Nein	Nein	Multi-Container-Apps
Kubernetes	Orchestrierung	Ja (API-Server)	Ja	Dashboard	Enterprise, Multi-Host
Podman	Runtime	Nein	Ja	Podman Desktop	Security-fokussiert
Portainer	Management	Ja	Ja	Ja (Hauptfeature)	GUI-Management
Helm	Package Manager	Nein	Nein	Nein	K8s-Deployments
Docker Swarm	Orchestrierung	Ja (via Docker)	Nein	Nein	Einfaches Clustering
Rancher	Management	Ja	Ja	Ja (Hauptfeature)	Multi-Cluster K8s
containerd	Runtime	Ja	Ja	Nein	Low-Level Runtime
LXC/LXD	System-Container	Ja	Ja	Nein	System-Container

4. Interaktive Generatoren

Erstellen Sie im Handumdrehen Dockerfiles und Compose-Dateien mit unseren interaktiven Generatoren.

Code-Generatoren

Dockerfile-Generator

Compose-Generator

Basis-Image

Working Directory

Port (EXPOSE)

Install-Befehl

Start-Befehl (CMD)

User (non-root)

Service-Name

Image

Port-Mapping

Datenbank hinzufügen?

Volume-Mount

Restart Policy

5. Container-Ressourcen-Rechner

Planen Sie die benötigten Ressourcen für Ihre Container-Umgebung.

Ressourcen-Planung

Konfiguration

Anzahl Container

Container-Typ

RAM pro Container (MB)

CPU-Cores pro Container

Storage pro Container (GB)

Ergebnis

Gesamt-RAM

–

Gesamt-CPU

–

Gesamt-Storage

–

Empfohlener Host

–

Puffer (20%)

–

6. Cheat Sheets – Die wichtigsten Befehle

Schnellreferenzen für die wichtigsten Container-Tools – immer griffbereit.

Docker Basics

docker build -t myapp:1.0 .

Image aus Dockerfile bauen

docker run -d -p 8080:80 myapp

Container im Hintergrund starten

docker ps

Laufende Container anzeigen

docker logs -f container_id

Logs live verfolgen

docker exec -it container_id /bin/sh

In Container-Shell einsteigen

docker stop container_id

Container stoppen

docker system prune -a

Nicht genutzte Ressourcen aufräumen

Kubernetes (kubectl)

kubectl get pods

Alle Pods anzeigen

kubectl apply -f deployment.yaml

Deployment anwenden

kubectl describe pod pod_name

Details eines Pods anzeigen

kubectl logs pod_name

Logs eines Pods anzeigen

kubectl exec -it pod_name -- /bin/sh

In Pod-Shell einsteigen

kubectl scale deployment name --replicas=5

Deployment skalieren

kubectl rollout status deployment/name

Rollout-Status prüfen

Docker Compose

docker compose up -d

Services im Hintergrund starten

docker compose down

Alle Services stoppen

docker compose ps

Status aller Services

docker compose logs -f service

Logs eines Service verfolgen

docker compose build --no-cache

Images neu bauen

docker compose exec service /bin/sh

In Service-Shell einsteigen

docker compose pull

Neueste Images pullen

Podman

podman run -d --name web nginx

Container starten (wie Docker)

podman pod create --name mypod

Pod erstellen (K8s-ähnlich)

podman generate kube pod > pod.yaml

Pod als K8s-YAML exportieren

podman play kube pod.yaml

K8s-YAML als Pod starten

podman system df

Speicherverbrauch anzeigen

podman unshare

User-Namespace betreten

7. Best Practices für Container

Security

Container nicht als root ausführen
Regelmäßige Image-Scans (Trivy, Snyk)
Read-only Filesystem verwenden
Keine Secrets in Images hardcoden
Resource Limits setzen (CPU/RAM)
Minimale Basis-Images nutzen (Alpine, Distroless)

Performance

Multi-Stage Builds für kleinere Images
Layer-Caching optimal nutzen
Wenige RUN-Befehle (zusammenfassen)
.dockerignore für unnötige Dateien
Health-Checks konfigurieren
Readiness/Liveness Probes in K8s

Image-Größe

Alpine oder Distroless als Basis
Keine unnötigen Packages installieren
Cache und Temp-Dateien löschen
Multi-Stage-Builds: Build-Tools nur in Stage 1
Regelmäßig docker system prune
Image-Größe im CI/CD prüfen

Networking

Eigene Docker-Netzwerke erstellen
Services über Namen ansprechen
Reverse Proxy (Traefik, Nginx) nutzen
Keine Ports unnötig exponieren
TLS/SSL für externe Kommunikation
Network Policies in K8s definieren

12-Factor-App Methodology

Die 12-Factor-App ist ein Leitfaden für moderne, containerisierte Anwendungen:

Codebase: Eine Codebase, viele Deployments
Dependencies: Explizit deklarieren
Config: In Umgebungsvariablen speichern
Backing Services: Als angehängte Ressourcen behandeln
Build, Release, Run: Streng trennen
Processes: Stateless, shared-nothing
Port binding: Selbst exportieren
Concurrency: Scale out via Prozesse
Disposability: Schneller Start, graceful Shutdown
Dev/Prod parity: Möglichst gleich halten
Logs: Als Event-Stream behandeln
Admin processes: Als one-off Tasks

8. FAQ – Häufige Fragen & Antworten

Häufige Fragen zu Container-Tools

Was ist der Unterschied zwischen Docker und Kubernetes?

Docker ist eine Container-Runtime – es baut und betreibt einzelne Container. Kubernetes ist ein Orchestrierungssystem – es verwaltet viele Container über mehrere Hosts hinweg.

Docker: "Wie baue und starte ich einen Container?"
Kubernetes: "Wie betreibe ich 100 Container auf 10 Servern?"

Sie ergänzen sich: Docker baut die Container, Kubernetes orchestriert sie.

Warum sollte ich Podman statt Docker verwenden?

Podman hat einige Vorteile gegenüber Docker:

Daemonless: Kein Hintergrunddienst nötig → weniger Angriffsfläche
Rootless: Container können ohne Root-Rechte laufen → sicherer
Docker-kompatibel: Alias alias docker=podman funktioniert
Pod-Konzept: Ähnlich wie Kubernetes-Pods

Nachteile: Kleinere Community, weniger Tools, Docker Compose nur eingeschränkt unterstützt (podman-compose).

Wann sollte ich Kubernetes verwenden?

Kubernetes ist sinnvoll bei:

Mehr als 10-20 Container
Auto-Scaling erforderlich
Multi-Host-Deployment
Self-Healing gewünscht
Complex Rollouts & Rollbacks
Multi-Cloud-Strategie

Kubernetes ist Overhead bei:

Wenigen Containern (< 5)
Single-Host-Deployment
Einfachen Anwendungen
Begrenztem Team-Know-how

Für einfache Setups reicht Docker Compose oder Docker Swarm.

Wie mache ich meine Docker-Images kleiner?

Die wichtigsten Strategien:

Alpine als Basis: ~5 MB statt ~100 MB (Ubuntu)
Multi-Stage Builds: Build-Tools nur in Stage 1, nur App in Stage 2
Weniger Layers: RUN-Befehle zusammenfassen mit &&
Cache löschen: rm -rf /var/cache/apt/* nach Installation
.dockerignore: Unnötige Dateien ausschließen
Distroless Images: Nur Runtime, keine Shell

Beispiel Multi-Stage:

FROM node:20 AS builder
WORKDIR /app
COPY . .
RUN npm ci && npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
CMD ["node", "dist/index.js"]

Was ist der Unterschied zwischen Image und Container?

Image: Ein read-only Template mit allem, was zum Ausführen einer Anwendung nötig ist (Code, Runtime, Libraries, ENV). Vergleichbar mit einer BluRay.

Container: Eine laufende Instanz eines Images. Vergleichbar mit dem abgespielten Film. Container können gestartet, gestoppt, gelöscht werden – das Image bleibt unverändert.

Analogie:

Image = Rezept (statisch)
Container = Der zubereitete Kuchen (instanziiert)

Wie sichere ich meine Container ab?

Die wichtigsten Security-Maßnahmen:

Non-root User: USER node im Dockerfile
Read-only FS: --read-only Flag
Image Scanning: Trivy, Snyk, Docker Scout
Resource Limits: --memory=512m --cpus=0.5
Secrets Management: Docker Secrets, K8s Secrets, Vault
Network Policies: Nur notwendige Kommunikation erlauben
Regelmäßige Updates: Basis-Images aktuell halten
Capabilities reduzieren: --cap-drop=ALL

Was ist Helm und warum brauche ich das?

Helm ist der Package Manager für Kubernetes. Ähnlich wie apt für Debian oder npm für Node.js.

Vorteile:

Charts: Vorgefertigte Pakete für komplexe Apps (WordPress, MySQL, etc.)
Templating: Go-Templates für flexible Konfiguration
Versionierung: Rollbacks auf vorige Versionen
Repositories: Artifact Hub mit tausenden Charts

Beispiel:

helm repo add bitnami https://charts.bitnami.com/bitnami
helm install my-wordpress bitnami/wordpress

Wie persistiere ich Daten in Containern?

Container sind ephemeral – Daten im Container gehen beim Löschen verloren. Für Persistenz gibt es drei Optionen:

Volumes: Von Docker verwaltet, beste Performance
docker volume create mydata
docker run -v mydata:/app/data myapp
Bind Mounts: Direktes Mapping zum Host-Dateisystem
docker run -v /host/path:/container/path myapp
tmpfs Mounts: Im RAM, nicht persistent
docker run --tmpfs /tmp myapp

Empfehlung: Volumes für Datenbanken, Bind Mounts für Entwicklung.

Was ist der Unterschied zwischen Docker Swarm und Kubernetes?

Beide sind Orchestrierungstools, aber mit unterschiedlicher Komplexität:

Docker Swarm:

In Docker integriert (einfach zu aktivieren)
Weniger Features, aber einfacher zu lernen
Gut für kleine bis mittlere Setups
YAML-basierte Konfiguration

Kubernetes:

Industriestandard, sehr mächtig
Steile Lernkurve
Ideal für Enterprise und komplexe Setups
Riesiges Ökosystem (Helm, Operators, etc.)

Empfehlung: Swarm für einfache Setups, K8s für Enterprise.

Wie debugge ich einen Container, der nicht startet?

Schritt-für-Schritt Debugging:

Logs prüfen: docker logs container_id
Status prüfen: docker inspect container_id
Exit Code analysieren:
- 0 = normal beendet
- 1 = allgemeiner Fehler
- 126 = Command nicht ausführbar
- 127 = Command nicht gefunden
- 137 = OOM killed (zu wenig RAM)
- 139 = Segmentation Fault
Interaktiv starten: docker run -it image /bin/sh
Command manuell testen: CMD im Dockerfile durch sleep infinity ersetzen, dann exec

Zusammenfassung

             Die wichtigsten Punkte
            Container: Leichtgewichtige, portable Ausführungseinheiten mit allen Abhängigkeiten
Docker: Der De-facto-Standard für Container-Runtime
Docker Compose: Multi-Container-Apps über YAML definieren
Kubernetes: Enterprise-Orchestrierung für viele Container
Podman: Daemonless, rootless Alternative zu Docker
Portainer: Web-GUI für einfaches Container-Management
Helm: Package Manager für Kubernetes
Best Practices: Non-root, Image Scanning, Multi-Stage Builds, Resource Limits
12-Factor-App: Leitfaden für moderne, containerisierte Anwendungen
Security: Read-only FS, Secrets Management, Network Policies

        

             Empfehlung für den Einstieg
            Schritt 1: Docker installieren und erste Container starten
Schritt 2: Dockerfile schreiben lernen
Schritt 3: Docker Compose für Multi-Container-Apps
Schritt 4: Portainer für GUI-Management ausprobieren
Schritt 5: Bei Bedarf zu Kubernetes wechseln

        

Weiterführende Themen

Cloud Computing

IaaS, PaaS, SaaS – Cloud-Modelle und Deployment-Strategien.

Zu Cloud Computing

Linux Server

Linux als Basis für Container-Hosts – Administration und Best Practices.

Zu Linux Server

Netzwerkdienste

DNS, DHCP und weitere Netzwerkdienste im Container-Umfeld.

Zu Netzwerkdiensten

Container-Sicherheit

Security-Best Practices für Container und Kubernetes.

Zur Netzwerksicherheit