Podman: Rootless-Container als Docker-Alternative ausfuehren

Podman (Pod Manager) ist eine daemon-lose, quelloffene Container-Engine, die von Red Hat entwickelt wurde und eine Docker-kompatible CLI zum Erstellen, Ausfuehren und Verwalten von OCI-Containern und Pods bietet. Im Gegensatz zu Docker benoetigt Podman keinen staendig laufenden Hintergrund-Daemon mit Root-Rechten, was es von Natur aus sicherer fuer Entwicklungsrechner und Produktionsserver macht. Wenn Sie Docker verwenden und nach einer sichereren, systemd-freundlichen Alternative suchen, die Container unter Ihrem regulaeren Benutzer ausfuehrt, ist Podman das richtige Werkzeug.

Diese Anleitung behandelt alles, was Sie benoetigen, um mit Podman unter Ubuntu zu starten: Installation, Rootless-Container-Ausfuehrung, Image-Verwaltung, Pod-Erstellung, Compose-Kompatibilitaet, systemd-Integration, Netzwerk und einen vollstaendigen Migrationspfad von Docker.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Ein System mit Ubuntu 22.04 oder 24.04 (Desktop- oder Server-Edition)
• Terminalzugriff mit sudo-Berechtigungen
• Eine stabile Internetverbindung
• Grundlegende Vertrautheit mit Containern und der Linux-Kommandozeile
• Mindestens 2 GB freier Speicherplatz fuer Images

Hinweis: Podman funktioniert auf jeder modernen Linux-Distribution, aber diese Anleitung konzentriert sich auf Ubuntu. Wenn Sie von Docker migrieren, ist keine Docker-Installation erforderlich — Podman ersetzt es vollstaendig.

Was ist Podman?

Podman ist ein Container-Verwaltungswerkzeug, das dieselbe CLI-Schnittstelle wie Docker implementiert, aber eine grundlegend andere Architektur hat. Der Name kommt von Pod Manager und spiegelt die native Unterstuetzung fuer Kubernetes-aehnliche Pods wider — Gruppen von Containern, die Netzwerk- und IPC-Namespaces teilen.

Hauptmerkmale von Podman:

• Daemon-los: Kein Hintergrunddienst laeuft als Root. Jeder podman-Befehl startet Container direkt als Kindprozesse ueber conmon (den Container-Monitor).
• Standardmaessig rootless: Container laufen unter Ihrem regulaeren Benutzerkonto mithilfe von Linux-User-Namespaces, ohne Root-Rechte zu benoetigen.
• OCI-konform: Podman erstellt und fuehrt Images aus, die der Open Container Initiative (OCI) Spezifikation entsprechen, was volle Kompatibilitaet mit Docker-Images und Registries gewaehrleistet.
• Pod-nativ: Podman kann Container in Pods gruppieren und so Kubernetes-Pod-Semantik fuer lokale Entwicklung und Tests abbilden.
• systemd-Integration: Podman generiert systemd-Unit-Dateien aus laufenden Containern, was die Verwaltung des Container-Lebenszyklus als Systemdienste vereinfacht.

Podman vs Docker

Das Verstaendnis der architektonischen Unterschiede zwischen Podman und Docker hilft Ihnen, eine fundierte Entscheidung zu treffen und Ihre Migration zu planen.

Merkmal	Podman	Docker
Architektur	Daemon-los (fork/exec)	Client-Server (dockerd-Daemon)
Root-Anforderung	Standardmaessig rootless	Erfordert Root-Daemon (Rootless-Modus optional)
Container-Runtime	crun / runc ueber conmon	containerd + runc
CLI-Kompatibilitaet	Direkter Ersatz (podman = docker)	Native CLI
Pod-Unterstuetzung	Nativ (Kubernetes-aehnlich)	Nicht verfuegbar
Compose-Unterstuetzung	podman-compose / podman compose	docker compose (integriertes Plugin)
systemd-Integration	Nativ (podman generate systemd)	Erfordert manuelle Unit-Dateien
Image-Format	OCI / Docker	OCI / Docker
Build-Werkzeug	Buildah (integriert)	BuildKit
Sicherheitsmodell	Kein Root-Daemon, User-Namespaces	Root-Daemon, optionales Rootless
Socket	Optional (podman.socket)	Erforderlich (docker.socket)

