Podman Cheatsheet – Sysadmin Referenz

Podman/Docker Kurs – Zum Mitnehmen

Überblick verschaffen

Was will ich wissen?	Befehl
Was läuft?	`podman ps`
Was läuft auch gestoppt?	`podman ps -a`
Wo sind die Logs?	`podman logs <name>`
Logs live verfolgen	`podman logs -f <name>`
Letzte 20 Zeilen	`podman logs --tail 20 <name>`
Welcher User läuft im Container?	`podman exec <name> id`
Welche Ports sind gemappt?	`podman port <name>`
Welche Mounts?	`podman inspect --format '{{.Mounts}}' <name>`
Wie viel RAM/CPU?	`podman stats --no-stream`
Was hat sich verändert?	`podman diff <name>`
Welche Umgebungsvariablen?	`podman inspect --format '{{.Config.Env}}' <name>`
Welche IP hat der Container?	`podman inspect --format '{{.NetworkSettings.IPAddress}}' <name>`
In welchem Netzwerk?	`podman inspect --format '{{.NetworkSettings.Networks}}' <name>`

Container starten

# Einfach starten
podman run nginx

# Im Hintergrund mit Name und Port
podman run -d --name mein-nginx -p 8100:80 nginx

# Mit Bind Mount
podman run -d -v ~/webroot:/usr/share/nginx/html:ro nginx

# Mit Volume
podman run -d -v meine-daten:/data nginx

# Mit Umgebungsvariable
podman run -d -e APP_ENV=production nginx

# Aus Env-Datei
podman run -d --env-file ~/app.env nginx

# Automatisch löschen nach Beendigung
podman run --rm nginx echo "test"

# Im Custom-Netzwerk
podman run -d --network mein-netz nginx

# Ressourcen begrenzen
podman run -d --memory 512m --cpus 0.5 nginx

In Container einsteigen

# Interaktive Shell
podman exec -it mein-nginx bash
podman exec -it mein-nginx sh        # Falls bash fehlt

# Einzelner Befehl
podman exec mein-nginx nginx -t      # Config testen
podman exec mein-nginx id            # User prüfen
podman exec mein-nginx env           # Env-Variablen
podman exec mein-nginx cat /etc/nginx/nginx.conf

# Netzwerk von innen testen
podman exec mein-nginx curl http://anderer-container
podman exec mein-nginx nslookup anderer-container  # bind-utils nötig
podman exec mein-nginx curl http://anderer-container   # Alternative

⚠️ Niemals podman attach – CTRL+C stoppt den Container!

Container-Lifecycle

podman start mein-nginx
podman stop mein-nginx            # Graceful (SIGTERM)
podman stop -t 30 mein-nginx      # 30s warten
podman restart mein-nginx
podman kill mein-nginx            # SIGKILL – nur Notfall

podman rm mein-nginx              # Nur wenn gestoppt
podman rm -f mein-nginx           # Erzwingen

Images

podman images                     # Lokale Images
podman pull nginx:latest          # Image holen
podman pull docker.io/library/nginx:latest  # Vollständiger Name
podman rmi nginx                  # Image löschen
podman history nginx              # Layer-Aufbau
podman inspect nginx              # Details

# Image bauen
podman build -t mein-image:v1 .

# Image zwischen Root- und User-Store kopieren
sudo podman image scp nginx:latest teilnehmer01@::

Netzwerk

podman network ls                          # Alle Netzwerke
podman network create mein-netz            # Neues Netzwerk
podman network inspect mein-netz           # Details
podman network connect mein-netz nginx     # Container verbinden
podman network disconnect mein-netz nginx  # Trennen
podman network rm mein-netz                # Löschen
podman network prune                       # Ungenutzte löschen

iptables – was Container im Hintergrund schreiben:

sudo iptables -t nat -L -n -v                              # Alle NAT-Regeln
sudo iptables -t nat -L -n -v | grep -E 'DOCKER|PODMAN|KUBE'  # Nur Container-Chains
sudo nft list ruleset                                      # nftables (RHEL 9)

Podman rootless schreibt keine iptables-Regeln. Docker und Podman rootful schreiben NAT-Regeln. Kubernetes/k3s schreiben viele Regeln via kube-proxy.

Volumes & Storage

podman volume create meine-daten     # Volume erstellen
podman volume ls                     # Volumes anzeigen
podman volume inspect meine-daten    # Details + Pfad
podman volume rm meine-daten         # Löschen
podman volume prune                  # Ungenutzte löschen

Mount-Syntax:

-v /host/pfad:/container/pfad       # Bind Mount (rw)
-v /host/pfad:/container/pfad:ro    # Read-only
-v /host/pfad:/container/pfad:ro,z  # + SELinux shared
-v volume-name:/container/pfad      # Named Volume

Rootless & Systemd

# Lingering prüfen/aktivieren
loginctl show-user $(whoami) | grep Linger
sudo loginctl enable-linger <username>

# UID-Mapping anzeigen
cat /etc/subuid
podman unshare cat /proc/self/uid_map

# Quadlet aktivieren
systemctl --user daemon-reload
systemctl --user start mein-nginx
systemctl --user enable mein-nginx
systemctl --user status mein-nginx
journalctl --user -u mein-nginx -f
# ⚠️ Nur in echter SSH-Session als dieser User
# "Failed to connect to bus" → export XDG_RUNTIME_DIR=/run/user/$(id -u)
# Alternative: podman logs -f mein-nginx

Troubleshooting

# Exit-Code anzeigen
podman ps -a
# Exited (0)  = ok | (1) = Fehler | (137) = SIGKILL | (127) = not found

# Speicher-Überblick
podman system df

# Aufräumen
podman container prune     # Gestoppte Container
podman image prune         # Ungenutzte Images
podman volume prune        # Ungenutzte Volumes
podman system prune        # Alles ungenutzte
podman system prune -a     # ⚠️ Auch nicht verwendete Images

Troubleshooting-Ablauf

Container läuft nicht?
  → podman ps -a          (Exit-Code?)
  → podman logs <n>       (Was sagt der Prozess?)
  → podman inspect <n>    (Config/Mounts/Netzwerk ok?)
  → podman exec <n> ...   (Manuell im Container prüfen)
  → podman run --rm ...   (Frischer Container zum Vergleich)

kubectl – Kubernetes Kurzreferenz

Was	Befehl
Nodes anzeigen	`kubectl get nodes`
Pods anzeigen	`kubectl get pods`
Alle Namespaces	`kubectl get pods -A`
Pod Details	`kubectl describe pod <name>`
Logs	`kubectl logs <pod>`
Logs live	`kubectl logs -f <pod>`
In Pod einsteigen	`kubectl exec -it <pod> -- bash`
Pod löschen	`kubectl delete pod <name>`
Deployments	`kubectl get deployments`

Tools

Tool	Zweck	Starten
`k9s`	Terminal-UI für Kubernetes	`k9s`
`podman stats`	Ressourcen live	`podman stats`
`podman system df`	Speicherverbrauch	`podman system df`

Image-Namen Aufbau

registry.redhat.io  /  ubi9/nginx  :  1.24
│                      │              │
│                      │              └─ Tag (Version, "latest" wenn leer)
│                      └─ Image-Name
└─ Registry-Adresse

Bekannte Registries: - registry.redhat.io – offizielle Red Hat Images - docker.io/library/ – Docker Hub offizielle Images - quay.io – Red Hat Community - Firmen-intern: Artifactory

Storage-Verzeichnisse – was wo liegt

Podman

Rootful:   /var/lib/containers/storage/          ← Images, Container
           /var/lib/containers/storage/volumes/  ← Named Volumes
           /run/containers/                       ← Laufzeit (tmpfs)

Rootless:  ~/.local/share/containers/storage/         ← Images, Container
           ~/.local/share/containers/storage/volumes/ ← Named Volumes
           /run/user/<UID>/containers/                 ← Laufzeit

Alle User: /home/*/.local/share/containers/storage/  ← pro User!

Docker

Rootful:   /var/lib/docker/           ← alles: Images, Container
           /var/lib/docker/volumes/   ← Named Volumes
           /var/lib/docker/overlay2/  ← Image-Layer (grösster Teil)

Disk-Übersicht

# Podman
podman system df                    # eigener Store
sudo podman system df               # root Store
du -sh /var/lib/containers/
du -sh /home/*/.local/share/containers/ 2>/dev/null

# Docker
sudo docker system df
sudo du -sh /var/lib/docker/

Was ins Backup?

Images → kein Backup nötig wenn aus Registry pullbar
Volumes → ✅ Backup nötig – dort liegen die Anwendungsdaten
Bind Mounts → ✅ Backup nötig – liegt wo du es hingelegt hast

Rootless: Root-Store vs. User-Store

/var/lib/containers/storage/    ← Root-Store  (sudo podman)
~/.local/share/containers/      ← User-Store  (podman als User)

Root und User sehen nicht die gleichen Images!

# Image von root zu User kopieren
sudo podman image scp nginx:latest meinuser@::