Commandes essentielles Podman

Quand vous travaillez avec des conteneurs, vous passez la majorité de votre temps à lancer des conteneurs, consulter leurs logs, exécuter des commandes dedans et nettoyer les ressources. Podman est un moteur de conteneurs rootless compatible Docker qui vous permet de gérer images et conteneurs sans privilèges root.

Ce que vous allez apprendre

• Rechercher, télécharger et gérer des images
• Lancer des conteneurs en avant-plan et arrière-plan
• Interagir avec des conteneurs en cours d'exécution (exec, logs, cp)
• Exposer des ports et monter des volumes
• Diagnostiquer et nettoyer vos ressources

La commande podman dans l'écosystème conteneurs

Podman fait partie d'un écosystème d'outils complémentaires. Chaque outil a sa spécialité :

Commande	Spécialité	Quand l'utiliser
podman	Exécuter et gérer les conteneurs	run, ps, exec, logs, stop, rm
buildah	Construire des images	Build avancé, multi-stage, rootless
skopeo	Copier des images entre registries	Mirroring, air-gap, inspection
podman-compose	Orchestrer plusieurs conteneurs	Stack multi-conteneurs (comme docker-compose)

Glissez pour voir

Combinaisons fréquentes :

# buildah + podman : construire puis lancer
buildah build -t mon-app . && podman run mon-app

# skopeo + podman : copier puis exécuter
skopeo copy docker://nginx:alpine oci-archive:nginx.tar
podman load < nginx.tar && podman run nginx:alpine

# podman + grep : filtrer les logs
podman logs mon-app | grep ERROR

Comprendre Podman en 2 min

Avant les commandes, un modèle mental. Podman ne s'appuie sur aucun daemon : chaque podman run démarre directement le processus du conteneur sous votre compte utilisateur. C'est la différence structurelle avec Docker, et elle explique la plupart des écarts de comportement que vous rencontrerez, à commencer par ceux du mode rootless.

🧠 Modèle mental — Comment fonctionne Podman

podman = Image → Conteneur → Processus isolé (rootless par défaut)

Points clés

• Une image est un modèle en lecture seule (template)
• Un conteneur est une instance exécutable d'une image
• Chaque conteneur est un processus isolé supervisé par conmon
• Mode rootless par défaut = pas de privilèges root nécessaires
• Les données sont perdues à la suppression du conteneur (sauf volumes)
• Les commandes sont compatibles Docker (alias docker=podman)

Règles d'or

1

Toujours nommer vos conteneurs Utilisez --name pour éviter les IDs aléatoires difficiles à retenir.

2

Utiliser --rm pour les conteneurs jetables --rm supprime le conteneur automatiquement à l'arrêt, évite l'accumulation.

3

Préférer les tags explicites aux :latest :latest change sans prévenir. Utilisez :3.20, :1.25 pour la reproductibilité.

Vocabulaire essentiel

image

Modèle en lecture seule contenant l'application et ses dépendances

conteneur

Instance exécutable d'une image (processus isolé)

registry

Serveur qui stocke et distribue les images (Docker Hub, Quay.io)

tag

Version ou variante d'une image (alpine:3.20, nginx:1.25)

volume

Stockage persistant indépendant du cycle de vie du conteneur

port mapping

Liaison port hôte → port conteneur (-p 8080:80)

📚 Pour aller plus loin — 8 options avancées

rootless

Exécution sans privilèges root (user namespaces)

conmon

Superviseur léger qui maintient le conteneur

pod

Groupe de conteneurs partageant le même namespace réseau

bind mount

Montage direct d'un dossier hôte dans le conteneur

overlay

Système de fichiers en couches pour les images

entrypoint

Commande par défaut exécutée au démarrage du conteneur

CMD

Arguments par défaut passés à l'entrypoint

namespace

Isolation des ressources (PID, network, mount, user)

Contrairement à Docker qui nécessite un daemon root, Podman exécute chaque conteneur comme un processus indépendant supervisé par conmon. C'est rootless par défaut.

Syntaxe complète

Toutes les commandes suivent la même forme. L'ordre des éléments compte : ce qui est placé après le nom de l'image est transmis au conteneur, pas à Podman.

podman <commande> [options] [arguments]

Commandes les plus utilisées :

