# Fichier: python_cheats/cheatsheets/podman.txt
# Cheatsheet Podman - Guide Ultra-Détaillé pour Grands Débutants


[OK] CONCEPTS FONDAMENTAUX (EXPLICATIONS TRÈS DÉTAILLÉES)

# === QU'EST-CE QUE PODMAN? ===

# Imagine que tu as créé une super app Python sur ton ordinateur
# Elle fonctionne parfaitement sur TON ordinateur
# Mais quand tu la donnes à quelqu'un d'autre:
#   - Ils ont une version Python différente
#   - Leurs packages sont installés différemment
#   - L'app ne marche pas! (classic "ça marche sur ma machine")

# Problème classique:
# - Tu as Python 3.11 + Flask 2.3.0 + PostgreSQL 14
# - Ton collègue a Python 3.8 + Flask 1.1.0 + PostgreSQL 12
# - Ton app crash chez lui!

# PODMAN = Solution: "Conteneur" qui encapsule TOUT
# = Petit ordinateur virtuel ultra-léger
# = Contient: Python, Flask, tous les packages, configuration, TOUT
# = Quelqu'un d'autre peut exécuter le conteneur et ça marche 100%!

# Podman s'appelle un "Container Runtime"
# = Logiciel qui gère les conteneurs

# Différence Podman vs Docker:
# - Docker = Plus populaire, mais propriétaire (Oracle)
# - Podman = Open source, plus sécurisé, pas besoin de daemon root
# = Pour débutants: Podman et Docker fonctionnent EXACTEMENT pareil!
# = Podman est plus moderne


# === VOCABULAIRE PODMAN (TRÈS IMPORTANT!) ===

# IMAGE (Moule)
# = Un blueprint/template pour créer des conteneurs
# = Contient: OS, Python, packages, code, configuration
# = C'est comme une photo d'un ordinateur fonctionnel complet
# = Tu crées une IMAGE une fois
# = Tu peux créer PLUSIEURS CONTENEURS à partir de cette image
# Analogie: IMAGE = moule à gâteau, CONTENEUR = gâteau

# Exemple:
# IMAGE "python-flask-app:1.0" = moule
# -> Crée CONTENEUR #1 = gâteau #1 (tourne sur port 8000)
# -> Crée CONTENEUR #2 = gâteau #2 (tourne sur port 8001)
# = Deux instances indépendantes de la même app!

# CONTENEUR (Instance)
# = Un instance d'une image en cours d'exécution
# = C'est le "gâteau" créé à partir du moule (image)
# = Lightweight (très peu de ressources)
# = Fast (démarre en millisecondes)
# = Isolé (ce qui se passe dedans n'affecte pas le reste du système)

# Exemple: Tu crées un conteneur Flask
# - Podman crée un mini Linux isolé
# - Installe Python 3.11 dedans
# - Lance ton app Flask
# - Elle écoute sur le port 5000 (du conteneur)
# - Pour accéder: tu "maps" le port 5000 du conteneur sur 8000 de ton ordinateur
# = localhost:8000 -> Conteneur:5000

# DOCKERFILE (Recette)
# = Un fichier qui dit à Podman: "Comment construire cette image?"
# = C'est une recette: "D'abord fais ceci, ensuite cela"
# = Chaque ligne = une instruction
# Format:
#   FROM ubuntu:22.04
#   RUN apt-get install python3
#   COPY app.py /app/
#   ENTRYPOINT ["python3", "app.py"]
# = "Utilise Ubuntu, installe Python, copie app, lance app"

# Analogie: Dockerfile = recette de cuisine détaillée
# IMAGE = gâteau cuit et prêt
# CONTENEUR = gâteau que tu manges

# REGISTRY (Dépôt d'images)
# = Serveur où sont stockées les images
# = Comme GitHub mais pour les images!
# = Tu peux télécharger une image du registry
# = Ou pousser ta propre image

# Registries populaires:
#   - Docker Hub (registry.hub.docker.com) = Plus populaire
#   - Quay.io = Alternative
#   - GitHub Container Registry = Intégré à GitHub

# Exemple:
# podman pull ubuntu:22.04
# = "Télécharge l'image 'ubuntu' version '22.04' depuis Docker Hub"

# LAYER (Couche)
# = Chaque instruction Dockerfile crée une "couche"
# = Les couches sont mises en cache
# = Accélère la construction des images