Der bedeutendste Unterschied ist der Daemon. Docker erfordert, dass der dockerd-Daemon staendig als Root laeuft, was einen Single Point of Failure und einen potenziellen Vektor fuer Privilegieneskalation schafft. Podman eliminiert dies vollstaendig — wenn Sie podman run ausfuehren, wird direkt ein neuer Prozess fuer den Container erstellt, wobei conmon als Container-Monitor dient. Wenn Podman selbst abstuerzt, laufen die Container weiter.

Podman unter Ubuntu installieren

Podman ist ab Ubuntu 22.04 in den Standard-Repositories verfuegbar. Installieren Sie es zusammen mit den unterstuetzenden Werkzeugen:

sudo apt update
sudo apt install -y podman

Ueberpruefen Sie die Installation:

podman --version

Erwartete Ausgabe:

podman version 4.9.3

Pruefen Sie die Systeminformationen, um zu bestaetigen, dass der Rootless-Modus verfuegbar ist:

podman info --format '{{.Host.Security.Rootless}}'

Dies sollte true zurueckgeben, wenn es als Nicht-Root-Benutzer ausgefuehrt wird.

Fuer die neueste Podman-Version (falls die Ubuntu-Repository-Version zu alt ist) koennen Sie das offizielle Kubic-Repository hinzufuegen:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL "https://download.opensuse.org/repositories/devel:kubic:libcontainers:unstable/xUbuntu_$(lsb_release -rs)/Release.key" \
  | gpg --dearmor \
  | sudo tee /etc/apt/keyrings/devel_kubic_libcontainers_unstable.gpg > /dev/null

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/devel_kubic_libcontainers_unstable.gpg] \
  https://download.opensuse.org/repositories/devel:kubic:libcontainers:unstable/xUbuntu_$(lsb_release -rs)/ /" \
  | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:unstable.list > /dev/null

sudo apt update
sudo apt install -y podman

Container-Registries konfigurieren

Standardmaessig erfordert Podman vollstaendig qualifizierte Image-Namen (z.B. docker.io/library/nginx). Um Kurznamen wie nginx zu ermoeglichen, konfigurieren Sie die unqualifizierten Such-Registries:

sudo tee /etc/containers/registries.conf.d/00-unqualified-search.conf <<'EOF'
[registries.search]
registries = ['docker.io', 'quay.io', 'ghcr.io']
EOF

Alternativ bearbeiten Sie /etc/containers/registries.conf und fuegen Sie die Such-Registries unter dem Abschnitt [registries.search] hinzu.

Ihren ersten Container ausfuehren

Mit installiertem Podman fuehren Sie einen Test-Container als regulaerer (Nicht-Root-)Benutzer aus:

podman run --rm docker.io/library/hello-world

Sie sollten die bekannte Nachricht “Hello from Docker!” sehen, die bestaetigt, dass Podman OCI-Images abrufen und ausfuehren kann. Beachten Sie, dass kein sudo erforderlich ist.

Fuehren Sie einen interaktiven Container aus:

podman run -it --rm docker.io/library/ubuntu:24.04 bash

Innerhalb des Containers pruefen Sie den Benutzer:

whoami
# root (innerhalb des User-Namespace des Containers)
id
# uid=0(root) gid=0(root) groups=0(root)

Obwohl Sie innerhalb des Containers als Root erscheinen, laufen Sie tatsaechlich als regulaerer Benutzer auf dem Host. Das ist die Staerke von Rootless-Containern mit User-Namespace-Mapping.

Verlassen Sie den Container mit exit oder Ctrl+D.

Rootless-Container

Rootless-Container sind das definierende Merkmal von Podman. Das Verstaendnis ihrer Funktionsweise hilft Ihnen bei der Fehlerbehebung von Berechtigungsproblemen und beim Entwurf sicherer Container-Bereitstellungen.

Wie Rootless-Container funktionieren

Wenn Sie einen Container als Nicht-Root-Benutzer ausfuehren, verwendet Podman Linux-User-Namespaces, um eine isolierte Umgebung zu erstellen, in der:

1. Der Container-Prozess sich als root (UID 0) innerhalb des Containers sieht.
2. Auf dem Host laeuft der Prozess als untergeordnete UID, die aus dem erlaubten Bereich Ihres Benutzers gemappt wird.
3. Das Mapping ist in /etc/subuid und /etc/subgid definiert.

Pruefen Sie die untergeordneten UID/GID-Mappings Ihres Benutzers:

cat /etc/subuid
# jc:100000:65536