Commande	Description	Exemple
run	Créer et démarrer un conteneur	podman run -d nginx
ps	Lister les conteneurs	podman ps -a
exec	Exécuter une commande dans un conteneur	podman exec -it web sh
logs	Afficher les logs	podman logs -f web
stop / start	Arrêter / démarrer un conteneur	podman stop web
rm	Supprimer un conteneur	podman rm web
images	Lister les images	podman images
pull	Télécharger une image	podman pull alpine:3.20

Glissez pour voir

Les concepts clés

Podman repose sur quelques concepts essentiels :

Concept	Ce que c'est	Exemple
Image	Modèle en lecture seule	nginx:alpine, alpine:3.20
Conteneur	Instance exécutable d'une image	podman run nginx crée un conteneur
Registry	Serveur de distribution d'images	Docker Hub, Quay.io, GHCR
Volume	Stockage persistant	podman run -v data:/app/data
Port mapping	Exposition réseau	podman run -p 8080:80

Glissez pour voir

Les options essentielles de run

La commande podman run est la plus utilisée. Voici ses options principales :

Option	Forme longue	Description
-d	--detach	Exécuter en arrière-plan
-it	--interactive --tty	Mode interactif avec terminal
--rm		Supprimer après arrêt
--name		Nommer le conteneur
-p	--publish	Mapper un port hôte:conteneur
-e	--env	Définir une variable d'environnement
-v	--volume	Monter un volume

Glissez pour voir

Formes courantes :

# Conteneur jetable interactif
podman run -it --rm alpine:3.20 sh

# Service en arrière-plan
podman run -d --name web -p 8080:80 nginx:alpine

# Avec volume et variable d'environnement
podman run -d --name db -v pgdata:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret postgres:16

Cycle de vie d'un conteneur

Un conteneur passe par plusieurs états :

Created → Running → Paused/Exited → Removed

État	Signification	Commande pour y arriver
Created	Conteneur créé mais pas démarré	podman create
Running	En cours d'exécution	podman start ou podman run
Paused	Processus gelés (SIGSTOP)	podman pause
Exited	Arrêté (code de sortie)	podman stop ou fin du processus
Removed	Supprimé	podman rm

Glissez pour voir

Erreurs typiques (et solutions)

Ces cinq messages représentent la quasi-totalité des blocages en début d'utilisation. Chacun est repris en détail dans la partie consacrée aux pièges ; ce tableau sert de référence rapide quand vous avez le message sous les yeux.

Erreur	Cause	Solution
name already in use	Conteneur existant avec ce nom	podman rm -f nom ou --replace
image not known	Image non téléchargée	podman pull docker.io/library/image:tag
address already in use	Port déjà utilisé	Changer le port (-p 8081:80)
permission denied	Problème rootless/SELinux	--userns=keep-id ou :Z sur volume
Conteneur s'arrête immédiatement	CMD se termine	Utiliser un processus persistant

Glissez pour voir

Gestion des images

Une image est un modèle en lecture seule contenant l'application et ses dépendances.

Rechercher et télécharger

podman search liste des dépôts, pas des versions : ajoutez --list-tags pour connaître les tags disponibles avant de choisir celui à télécharger. Un podman pull sans tag récupère implicitement :latest.

# Rechercher une image
podman search docker.io/alpine --limit 3

# Télécharger une image (avec tag explicite)
podman pull docker.io/library/alpine:3.20

# Lister les images locales
podman images

Résultat podman images :

REPOSITORY                    TAG      IMAGE ID      CREATED       SIZE
docker.io/library/alpine      3.20     cc9071bd1610  2 weeks ago   8.1 MB
docker.io/library/nginx       alpine   b76de378d572  8 days ago    63.5 MB

Inspecter et supprimer

podman image inspect renvoie un JSON complet ; --format accepte un template Go pour n'extraire que les champs voulus. Attention à podman image prune -a : il supprime toute image qu'aucun conteneur n'utilise, y compris celles que vous venez de télécharger.

# Détails d'une image (format Go template)
podman image inspect alpine:3.20 --format 'ID: {{.Id}} | Size: {{.Size}}'

# Supprimer une image
podman rmi alpine:3.20

# Supprimer toutes les images non utilisées
podman image prune -a

Images en cours d'utilisation

Vous ne pouvez pas supprimer une image utilisée par un conteneur. Supprimez d'abord les conteneurs concernés avec podman rm.

Exécution de conteneurs

Trois façons de lancer un conteneur couvrent la quasi-totalité des besoins : au premier plan pour une commande ponctuelle, en arrière-plan pour un service, en interactif pour explorer une image. Le choix se joue sur deux options seulement, -d et -it.