# Dockerfile:
# FROM ubuntu:22.04        # Couche 1
# RUN apt-get update       # Couche 2
# RUN apt-get install ...  # Couche 3
# COPY app.py /app/        # Couche 4
# = 4 couches au total

# Si tu changes la couche 4 seulement:
# = Podman réutilise les couches 1-3 du cache
# = Construction plus rapide!

# VOLUME (Stockage persistent)
# = Dossier partagé entre le conteneur et l'ordinateur
# = Ce qui est écrit dans le volume PERSISTE après arrêt du conteneur
# = Sans volume: les données disparaissent quand le conteneur s'arrête!

# Exemple:
# Conteneur tourne, écrit des données dans /data/
# Sans volume: Quand conteneur s'arrête -> données perdues!
# Avec volume: Dossier /data/ est lié à un dossier de l'ordinateur
#            -> Les données sont sauvegardées sur ton disque!

# PORT MAPPING (Forwarding de port)
# = Exposer les ports du conteneur vers ton ordinateur
# = Le conteneur a ses propres ports (isolés)
# = Tu dois les "mapper" pour y accéder

# Exemple:
# Conteneur Flask tourne sur port 5000 (interne)
# Tu veux accéder depuis ton navigateur: localhost:8000
# Port mapping: 8000 (ton ordinateur) -> 5000 (conteneur)
# = Requête localhost:8000 est redirigée vers port 5000 du conteneur


# === COMMENT ÇA MARCHE? (FLUX COMPLET) ===

# 1. Tu crées un Dockerfile
#    Dockerfile
#    ├── FROM python:3.11    (utilise image Python 3.11)
#    ├── WORKDIR /app        (dossier de travail)
#    ├── COPY . .            (copie le code)
#    ├── RUN pip install ... (installe packages)
#    └── CMD ["python", "app.py"]  (démarre l'app)

# 2. Tu construis l'image:
#    podman build -t myapp:1.0 .
#    = "Podman, lis le Dockerfile et crée une image nommée 'myapp:1.0'"
#    Résultat: Image "myapp:1.0" créée et stockée localement

# 3. Tu exécutes un conteneur:
#    podman run -p 8000:5000 myapp:1.0
#    = "Podman, lance un conteneur basé sur l'image 'myapp:1.0'"
#    = "Map le port 5000 du conteneur sur port 8000 de mon ordinateur"
#    Résultat: Conteneur tourne, app accessible sur localhost:8000

# 4. Tu pousses l'image vers un registry:
#    podman push myapp:1.0 quay.io/myusername/myapp:1.0
#    = "Podman, copie l'image vers le registry"
#    Résultat: Quelqu'un d'autre peut faire: podman pull quay.io/myusername/myapp:1.0

# 5. Quelqu'un d'autre télécharge et lance:
#    podman pull quay.io/myusername/myapp:1.0
#    podman run -p 8000:5000 quay.io/myusername/myapp:1.0
#    = L'app tourne EXACTEMENT pareille sur son ordinateur!
#    = Même Python, mêmes packages, même configuration
#    = "Ça marche sur ma machine" -> "Ça marche partout"!


[OK] INSTALLATION SUPER DÉTAILLÉE

# === ÉTAPE 1: INSTALLER PODMAN ===

# Podman est disponible sur toutes les plateformes
# Mais l'installation varie selon l'OS


# ========== macOS (avec Homebrew) ==========

# Si tu n'as pas Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

brew install podman

# Après l'installation:
podman machine init

# Crée une VM Linux (Podman a besoin d'un kernel Linux)
# Affiche: Initializing machine 'podman-machine-default'...

podman machine start

# Démarre la VM
# Affiche: Starting machine...

# Vérifier:
podman --version
# Affiche: podman version 4.X.X

# Ouvrir Terminal et vérifier:
podman system info
# Affiche: informations système


# ========== Windows (avec WSL2) ==========

# Prérequis: Windows 11 ou Windows 10 version 1903+

# 1. Installer WSL2:
wsl --install

# Puis redémarre ton ordinateur

# 2. Installer Podman:
# Ouvre PowerShell (Admin) et tape:
wsl.exe

# Dans WSL, tape:
sudo apt-get update && sudo apt-get install -y podman

# Vérifier:
podman --version


# ========== Linux (Ubuntu/Debian) ==========

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

# Vérifier:
podman --version

# Pour éviter les permissions sudo:
sudo usermod -aG podman $USER

# Puis log out et log in (ou redémarre)


# === ÉTAPE 2: VÉRIFIER L'INSTALLATION ===

podman --version
# Affiche: podman version 4.X.X

