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)

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

🧠 Modèle mental — Comment fonctionne Podman

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

Modèle mental Podman : Registry → Image → Conteneur → Processus isolé via conmon

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

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

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

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

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`

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`

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

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`

Erreurs typiques (et solutions)

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

Gestion des images

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

Rechercher et télécharger

# 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

# 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

Exécution de conteneurs

Conteneur simple (avant-plan)

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

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

Vérification :

curl localhost:8080

Conteneur interactif

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

Lister les conteneurs

# 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

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

# Extraire un champ spécifique
podman inspect --format '{{.NetworkSettings.IPAddress}}' mon-nginx

# Voir les processus
podman top mon-nginx

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

Interagir avec un conteneur

Exécuter une commande

# 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

# 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

# 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

# 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

# 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 :

ID            NAME        CPU %   MEM USAGE / LIMIT   MEM %   NET IO       PIDS
a79693ad4f28  mon-nginx   0.04%   10.89MB / 50.28GB   0.02%   110B / 430B  17

Nettoyage des ressources

# 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

Sauvegarder et transférer

# 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 '{{.NetworkSettings.IPAddress}}' mon-nginx

--format : template Go ; {{.State.Status}} : état du conteneur.

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é

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 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é

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

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`

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

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

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

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.
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.
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.
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.
Shell interactif — podman exec -it test-bg sh. -i garde stdin ouvert, -t alloue un pseudo-terminal. Tapez exit pour sortir.
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 — Inspecter l'IP d'un conteneur. Récupérez l'adresse IP du conteneur web avec --format.

Indice : --format avec le template Go {{.NetworkSettings.IPAddress}}.

Voir la solution

podman inspect --format '{{.NetworkSettings.IPAddress}}' web

inspect renvoie un JSON complet ; --format en extrait un champ précis.

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

# 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

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

Aide-mémoire podman

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

Images

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`

Création de conteneurs

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`

Gestion et interaction

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`

Diagnostic et nettoyage

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`

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.

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.

Commandes essentielles Podman

Ce que vous allez apprendre

La commande podman dans l'écosystème conteneurs

Comprendre Podman en 2 min

🧠 Modèle mental — Comment fonctionne Podman

Points clés

Règles d'or

Vocabulaire essentiel

Syntaxe complète

Les concepts clés

Les options essentielles de run

Cycle de vie d'un conteneur

Erreurs typiques (et solutions)

Gestion des images

Rechercher et télécharger

Inspecter et supprimer

Exécution de conteneurs

Conteneur simple (avant-plan)

Conteneur en arrière-plan

Conteneur interactif

Lister et inspecter

Lister les conteneurs

Inspecter un conteneur

Interagir avec un conteneur

Exécuter une commande

Consulter les logs

Copier des fichiers

Contrôler le cycle de vie

Surveillance et statistiques

Nettoyage des ressources

Sauvegarder et transférer

Les patterns de commandes courants

Conteneur interactif jetable

Service en arrière-plan

Exposer un port

Monter un dossier

Variables d'environnement

Debug dans un conteneur

Suivre les logs en temps réel

Nettoyage complet

Extraire des infos avec --format

Limiter les ressources

Vérification de santé

Copier des fichiers

Les pièges à éviter

Nom de conteneur déjà utilisé

Image non trouvée

Port déjà utilisé

Permission denied sur un volume

Utilisation de :latest

Perte de données sans volume

Ports privilégiés en rootless

Conteneur arrêté immédiatement

Travaux pratiques

Préparer le terrain

Les 6 étapes du lab

Exercices progressifs

Niveau fondations

Niveau composition

Niveau industrialisation

Dépannage

Méthodes de diagnostic

Erreurs fréquentes

Aide-mémoire podman

Images

Création de conteneurs

Gestion et interaction

Diagnostic et nettoyage

Checklist de maîtrise

Conclusion

Prochaines étapes

La commande `podman` dans l'écosystème conteneurs

Les options essentielles de `run`

Utilisation de `:latest`