cat /etc/subgid
# jc:100000:65536

Das bedeutet, dass der Benutzer jc UIDs 100000 bis 165535 innerhalb von Containern mappen kann. Die UID 0 des Containers entspricht der UID Ihres Host-Benutzers, und UIDs 1-65535 im Container entsprechen den Host-UIDs 100000-165535.

Rootless-Betrieb ueberpruefen

Fuehren Sie einen Container aus und pruefen Sie den Prozess vom Host:

podman run -d --name test-rootless docker.io/library/nginx:alpine

Von einem anderen Terminal auf dem Host:

ps aux | grep nginx
# jc  12345  ... nginx: master process

Der Nginx-Prozess laeuft unter Ihrem Benutzer (jc), nicht als Root. Wenn der Container kompromittiert wuerde, haette der Angreifer nur die Rechte Ihres Benutzers — keinen Root-Zugriff auf den Host.

User-Namespaces konfigurieren

Wenn /etc/subuid oder /etc/subgid keine Eintraege fuer Ihren Benutzer enthalten, fuegen Sie sie hinzu:

sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER

Nach der Aenderung dieser Dateien setzen Sie den Podman-Speicher zurueck, um die Aenderungen anzuwenden:

podman system migrate

Arbeiten mit Images

Podman verwendet dasselbe Image-Format wie Docker und kann von jedem OCI-kompatiblen Registry abrufen.

Images abrufen

# Von Docker Hub abrufen
podman pull docker.io/library/nginx:alpine

# Von Quay.io abrufen
podman pull quay.io/podman/hello

# Von GitHub Container Registry abrufen
podman pull ghcr.io/actions/actions-runner:latest

Images auflisten

podman images

Ausgabe:

REPOSITORY                        TAG       IMAGE ID      CREATED       SIZE
docker.io/library/nginx           alpine    a2bd6d6e82f0  2 weeks ago   43.3 MB
quay.io/podman/hello              latest    5dd467fce50b  3 months ago  787 kB

Images erstellen

Podman verwendet Containerfile (oder Dockerfile — beide werden unterstuetzt) und Buildah im Hintergrund:

# Containerfile
FROM docker.io/library/python:3.12-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "app.py"]

Das Image erstellen:

podman build -t my-python-app:latest .

Mit einem bestimmten Dateinamen erstellen:

podman build -f Containerfile.prod -t my-python-app:prod .

Images in ein Registry pushen

Ein Image taggen und in ein Registry pushen:

podman tag my-python-app:latest quay.io/myuser/my-python-app:latest
podman login quay.io
podman push quay.io/myuser/my-python-app:latest

Images entfernen

# Ein bestimmtes Image entfernen
podman rmi docker.io/library/nginx:alpine

# Alle ungenutzten Images entfernen
podman image prune -a

Pod-Verwaltung

Pods sind ein Konzept aus Kubernetes. Ein Pod gruppiert einen oder mehrere Container, die denselben Netzwerk-Namespace teilen, was bedeutet, dass sie ueber localhost kommunizieren und Port-Mappings teilen koennen.

Einen Pod erstellen

Erstellen Sie einen Pod mit Port-Mappings auf Pod-Ebene:

podman pod create --name my-web-pod -p 8080:80 -p 5432:5432

Container zu einem Pod hinzufuegen

Fuegen Sie einen Nginx-Container und einen PostgreSQL-Container zum Pod hinzu:

podman run -d --pod my-web-pod --name web-server docker.io/library/nginx:alpine

podman run -d --pod my-web-pod --name db-server \
  -e POSTGRES_PASSWORD=secretpass \
  -e POSTGRES_DB=appdb \
  docker.io/library/postgres:16-alpine

Beide Container teilen nun denselben Netzwerk-Namespace. Der Nginx-Container kann sich mit PostgreSQL ueber localhost:5432 verbinden, und externe Clients greifen auf Nginx ueber host:8080 zu.

Pods verwalten

# Alle Pods auflisten
podman pod ls

# Pod-Details anzeigen
podman pod inspect my-web-pod

# Alle Container in einem Pod stoppen
podman pod stop my-web-pod

# Einen Pod starten
podman pod start my-web-pod

# Einen Pod und seine Container entfernen
podman pod rm -f my-web-pod

Kubernetes-YAML aus Pods generieren

Eine der einzigartigen Funktionen von Podman ist die Generierung von Kubernetes-Manifesten aus laufenden Pods:

podman generate kube my-web-pod > my-web-pod.yaml

Dies erstellt eine Kubernetes-kompatible YAML-Datei, die Sie direkt mit kubectl apply -f my-web-pod.yaml in einem Kubernetes-Cluster bereitstellen koennen. Das macht Podman zu einem hervorragenden Werkzeug fuer die lokale Entwicklung, wenn Ihr Produktionsziel Kubernetes ist.

Podman Compose

Podman unterstuetzt Docker-Compose-Dateien fuer Multi-Container-Anwendungsstapel. Es gibt zwei Ansaetze:

Verwendung von podman-compose

Installieren Sie podman-compose (eine Community-Neuimplementierung in Python):

sudo apt install -y python3-pip
pip3 install podman-compose

Verwenden Sie es wie docker-compose:

podman-compose up -d
podman-compose ps
podman-compose logs -f
podman-compose down

Verwendung des integrierten podman compose

Podman 4.7+ enthaelt einen integrierten podman compose-Befehl, der an einen externen Compose-Provider (docker-compose oder podman-compose) delegiert:

podman compose up -d
podman compose down

Beispiel docker-compose.yml

Eine Standard-docker-compose.yml funktioniert ohne Aenderungen:

version: "3.8"
services:
  web:
    image: docker.io/library/nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
    depends_on:
      - api

  api:
    image: docker.io/library/node:20-alpine
    working_dir: /app
    volumes:
      - ./api:/app
    command: node server.js
    environment:
      - DB_HOST=db
      - DB_PORT=5432

  db:
    image: docker.io/library/postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: secretpass
      POSTGRES_DB: myapp
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Mit Podman Compose ausfuehren:

podman-compose up -d

systemd-Units aus Containern generieren

Podman integriert sich mit systemd, um Container als Systemdienste zu verwalten. Dies ist besonders nuetzlich fuer Server, auf denen Container beim Booten starten und bei Fehlern neustarten sollen.

Eine Unit-Datei aus einem laufenden Container generieren

Starten Sie zunaechst einen Container:

podman run -d --name my-nginx -p 8080:80 docker.io/library/nginx:alpine

Generieren Sie die systemd-Unit:

podman generate systemd --new --name my-nginx > ~/.config/systemd/user/container-my-nginx.service

Die Option --new stellt sicher, dass die Unit-Datei bei jedem Start einen frischen Container erstellt (anstatt einen bestehenden neu zu starten), was die empfohlene Vorgehensweise ist.

Den Dienst aktivieren und starten

mkdir -p ~/.config/systemd/user
systemctl --user daemon-reload
systemctl --user enable --now container-my-nginx.service

Lingering fuer Nicht-Login-Sitzungen aktivieren

Standardmaessig stoppen Benutzer-systemd-Dienste, wenn sich der Benutzer abmeldet. Aktivieren Sie Lingering, um sie am Laufen zu halten:

sudo loginctl enable-linger $USER

Den Dienst ueberpruefen

systemctl --user status container-my-nginx.service

Quadlet (Podman 4.4+)

Fuer Podman 4.4 und spaeter bietet Quadlet ein einfacheres deklaratives Format. Erstellen Sie eine .container-Datei in ~/.config/containers/systemd/:

# ~/.config/containers/systemd/my-nginx.container
[Container]
Image=docker.io/library/nginx:alpine
PublishPort=8080:80
Volume=./html:/usr/share/nginx/html:ro

[Service]
Restart=always

[Install]
WantedBy=default.target

Laden Sie systemd neu und starten Sie den Dienst:

systemctl --user daemon-reload
systemctl --user start my-nginx.service

Migration von Docker zu Podman

Wenn Sie derzeit Docker verwenden, ist der Migrationspfad zu Podman unkompliziert.

Das Docker-Kompatibilitaetspaket installieren

sudo apt install -y podman-docker

Dies installiert einen docker-Befehl, der als Alias auf podman verweist, und erstellt einen /var/run/docker.sock-Emulations-Socket. Bestehende Skripte, die docker aufrufen, verwenden stattdessen Podman.

Docker-Images migrieren

Exportieren Sie Images von Docker und importieren Sie sie in Podman:

# Auf dem Docker-System
docker save my-app:latest -o my-app.tar

# Auf dem Podman-System
podman load -i my-app.tar

Docker-Compose-Dateien konvertieren

