Dieses Dokument deckt eine recht breite Themenlandschaft rund um Podman ab – von den technischen Grundlagen der Container-Runtime über Build- und Image-Handling, Netzwerk- und Storage-Modelle, Pods, Compose-Workflows, Systemintegration mit systemd, bis hin zur Interaktion mit Kubernetes und advanced Diagnostics. Die Kapitelstruktur ermöglicht es, sehr unterschiedliche Lernziele abzudecken:
– Einstieg in Podman als moderne Container-Engine
– Architektur- und Sicherheitsverständnis auf Kernel-Ebene
– Operativer Betrieb und Troubleshooting
– Multi-Container-Workflows ohne Orchestrator
– Strukturierte Image-Build- und Delivery-Pipelines
– Integration mit systemd für reale Deployments
– Nutzung von Podman als Entwicklungs- und Testumgebung
– Brücken in Richtung Kubernetes und OCI-Ökosystem
Damit der Lernprozess flexibel bleibt, bietet dieser Abschnitt mehrere alternative Routen durch die Themen. Sie bilden didaktische Wege, die je nach Schulungstyp, Zielgruppe und technischer Tiefe eingeschlagen werden können.
Dieser Pfad vermittelt die Kernkompetenzen für praktischen Podman-Einsatz ohne tiefere Systemintegration:
Fokus: Konzepte, Bedienung, Container-Lifecycle, Images, Networking, grundlegende Fehlerdiagnose.
Dieser Pfad geht auf Kernel-Mechanismen, Prozessmodelle und Podman-Architektur ein.
Fokus: Conmon, runc/crun, Namespaces, Cgroups v2, Storage, Netavark, SELinux/AppArmor, Capabilities.
Für Entwickler, die Podman als Alternative zu Docker Desktop oder als Multi-Service-Dev-Environment einsetzen:
Fokus: Build-Optimierung, Multi-Stage, Compose, Pods für Microservices, Hot-Reload-Workflows, Systemd-Einbindung, Roundtrip zu Kubernetes.
Operativer Fokus mit realistischen Fehlerbildern:
Fokus: Diagnose, Netzwerk- und Storage-Fehler, Pod-Fehlerbilder, Analyse von Cgroups, SELinux und Namespace-Interaktionen.
Für Teams, die Podman in der Nähe von Kubernetes nutzen oder „generate/play kube“ einsetzen:
Fokus: OCI-Pod-Modell, Roundtrip-Fähigkeiten, Vergleich zu Kubernetes-Pods, Mapping von Netzwerk, Storage und Lifecycle.
Dieses Programm ist für sehr heterogene Gruppen gebaut: Einsteiger in Containerbetrieb, Entwickler, Linux-Affinere, Architekten und DevOps-Teams. Jeder Themenblock enthält:
– Kerninhalte (Pflichtteil)
– optionale Vertiefungen (wenn die Gruppe tiefer gehen
will)
– flankierende Themen (z. B. Security, Build,
Debugging, Compose), die je nach Gruppe unterschiedlich stark gewichtet
werden.
Das Programm orientiert sich vollständig an den farblich priorisierten Kapiteln.
(Pflicht, kurz, Fokus auf mentale Modelle)
Kapitel: 2, 3, 4, 5
– Warum Podman
– Daemonless vs Docker
– OCI-Ökosystem
– Engine vs Orchestrator
Optionale Vertiefung (je nach Gruppe):
– Historie, CRI-O, Entstehung (Kapitel 6–9)
(Pflichtinhalt, großes Verständnis-Modul)
Kapitel: 11–18
– Prozessmodell: Conmon, runc/crun
– User Namespace Mapping
– Storage Backends
– Networking: Netavark, Aardvark DNS
– Sicherheitsmechanismen
Mögliche Vertiefungen:
– tiefer in Namespaces
– Rootless als Sicherheitsmodell
– Capabilities/Seccomp in realen Szenarien
(Praxisfokus, Pflicht)
Kapitel: 19–23
– Installation
– Rootless vs rootful
– Registry-Integration
– Konfigurationsdateien: storage.conf / containers.conf /
registries.conf
Flankierend (bei Bedarf):
– Podman Machine (Kap. 21)
(Pflicht-Inhalt für jeden Teilnehmer)
Kapitel: 25–29
– Create/Start/Stop/Kill
– Inspect, Logs, Exec, Events
– Ressourcenlimits (CPU, RAM, PID, I/O)
Vertiefungen:
– Events als Debugging-Instrument
– Lifecycle vs systemd
(Pflicht für DevOps + Entwickler)
Kapitel: 30–36
– Pull/Push
– Tagging
– Registry-Selection
– Pruning / Cleanup
– Signaturen / Policy
– Save/Load/Export/Import
Vertiefungen:
– Multi-Arch Manifeste
– Skopeo/Buildah Interaktion
(Pflichtblock für Entwickler / optional für reine Ops)
Kapitel: 37–42
– Buildah in Podman
– Dockerfile-Verarbeitung
– Multi-Stage
– Layer-Handling / Caching
Optionales Deep Dive:
– Rootless Build Performance
– Build Troubleshooting
– CI/CD-Patterns
(Pflicht für Infrastruktur-/DevOps-Profil)
Kapitel: 43–47
– Netzwerkmodelle
– Host / Bridge / Slirp4netns
– DNS-Verhalten
– Port-Mapping
– Custom Networks
Optional:
– Multi-Network-Container
– IPAM-Design
– Performance-Betrachtungen
(Pflicht | sehr praxisrelevant)
Kapitel: 48–49
– Bind-Mounts
– Named Volumes
– Storage-Verhalten rootless/root
– Ownership-Mapping
Optional:
– Container-Storage intern
– Storage-Strategien für Datenbanken
– Volumes in CI/CD
(Pflicht, da Podman ohne Orchestrator hier glänzt)
Kapitel: 50–55
– Pod-Architektur (Infra-Container etc.)
– Netzwerk & Namespace-Sharing
– Einsatzszenarien
– Unterschiede zu Kubernetes-Pods
Optional:
– Architekturmuster im Detail
– Sidecar-Patterns
(Pflicht für Entwickler, sehr sinnvoll für Ops)
Kapitel: 56–60
– Compose → Pod-Modell
– Unterschiede zu docker-compose
– Best Practices
– Compose + systemd
Optional:
– Multi-Container-Patterns
– Profiles / komplexe Topologien
(Pflicht – realer Betrieb funktioniert nur damit)
Kapitel: 67–72
– generate systemd
– Units für Container & Pods
– Rootless systemd
– Persistente Services
– Restart-Strategien
Optional:
– Linger / User-Scope-Betrieb
– Clusterlose HA-Muster
(Pflicht für Kubernetes-affine Gruppen, sonst optional)
Kapitel: 73–77
– generate kube
– play kube
– Roundtrip: Podman ↔︎ Kubernetes
– Grenzen der Konvertierung
(Pflicht für alle Ops-, DevOps- und Architektengruppen) Kapitel: 85–90
– Inspect / Logs / Events
– Netzwerk-Diagnose
– Storage-Diagnose
– Typische Fehlermuster
– Debugging unter systemd
Optional:
– seccomp / SELinux / MAC-Debugging
– tiefe Kernel-Analysen
Die Struktur erfüllt genau den GFU-Ansatz:
Der Trainer steuert die Route – die Teilnehmenden steuern die Tiefe.
– Jeder Block enthält ein Minimum (P1)
– optionale Vertiefungen (P2)
– und echte Spezialthemen (P3)
So kann die Gruppe situativ entscheiden, wie weit sie in die Kernelmechanik, Security-Details, Build-Optimierungen oder Kubernetes-Roundtrip einsteigen möchte – ohne den roten Faden zu verlieren.