# Podman — Container daemonless und rootless verwalten

> Praxis-Guide zu Podman: daemonless und rootless Container und Pods verwalten — Lebenszyklus, Images, Volumes, Netzwerke und Docker-Kompatibilität.

Source: https://www.jpkc.com/db/cheatsheets/containers/podman/

<!-- PROSE:intro -->
Podman ist eine Container-Engine, die ohne Hintergrund-Daemon auskommt: Jeder Container läuft als regulärer Kindprozess deines Benutzers und nicht unter einem zentralen Dienst. Das macht den rootless-Betrieb zum Normalfall – du startest Container ohne Root-Rechte und reduzierst so die Angriffsfläche deutlich. Die Kommandozeile ist weitgehend Docker-kompatibel, sodass die meisten `docker`-Befehle unverändert funktionieren, wenn du `docker` durch `podman` ersetzt. Zusätzlich kennt Podman Pods, gruppiert also mehrere Container wie in Kubernetes, und kann passende YAML-Manifeste erzeugen. Dieser Guide führt dich vom Container-Lebenszyklus über Images, Volumes und Netzwerke bis zu Rootless-Sicherheit und systemd-Integration.
<!-- PROSE:intro:end -->

## Container-Lebenszyklus

`podman run <image>` — Erstellt und startet einen neuen Container aus einem Image.

```bash
podman run nginx
```

`podman run -d <image>` — Startet einen Container im Hintergrund (detached).

```bash
podman run -d nginx
```

`podman run -it <image> <command>` — Startet einen Container interaktiv mit TTY.

```bash
podman run -it ubuntu bash
```

`podman run --name <name> <image>` — Startet einen Container mit eigenem Namen.

```bash
podman run --name my-web -d nginx
```

`podman run --rm <image>` — Entfernt den Container automatisch, sobald er beendet wird.

```bash
podman run --rm alpine echo "Hello"
```

`podman start <container>` — Startet einen gestoppten Container.

```bash
podman start my-web
```

`podman stop <container>` — Stoppt einen laufenden Container kontrolliert.

```bash
podman stop my-web
```

`podman stop -a` — Stoppt alle laufenden Container auf einmal.

```bash
podman stop -a
```

`podman restart <container>` — Stoppt einen Container und startet ihn anschließend neu.

```bash
podman restart my-web
```

`podman rm <container>` — Entfernt einen gestoppten Container.

```bash
podman rm my-web
```

`podman rm -f <container>` — Entfernt einen laufenden Container erzwungen.

```bash
podman rm -f my-web
```

`podman rm -a` — Entfernt alle gestoppten Container.

```bash
podman rm -a
```

## Ports, Umgebung & Ressourcen

`podman run -p <host_port>:<container_port> <image>` — Bildet einen Host-Port auf einen Container-Port ab.

```bash
podman run -d -p 8080:80 nginx
```

`podman run -e <KEY>=<value> <image>` — Setzt eine Umgebungsvariable im Container.

```bash
podman run -d -e MYSQL_ROOT_PASSWORD=secret mysql:8
```

`podman run --env-file <file> <image>` — Lädt Umgebungsvariablen aus einer Datei.

```bash
podman run -d --env-file .env my-app
```

`podman run -m <memory> <image>` — Setzt ein Speicherlimit für den Container.

```bash
podman run -d -m 512m nginx
```

`podman run --cpus=<number> <image>` — Begrenzt die Anzahl der CPU-Kerne, die der Container nutzen darf.

```bash
podman run -d --cpus=1.5 my-app
```

`podman run --restart=<policy> <image>` — Setzt die Restart-Policy: no, on-failure, always, unless-stopped.

```bash
podman run -d --restart=always nginx
```

## Volumes & Mounts

`podman run -v <host_path>:<container_path> <image>` — Bindet ein Host-Verzeichnis als Bind-Mount in den Container ein.

```bash
podman run -d -v ./html:/usr/share/nginx/html nginx
```