podman ps
# Affiche: CONTAINER ID  IMAGE  COMMAND  CREATED  STATUS  PORTS  NAMES
# (liste vide = normal si pas de conteneurs en cours)

podman images
# Affiche: REPOSITORY  TAG  IMAGE ID  CREATED  SIZE
# (liste vide = normal si pas d'images téléchargées)


[OK] STRUCTURE D'UN PROJET (EXPLICATIONS TRÈS DÉTAILLÉES)

# === POURQUOI CETTE STRUCTURE? ===

# Podman a besoin de savoir comment construire l'image
# Tu dois lui donner les instructions via un Dockerfile

# === FICHIER PRINCIPAL: Dockerfile ===

# Qu'est-ce que c'est?
# = Un fichier de configuration qui dit à Podman comment créer l'image
# = PAS d'extension (.txt, .py... rien!)
# = Contient des instructions ligne par ligne

# Pourquoi?
# Sur ton ordinateur tu fais: python app.py
# Avec Podman tu dois dire: "Comment créer l'environnement, puis lancer l'app"
# Dockerfile dit: "Voici les instructions"

# Format général:
# INSTRUCTION argument

# Explications des instructions principales:

# FROM = Image de base
# = Chaque Dockerfile doit commencer par FROM!
# = C'est l'image "parent"
# Exemples:
#   FROM ubuntu:22.04        (système Ubuntu minimal)
#   FROM python:3.11         (Python 3.11 pré-installé)
#   FROM python:3.11-slim    (Python 3.11, version légère)
#   FROM alpine:3.18         (système ultra-minimal)

# RUN = Exécute une commande
# = Pendant la construction de l'image
# = Utilisé pour installer des packages, créer des dossiers, etc
# Exemples:
#   RUN apt-get update
#   RUN apt-get install -y python3
#   RUN pip install flask
#   RUN mkdir -p /app

# WORKDIR = Dossier de travail
# = Crée un dossier et navigue dedans
# = Toutes les commandes suivantes s'exécutent dedans
# Exemple:
#   WORKDIR /app
#   = "Crée /app et mets-toi dedans"

# COPY = Copie des fichiers
# = Copie depuis ton ordinateur vers le conteneur
# = Format: COPY source destination
# Exemples:
#   COPY app.py /app/app.py    (copie app.py)
#   COPY . .                   (copie tout le dossier)
#   COPY requirements.txt /app/ (copie requirements.txt)

# ENV = Variable d'environnement
# = Défini une variable d'environnement dans le conteneur
# Exemples:
#   ENV PYTHONUNBUFFERED=1    (Python affiche les logs directement)
#   ENV PORT=5000              (défini PORT à 5000)
#   ENV DEBUG=False            (mode production)

# EXPOSE = Expose un port
# = Dit à Podman: "Ce conteneur écoute sur ce port"
# = C'est documentaire (le port doit encore être mappé au démarrage)
# Exemple:
#   EXPOSE 5000
#   = "L'app écoute sur port 5000 du conteneur"

# CMD = Commande par défaut
# = La commande qui s'exécute quand le conteneur démarre
# = Il ne peut y avoir qu'un CMD par Dockerfile
# Exemples:
#   CMD ["python", "app.py"]
#   CMD ["flask", "run"]
#   CMD ["/bin/bash"]

# ENTRYPOINT = Point d'entrée
# = Comme CMD mais avec des différences subtiles
# = Généralement: utilise ENTRYPOINT pour cmd principale
# Exemple:
#   ENTRYPOINT ["python"]
#   CMD ["app.py"]
#   = Lance: python app.py

# === Exemple Dockerfile complet: ===

# Dockerfile
# FROM python:3.11-slim
# = Utilise l'image Python 3.11 version légère

# WORKDIR /app
# = Crée dossier /app et dedans à partir de maintenant

# COPY requirements.txt .
# = Copie requirements.txt de ton ordinateur vers /app/

# RUN pip install -r requirements.txt
# = Installe les packages listés dans requirements.txt

# COPY . .
# = Copie tout le code de ton ordinateur vers /app/

# EXPOSE 5000
# = L'app écoute sur port 5000

# ENV PYTHONUNBUFFERED=1
# = Python affiche les logs directement (pas buffered)

# CMD ["python", "app.py"]
# = Démarre avec: python app.py


# === FICHIERS COMPLÉMENTAIRES ===

# === FILE #1: .dockerignore (RECOMMANDÉ) ===