Die meisten docker-compose.yml-Dateien funktionieren ohne Aenderungen. Die wichtigsten Anpassungen, auf die Sie achten sollten:

1. Image-Namen vollstaendig qualifizieren: Ersetzen Sie nginx:alpine durch docker.io/library/nginx:alpine
2. Netzwerkmodus: Einige Docker-spezifische Netzwerkmodi koennen sich unterscheiden
3. Volume-Plugins: Docker-Volume-Plugins werden nicht unterstuetzt; verwenden Sie Podmans native Volume-Treiber

CI/CD-Pipelines aktualisieren

Ersetzen Sie docker-Befehle durch podman in Ihren Pipeline-Skripten oder installieren Sie podman-docker, damit der docker-Alias das uebernimmt:

# GitHub-Actions-Beispiel
steps:
  - name: Install Podman
    run: sudo apt install -y podman podman-docker

  - name: Build image
    run: podman build -t my-app:${{ github.sha }} .

  - name: Push image
    run: |
      podman login -u ${{ secrets.REGISTRY_USER }} -p ${{ secrets.REGISTRY_PASS }} ghcr.io
      podman push my-app:${{ github.sha }} ghcr.io/${{ github.repository }}:${{ github.sha }}

Netzwerk

Podmans Netzwerkmodell unterscheidet sich zwischen Root- und Rootless-Modi.

Rootless-Netzwerk

Im Rootless-Modus verwendet Podman slirp4netns oder pasta (Podman 5.0+), um Netzwerkkonnektivitaet ohne Root-Rechte bereitzustellen:

• slirp4netns: Erstellt ein TAP-Geraet in einem User-Namespace und bietet NAT-basiertes Netzwerk. Portweiterleitung ueber Port 1024 funktioniert ohne Root.
• pasta: Eine neuere, schnellere Alternative mit verbesserter Leistung und geringerem Overhead.

Ports im Rootless-Modus mappen:

podman run -d -p 8080:80 docker.io/library/nginx:alpine

Hinweis: Das Binden an Ports unter 1024 (z.B. 80, 443) erfordert Root-Rechte oder die Anpassung des Schwellenwerts fuer unprivilegierte Ports mit sudo sysctl net.ipv4.ip_unprivileged_port_start=80.

CNI und Netavark

Podman unterstuetzt zwei Netzwerk-Backends:

• CNI (Container Network Interface): Das historische Backend mit CNI-Plugins.
• Netavark: Der moderne, Rust-basierte Netzwerk-Stack (Standard in Podman 4.0+).

Ein benutzerdefiniertes Netzwerk erstellen:

podman network create my-network

Container im benutzerdefinierten Netzwerk ausfuehren:

podman run -d --network my-network --name container-a docker.io/library/alpine sleep 3600
podman run -d --network my-network --name container-b docker.io/library/alpine sleep 3600

Container im selben Netzwerk koennen sich gegenseitig per Name erreichen:

podman exec container-a ping -c 3 container-b

Netzwerke inspizieren

# Netzwerke auflisten
podman network ls

# Ein Netzwerk inspizieren
podman network inspect my-network

# Ein Netzwerk entfernen
podman network rm my-network

Podman-Befehlsreferenz

Die folgende Tabelle listet die am haeufigsten verwendeten Podman-Befehle und ihre Docker-Entsprechungen auf:

Podman-Befehl	Docker-Entsprechung	Beschreibung
podman run	docker run	Container erstellen und starten
podman ps	docker ps	Laufende Container auflisten
podman ps -a	docker ps -a	Alle Container auflisten
podman images	docker images	Lokale Images auflisten
podman pull	docker pull	Ein Image aus einem Registry abrufen
podman build	docker build	Ein Image aus einem Containerfile/Dockerfile erstellen
podman push	docker push	Ein Image in ein Registry pushen
podman exec	docker exec	Einen Befehl in einem laufenden Container ausfuehren
podman logs	docker logs	Container-Logs anzeigen
podman stop	docker stop	Einen laufenden Container stoppen
podman rm	docker rm	Einen Container entfernen
podman rmi	docker rmi	Ein Image entfernen
podman volume create	docker volume create	Ein benanntes Volume erstellen
podman network create	docker network create	Ein Netzwerk erstellen
podman pod create	N/A	Einen Pod erstellen
podman pod ls	N/A	Pods auflisten
podman generate systemd	N/A	systemd-Unit-Dateien generieren
podman generate kube	N/A	Kubernetes-YAML generieren
podman system prune	docker system prune	Ungenutzte Daten entfernen
podman login	docker login	Bei einem Container-Registry anmelden
podman inspect	docker inspect	Detaillierte Container-/Image-Informationen anzeigen