`podman run -v <host_path>:<container_path>:Z <image>` — Bind-Mount mit privatem SELinux-Label (Zugriff für einen einzelnen Container).

```bash
podman run -d -v ./data:/data:Z my-app
```

`podman run -v <host_path>:<container_path>:z <image>` — Bind-Mount mit geteiltem SELinux-Label (mehrere Container dürfen zugreifen).

```bash
podman run -d -v ./shared:/shared:z my-app
```

`podman run -v <volume_name>:<container_path> <image>` — Bindet ein benanntes Podman-Volume in den Container ein.

```bash
podman run -d -v db-data:/var/lib/mysql mysql:8
```

`podman volume create <name>` — Erstellt ein benanntes Volume für persistente Daten.

```bash
podman volume create db-data
```

`podman volume ls` — Listet alle Podman-Volumes auf.

```bash
podman volume ls
```

`podman volume inspect <name>` — Zeigt detaillierte Informationen zu einem Volume.

```bash
podman volume inspect db-data
```

`podman volume rm <name>` — Entfernt ein Volume.

```bash
podman volume rm db-data
```

`podman volume prune` — Entfernt alle ungenutzten Volumes.

```bash
podman volume prune
```

## Auflisten & Inspizieren

`podman ps` — Listet alle laufenden Container auf.

```bash
podman ps
```

`podman ps -a` — Listet alle Container auf, auch gestoppte.

```bash
podman ps -a
```

`podman ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"` — Listet Container mit eigenem Ausgabeformat.

```bash
podman ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
```

`podman inspect <container>` — Zeigt detaillierte JSON-Informationen zu einem Container.

```bash
podman inspect my-web
```

`podman port <container>` — Zeigt die Port-Zuordnungen eines Containers.

```bash
podman port my-web
```

`podman stats` — Zeigt die Ressourcennutzung aller laufenden Container in Echtzeit.

```bash
podman stats
```

`podman top <container>` — Zeigt die im Container laufenden Prozesse.

```bash
podman top my-web
```

`podman top <container> hpid user args` — Zeigt Prozesse mit eigenen ps-Format-Deskriptoren (Podman-spezifisch).

```bash
podman top my-web hpid user args
```

## Logs & Exec

`podman logs <container>` — Zeigt die Logs eines Containers.

```bash
podman logs my-web
```

`podman logs -f <container>` — Folgt der Log-Ausgabe in Echtzeit.

```bash
podman logs -f my-web
```

`podman logs --tail <n> <container>` — Zeigt nur die letzten N Zeilen der Logs.

```bash
podman logs --tail 50 my-web
```

`podman logs --since <time> <container>` — Zeigt Logs ab einem Zeitstempel oder einer relativen Zeit.

```bash
podman logs --since 30m my-web
```

`podman exec -it <container> <command>` — Führt einen Befehl interaktiv in einem laufenden Container aus.

```bash
podman exec -it my-web bash
```

`podman exec <container> <command>` — Führt einen Befehl in einem laufenden Container aus (nicht interaktiv).

```bash
podman exec my-web cat /etc/nginx/nginx.conf
```

`podman cp <container>:<path> <host_path>` — Kopiert Dateien aus einem Container auf den Host.

```bash
podman cp my-web:/etc/nginx/nginx.conf ./nginx.conf
```

`podman cp <host_path> <container>:<path>` — Kopiert Dateien vom Host in einen Container.

```bash
podman cp ./index.html my-web:/usr/share/nginx/html/
```

## Images

`podman images` — Listet alle lokal verfügbaren Images auf.

```bash
podman images
```

`podman pull <image>` — Lädt ein Image aus einer Registry herunter.

```bash
podman pull docker.io/library/nginx:alpine
```

`podman push <image>` — Lädt ein Image in eine Registry hoch.

```bash
podman push quay.io/myuser/my-app:latest
```

`podman tag <source_image> <target_image>` — Vergibt einen neuen Tag für ein bestehendes Image.

```bash
podman tag my-app:latest quay.io/myuser/my-app:v1.0
```