Conteneur simple (avant-plan)

Sans option, Podman rattache la sortie du conteneur à votre terminal et attend la fin du processus avant de rendre la main.

podman run docker.io/library/alpine:3.20 echo "Hello Podman"

Le conteneur exécute la commande, affiche le résultat, puis s'arrête.

Conteneur en arrière-plan

L'option -d rend la main immédiatement et affiche l'identifiant du conteneur créé, qui devient le moyen de le retrouver si vous ne l'avez pas nommé.

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

Option	Description
-d	Détaché (arrière-plan)
--name mon-nginx	Nom explicite pour référencer facilement
-p 8080:80	Port 8080 sur l'hôte → port 80 du conteneur

Glissez pour voir

Vérification :

curl localhost:8080

Conteneur interactif

La combinaison -it est indispensable pour obtenir un shell utilisable : sans -t, aucune invite ni gestion des touches ; sans -i, votre clavier n'est pas transmis au conteneur.

podman run -it --rm docker.io/library/alpine:3.20 sh

Vous obtenez un shell dans le conteneur. Tapez exit pour quitter. --rm supprime le conteneur à la sortie.

Lister et inspecter

Deux besoins distincts se présentent : savoir ce qui tourne, et savoir comment un conteneur précis est configuré. La première question se règle avec podman ps, la seconde avec podman inspect, qui expose l'intégralité de la configuration au format JSON.

Lister les conteneurs

podman ps n'affiche que les conteneurs actifs. Les conteneurs arrêtés existent toujours : ils continuent d'occuper leur nom et leur espace disque tant qu'ils ne sont pas supprimés.

# Conteneurs en cours d'exécution
podman ps

# Tous les conteneurs (y compris arrêtés)
podman ps -a

# Format personnalisé
podman ps --format "{{.Names}}: {{.Image}} ({{.Status}})"

Inspecter un conteneur

podman inspect renvoie plusieurs centaines de lignes de JSON, d'où l'intérêt de --format pour cibler un seul champ. Les commandes podman top et podman port donnent en revanche des vues déjà lisibles : processus en cours et ports publiés.

# Configuration complète (JSON)
podman inspect mon-nginx

# Extraire un champ spécifique (état, image...)
podman inspect --format '{{.State.Status}}' mon-nginx

# Voir les processus
podman top mon-nginx

# Voir les ports exposés
podman port mon-nginx

Pas d'IP de conteneur en rootless

En rootless avec le réseau par défaut (pasta), un conteneur n'a pas d'IP routable : {{.NetworkSettings.IPAddress}} renvoie une valeur vide. Pour joindre le service, utilisez le port publié (podman port), ou attachez le conteneur à un réseau dédié (podman network create), où l'IP se lit alors dans {{.NetworkSettings.Networks.<réseau>.IPAddress}}.

Interagir avec un conteneur

Une fois le conteneur démarré, trois opérations reviennent en permanence : lancer une commande à l'intérieur, lire ce qu'il écrit, et échanger des fichiers avec lui. Aucune n'oblige à arrêter le conteneur ni à reconstruire son image.

Exécuter une commande

podman exec s'adresse à un conteneur déjà en cours d'exécution et échoue sur un conteneur arrêté. Il lance un processus supplémentaire : il ne remplace pas le processus principal du conteneur.

# Commande simple
podman exec mon-nginx cat /etc/nginx/nginx.conf

# Shell interactif
podman exec -it mon-nginx sh

# En tant que root (même en rootless)
podman exec -u root mon-nginx whoami

Consulter les logs

podman logs restitue ce que le conteneur a écrit sur sa sortie standard et sa sortie d'erreur. Une application qui journalise dans un fichier interne n'apparaîtra donc pas ici, quel que soit le nombre d'options ajoutées.

# Tous les logs
podman logs mon-nginx

# Dernières 20 lignes
podman logs --tail 20 mon-nginx

# Suivre en temps réel (comme tail -f)
podman logs -f mon-nginx

# Avec timestamps
podman logs -t mon-nginx

Copier des fichiers

podman cp fonctionne dans les deux sens et même sur un conteneur arrêté. podman diff complète utilement la manipulation : il liste ce qui a été ajouté, modifié ou supprimé par rapport à l'image d'origine.

# Vers le conteneur
podman cp config.yml mon-nginx:/etc/nginx/

# Depuis le conteneur
podman cp mon-nginx:/etc/nginx/nginx.conf ./backup/

