Podman : installation, configuration et commandes

Podman est un outil de gestion de conteneurs développé par Red Hat. Contrairement à Docker Engine, il n'utilise pas de daemon centralisé : chaque commande podman forke directement le processus du conteneur (modèle fork/exec). Il est rootless par défaut - les conteneurs peuvent tourner sans aucun processus root sur l'hôte, ce qui réduit significativement la surface d'attaque.

Podman est compatible avec l'API Docker (alias docker=podman fonctionne dans la plupart des cas). Il gère nativement les pods (groupes de conteneurs partageant le même réseau/IPC), reflétant la sémantique Kubernetes. La version 5.x est la branche active.

Idéal pour : environnements RHEL/Fedora/CentOS, workloads nécessitant rootless sans compromis, remplacement drop-in de Docker Engine, génération de manifestes Kubernetes depuis des conteneurs locaux.

Informations essentielles

Origine : Red Hat · Licence : Apache 2.0 · Architectures : x86_64, ARM64, ppc64le, s390x

Liens : Site officiel · Documentation · GitHub · Releases

Support : Podman suit le cycle de RHEL. Versions maintenues : Podman 5.x (actuel) et 4.x (versions RHEL 9). Podman Desktop est maintenu séparément.

Architecture

Composant	Rôle
podman	CLI et daemon optionnel (podman.socket pour compatibilité API Docker)
conmon	Monitor de processus conteneur (surveille et collecte les logs)
runc / crun	Runtime OCI bas niveau (crun est le défaut sur RHEL 9+)
libpod	Bibliothèque Go centrale de Podman
Netavark + Aardvark	Stack réseau rootless (remplace CNI depuis Podman 4.0)

Podman 4.0+ utilise Netavark (réseau) et Aardvark (DNS) à la place des plugins CNI. Sur les systèmes plus anciens, la stack CNI peut encore être présente.

Installation

RHEL / Rocky Linux / AlmaLinux / Fedora

# Inclus dans les dépôts officiels
sudo dnf install -y podman

podman --version

Ubuntu / Debian

sudo apt-get install -y podman

podman --version

Binaires officiels (dernière version)

# Pour une version plus récente que celle des dépôts distros
# Via le dépôt Kubic (openSUSE Build Service)
# Ubuntu 22.04+
. /etc/os-release
echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/unstable/xUbuntu_${VERSION_ID}/ /" \
  | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:unstable.list

curl -fsSL https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/unstable/xUbuntu_${VERSION_ID}/Release.key \
  | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/devel_kubic_libcontainers_unstable.gpg > /dev/null

sudo apt-get update && sudo apt-get install -y podman

Commandes de base

Podman est compatible avec les commandes Docker. L'alias alias docker=podman fonctionne pour les usages courants.

# Lancer un conteneur interactif
podman run --rm -it ubuntu:24.04 bash

# Lancer en arrière-plan avec port forwarding
podman run -d --name nginx -p 8080:80 nginx:alpine

# Lister les conteneurs actifs
podman ps

# Tous les conteneurs
podman ps -a

# Logs
podman logs nginx
podman logs -f nginx

# Shell dans un conteneur actif
podman exec -it nginx bash

# Arrêter / supprimer
podman stop nginx
podman rm nginx

Mode rootless

# Podman rootless fonctionne sans sudo par défaut
podman run --rm hello-world

# Vérifier que le conteneur tourne sans root
podman run --rm -it alpine id
# uid=0(root) dans le conteneur = utilisateur courant sur l'hôte (user namespace)

# Mapping UID : le root du conteneur est mappé sur l'UID courant de l'hôte
podman unshare cat /proc/self/uid_map

Gestion des pods

Podman gère nativement les pods, avec un conteneur "infra" (pause) qui maintient les namespaces partagés.

# Créer un pod avec port forwarding
podman pod create --name mon-pod -p 8080:80

# Ajouter des conteneurs au pod
podman run -d --pod mon-pod --name nginx nginx:alpine
podman run -d --pod mon-pod --name app mon-app:latest

# Les conteneurs du même pod communiquent via localhost
# État du pod
podman pod ps
podman pod inspect mon-pod