`podman rmi <image>` — Entfernt ein lokales Image.

```bash
podman rmi nginx:alpine
```

`podman image prune` — Entfernt alle ungetaggten (dangling) Images.

```bash
podman image prune
```

`podman image prune -a` — Entfernt alle Images, die von keinem Container genutzt werden.

```bash
podman image prune -a
```

`podman history <image>` — Zeigt die Layer-Historie eines Images.

```bash
podman history nginx:alpine
```

`podman save -o <file> <image>` — Exportiert ein Image in ein tar-Archiv.

```bash
podman save -o my-app.tar my-app:latest
```

`podman load -i <file>` — Importiert ein Image aus einem tar-Archiv.

```bash
podman load -i my-app.tar
```

`podman search <term>` — Durchsucht Registries nach passenden Images.

```bash
podman search nginx
```

## Images bauen

`podman build -t <name>:<tag> .` — Baut ein Image aus einem Dockerfile/Containerfile im aktuellen Verzeichnis.

```bash
podman build -t my-app:latest .
```

`podman build -t <name> -f <file> .` — Baut mit einem bestimmten Dockerfile oder Containerfile.

```bash
podman build -t my-app -f Containerfile.prod .
```

`podman build --no-cache -t <name> .` — Baut, ohne den Layer-Cache zu verwenden.

```bash
podman build --no-cache -t my-app:latest .
```

`podman build --build-arg <KEY>=<value> -t <name> .` — Übergibt eine Build-Variable an den Build.

```bash
podman build --build-arg NODE_ENV=production -t my-app .
```

`podman build --target <stage> -t <name> .` — Baut nur bis zu einer bestimmten Stage in einem Multi-Stage-Build.

```bash
podman build --target builder -t my-app:build .
```

`podman build --platform <platform> -t <name> .` — Baut für eine bestimmte Plattform-Architektur.

```bash
podman build --platform linux/arm64 -t my-app .
```

`podman build --layers=false -t <name> .` — Baut ohne Zwischen-Layer (kleineres Image, keine Cache-Wiederverwendung).

```bash
podman build --layers=false -t my-app .
```

## Pods

`podman pod create --name <name>` — Erstellt einen neuen Pod. Pods gruppieren Container, die sich Netzwerk- und IPC-Namespaces teilen.

```bash
podman pod create --name my-pod
```

`podman pod create --name <name> -p <host_port>:<container_port>` — Erstellt einen Pod mit veröffentlichten Ports. Ports werden auf Pod-Ebene gesetzt, nicht pro Container.

```bash
podman pod create --name web-pod -p 8080:80 -p 3306:3306
```

`podman run --pod <pod> <image>` — Startet einen Container in einem bestehenden Pod.

```bash
podman run -d --pod my-pod --name web nginx
```

`podman pod ls` — Listet alle Pods mit Status und Container-Anzahl auf.

```bash
podman pod ls
```

`podman pod inspect <pod>` — Zeigt detaillierte JSON-Informationen zu einem Pod.

```bash
podman pod inspect my-pod
```

`podman pod start <pod>` — Startet alle Container in einem Pod.

```bash
podman pod start my-pod
```

`podman pod stop <pod>` — Stoppt alle Container in einem Pod.

```bash
podman pod stop my-pod
```

`podman pod restart <pod>` — Startet alle Container in einem Pod neu.

```bash
podman pod restart my-pod
```

`podman pod rm <pod>` — Entfernt einen gestoppten Pod und alle seine Container.

```bash
podman pod rm my-pod
```

`podman pod rm -f <pod>` — Entfernt einen Pod erzwungen, inklusive laufender Container.

```bash
podman pod rm -f my-pod
```

`podman pod top <pod>` — Zeigt die laufenden Prozesse aller Container in einem Pod.

```bash
podman pod top my-pod
```

`podman pod logs <pod>` — Zeigt die kombinierten Logs aller Container in einem Pod.

```bash
podman pod logs my-pod
```

## Netzwerke

`podman network ls` — Listet alle Podman-Netzwerke auf.