# Vérifier les modifications du filesystem
podman diff mon-nginx

Contrôler le cycle de vie

Ces commandes déplacent un conteneur d'un état à l'autre sans le détruire. La distinction entre stop et kill est celle qui compte : le premier envoie SIGTERM et laisse l'application se fermer proprement avant de forcer, le second envoie directement SIGKILL et coupe tout traitement en cours.

# Arrêter (SIGTERM puis SIGKILL après timeout)
podman stop mon-nginx

# Arrêter immédiatement (SIGKILL)
podman kill mon-nginx

# Redémarrer
podman restart mon-nginx

# Démarrer un conteneur arrêté
podman start mon-nginx

# Mettre en pause / reprendre
podman pause mon-nginx
podman unpause mon-nginx

Surveillance et statistiques

podman stats se rafraîchit en continu jusqu'à interruption ; --no-stream en donne un instantané, seule forme exploitable dans un script. podman system df répond à une autre question, celle de l'espace disque consommé par les images, les conteneurs et les volumes.

# Statistiques en temps réel
podman stats

# Snapshot (sans rafraîchissement)
podman stats --no-stream

# Espace disque utilisé
podman system df

Exemple de sortie podman stats (Podman 5.8, colonnes enrichies) :

ID            NAME        CPU %   MEM USAGE / LIMIT   MEM %   NET IO       BLOCK IO   PIDS   CPU TIME   AVG CPU %
a79693ad4f28  mon-nginx   0.04%   10.89MB / 3.82GB    0.28%   110B / 430B  0B / 0B    17     42ms       0.03%

Nettoyage des ressources

Les conteneurs arrêtés ne disparaissent pas d'eux-mêmes, sauf s'ils ont été lancés avec --rm. Sur un poste de développement, ils s'accumulent avec leur couche d'écriture et finissent par peser lourd, d'où les commandes de nettoyage groupé ci-dessous.

# Supprimer un conteneur arrêté
podman rm mon-nginx

# Forcer la suppression (même si running)
podman rm -f mon-nginx

# Supprimer tous les conteneurs arrêtés
podman rm $(podman ps -aq --filter status=exited)

# Nettoyage automatique (conteneurs + images non utilisées)
podman system prune

# Nettoyage complet (inclut volumes orphelins)
podman system prune -a --volumes -f

Attention avec prune

podman system prune supprime définitivement des données. En production, préférez supprimer explicitement ce dont vous n'avez plus besoin.

Sauvegarder et transférer

Ces commandes servent aux environnements privés de registre : save et load transportent une image sous forme de fichier tar. podman commit fige l'état d'un conteneur dans une nouvelle image, ce qui dépanne mais reste à proscrire pour produire une image de production, dont l'origine doit rester reproductible depuis un Containerfile.

# Exporter une image en archive tar
podman save docker.io/library/alpine:3.20 -o alpine.tar

# Importer une archive
podman load -i alpine.tar

# Taguer une image (créer un alias)
podman tag alpine:3.20 mon-registre/alpine:stable

# Exporter un conteneur en image
podman commit mon-nginx mon-nginx-custom:v1

Les patterns de commandes courants

Maintenant que vous comprenez les commandes de base, voici des recettes prêtes à l'emploi pour les usages les plus fréquents. Chacune associe une formule générique et un exemple concret à adapter.

Conteneur interactif jetable

Tester une commande ou explorer une image, sans rien laisser derrière.

# Formule
podman run -it --rm <image> <shell>

# Exemple
podman run -it --rm alpine:3.20 sh

• -it : interactif avec TTY ; --rm : supprime le conteneur à l'arrêt.

Service en arrière-plan

Lancer un service qui tourne en continu.

# Formule
podman run -d --name <nom> <image>

# Exemple
podman run -d --name mon-nginx nginx:alpine

• -d : mode détaché ; --name : nomme le conteneur pour le retrouver facilement.

Exposer un port

Rendre un service accessible depuis l'hôte.

# Formule
podman run -d -p <hôte>:<conteneur> <image>

# Exemple
podman run -d -p 8080:80 --name web nginx:alpine

• -p 8080:80 : mappe le port 8080 de l'hôte sur le port 80 du conteneur.

Monter un dossier

Partager des fichiers entre l'hôte et le conteneur.

# Formule
podman run -v <chemin_hôte>:<chemin_conteneur> <image>

# Exemple
podman run -v ~/data:/app/data:Z alpine ls /app/data

