Podman – Rootless Docker-Alternative Grundlagen und Installation

Was ist Podman?

Podman (Pod Manager) ist eine Container-Verwaltungsplattform, die eine komplette Alternative zu Docker darstellt. Im Gegensatz zu Docker ist Podman eine daemonless Architektur – es gibt keinen zentralen Daemon-Prozess, der mit Root-Rechten läuft. Jeder Benutzer kann seine eigenen Container ohne sudo verwalten. Podman ist vollständig OCI-kompatibel (Open Container Initiative) und kann daher dasselbe Image-Format wie Docker verwenden.

Hauptunterschiede zwischen Docker und Podman

Merkmal	Docker	Podman
Architektur	Client-Server mit Docker Daemon	Daemonless (direkte Kommunikation mit Container-Runtime)
Rootless Standard	Nein, Docker Daemon läuft als root	Ja, Container als normaler Benutzer
Security-Modell	User in docker-Gruppe benötigt Elevated Privileges	Keine Privilege Escalation nötig
Pods-Konzept	Docker Compose für Multi-Container Orchestrierung	Native Pod-Unterstützung (wie Kubernetes)
Systemd Integration	Manuelle Erstellung von Systemd Units	Automatische Generierung von Units
Performance	Gut, aber durch Daemon-Overhead	Minimal, direkter Prozesszugriff
Networking	Docker Network Command	Podman Network, bessere Integration
Image Storage	Docker Desktop/Engine spezifisches Format	OCI Image Format kompatibel

Installation auf Ubuntu

Option 1: Aus Standard-Repository

Die einfachste Methode ist die Installation aus dem Standard Ubuntu Repository:

# Paketlisten aktualisieren
sudo apt update

# Podman installieren
sudo apt install podman podman-compose -y

# Version überprüfen
podman --version

# Systemd Services für Podman aktivieren
systemctl --user start podman
systemctl --user enable podman

Option 2: Aus dem Official Podman Repository (neueste Version)

Für eine neuere Version als im Standard Repository verfügbar:

# Podman Repository hinzufügen
. /etc/os-release
echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_${VERSION_ID}/ /" | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list

# GPG Key importieren
curl -fsSL https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable/Release.key | sudo apt-key add -

# Repository aktualisieren
sudo apt update

# Podman installieren
sudo apt install podman -y

# Überprüfung
podman --version

Rootless Container – Der Hauptvorteil

Einer der größten Vorteile von Podman ist die Möglichkeit, Container als normaler Benutzer ohne sudo-Rechte zu starten. Dies eliminiert ein großes Sicherheitsrisiko, das mit der Verwendung von Docker besteht.

Rootless Container starten

# Als normaler Benutzer (ohne sudo!) Container starten
podman run -d --name mywebserver -p 8080:80 nginx

# Container-Status überprüfen
podman ps

# Container-Logs ansehen
podman logs mywebserver

# Container stoppen
podman stop mywebserver

# Container löschen
podman rm mywebserver

# Alle User-Container auflisten
podman ps -a

Grundlegende Podman Befehle

Image-Management

# Images durchsuchen
podman search nginx

# Image herunterladen/pullen
podman pull docker.io/library/nginx:latest

# Lokale Images auflisten
podman images

# Image inspizieren
podman inspect docker.io/library/nginx:latest

# Image löschen
podman rmi docker.io/library/nginx:latest

# Image mit Tag erstellen
podman tag docker.io/library/nginx:latest myrepo/nginx:v1.0

Container-Management

# Interaktiver Container
podman run -it ubuntu:22.04 /bin/bash

# Container mit Port-Mapping
podman run -d -p 80:80 --name web nginx

# Container mit Volume
podman run -d -v /local/path:/container/path nginx

# Container mit Umgebungsvariablen
podman run -e DATABASE_URL=postgres://localhost -d nginx

# Container mit Ressourcen-Limits
podman run -d --memory 512m --cpus 1 --name limited nginx