```bash
podman network ls
```

`podman network create <name>` — Erstellt ein neues Netzwerk.

```bash
podman network create my-network
```

`podman network inspect <name>` — Zeigt detaillierte Informationen zu einem Netzwerk.

```bash
podman network inspect my-network
```

`podman network connect <network> <container>` — Verbindet einen laufenden Container mit einem Netzwerk.

```bash
podman network connect my-network my-web
```

`podman network disconnect <network> <container>` — Trennt einen Container von einem Netzwerk.

```bash
podman network disconnect my-network my-web
```

`podman run --network <name> <image>` — Startet einen Container in einem bestimmten Netzwerk.

```bash
podman run -d --network my-network --name api my-api
```

`podman network rm <name>` — Entfernt ein Netzwerk.

```bash
podman network rm my-network
```

`podman network prune` — Entfernt alle ungenutzten Netzwerke.

```bash
podman network prune
```

## Rootless & Sicherheit

`podman unshare <command>` — Führt einen Befehl im User-Namespace des rootless Podman aus. Nützlich, um Volume-Berechtigungen zu korrigieren.

```bash
podman unshare chown 1000:1000 /home/user/data
```

`podman run --userns=keep-id <image>` — Bildet die aktuelle UID/GID in den Container ab. Erstellte Dateien erhalten die korrekte Host-Eigentümerschaft.

```bash
podman run --userns=keep-id -v ./data:/data my-app
```

`podman run --user <uid>:<gid> <image>` — Lässt den Container-Prozess als bestimmten Benutzer und Gruppe laufen.

```bash
podman run --user 1000:1000 my-app
```

`podman run --security-opt label=disable <image>` — Deaktiviert die SELinux-Label-Einschränkung für den Container. Schwächt die Isolation – nur gezielt einsetzen, etwa um ein konkretes Volume-Mount-Problem zu umgehen.

```bash
podman run --security-opt label=disable -v ./data:/data my-app
```

`podman run --cap-add <capability> <image>` — Fügt dem Container eine Linux-Capability hinzu.

```bash
podman run --cap-add NET_ADMIN my-app
```

`podman run --cap-drop ALL <image>` — Entzieht alle Linux-Capabilities für maximale Sicherheit.

```bash
podman run --cap-drop ALL --cap-add NET_BIND_SERVICE my-app
```

`podman run --read-only <image>` — Bindet das Root-Dateisystem des Containers schreibgeschützt ein.

```bash
podman run --read-only --tmpfs /tmp my-app
```

## systemd-Integration

Für neue Setups empfiehlt Podman seit Version 4.4 **Quadlet** (deklarative `.container`-Dateien) statt `generate systemd`; die folgenden `generate systemd`-Befehle funktionieren weiterhin und sind für bestehende Units nützlich.

`podman generate systemd --new --name <container>` — Erzeugt eine systemd-Unit, die beim Start einen frischen Container erstellt.

```bash
podman generate systemd --new --name my-web
```

`podman generate systemd --new --name <container> --files` — Erzeugt die systemd-Unit und schreibt sie auf die Festplatte.

```bash
podman generate systemd --new --name my-web --files
```

`podman generate systemd --new --name <pod> --files` — Erzeugt systemd-Units für einen ganzen Pod und seine Container.

```bash
podman generate systemd --new --name my-pod --files
```

`podman auto-update` — Aktualisiert Container mit dem Label io.containers.autoupdate automatisch.

```bash
podman auto-update
```

`podman auto-update --dry-run` — Prüft, welche Container aktualisiert würden, ohne Änderungen anzuwenden.

```bash
podman auto-update --dry-run
```

`podman generate kube <pod>` — Erzeugt eine Kubernetes-YAML-Definition aus einem Pod oder Container.

```bash
podman generate kube my-pod > my-pod.yaml
```

`podman play kube <file>` — Erstellt Pods und Container aus einer Kubernetes-YAML-Datei.

```bash
podman play kube my-pod.yaml
```