• :Z : relabeling SELinux ; :ro : montage en lecture seule.

Variables d'environnement

Configurer l'application via son environnement.

# Formule
podman run -e VAR=valeur <image>

# Exemple
podman run -e POSTGRES_PASSWORD=secret -e POSTGRES_DB=app postgres:16

• -e VAR=val : définit une variable ; --env-file : charge depuis un fichier.

Debug dans un conteneur

Inspecter un conteneur déjà en cours d'exécution.

# Formule
podman exec -it <conteneur> <shell>

# Exemple
podman exec -it mon-nginx sh

• -it : interactif avec TTY ; -u root : exécute en tant que root.

Suivre les logs en temps réel

Monitorer l'activité d'un conteneur.

# Formule
podman logs -f <conteneur>

# Exemple
podman logs -f --tail 50 mon-nginx

• -f : suit en temps réel ; --tail N : limite aux N dernières lignes ; -t : affiche les timestamps.

Nettoyage complet

Supprimer toutes les ressources inutilisées et libérer de l'espace.

# Formule
podman system prune -a

# Exemple
podman system prune -a --volumes -f

• -a : inclut les images non utilisées ; --volumes : inclut les volumes orphelins ; -f : sans confirmation.

Extraire des infos avec --format

Obtenir une information précise d'un conteneur, utile en scripting.

# Formule
podman inspect --format '{{.Field}}' <conteneur>

# Exemple
podman inspect --format '{{.State.Status}}' mon-nginx

• --format : template Go ; {{.State.Status}} : état du conteneur. En rootless, préférez podman port à {{.NetworkSettings.IPAddress}} (vide par défaut).

Limiter les ressources

Contrôler la consommation CPU et mémoire d'un conteneur.

# Formule
podman run --memory=<limit> --cpus=<N> <image>

# Exemple
podman run -d --memory=512m --cpus=1 --name limited nginx:alpine

• --memory : limite mémoire (512m, 1g) ; --cpus : nombre de CPUs ; --pids-limit : nombre de processus.

Vérification de santé

Surveiller automatiquement la santé d'un service.

# Formule
podman run --health-cmd="<cmd>" --health-interval=<durée> <image>

# Exemple
podman run -d --health-cmd="curl -f http://localhost/" --health-interval=30s nginx:alpine

• --health-cmd : commande de vérification ; --health-interval : intervalle entre les contrôles.

Copier des fichiers

Transférer des fichiers depuis ou vers un conteneur.

# Formule
podman cp <src> <dest>

# Exemple
podman cp mon-nginx:/etc/nginx/nginx.conf ./backup/

• La syntaxe conteneur:chemin désigne un emplacement dans le conteneur.

Les pièges à éviter

Ces erreurs reviennent constamment avec Podman. Plusieurs touchent la persistance des données ou le mode rootless : les connaître évite des pertes et des blocages.

Nom de conteneur déjà utilisé

Un nom reste réservé jusqu'à la suppression effective du conteneur : podman stop ne le libère pas.

podman run --name mon-app image

Symptôme : erreur container name is already in use.

Cause : un conteneur, même arrêté, existe déjà avec ce nom.

podman rm -f mon-app && podman run --name mon-app image
# ou directement
podman run --replace --name mon-app image

Image non trouvée

Podman ne consulte pas Docker Hub d'office. La liste des registres interrogés est celle de /etc/containers/registries.conf, et un nom d'image sans domaine peut donc rester introuvable.

podman run alpine

Symptôme : erreur image not known ou manifest unknown.

Cause : Podman ne trouve pas l'image dans ses registres configurés.

podman pull docker.io/library/alpine:3.20
podman run docker.io/library/alpine:3.20

Port déjà utilisé

Le conflit porte sur le port de l'hôte, à gauche du deux-points. Le port du conteneur, à droite, peut être identique sur plusieurs conteneurs sans poser de problème.

podman run -p 8080:80 nginx

Symptôme : erreur bind: address already in use.

Cause : un autre processus ou conteneur occupe déjà ce port.

# Trouver qui utilise le port
ss -tlnp | grep 8080
# Utiliser un autre port
podman run -p 8081:80 nginx

Permission denied sur un volume

En rootless, votre UID de l'hôte devient l'UID 0 à l'intérieur du conteneur, et les autres utilisateurs du conteneur tombent dans une plage subuid qui n'a aucun droit sur vos fichiers.

podman run -v ~/data:/app/data image

Symptôme : erreur de permission sur les fichiers montés.