# Container starten/stoppen/neustarten
podman start mycontainer
podman stop mycontainer
podman restart mycontainer

# Container-Informationen
podman ps
podman inspect mycontainer
podman stats mycontainer

Befehle in laufenden Containern ausführen

# Shell im laufenden Container öffnen
podman exec -it mycontainer /bin/bash

# Befehl im Container ausführen
podman exec mycontainer apt update

# Dateien kopieren
podman cp mycontainer:/app/data /local/path
podman cp /local/file mycontainer:/app/

Podman Pods

Ein Pod ist ein Konzept, das von Kubernetes bekannt ist und von Podman nativ unterstützt wird. Ein Pod ist eine Gruppe von Containern, die zusammen arbeiten und Netzwerk-Ressourcen teilen, ähnlich wie in Kubernetes.

# Pod erstellen
podman pod create --name mypod -p 8080:80

# Container in Pod starten
podman run -d --pod mypod --name web nginx
podman run -d --pod mypod --name db postgres:latest

# Pod-Status überprüfen
podman pod ps

# Pod inspizieren
podman pod inspect mypod

# Alle Container in einem Pod überprüfen
podman ps --pod

# Pod stoppen
podman pod stop mypod

# Pod löschen (und alle darin enthaltenen Container)
podman pod rm mypod

Systemd Service aus Container generieren

Podman kann automatisch Systemd Service-Dateien aus laufenden Containern generieren. Dies ist sehr praktisch für die Verwaltung von Containern als Systemd Services.

# Container starten
podman run -d --name myservice nginx:latest

# Systemd Service generieren
podman generate systemd --new --name myservice > /tmp/myservice.service

# Service-Datei überprüfen
cat /tmp/myservice.service

# Service-Datei in Systemd-Verzeichnis kopieren
mkdir -p ~/.config/systemd/user
cp /tmp/myservice.service ~/.config/systemd/user/myservice.service

# Systemd-Cache aktualisieren
systemctl --user daemon-reload

# Service starten
systemctl --user start myservice

# Service aktivieren (beim Booten starten)
systemctl --user enable myservice

# Status überprüfen
systemctl --user status myservice

# Service stoppen
systemctl --user stop myservice

Podman Compose

Podman Compose ist ein Tool zur Verwaltung von Multi-Container-Anwendungen mit YAML-Definitionen, ähnlich wie Docker Compose. Die Syntax ist identisch, aber Podman Compose nutzt Podman statt Docker.

Installation

# Podman Compose installieren
pip3 install podman-compose

# Version überprüfen
podman-compose --version

Docker Compose Datei mit Podman verwenden

# docker-compose.yml
version: '3'
services:
  web:
    image: nginx:latest
    container_name: web
    ports:
      - "80:80"
    volumes:
      - ./www:/usr/share/nginx/html
    networks:
      - mynetwork

  database:
    image: postgres:15
    container_name: db
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secure123
      POSTGRES_DB: myapp
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynetwork

networks:
  mynetwork:
    driver: bridge

volumes:
  db_data:

Mit Podman Compose verwalten

# Alle Services starten
podman-compose -f docker-compose.yml up -d

# Services überprüfen
podman-compose -f docker-compose.yml ps

# Logs anzeigen
podman-compose -f docker-compose.yml logs -f web

# Spezifischen Service neustarten
podman-compose -f docker-compose.yml restart web

# Services stoppen
podman-compose -f docker-compose.yml down

# Volumes löschen (mit down)
podman-compose -f docker-compose.yml down -v

Migration von Docker zu Podman

Schnelle Kompatibilität mit Alias

# Docker-Alias für Podman erstellen
echo "alias docker=podman" >> ~/.bashrc
source ~/.bashrc

# Nun funktionieren Docker-Befehle direkt mit Podman
docker run -d nginx
docker ps
docker stop mycontainer

Images von Docker zu Podman migrieren

# Docker-Daemon muss nicht laufen!
# Aber Docker CLI muss installiert sein

# Docker Image als Tarball exportieren
docker save myimage:latest -o myimage.tar