# Qu'est-ce que c'est?
# = Fichier qui dit à Podman: "Ignore ces fichiers quand tu fais COPY . ."
# = Similaire à .gitignore

# Pourquoi?
# Sans .dockerignore, tout est copié dans l'image
# Taille de l'image augmente inutilement (peut être 1GB+!)
# Exemple: copier le dossier venv/ = +500MB!

# Contenu typique:
.dockerignore
venv/
.env
__pycache__/
*.pyc
.git/
.gitignore
.DS_Store
node_modules/
*.log
.pytest_cache/
build/
dist/
*.egg-info/


# === FILE #2: .env.example (RECOMMANDÉ) ===

# Qu'est-ce que c'est?
# = Exemple des variables d'environnement nécessaires
# = Aide les autres développeurs

# Contenu:
.env.example
DATABASE_URL=postgresql://user:pass@localhost/dbname
SECRET_KEY=change-this-in-production
DEBUG=True
PORT=5000


# === Structure complète d'un projet ===

myproject/
│
├── Dockerfile              # Instructions de construction
├── .dockerignore           # Fichiers à ignorer
├── requirements.txt        # Packages Python
├── .env.example            # Exemple de variables
├── .gitignore             # Fichiers git à ignorer
│
├── app.py                 # Ton app Flask/Django/autre
├── config.py              # Configuration
│
├── templates/             # Dossier: templates HTML
├── static/                # Dossier: fichiers statiques (CSS, JS)
│
└── README.md              # Documentation


[OK] PRÉPARATION DÉTAILLÉE AVANT DE CRÉER L'IMAGE

# === ÉTAPE 1: Créer le dossier du projet ===

# macOS/Linux:
mkdir myproject && cd myproject

# Windows PowerShell:
mkdir myproject
cd myproject


# === ÉTAPE 2: Initialiser git (optionnel mais recommandé) ===

git init

# Pourquoi?
# Même si tu utilises Podman, avoir git c'est utile
# Pour versionner le code, Dockerfile, etc


# === ÉTAPE 3: Créer l'app Python ===

# Crée un fichier "app.py" minimal:

from flask import Flask
import os

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello! App est dans un conteneur Podman!"

@app.route("/api/info")
def info():
    return {
        "message": "API fonctionne",
        "container": "Oui, tu es dans un conteneur Podman!"
    }

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 5000))
    app.run(host="0.0.0.0", port=port, debug=False)

# Explications:
# host="0.0.0.0" = TRÈS IMPORTANT dans les conteneurs!
#                 = Sans ça, flask n'est accessible que depuis l'intérieur
#                 = Avec ça, accessible depuis l'extérieur
# port = utilise PORT de .env ou 5000 par défaut
# debug=False = Mode production (pas de reload auto)


# === ÉTAPE 4: Créer requirements.txt ===

# Créer un fichier "requirements.txt":

Flask==2.3.0
Werkzeug==2.3.0
gunicorn==21.2.0

# Ou créer avec pip (si tu as un venv):
python -m venv venv
source venv/bin/activate  # ou venv\Scripts\activate
pip install flask gunicorn
pip freeze > requirements.txt


# === ÉTAPE 5: Créer le Dockerfile ===

# Crée un fichier "Dockerfile" (SANS extension!):

FROM python:3.11-slim

# Explications:
# FROM python:3.11-slim = Image de base: Python 3.11 version légère
#                         slim = sans packages supplémentaires

WORKDIR /app

# Crée dossier /app et navigue dedans

COPY requirements.txt .

# Copie requirements.txt de ton ordinateur vers /app/

RUN pip install --no-cache-dir -r requirements.txt

# Installe tous les packages
# --no-cache-dir = Ne garde pas les caches (économise de l'espace)

COPY . .

# Copie tout le code

ENV PYTHONUNBUFFERED=1

# Python envoie les logs directement (pas buffered)
# Utile pour voir les logs en temps réel

EXPOSE 5000

# Document: le conteneur écoute sur port 5000

CMD ["python", "app.py"]

# Commande au démarrage du conteneur


# === ÉTAPE 6: Créer .dockerignore ===

.dockerignore
venv/
.env
.git/
__pycache__/
*.pyc
.pytest_cache/
*.log


# === ÉTAPE 7: Créer .env.example ===

.env.example
PORT=5000
DEBUG=False


# === ÉTAPE 8: Tester l'app localement (optionnel) ===

# Avant de créer l'image, teste sur ton ordinateur!