Cause : le mapping d'UID en mode rootless ou SELinux bloque l'accès.

podman run --userns=keep-id -v ~/data:/app/data image
# ou avec SELinux
podman run -v ~/data:/app/data:Z image

Utilisation de :latest

Une image citée sans tag est complétée implicitement par :latest, qui n'est pas un numéro de version mais un simple alias déplaçable par le mainteneur.

podman run nginx

Symptôme : le comportement change après un pull.

Cause : :latest n'est pas une version fixe, elle évolue sans prévenir. Spécifiez toujours un tag de version explicite.

podman run nginx:1.25-alpine

Perte de données sans volume

Vous lancez postgres, puis supprimez le conteneur avec podman rm.

Symptôme : les données disparaissent à la suppression du conteneur.

Cause : les données écrites dans le conteneur sont éphémères.

podman run -v postgres_data:/var/lib/postgresql/data postgres:16

Ports privilégiés en rootless

En rootless, le processus qui ouvre le port est le vôtre et non root : le noyau applique donc la restriction historique sur les ports inférieurs à 1024.

podman run -p 80:80 nginx

Symptôme : permission denied au moment du bind.

Cause : les ports inférieurs à 1024 sont réservés à root par défaut.

# Utiliser un port haut
podman run -p 8080:80 nginx
# ou autoriser les ports bas
sudo sysctl net.ipv4.ip_unprivileged_port_start=80

Conteneur arrêté immédiatement

L'option -d ne rend pas un conteneur persistant, elle détache seulement votre terminal. La durée de vie du conteneur reste celle de son processus principal.

podman run -d alpine

Symptôme : le conteneur passe en Exited (0) aussitôt après le démarrage.

Cause : le processus principal (CMD) se termine instantanément. Un conteneur vit tant que son processus principal tourne.

# Garder actif avec un processus durable
podman run -d alpine sleep infinity
# ou lancer un service qui reste actif
podman run -d nginx

Travaux pratiques

Ce lab vous fait manipuler Podman du téléchargement d'image à la consultation de logs. Comptez 20 minutes.

Préparer le terrain

Le script suivant crée un dossier de travail avec une configuration et des données de test :

# Créer le lab
mkdir -p ~/podman-lab/data ~/podman-lab/config
cd ~/podman-lab

# Créer un fichier de configuration de test
cat > config/app.conf << 'EOF'
# Configuration de test
APP_NAME=demo
APP_PORT=8080
DEBUG=true
EOF

# Créer des données de test
echo "Données de test $(date)" > data/test.txt

# Vérifier que Podman fonctionne
podman version

echo "Lab créé dans ~/podman-lab"
ls -la ~/podman-lab

Pour tout nettoyer à la fin : podman rm -f $(podman ps -aq --filter "name=test-") 2>/dev/null; rm -rf ~/podman-lab.

Les 6 étapes du lab

Enchaînez-les dans l'ordre, chacune réutilisant le résultat de la précédente. Les conteneurs créés portent tous le préfixe test-, ce qui rend possible la suppression groupée donnée plus haut.

1. Télécharger une image, podman pull docker.io/library/alpine:3.20. Le préfixe docker.io/library/ désigne les images officielles ; :3.20 fixe la version.

2. Lancer un conteneur simple, podman run --rm docker.io/library/alpine:3.20 echo "Hello Podman". --rm supprime le conteneur après exécution ; echo remplace le CMD par défaut.

3. Conteneur en arrière-plan, podman run -d --name test-bg docker.io/library/alpine:3.20 sleep 300. -d détache le conteneur ; --name le rend facile à référencer.

4. Exécuter une commande dans un conteneur, podman exec test-bg cat /etc/os-release. exec lance une commande dans un conteneur déjà en cours d'exécution.

5. Shell interactif, podman exec -it test-bg sh. -i garde stdin ouvert, -t alloue un pseudo-terminal. Tapez exit pour sortir.

6. Consulter les logs, podman run -d --name test-nginx docker.io/library/nginx:alpine && podman logs --tail 5 test-nginx. --tail N limite aux N dernières lignes.

Exercices progressifs

Ces exercices vont du lancement d'un conteneur simple à la limitation de ressources. Lisez l'énoncé, cherchez la commande, puis dépliez la solution.

Niveau fondations

Exercice 1, Lancer un conteneur nginx. Lancez un conteneur nginx en arrière-plan, nommé web, accessible sur le port 8080.

Indice : -d pour l'arrière-plan, -p pour le port, --name pour le nom.