`podman play kube --down <file>` — Baut Pods und Container ab, die aus einer Kubernetes-YAML-Datei erstellt wurden.

```bash
podman play kube --down my-pod.yaml
```

## Podman Compose

`podman compose up -d` — Startet alle in docker-compose.yml definierten Services im Hintergrund.

```bash
podman compose up -d
```

`podman compose down` — Stoppt und entfernt alle Container und Netzwerke des Compose-Projekts.

```bash
podman compose down
```

`podman compose ps` — Listet die vom Compose-Projekt verwalteten Container auf.

```bash
podman compose ps
```

`podman compose logs -f` — Folgt den Logs aller Services in Echtzeit.

```bash
podman compose logs -f
```

`podman compose exec <service> <command>` — Führt einen Befehl in einem laufenden Compose-Service-Container aus.

```bash
podman compose exec web bash
```

`podman compose build` — Baut oder erneuert alle Service-Images.

```bash
podman compose build
```

## Aufräumen & System

`podman system df` — Zeigt den Speicherverbrauch: Images, Container, Volumes.

```bash
podman system df
```

`podman system prune` — Entfernt alle gestoppten Container, ungenutzten Images und Netzwerke.

```bash
podman system prune
```

`podman system prune -a --volumes` — Vollständige Bereinigung inklusive aller ungenutzten Images und Volumes.

```bash
podman system prune -a --volumes
```

`podman system reset` — Setzt den Podman-Speicher auf den Ausgangszustand zurück. Entfernt alle Container, Images und Volumes.

```bash
podman system reset
```

`podman system migrate` — Migriert Container nach einem Podman-Upgrade auf das neueste Format.

```bash
podman system migrate
```

`podman info` — Zeigt systemweite Podman-Informationen (Version, Storage, Registries usw.).

```bash
podman info
```

`podman version` — Zeigt Details zur Podman-Version.

```bash
podman version
```

`podman login <registry>` — Meldet sich an einer Container-Registry an.

```bash
podman login quay.io
```

`podman logout <registry>` — Meldet sich von einer Container-Registry ab.

```bash
podman logout quay.io
```

## Docker-Kompatibilität

`alias docker=podman` — Erstellt einen Shell-Alias, sodass docker-Befehle automatisch Podman nutzen.

```bash
alias docker=podman
```

`podman system service --time=0` — Startet den Podman-API-Service. Ermöglicht Kompatibilität mit Docker-API-Clients.

```bash
podman system service --time=0 unix:///tmp/podman.sock
```

`export DOCKER_HOST=unix://<socket_path>` — Verweist Docker-CLI oder docker-compose auf den Podman-Socket.

```bash
export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
```

<!-- PROSE:outro -->
## Fazit

Podman ist mehr als ein Drop-in-Ersatz für Docker: Das daemonless-Modell und der rootless-Betrieb passen besser zu modernen Sicherheitsanforderungen, und die native Pod- und Kubernetes-Unterstützung schlägt eine Brücke zur Orchestrierung. Wenn du von Docker kommst, setzt du am schnellsten `alias docker=podman` und arbeitest wie gewohnt weiter; auf Servern lohnt sich die systemd-Integration via Quadlet oder `generate systemd`, um Container sauber als Dienste zu betreiben.

## Weiterführende Links

- [Podman – offizielle Dokumentation](https://docs.podman.io/) – Referenz und Handbuch (englisch)
- [Podman – Projektseite](https://podman.io/) – Downloads, Installation und News (englisch)
- [Podman – Wikipedia](https://de.wikipedia.org/wiki/Podman) – Hintergrund und Architektur
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [ddev](https://www.jpkc.com/db/cheatsheets/containers/ddev/) – container-basierte lokale Entwicklungsumgebungen
- [docker](https://www.jpkc.com/db/cheatsheets/containers/docker/) – die klassische Container-Engine mit Daemon
- [docker-compose](https://www.jpkc.com/db/cheatsheets/containers/docker-compose/) – Multi-Container-Anwendungen deklarativ definieren