Fehlerbehebung

Fehler: short-name resolution enforced

Problem: Podman verweigert das Abrufen eines Images mit einem Kurznamen wie nginx.

Loesung: Verwenden Sie den vollstaendig qualifizierten Image-Namen oder konfigurieren Sie Such-Registries:

# Vollstaendig qualifizierten Namen verwenden
podman pull docker.io/library/nginx:alpine

# Oder Such-Registries konfigurieren
sudo tee /etc/containers/registries.conf.d/00-unqualified-search.conf <<'EOF'
[registries.search]
registries = ['docker.io', 'quay.io']
EOF

Fehler: cannot find UID/GID mapping

Problem: Rootless-Container scheitern, weil untergeordnete UID/GID-Mappings nicht konfiguriert sind.

Loesung: Fuegen Sie Mappings fuer Ihren Benutzer hinzu:

sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER
podman system migrate

Fehler: permission denied on volume mount

Problem: Ein Rootless-Container kann nicht auf ein bind-gemountetes Verzeichnis zugreifen.

Loesung: Fuegen Sie das SELinux-Label-Suffix :Z oder :z hinzu oder stellen Sie sicher, dass das Verzeichnis Ihrem Benutzer gehoert:

# Eigentuemer korrigieren
podman unshare chown -R 0:0 /path/to/volume

# Oder Z-Flag fuer SELinux verwenden
podman run -v /path/to/volume:/data:Z my-image

Container kann nicht an Port 80 binden

Problem: Rootless Podman kann nicht an Ports unter 1024 binden.

Loesung: Senken Sie den Schwellenwert fuer unprivilegierte Ports:

sudo sysctl -w net.ipv4.ip_unprivileged_port_start=80
# Persistent machen
echo "net.ipv4.ip_unprivileged_port_start=80" | sudo tee /etc/sysctl.d/99-podman-ports.conf
sudo sysctl --system

Podman Compose scheitert mit Netzwerkfehler

Problem: podman-compose gibt Fehler beim Erstellen von Netzwerken aus.

Loesung: Stellen Sie sicher, dass das Podman-Netzwerk-Backend laeuft und setzen Sie es bei Bedarf zurueck:

podman network ls
podman system reset --force
# Erstellen Sie Ihre Container nach dem Reset neu

Container starten nach dem Neustart nicht

Problem: systemd-Container auf Benutzerebene starten nach einem Neustart nicht.

Loesung: Aktivieren Sie Lingering fuer Ihren Benutzer:

sudo loginctl enable-linger $USER

Langsames Herunterladen von Images

Problem: Das Abrufen von Images ist im Rootless-Modus langsam.

Loesung: Aktivieren Sie fuse-overlayfs fuer bessere Speicherleistung:

sudo apt install -y fuse-overlayfs

Ueberpruefen Sie, ob es verwendet wird:

podman info --format '{{.Store.GraphDriverName}}'
# Sollte ausgeben: overlay

Zusammenfassung

Podman ist eine ausgereifte, sichere und Docker-kompatible Container-Engine, die den Bedarf an einem privilegierten Daemon-Prozess eliminiert. Sein standardmaessiger Rootless-Ansatz, die native Pod-Unterstuetzung und die systemd-Integration machen es zu einer hervorragenden Wahl fuer Linux-Entwicklungs- und Produktionsumgebungen. Fuer jeden, der Container auf Linux-Servern betreibt, bietet Podman einen klaren Sicherheitsvorteil, ohne die Kompatibilitaet mit dem Docker-Oekosystem zu opfern.

In dieser Anleitung haben Sie gelernt, wie Sie Podman unter Ubuntu installieren, Rootless-Container ausfuehren, Images und Pods verwalten, Podman Compose mit bestehenden docker-compose.yml-Dateien verwenden, systemd-Units fuer die automatische Container-Lebenszyklus-Verwaltung generieren, Netzwerke konfigurieren und von Docker migrieren.

Fuer verwandte Container-Themen lesen Sie unsere Anleitungen zu Docker unter Ubuntu installieren und Docker Compose: Praktischer Leitfaden fuer Systemadministratoren.