python -m venv venv
source venv/bin/activate  # ou venv\Scripts\activate
pip install -r requirements.txt
python app.py

# Ouvre http://localhost:5000
# Doit afficher: "Hello! App est dans un conteneur Podman!"

# Arrête: Ctrl+C


[OK] CONSTRUCTION DE L'IMAGE (BUILD)

# === ÉTAPE 1: Construire l'image ===

# Tu dois être DANS le dossier du projet!

pwd  # macOS/Linux: affiche le chemin actuel
cd   # Windows PowerShell: affiche le chemin actuel

# Construire:
podman build -t myapp:1.0 .

# Explications:
# podman build = "Podman, construis une image"
# -t myapp:1.0 = "Tag (nommage): myapp avec version 1.0"
# . = "Le Dockerfile est dans le dossier courant"

# Affiche beaucoup de logs:
# STEP 1/8: FROM python:3.11-slim
# -> Télécharge l'image python:3.11-slim depuis Docker Hub
# STEP 2/8: WORKDIR /app
# -> Crée /app
# STEP 3/8: COPY requirements.txt .
# -> Copie requirements.txt
# STEP 4/8: RUN pip install --no-cache-dir -r requirements.txt
# -> Installe les packages (peut prendre 1-2 minutes)
# ...
# STEP 8/8: CMD ["python", "app.py"]
# -> Définit la commande de démarrage
# COMMIT myapp:1.0
# -> Finalise et enregistre l'image

# Cela peut prendre 2-5 minutes la première fois
# (téléchargement de l'image de base, installation des packages)

# Les fois suivantes: plus rapide (mise en cache)


# === ÉTAPE 2: Vérifier que l'image a été créée ===

podman images

# Affiche:
# REPOSITORY  TAG  IMAGE ID      CREATED      SIZE
# myapp       1.0  abc123def456  1 min ago    450MB

# Explications:
# REPOSITORY = myapp (nom de ton image)
# TAG = 1.0 (version)
# IMAGE ID = ID unique (long identifiant)
# SIZE = 450MB (taille de l'image)


# === ÉTAPE 3: Déboguer si erreur ===

# Erreur: "Step X failed"
# Solution: Regarde le message d'erreur
# Exemple erreur:
# ERROR: pip: command not found
# Signifie: pip n'est pas installé
# Solution: Utilise python -m pip au lieu de pip dans le Dockerfile

# Erreur: "COPY failed"
# Signifie: Le fichier n'existe pas
# Vérification: ls (affiche les fichiers du dossier)

# Erreur: "Image not found"
# Signifie: L'image de base (FROM python:3.11) n'existe pas
# Solution: Crée d'abord l'image de base:
# podman pull python:3.11-slim

# Pour reconstruire et ignorer le cache:
podman build --no-cache -t myapp:1.0 .

# Utile si tu modifies le Dockerfile et veux reconstruire depuis zéro


[OK] EXÉCUTION DE CONTENEURS (RUN)

# === ÉTAPE 1: Lancer un conteneur ===

podman run -p 8000:5000 myapp:1.0

# Explications:
# podman run = "Podman, lance un conteneur"
# -p 8000:5000 = "Map port 8000 (ordinateur) sur port 5000 (conteneur)"
# myapp:1.0 = "À partir de l'image myapp version 1.0"

# Affiche:
#  * Running on http://0.0.0.0:5000
#  * WARNING: This is a development server
# ...

# Cela signifie: le conteneur tourne et l'app écoute!

# IMPORTANT: Tu vois http://0.0.0.0:5000
# Mais n'ouvre PAS cette URL!
# À la place, ouvre: http://localhost:8000
# Pourquoi? Parce que tu as mappé 8000 -> 5000


# === ÉTAPE 2: Tester l'app ===

# Dans un navigateur:
http://localhost:8000

# Doit afficher: "Hello! App est dans un conteneur Podman!"

# Essaie aussi:
http://localhost:8000/api/info

# Doit afficher du JSON


# === ÉTAPE 3: Arrêter le conteneur ===

# Dans le terminal: Ctrl+C

# Affiche:
# Shutdown signal received, exiting


# === OPTIONS PRINCIPALES DE RUN ===

# Lancer en arrière-plan (detached mode):
podman run -d -p 8000:5000 myapp:1.0

# Affiche l'ID du conteneur: abc123def456789

# Tester:
http://localhost:8000

# Le terminal est libre!

# Voir les conteneurs en cours:
podman ps