# In Podman importieren
podman load -i myimage.tar

# Oder direkt von Docker Registry in Podman pullen
podman pull docker.io/myusername/myimage:latest

Buildah für Container-Images erstellen

Buildah ist ein spezialisiertes Werkzeug zum Erstellen von OCI-konformen Container-Images. Es funktioniert perfekt mit Podman und bietet mehr Kontrolle als dockerfile-basierte Builds.

# Buildah installieren
sudo apt install buildah -y

# Neuen Container-Build-Kontext erstellen
buildah from alpine:latest

# Befehle im Build-Kontext ausführen
buildah run alpine:latest apk add nginx

# Datei in Build-Kontext kopieren
buildah copy alpine:latest app.conf /etc/nginx/conf.d/

# Umgebungsvariable setzen
buildah config --env "APP_ENV=production" alpine:latest

# Port exponieren
buildah config --expose 80 alpine:latest

# Image committen
buildah commit alpine:latest mynginx:v1

# Mit Podman verwenden
podman run -d -p 80:80 mynginx:v1

Skopeo für Image-Management

Skopeo ist ein Werkzeug zur Inspizierung, Kopierung und Verwaltung von Container-Images, ohne einen Daemon zu benötigen.

# Skopeo installieren
sudo apt install skopeo -y

# Image-Informationen inspizieren (direkt vom Registry)
skopeo inspect docker://docker.io/library/nginx:latest

# Image zwischen Registries kopieren
skopeo copy docker://docker.io/library/nginx:latest docker://myregistry.com/nginx:latest

# Image-Konfiguration anzeigen
skopeo inspect --config docker://docker.io/library/nginx:latest

# Image lokales Podman-System kopieren
skopeo copy docker://docker.io/library/nginx:latest containers-storage:localhost/nginx:latest

Vergleich: Docker vs Podman vs containerd

Aspekt	Docker	Podman	containerd
Architektur	Daemon-basiert	Daemonless	Daemon-basiert (minimal)
Rootless	Mit Konfiguration	Standard	Mit Konfiguration
CLI Benutzerfreundlichkeit	Sehr gut	Sehr gut (Docker-kompatibel)	Niedrig (ctr, nerdctl)
Pods-Unterstützung	Nein (nur Compose)	Ja (native)	Nein
Kubernetes Integration	Docker-Shim in K8s	CRI-O ähnlich	Direkte CRI-Integration
Systemd-Integrationx	Manuell	Automatisch generiert	Minimal
Lernkurve	Mittelmäßig	Sehr gering (Docker-kompatibel)	Steil
Für Production Ready	Ja	Ja (Red Hat Standard)	Ja (Kubernetes Standard)

Best Practices mit Podman

Systemd Services für permanente Container

# Permanenter Service-Unit (nicht temporary)
podman generate systemd --new --name myservice --after network-online.target > ~/.config/systemd/user/myservice.service

# Der Service wird auch nach Neustart des Systems weiterlaufen
systemctl --user enable myservice

# Login-Session muss nicht aktiv sein
loginctl enable-linger $USER

Netzwerk-Konfiguration

# Custom Netzwerk erstellen
podman network create mynet

# Mit Netzwerk und Hostname starten
podman run -d --network mynet --hostname webserver nginx

# DNS-Auflösung wird unterstützt
podman exec -it webserver ping webserver

# Netzwerk inspizieren
podman network inspect mynet

# Netzwerk löschen
podman network rm mynet

Weitere Ressourcen

• 📖 Docker für Anfänger erklärt
• 📖 Docker Compose Grundlagen und Anleitung
• 📖 Container Security Best Practices
• 📖 Kubernetes Grundlagen Einführung
• 📖 Linux Benutzer und Gruppen Verwaltung
• 🔧 Sichere Server bei Enjyn mieten
• 🔧 Enjyn Status Monitor – Kostenlose Uptime-Überwachung

---

Letzte Aktualisierung: April 2026 | Podman Version 5.0+