Voir la solution

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

-d détache, -p 8080:80 mappe le port, --name identifie le conteneur. curl localhost:8080 doit ensuite répondre.

Exercice 2, Consulter les logs nginx. Affichez les 10 dernières lignes de logs du conteneur web, avec les timestamps.

Indice : --tail pour limiter, -t pour les timestamps.

Voir la solution

podman logs --tail 10 -t web

--tail N limite aux N dernières lignes, -t ajoute la date et l'heure.

Exercice 3, Shell dans le conteneur. Ouvrez un shell interactif dans le conteneur web et vérifiez la version de nginx.

Indice : -it pour le mode interactif, puis nginx -v.

Voir la solution

podman exec -it web sh
# Puis dans le shell :
nginx -v

-it combine interactif et TTY pour obtenir un shell fonctionnel.

Niveau composition

Exercice 4, Monter un volume. Lancez un conteneur alpine qui affiche le contenu de ~/podman-lab/data, monté en /data.

Indice : -v source:destination.

Voir la solution

podman run --rm -v ~/podman-lab/data:/data:Z alpine ls -la /data

-v monte un dossier de l'hôte ; :Z gère le relabeling SELinux si nécessaire.

Exercice 5, Variables d'environnement. Lancez un conteneur postgres avec POSTGRES_PASSWORD=secret et POSTGRES_DB=demo.

Indice : un -e par variable, ou --env-file.

Voir la solution

podman run -d --name pg -e POSTGRES_PASSWORD=secret -e POSTGRES_DB=demo postgres:16-alpine

-e définit une variable ; on peut en enchaîner plusieurs.

Exercice 6, Trouver le port publié d'un conteneur. Récupérez le mapping de ports du conteneur web. En rootless, un conteneur n'a pas d'IP routable : c'est le port publié qui compte.

Indice : podman port, ou --format sur {{.NetworkSettings.Ports}}.

Voir la solution

podman port web
# 80/tcp -> 0.0.0.0:8080

En rootless, {{.NetworkSettings.IPAddress}} est vide ; podman port donne l'accès réel au service.

Niveau industrialisation

Exercice 7, Nettoyage des ressources. Supprimez tous les conteneurs arrêtés et les images non utilisées.

Indice : podman system prune avec les bonnes options.

Voir la solution

podman system prune -a -f

-a inclut les images non utilisées, -f exécute sans demander confirmation.

Exercice 8, Conteneur avec limite de ressources. Lancez un conteneur nginx avec au maximum 256 Mo de RAM et 0,5 CPU.

Indice : --memory et --cpus.

Voir la solution

podman run -d --name limited --memory=256m --cpus=0.5 nginx:alpine

--memory plafonne la RAM, --cpus limite les cycles CPU. Vérifiez avec podman stats.

Dépannage

Quand un conteneur se comporte mal, ces méthodes de diagnostic et ces erreurs fréquentes couvrent la grande majorité des cas.

Méthodes de diagnostic

Suivez cet ordre : l'état du conteneur d'abord, ses logs ensuite, sa configuration en dernier recours. Les trois dernières commandes servent quand le conteneur tourne mais se comporte mal, pas quand il refuse de démarrer.

# Voir tous les conteneurs, y compris arrêtés
podman ps -a

# Consulter les derniers logs
podman logs --tail 100 <conteneur>

# Voir toute la configuration d'un conteneur
podman inspect <conteneur> | less

# Lister les processus actifs dans le conteneur
podman top <conteneur>

# Suivre l'utilisation CPU/mémoire en temps réel
podman stats

# Voir les modifications du filesystem par rapport à l'image
podman diff <conteneur>

Erreurs fréquentes

Ces trois erreurs tiennent au contexte d'exécution plutôt qu'à la commande tapée : elles viennent du mode rootless, de la configuration réseau ou des limites de ressources. Aucune ne se corrige en changeant la syntaxe.

Erreur	Cause probable	Solution
Error: permission denied	Mapping d'UID rootless, SELinux, ou fichiers d'un autre utilisateur	Utiliser --userns=keep-id ou ajouter :Z au volume
Network is unreachable	Réseau rootless mal configuré, DNS, ou pare-feu	Tester avec --network=host, vérifier /etc/resolv.conf et les règles du pare-feu
Container was OOMKilled	Limite mémoire dépassée, fuite mémoire, ou limite trop stricte	Augmenter --memory ou optimiser l'application

Glissez pour voir