# Affiche:
# CONTAINER ID  IMAGE        COMMAND        CREATED     STATUS     PORTS              NAMES
# abc123def456  myapp:1.0    python app.py  2 min ago   Up 2 min   0.0.0.0:8000->...  thirsty_einstein

# Arrêter le conteneur:
podman stop abc123def456

# Vérifier (n'apparaît plus dans ps):
podman ps

# Voir tous les conteneurs (même arrêtés):
podman ps -a


# === LANCER AVEC UN NOM PERSONNALISÉ ===

podman run -d --name my-app-container -p 8000:5000 myapp:1.0

# Affiche l'ID du conteneur

# NAMES = "my-app-container"

# Au lieu d'utiliser l'ID, tu peux utiliser le nom:
podman stop my-app-container
podman start my-app-container


# === PASSER DES VARIABLES D'ENVIRONNEMENT ===

podman run -d -p 8000:5000 -e PORT=8080 -e DEBUG=True myapp:1.0

# Explications:
# -e PORT=8080 = Défini la variable PORT à 8080
# -e DEBUG=True = Défini la variable DEBUG à True

# Ces variables sont accessibles dans l'app via os.environ.get("PORT")


# === MONTER UN VOLUME (STOCKAGE PERSISTENT) ===

# Créer un dossier sur ton ordinateur:
mkdir data

# Lancer le conteneur avec volume:
podman run -d -p 8000:5000 -v $(pwd)/data:/app/data myapp:1.0

# Explications:
# -v source:destination = Monte un volume
# $(pwd)/data = Dossier "data" sur TON ordinateur (chemin complet)
# :/app/data = Dossier "data" DANS le conteneur

# Maintenant:
# - L'app écrit dans /app/data (dans le conteneur)
# - Les données sont sauvegardées dans ton dossier data/
# - Les données PERSISTENT après arrêt du conteneur!

# Windows PowerShell:
podman run -d -p 8000:5000 -v C:\data:/app/data myapp:1.0


# === LANCER AVEC LE SHELL INTERACTIF ===

# Pour déboguer/explorer:
podman run -it myapp:1.0 /bin/bash

# Explications:
# -it = Mode interactif et terminal
# /bin/bash = Lance un shell bash au lieu de l'app

# Affiche:
# root@container-id:/app#

# Tu es maintenant DANS le conteneur!
# Tu peux taper des commandes:

ls
# Affiche les fichiers dans /app

cat app.py
# Affiche le contenu de app.py

python --version
# Affiche: Python 3.11.X

exit
# Quitte le conteneur


[OK] GESTION DES IMAGES

# === LISTER LES IMAGES ===

podman images

# Affiche:
# REPOSITORY  TAG       IMAGE ID      CREATED       SIZE
# myapp       1.0       abc123def456  5 min ago     450MB
# python      3.11-slim def456abc123  2 weeks ago   130MB


# === CHERCHER UNE IMAGE ===

# Dans Docker Hub (registry en ligne):
podman search python

# Affiche des résultats:
# REPOSITORY                  STARS
# python                       13000
# bitnami/python               200
# pypy                         100
# ...


# === TÉLÉCHARGER UNE IMAGE ===

podman pull python:3.11

# Télécharge l'image "python" avec le tag "3.11"

# Vérifier:
podman images | grep python


# === TAGGER UNE IMAGE (RENOMMER) ===

# Tu as myapp:1.0 et tu veux créer myapp:latest

podman tag myapp:1.0 myapp:latest

# Vérifier:
podman images

# Affiche:
# REPOSITORY  TAG       IMAGE ID
# myapp       1.0       abc123def456
# myapp       latest    abc123def456
# (même IMAGE ID = c'est la même image, juste un tag différent)


# === SUPPRIMER UNE IMAGE ===

podman rmi myapp:1.0

# Affiche:
# Untagged: myapp:1.0
# Deleted: abc123def456789

# IMPORTANT: Il ne doit y avoir aucun conteneur basé sur cette image!
# Sinon erreur

# Supprimer en forçant:
podman rmi -f myapp:1.0


# === VOIR L'HISTORIQUE D'UNE IMAGE ===

podman history myapp:1.0

# Affiche:
# ID         CREATED       CREATED BY                                  SIZE
# abc123     5 min ago     /bin/sh -c python app.py                    100B
# def456     5 min ago     /bin/sh -c #(nop) ENV PYTHONUNBUFFERED=1   0B
# ghi789     5 min ago     /bin/sh -c cp -r . .                        50MB
# ...