# Arrêter et supprimer le pod et tous ses conteneurs
podman pod stop mon-pod
podman pod rm mon-pod

Intégration Kubernetes

Générer un manifeste Kubernetes depuis un pod Podman

# Créer un pod local
podman run -d --name mon-app -p 8080:80 nginx:alpine

# Générer le YAML Kubernetes correspondant
podman kube generate mon-app > mon-app.yaml

# Le YAML généré est compatible kubectl apply
kubectl apply -f mon-app.yaml

Lancer un manifeste Kubernetes avec Podman (dev local)

# Créer des pods locaux depuis un manifeste Kubernetes
podman kube play mon-app.yaml

# Supprimer les ressources créées
podman kube play --down mon-app.yaml

podman kube generate (anciennement podman generate kube) et podman kube play (anciennement podman play kube) sont les noms depuis Podman 4.x.

Quadlets - intégration systemd

Les Quadlets permettent de décrire des conteneurs comme des unités systemd, gérés par systemd --user ou root systemd.

# ~/.config/containers/systemd/mon-app.container
[Unit]
Description=Mon application conteneurisée

[Container]
Image=nginx:alpine
PublishPort=8080:80
Volume=/data:/data:z

[Service]
Restart=on-failure

[Install]
WantedBy=default.target

# Recharger systemd et démarrer
systemctl --user daemon-reload
systemctl --user enable --now mon-app

# Vérifier
systemctl --user status mon-app
podman ps

Podman Machine (macOS / Windows)

Sur macOS et Windows, Podman crée une VM Linux pour faire tourner les conteneurs.

# Initialiser et démarrer la VM Podman
podman machine init
podman machine start

# Utiliser normalement
podman run --rm hello-world

# Arrêter la VM
podman machine stop

# Lister les machines
podman machine list

Compatibilité API Docker

Podman peut exposer un socket compatible avec l'API Docker Engine, permettant à des outils tiers (docker-compose, Testcontainers...) d'utiliser Podman sans modification.

# Activer le socket Podman (compatible API Docker)
systemctl --user enable --now podman.socket

# Variables d'environnement pour rediriger Docker vers Podman
export DOCKER_HOST=unix://${XDG_RUNTIME_DIR}/podman/podman.sock

# docker-compose fonctionne alors via Podman
docker-compose up -d

Mise à jour

# RHEL / Rocky / Fedora
sudo dnf update podman

# Ubuntu / Debian
sudo apt-get install --only-upgrade podman

# Vérifier
podman --version

Troubleshooting

Erreur rootless : "user namespaces not supported"

# Vérifier le support des user namespaces kernel
sysctl kernel.unprivileged_userns_clone
# Doit être 1

# Activer si désactivé
sudo sysctl kernel.unprivileged_userns_clone=1

# Vérifier /etc/subuid et /etc/subgid
grep $USER /etc/subuid /etc/subgid
# Si absent : sudo usermod --add-subuids 100000-165535 --add-subgids 100000-165535 $USER

Réseau rootless - port < 1024 impossible

# En rootless, les ports < 1024 nécessitent un flag sysctl
sudo sysctl net.ipv4.ip_unprivileged_port_start=80

# Ou utiliser un port > 1024 et un reverse proxy
podman run -d -p 8080:80 nginx:alpine

Conteneur ne démarre pas

podman logs <nom>
podman inspect <nom>

# Vérifier les événements
podman events --filter container=<nom>

Commandes utiles

# Informations système
podman info
podman version

# Conteneurs
podman ps -a
podman stats           # CPU/RAM en temps réel
podman inspect <id>

# Pods
podman pod ps
podman pod inspect <nom>

# Kubernetes
podman kube generate <conteneur|pod>
podman kube play <fichier.yaml>

# Nettoyage
podman container prune
podman image prune -a
podman system prune -a

# Systemd (quadlets)
systemctl --user status <nom>.service

Ressources

Site officiel : https://podman.io
Documentation : https://docs.podman.io
GitHub : https://github.com/containers/podman
Podman Desktop : https://podman-desktop.io
Quadlets : https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html
Comparaison Docker vs Podman : https://docs.podman.io/en/latest/markdown/podman-vs-docker.md