Aide-mémoire podman

À garder sous la main : les commandes Podman regroupées par usage, images, création de conteneurs, interaction et diagnostic.

Images

Un nom d'image sans registre est complété par Podman selon registries.conf : en cas de doute, écrivez le nom complet, par exemple docker.io/library/nginx.

Syntaxe	Signification	Exemple
podman pull image:tag	Télécharger une image	podman pull nginx:alpine
podman images	Lister les images locales	podman images
podman rmi image	Supprimer une image	podman rmi nginx:alpine
podman search terme	Rechercher sur les registres	podman search --limit 5 nginx
podman tag source cible	Créer un alias d'image	podman tag nginx:alpine mon-nginx:v1

Glissez pour voir

Création de conteneurs

Les options se placent entre run et le nom de l'image ; tout ce qui suit l'image est passé au conteneur et non à Podman.

Syntaxe	Signification	Exemple
podman run image	Créer et démarrer un conteneur	podman run nginx
-d	Mode détaché (arrière-plan)	podman run -d nginx
-it	Mode interactif avec TTY	podman run -it alpine sh
--rm	Supprimer après l'arrêt	podman run --rm alpine echo test
--name NAME	Nommer le conteneur	podman run --name web nginx
-p HOST:CONT	Mapper un port	podman run -p 8080:80 nginx
-v SRC:DEST	Monter un volume	podman run -v ./html:/usr/share/nginx/html nginx
-e VAR=val	Définir une variable d'environnement	podman run -e MYSQL_ROOT_PASSWORD=secret mysql

Glissez pour voir

Gestion et interaction

Partout où un conteneur est attendu, son nom et son identifiant sont interchangeables, et l'identifiant peut être abrégé tant qu'il reste sans ambiguïté.

Syntaxe	Signification	Exemple
podman ps	Lister les conteneurs actifs	podman ps
podman ps -a	Lister tous les conteneurs	podman ps -a --filter status=exited
podman start X	Démarrer un conteneur	podman start web
podman stop X	Arrêter proprement	podman stop web
podman rm -f X	Forcer la suppression	podman rm -f web
podman exec X cmd	Exécuter une commande	podman exec web cat /etc/nginx/nginx.conf
podman exec -it X sh	Ouvrir un shell interactif	podman exec -it web /bin/bash
podman logs -f X	Suivre les logs en temps réel	podman logs -f --tail 50 web
podman cp SRC DEST	Copier des fichiers	podman cp web:/var/log/nginx ./logs

Glissez pour voir

Diagnostic et nettoyage

Toutes ces commandes sont en lecture seule, à l'exception de podman system prune qui supprime définitivement les ressources inutilisées.

Syntaxe	Signification	Exemple
podman inspect X	Détails complets en JSON	podman inspect web
podman top X	Processus du conteneur	podman top web
podman stats	Ressources en temps réel	podman stats --no-stream
podman port X	Ports exposés	podman port web
podman system prune	Nettoyer les ressources inutilisées	podman system prune -f
podman system df	Espace disque utilisé	podman system df -v

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez les commandes Podman quand vous pouvez cocher chacun de ces points sans hésiter :

• Je sais lancer un conteneur interactif ou en arrière-plan.
• Je sais exposer des ports et monter des volumes.
• Je sais exécuter des commandes dans un conteneur existant.
• Je sais consulter et suivre les logs en temps réel.
• Je maîtrise le cycle de vie (start, stop, restart, rm).
• Je sais inspecter un conteneur et en extraire des informations.
• Je sais nettoyer les ressources inutilisées.
• Je comprends le mode rootless et ses implications.

Conclusion

Les commandes podman run, ps, exec, logs et rm constituent le cœur de votre travail quotidien avec les conteneurs. La compatibilité avec Docker facilite la transition, et le mode rootless par défaut renforce la sécurité sans effort supplémentaire.

Guides complémentaires

• Concepts fondamentaux Podman, Architecture daemonless, rootless, pods
• Gestion des volumes, Persistance des données
• Réseau Podman, Configuration réseau rootless/rootful
• Construire des images, Containerfile et Buildah

Prochaines étapes

Run avancé Limites de ressources, devices, capabilities et options de sécurité.

Gestion des volumes Persister les données avec les volumes et bind mounts.

Réseaux Podman Connecter vos conteneurs entre eux et avec l'extérieur.

Construire des images Créer vos propres images avec Containerfile et Buildah.

×

📖 Voir la documentation →