CloudAcademia
FR

Cloud computing · Module 05 · Virtualisation et conteneurs

Lab : à l'intérieur d'un conteneur

Lab75 minDébutantMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Construire une petite image de conteneur à partir d'un `Containerfile` avec une image de base épinglée, puis inspecter ses couches. Ensuite, l'exécuter et observer le conteneur depuis l'hôte : ses processus, ses namespaces et son cgroup. Enfin, fixer des limites de CPU et de mémoire, les lire dans les fichiers du cgroup et déclencher volontairement une mise à mort pour manque de mémoire (OOM, out-of-memory) afin de la diagnostiquer.

## Objectifs
- Construire une image à partir d'un `Containerfile` avec une image de base épinglée et expliquer ses couches (objectif 4).
- Montrer qu'un conteneur est un processus ordinaire de l'hôte dans ses propres namespaces : comparer nom d'hôte, liste des processus et identifiants de namespace à l'intérieur et à l'extérieur (objectif 3).
- Fixer des limites `--cpus` et `--memory` et les lire sous forme de `cpu.max` et `memory.max` dans les fichiers cgroup v2 (objectifs 3 et 5).
- Déclencher une mise à mort par OOM et la diagnostiquer avec `OOMKilled`, le code de sortie 137 et le journal du noyau (objectif 5).

## Prérequis
- Une machine Linux, ou une VM Linux, avec Podman 4 ou version ultérieure (testé avec Podman 5.8.7, rootless, cgroups v2, `crun`, sans `sudo`). Docker convient moyennant de petits changements : voir la NOTE ci-dessous.
- Un shell utilisateur (pas `root`). Tout ce lab s'exécute sans `sudo`.
- Un accès à Internet pour récupérer l'image de base `docker.io/library/alpine:3.20.10` (environ 8 MB) et pour télécharger un petit paquet (`procps-ng`) pendant la construction.
- Environ 30 MB d'espace disque.
- [La leçon](lesson.fr.md) de ce module.

> [!WARNING]
> Le lab est gratuit et n'exécute que des conteneurs que vous lancez sur votre propre machine, en tant qu'utilisateur ordinaire et sans `--privileged`. Chaque conteneur s'appelle `lab-virt-...`, et les commandes qui suppriment des choses les nomment explicitement, afin de ne pas toucher à vos autres conteneurs. Une étape fait volontairement utiliser à un conteneur plus de mémoire que sa limite ; cela ne peut nuire qu'à ce conteneur, pas à votre machine. Le lab ne modifie rien sur votre système en dehors d'un dossier (`~/virt-lab`) et d'une image locale, tous deux supprimés à la fin.

> [!NOTE]
> Les sorties ci-dessous ont été capturées sur un Linux de la famille Fedora en novembre 2026. Les identifiants, les PID, les numéros de namespace, les heures et le nom d'hôte seront différents sur votre machine ; ce qu'il faut comparer, c'est la structure et les valeurs issues de vos commandes (comme `67108864`).
>
> **Docker :** remplacez `podman` par `docker` ; le nom `Containerfile` reste valable (`docker build -f Containerfile` si votre version ne le trouve pas). Deux différences : avec le Docker par défaut, qui s'exécute en root, les processus du conteneur appartiennent à `root`, donc lire `/proc/<pid>/ns` et le journal OOM peut nécessiter `sudo`, et `podman top ... hpid huser` n'a pas d'équivalent dans Docker. Cela n'a pas été testé avec Docker.

## Architecture
<figure class="diagram" style="--dg-w: 1100px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1100 560" width="1100" height="560" role="img" aria-labelledby="virt-lab-architecture-fr-title virt-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="virt-lab-architecture-fr-title">Architecture du lab : un Containerfile, une image, trois conteneurs rootless et le noyau de l&#x27;hôte</title>
<desc id="virt-lab-architecture-fr-desc">Sur votre machine Linux, avec Podman rootless et sans sudo, le dossier ~/virt-lab contient un Containerfile et app.sh. Podman les construit en l&#x27;image localhost/lab-virt-hello:1.0, qui compte trois couches et fait environ 9.4 MB. L&#x27;image de base provient d&#x27;un registre sur Internet, docker.io/library/alpine, tag 3.20.10. L&#x27;image s&#x27;exécute en trois conteneurs dont les noms commencent par lab-virt- : lab-virt-demo, qui exécute sleep 3600 sans limites ; lab-virt-limited, avec une limite de CPU de 0.5 et une limite de mémoire de 64 MB ; et lab-virt-oom, avec une limite de mémoire de 64 MB, qui alloue 200 MB et est tué. Les conteneurs sont isolés et limités par le noyau Linux de l&#x27;hôte, que vous inspectez depuis l&#x27;hôte : /proc/&lt;pid&gt;/ns pour les namespaces, /sys/fs/cgroup pour memory.max, cpu.max et pids.max, et le journal du noyau pour l&#x27;OOM killer et le code de sortie 137.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1099" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="20" width="230" height="160" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet</text></g>
<g class="dg-l2"><rect class="dg-tint" x="280" y="20" width="800" height="520" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(296 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="322" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Votre machine Linux : Podman rootless, sans sudo</text></g>
<g class="dg-l7"><rect class="dg-tint" x="620" y="56" width="440" height="298" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(636 69) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="662" y="83" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Conteneurs (noms commençant par lab-virt-)</text></g>
<g class="dg-l4"><rect class="dg-tint" x="296" y="400" width="768" height="124" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(312 413) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g>
<text x="338" y="427" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">Noyau Linux de l&#x27;hôte : ce que vous inspectez</text></g>
<rect class="dg-card" x="34" y="64" width="202" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(50 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l1"><text x="92" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Registre</text></g>
<text x="52" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">alpine:3.20.10</text>
<text x="52" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">docker.io/library</text>
<rect class="dg-card" x="310" y="64" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(326 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l1"><text x="368" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Image</text></g>
<text x="328" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">localhost/lab-virt-hello:1.0</text>
<text x="328" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">3 couches · environ 9.4 MB</text>
<rect class="dg-card" x="310" y="240" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(326 256) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="368" y="277" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/virt-lab</text>
<text x="328" y="308" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">Containerfile</text>
<text x="328" y="328" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">app.sh</text>
<rect class="dg-card" x="636" y="92" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 108) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="129" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-demo</text></g>
<text x="654" y="160" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">sleep 3600 · sans limites</text>
<rect class="dg-card" x="636" y="178" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 194) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="215" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-limited</text></g>
<text x="654" y="246" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 --memory 64m</text>
<rect class="dg-card" x="636" y="264" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(652 280) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-warn"><text x="694" y="301" font-size="15" class="dg-ink" fill="#b91c1c" font-weight="700">lab-virt-oom</text></g>
<text x="654" y="332" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--memory 64m · alloue 200 MB</text>
<rect class="dg-card" x="312" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(328 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="370" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/proc/&lt;pid&gt;/ns</text></g>
<text x="330" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">namespaces vus depuis l&#x27;hôte</text>
<rect class="dg-card" x="558" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(574 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="616" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/sys/fs/cgroup/…</text></g>
<text x="576" y="504" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">memory.max · cpu.max</text>
<rect class="dg-card" x="804" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(820 452) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g></g>
<g class="dg-warn"><text x="862" y="473" font-size="14" class="dg-ink" fill="#b91c1c" font-weight="700">Journal du noyau</text></g>
<text x="822" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">OOM killer : code de sortie 137</text>
<g class="dg-l1"><path class="dg-stroke" d="M238 116H300" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M293 110l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="247.12" y="104" width="43.76" height="24" rx="12" fill="#ffffff"/><text x="269" y="120.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">pull</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M435 238V172" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M429 179l6-8 6 8" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="409.9" y="193" width="50.2" height="24" rx="12" fill="#ffffff"/><text x="435" y="209.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">build</text></g>
<g class="dg-l7"><path class="dg-stroke" d="M562 116H610" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M605 110l8 6-8 6" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="568.34" y="104" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="587" y="120.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle">run</text></g>
<g class="dg-l4"><path class="dg-stroke" d="M840 358V392" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M834 387l6 8 6-8" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="763.38" y="364" width="153.24" height="24" rx="12" fill="#ffffff"/><text x="840" y="380.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">isolés et limités par</text></g>
</svg></figure>

*Figure 1. Vous construisez une image à partir d'un dossier, l'exécutez en trois conteneurs et lisez ce que le noyau de l'hôte a fait pour les isoler et les limiter.*

## Étapes

### Étape 1 — Vérifiez vos outils et créez un dossier de travail
Commencez par vérifier que vous avez Podman, qu'il fonctionne sans root et que votre système utilise les cgroups v2. Vous gardez tous les fichiers du lab dans un seul dossier pour que le nettoyage soit simple.

```bash
podman --version
podman info --format 'rootless={{.Host.Security.Rootless}} cgroups={{.Host.CgroupsVersion}} runtime={{.Host.OCIRuntime.Name}}'
stat -fc %T /sys/fs/cgroup
mkdir -p ~/virt-lab && cd ~/virt-lab
```

Sortie attendue (la version peut être plus récente ; le runtime peut être `runc`) :

```text
podman version 5.8.7
rootless=true cgroups=v2 runtime=crun
cgroup2fs
```

`cgroup2fs` signifie que le système de fichiers cgroup v2 est monté sur `/sys/fs/cgroup`. Si vous voyez `tmpfs`, votre système utilise les cgroups v1 et les étapes sur les limites ne correspondront pas ; voir Dépannage.

> [!WARNING]
> Exécutez toutes les commandes suivantes depuis `~/virt-lab`, sauf indication contraire d'une étape.

### Étape 2 — Écrivez l'application et le Containerfile
L'application est un minuscule script shell. Le `Containerfile` liste les étapes de construction ; chaque étape qui modifie des fichiers ajoute une couche. Épinglez l'image de base sur un tag de version exact (`3.20.10`), pas sur `latest`, pour que la construction soit reproductible.

```bash
cat > app.sh <<'EOF'
#!/bin/sh
echo "Hello from $(hostname), running as $(id -un) (PID $$)"
EOF
chmod +x app.sh

cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
LABEL org.opencontainers.image.title="lab-virt-hello"
RUN apk add --no-cache procps-ng
COPY app.sh /usr/local/bin/app.sh
CMD ["/usr/local/bin/app.sh"]
EOF
```

Ce que fait chaque ligne :
- `FROM` choisit l'image de base et ses couches.
- `LABEL` ajoute des métadonnées à la configuration de l'image (pas de nouvelle couche).
- `RUN` exécute une commande dans un conteneur temporaire et conserve les modifications de fichiers sous forme de nouvelle couche.
- `COPY` ajoute un fichier de votre dossier sous forme de nouvelle couche.
- `CMD` définit la commande par défaut (métadonnées uniquement).

> [!NOTE]
> La ligne `RUN` est là pour donner à l'image une couche que vous pouvez voir. Elle nécessite un accès réseau pendant la construction.

### Étape 3 — Construisez l'image

```bash
podman build -t lab-virt-hello:1.0 .
```

`-t` donne à l'image le nom `lab-virt-hello` avec le tag `1.0`, et `.` est le contexte de construction (ce dossier).

Sortie attendue (les identifiants diffèrent ; les lignes de téléchargement d'`apk` sont tronquées) :

```text
STEP 1/5: FROM docker.io/library/alpine:3.20.10
STEP 2/5: LABEL org.opencontainers.image.title="lab-virt-hello"
--> b1be2b84c186
STEP 3/5: RUN apk add --no-cache procps-ng
Executing busybox-1.36.1-r31.trigger
OK: 9 MiB in 19 packages
--> c76c408b748b
STEP 4/5: COPY app.sh /usr/local/bin/app.sh
--> 964fed8bd61c
STEP 5/5: CMD ["/usr/local/bin/app.sh"]
COMMIT lab-virt-hello:1.0
--> de5c993d6a99
Successfully tagged localhost/lab-virt-hello:1.0
de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
```

La première fois, Podman affiche aussi `Trying to pull docker.io/library/alpine:3.20.10...` et les lignes de téléchargement des blobs. Vérifiez l'image :

```bash
podman images lab-virt-hello
```

```text
REPOSITORY                TAG         IMAGE ID      CREATED                 SIZE
localhost/lab-virt-hello  1.0         de5c993d6a99  Less than a second ago  9.37 MB
```

### Étape 4 — Inspectez les couches
`podman history` liste une ligne par instruction de construction, avec la taille de la couche ajoutée.

```bash
podman history lab-virt-hello:1.0
```

Sortie attendue (tronquée pour tenir ; les heures et les identifiants diffèrent) :

```text
ID            CREATED                 CREATED BY                                     SIZE        COMMENT
964fed8bd61c  Less than a second ago  /bin/sh -c #(nop) CMD ["/usr/local/bin/app...  0B
<missing>     Less than a second ago  /bin/sh -c #(nop) COPY file:23760a3ecceb3e...  3.58kB
c76c408b748b  Less than a second ago  /bin/sh -c apk add --no-cache procps-ng        1.27MB
bf8527eb54c3  1 second ago            /bin/sh -c #(nop) LABEL org.opencontainers...  0B          FROM docker.i...
<missing>     6 months ago            CMD ["/bin/sh"]                                0B          buildkit.dock...
<missing>     6 months ago            ADD alpine-minirootfs-3.20.10-x86_64.tar.g...  8.09MB      buildkit.dock...
```

Lisez-la de bas en haut : le système de fichiers racine de l'image de base (8.09 MB), votre `RUN` (1.27 MB), votre `COPY` (3.58 kB). `CMD` et `LABEL` font 0 B : ils ne modifient que la configuration. Demandez maintenant directement les couches et le format :

```bash
podman image inspect lab-virt-hello:1.0 --format 'Layers: {{len .RootFS.Layers}}  Cmd: {{.Config.Cmd}}  Format: {{.ManifestType}}'
podman image inspect lab-virt-hello:1.0 --format '{{range .RootFS.Layers}}{{println .}}{{end}}'
```

Sortie attendue (la première couche, Alpine, est la même sur votre machine ; les deux autres diffèrent, car leur contenu inclut les heures de construction) :

```text
Layers: 3  Cmd: [/usr/local/bin/app.sh]  Format: application/vnd.oci.image.manifest.v1+json
sha256:08bc4e534116aa76b16015484b82eac51f9a593416feae9296c8a2d4bb7aa4a2
sha256:f55ed2bae43c665dab4e7586118f8ad3e837d47e4f580dbc8c6ae63b55ac8f5e
sha256:df259c8f1ca6356b3feac01c6d60efbe8439114afa5442ddbcfba2f5286d92c7
```

Trois couches (la base, `RUN`, `COPY`), chacune nommée par le digest SHA-256 de son contenu, et une image au format d'image OCI (`application/vnd.oci.image.manifest.v1+json`).

> [!NOTE]
> Les digests ci-dessus sont les identifiants de contenu non compressé (`diff_id` dans la configuration de l'image). Les digests des couches compressées du manifeste, qu'utilise un registre, sont des valeurs différentes.

### Étape 5 — Exécutez le conteneur
Exécutez-le une fois au premier plan. `--rm` supprime le conteneur à sa sortie, et `--name` respecte la règle `lab-virt-`.

```bash
podman run --rm --name lab-virt-hello lab-virt-hello:1.0
```

Sortie attendue (le nom d'hôte correspond aux 12 premiers caractères de l'identifiant du conteneur, donc le vôtre diffère) :

```text
Hello from 5088d1aeb13f, running as root (PID 1)
```

Notez trois choses : le nom d'hôte n'est pas celui de votre ordinateur (namespace uts), le script est le **PID 1** (namespace pid) et l'utilisateur est `root` (un namespace user, comme vous le verrez à l'étape 7).

### Étape 6 — Comparez la vue du conteneur et celle de l'hôte
Cette fois, démarrez un conteneur qui reste en cours d'exécution, afin de l'observer des deux côtés.

```bash
podman run -d --name lab-virt-demo lab-virt-hello:1.0 sleep 3600
podman ps --filter name=lab-virt- --format 'table {{.Names}}\t{{.Status}}\t{{.Command}}'
```

Sortie attendue (la première ligne est l'identifiant complet du conteneur) :

```text
9f26995a174db194e15e4322e83b28bdfb0928df0ed9f5be2a803f0607cc6b50
NAMES          STATUS                 COMMAND
lab-virt-demo  Up Less than a second  sleep 3600
```

Demandez à Podman les processus du conteneur, avec la vue de l'hôte à côté de celle du conteneur :

```bash
podman top lab-virt-demo user pid hpid huser comm
```

```text
USER        PID         HPID        HUSER       COMMAND
root        1           41390       1000        sleep
```

`PID` est le numéro à l'intérieur du conteneur (1) ; `HPID` est le PID du même processus sur l'hôte (41390 ici, le vôtre diffère) ; `USER` est `root` à l'intérieur, et `HUSER` est `1000` sur l'hôte : votre propre identifiant d'utilisateur. Le « root » du conteneur, c'est vous. Comparez maintenant les vues avec des commandes exécutées à l'intérieur et à l'extérieur :

```bash
podman exec lab-virt-demo hostname
podman exec lab-virt-demo ps -o pid,user,comm
podman exec lab-virt-demo uname -r
echo "--- host ---"
hostname
uname -r
```

Sortie attendue :

```text
9f26995a174d
    PID USER     COMMAND
      1 root     sleep
      3 root     ps
7.2.4-ogc3.1.fc44.x86_64
--- host ---
bazzite
7.2.4-ogc3.1.fc44.x86_64
```

À l'intérieur, vous voyez un autre nom d'hôte et seulement deux processus (`sleep` comme PID 1, et le `ps` que vous venez de lancer), alors que l'hôte en a des centaines. Mais `uname -r` affiche **la même version du noyau** : il n'y a pas de noyau invité, le conteneur partage celui de l'hôte. C'est la principale différence avec une VM.

### Étape 7 — Observez les namespaces depuis l'hôte
Chaque processus a un lien par namespace dans `/proc/<pid>/ns/`. Deux processus sont dans le même namespace quand le numéro du lien est identique. Comparez votre shell avec le `sleep` du conteneur, en utilisant son PID sur l'hôte :

```bash
PID=$(podman inspect lab-virt-demo --format '{{.State.Pid}}')
echo "container PID on the host: $PID"
for ns in cgroup ipc mnt net pid user uts time; do
  printf '%-7s host %-18s container %s\n' $ns "$(readlink /proc/self/ns/$ns)" "$(readlink /proc/$PID/ns/$ns)"
done
```

Sortie attendue (les numéros diffèrent sur votre machine ; comparez-les deux à deux) :

```text
container PID on the host: 41390
cgroup  host cgroup:[4026531835] container cgroup:[4026533219]
ipc     host ipc:[4026531839]   container ipc:[4026533217]
mnt     host mnt:[4026531832]   container mnt:[4026533215]
net     host net:[4026531833]   container net:[4026533103]
pid     host pid:[4026531836]   container pid:[4026533218]
user    host user:[4026531837]  container user:[4026533101]
uts     host uts:[4026531838]   container uts:[4026533216]
time    host time:[4026531834]  container time:[4026531834]
```

Sept namespaces sont différents. Le namespace `time` est le même : les conteneurs n'ont pas le leur par défaut. Si `lsns` est installé (paquet `util-linux`), il liste les mêmes informations :

```bash
lsns -p $PID -o NS,TYPE,NPROCS,PID,COMMAND
```

```text
        NS TYPE   NPROCS   PID COMMAND
4026531834 time      153  1853 /usr/bin/mpris-proxy
4026533101 user       16 15774 catatonit -P
4026533103 net         1 41390 sleep 3600
4026533215 mnt         1 41390 sleep 3600
4026533216 uts         1 41390 sleep 3600
4026533217 ipc         1 41390 sleep 3600
4026533218 pid         1 41390 sleep 3600
4026533219 cgroup      1 41390 sleep 3600
```

La première ligne est le namespace `time` que vous partagez avec l'hôte (le `COMMAND` affiché n'est que le plus ancien processus qui s'y trouve). La ligne `user` compte plus d'un processus : Podman rootless garde un seul namespace user pour tous vos conteneurs, maintenu par un petit assistant (`catatonit`).

Passons au namespace user. À l'intérieur du conteneur, vous êtes l'UID 0. Quel utilisateur l'hôte pense-t-il que vous êtes, et comment l'association est-elle faite ?

```bash
podman exec lab-virt-demo cat /proc/self/uid_map
stat -c 'owner of the host process: %U' /proc/$PID
```

```text
         0       1000          1
         1     524288      65536
owner of the host process: user
```

Lisez chaque ligne de `uid_map` comme `<premier UID à l'intérieur> <premier UID à l'extérieur> <combien>` : l'UID 0 du conteneur est l'UID 1000 de l'hôte (vous ; un effectif de 1), et les UID 1 à 65536 du conteneur sont associés à une plage d'UID qui vous est réservée dans `/etc/subuid`. Le processus sur l'hôte appartient à votre propre nom d'utilisateur (`user` ici ; le vôtre sera différent). Une faille qui permettrait au processus de s'échapper ne trouverait que vos droits, pas ceux de root.

### Étape 8 — Fixez des limites et lisez-les dans le cgroup
Démarrez un deuxième conteneur avec une limite d'un demi-CPU et de 64 MB de mémoire :

```bash
podman run -d --name lab-virt-limited --cpus 0.5 --memory 64m lab-virt-hello:1.0 sleep 3600
```

Le cgroup du conteneur est un répertoire sous `/sys/fs/cgroup`. Trouvez-le à partir du PID de l'hôte, puis lisez les fichiers de limites :

```bash
PID=$(podman inspect lab-virt-limited --format '{{.State.Pid}}')
CG=/sys/fs/cgroup$(cut -d: -f3 /proc/$PID/cgroup)
echo "$CG"
for f in memory.max cpu.max pids.max memory.current; do printf '%-15s %s\n' $f "$(cat $CG/$f)"; done
```

Sortie attendue (l'identifiant du conteneur dans le chemin diffère, abrégé ici en `<id>` ; `memory.current` varie) :

```text
/sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service/user.slice/libpod-<id>.scope/container
memory.max      67108864
cpu.max         50000 100000
pids.max        2048
memory.current  741376
```

- `memory.max` vaut `67108864` : 64 × 1024 × 1024 octets, issus de `--memory 64m`.
- `cpu.max` vaut `50000 100000` : 50 000 µs de temps CPU dans chaque période de 100 000 µs, soit 0.5 CPU, issus de `--cpus 0.5`.
- `pids.max` est une valeur par défaut fixée par Podman (2048 ici ; la vôtre peut différer).

Comparez avec le conteneur sans limites, `lab-virt-demo` :

```bash
CGD=/sys/fs/cgroup$(cut -d: -f3 /proc/$(podman inspect lab-virt-demo --format '{{.State.Pid}}')/cgroup)
for f in memory.max cpu.max; do printf '%-15s %s\n' $f "$(cat $CGD/$f)"; done
```

```text
memory.max      max
cpu.max         max 100000
```

`max` signifie « aucune limite ». Le conteneur peut aussi lire ses propres limites, car il a son propre namespace cgroup, dans lequel son cgroup apparaît comme la racine :

```bash
podman exec lab-virt-limited cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.max
podman inspect lab-virt-limited --format 'Memory={{.HostConfig.Memory}} NanoCpus={{.HostConfig.NanoCpus}} CpuQuota={{.HostConfig.CpuQuota}} CpuPeriod={{.HostConfig.CpuPeriod}}'
```

```text
67108864
50000 100000
Memory=67108864 NanoCpus=500000000 CpuQuota=50000 CpuPeriod=100000
```

### Étape 9 — Observez la limite de CPU brider un conteneur occupé
Lancez une boucle infinie dans le conteneur limité. Sans limite, elle utiliserait un CPU entier ; avec `--cpus 0.5`, elle devrait en obtenir environ la moitié.

```bash
podman exec -d lab-virt-limited sh -c 'while :; do :; done'
sleep 8
podman stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}' lab-virt-limited
grep -E 'nr_periods|nr_throttled|throttled_usec' $CG/cpu.stat
```

Sortie attendue (les pourcentages et les compteurs varient) :

```text
NAME              CPU %       MEM USAGE / LIMIT
lab-virt-limited  48.63%      450.6kB / 67.11MB
nr_periods 83
nr_throttled 78
throttled_usec 3373263
```

La boucle voudrait 100 % d'un CPU mais en obtient environ 50 %. `nr_throttled` compte les périodes pendant lesquelles le cgroup a épuisé son quota et a été mis en pause jusqu'à la période suivante : presque toutes (78 sur 83). Un dépassement de la limite de CPU signifie **plus lent**, pas tué.

Supprimez les deux conteneurs. `sleep` comme PID 1 ignore le signal d'arrêt (`SIGTERM`), donc `-t 0` évite l'attente de 10 secondes :

```bash
podman rm -f -t 0 lab-virt-limited lab-virt-demo
```

```text
lab-virt-demo
lab-virt-limited
```

### Étape 10 — Déclenchez volontairement une mise à mort par OOM
Donnez maintenant 64 MB à un conteneur et demandez à son shell de garder en mémoire une chaîne de 200 MB. La commande `head -c 200000000 /dev/zero | tr "\0" a` produit 200 MB de la lettre `a`, et le shell les garde tous dans la variable `x`.

```bash
podman run --name lab-virt-oom --memory 64m lab-virt-hello:1.0 \
  sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```

Sortie attendue :

```text
exit code: 137
```

Il n'y a pas de ligne « allocated » : le shell a été tué avant de pouvoir l'afficher. Le nom n'a pas de `--rm`, ce qui vous permet d'inspecter le conteneur arrêté. Le code de sortie 137 vaut 128 + 9, c'est-à-dire `SIGKILL`. Mais est-ce l'OOM killer ? Demandez au moteur :

```bash
podman inspect lab-virt-oom --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}} Status={{.State.Status}}'
```

```text
OOMKilled=true ExitCode=137 Status=exited
```

`OOMKilled=true` confirme que l'OOM killer du cgroup mémoire l'a arrêté. Le journal du noyau donne les détails :

```bash
journalctl -k --since "-2min" --no-pager | grep "Memory cgroup out of memory"
```

Sortie attendue (raccourcie ; le PID et les tailles varient) :

```text
nov 07 19:55:34 bazzite kernel: Memory cgroup out of memory: Killed process 43622 (sh) total-vm:136808kB, anon-rss:62252kB, file-rss:904kB, shmem-rss:0kB, UID:1000 pgtables:300kB oom_score_adj:200
```

Le processus utilisait environ 62 MB de mémoire résidente (`anon-rss`) lorsqu'il a atteint la limite de 64 MB, et c'est à ce moment-là qu'il a été tué.

> [!NOTE]
> Lire le journal du noyau nécessite un accès au journal : sur beaucoup de systèmes, un utilisateur ordinaire doit appartenir au groupe `systemd-journal` (ou `adm`), ou utiliser `dmesg` si le système le permet (`sysctl kernel.dmesg_restrict` vaut `0`). Sans accès, `podman inspect` et le code de sortie 137 suffisent pour terminer le lab ; la ligne du noyau n'est qu'une confirmation.

> [!NOTE]
> Si le processus qui manque de mémoire est lancé avec `podman exec` dans un conteneur dont le processus principal va bien, seul ce processus lancé par `exec` est tué : le conteneur continue de s'exécuter, et `OOMKilled` reste `false`. Le fichier `memory.events` du cgroup le montre malgré tout, sous la forme d'un compteur `oom_kill 1`. Quand vous diagnostiquez un redémarrage ou une mise à mort, regardez `memory.events` en plus de `OOMKilled`.

Corrigeons maintenant. Le travail a besoin d'environ 200 MB, donc relevez la limite à 512 MB. Cette fois, utilisez `--rm` :

```bash
podman rm lab-virt-oom
podman run --rm --name lab-virt-oom --memory 512m lab-virt-hello:1.0 \
  sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```

```text
lab-virt-oom
allocated 200000000 bytes
exit code: 0
```

La même commande réussit quand la limite correspond au besoin réel. La première ligne est la sortie de `podman rm`, qui affiche le nom du conteneur supprimé.

## Vérification
Contrôlez chaque résultat. Tout ce qui suit doit être vrai :

- `podman history lab-virt-hello:1.0` montre une couche de base d'environ 8 MB, une couche `RUN` d'environ 1 MB et une couche `COPY` de quelques kB ; `CMD` et `LABEL` affichent `0B`.
- À l'intérieur d'un conteneur, `hostname` diffère de celui de l'hôte, `ps` affiche `sleep` comme PID 1 et `uname -r` est égal à la version du noyau de l'hôte.
- `readlink /proc/<pid>/ns/...` donne des numéros différents pour `cgroup`, `ipc`, `mnt`, `net`, `pid`, `user` et `uts`, et le même numéro pour `time`.
- `memory.max` vaut `67108864` et `cpu.max` vaut `50000 100000` pour `lab-virt-limited`.
- L'exécution avec OOM se termine par `OOMKilled=true` et le code de sortie 137, et la nouvelle tentative avec `--memory 512m` se termine par `allocated 200000000 bytes`.

Auto-vérification rapide :

```bash
podman ps -a --filter name=lab-virt- --format '{{.Names}} {{.Status}}'
```

Après l'étape 10, cette commande n'affiche rien, car le dernier conteneur utilisait `--rm` et les précédents ont été supprimés.

## Dépannage
| Symptôme | Cause probable | Correction |
|---|---|---|
| `stat -fc %T /sys/fs/cgroup` affiche `tmpfs` | Le système utilise les cgroups v1, où les limites rootless ne sont pas prises en charge | Utilisez une distribution avec cgroups v2 (Fedora, Ubuntu 22.04 ou ultérieure, Debian 11 ou ultérieure) ou une VM. Podman avertit : `Resource limits are not supported and ignored on cgroups V1 rootless systems`. |
| `podman run --cpus 0.5` échoue ou le fichier `cpu.max` reste à `max` | Le contrôleur `cpu` n'est pas délégué à votre utilisateur | Exécutez `cat /sys/fs/cgroup/user.slice/user-$(id -u).slice/user@$(id -u).service/cgroup.controllers` ; il doit lister `cpu`, `memory` et `pids`. Sur les systèmes plus anciens, un administrateur doit activer la délégation (un drop-in systemd avec `Delegate=cpu cpuset io memory pids`). |
| `Error: pulling image ... connection refused` ou délai dépassé | Pas d'Internet ou un proxy | Définissez la variable `HTTPS_PROXY`, ou récupérez l'image depuis un registre accessible et modifiez la ligne `FROM`. |
| `apk add` échoue pendant la construction | Le conteneur n'a ni DNS ni réseau | Vérifiez que `podman run --rm docker.io/library/alpine:3.20.10 nslookup example.com` fonctionne ; vérifiez votre pare-feu et votre VPN. |
| `cannot clone: Operation not permitted` ou erreurs de namespace user | Le mode rootless nécessite des entrées dans `/etc/subuid` et `/etc/subgid` et des namespaces user non privilégiés | `grep $USER /etc/subuid /etc/subgid` ; un administrateur peut les ajouter (`usermod --add-subuids ...`). |
| Le conteneur s'exécute mais `OOMKilled` vaut `false` et le code de sortie est 137 | Tué pour une autre raison (par exemple l'expiration d'un stop), ou la limite de mémoire n'a pas été appliquée | Vérifiez `memory.max` dans le cgroup ; voir l'étape 10. |
| Pas de ligne OOM dans `journalctl -k` | Pas la permission de lire le journal du noyau, ou l'entrée est plus ancienne que la fenêtre `--since` | Voir la NOTE de l'étape 10 ; utilisez `--since "-10min"`. |
| `/proc/<pid>/ns` ou le chemin du cgroup n'existe pas | Le conteneur s'est déjà arrêté, ou le PID est périmé | Exécutez `podman ps` et relisez le PID. |
| `Error: creating container storage: the container name "lab-virt-oom" is already in use` | Un conteneur arrêté portant ce nom est resté | `podman rm lab-virt-oom` |

## Défi (facultatif)
À faire sans instructions pas à pas :
1. Démarrez un conteneur avec `--pids-limit 20` et essayez d'y lancer plus de 20 processus (par exemple avec une boucle shell qui exécute `sleep 300 &`). Quelle erreur obtenez-vous, et quel fichier et quel compteur du cgroup ont changé ? Supprimez ensuite le conteneur.
2. Démarrez un conteneur avec `--uts=host`, puis avec `--pid=host`, et comparez `hostname` et `ps` avec la configuration par défaut. Quelle isolation avez-vous retirée dans chaque cas ? Pourquoi voudrait-on rarement le faire ?
3. Reconstruisez l'image avec `FROM docker.io/library/alpine:3.20.10@sha256:<digest>` (obtenez le digest avec `podman image inspect docker.io/library/alpine:3.20.10 --format '{{.Digest}}'`). Qu'est-ce que le digest garantit que le tag ne garantit pas ?

## Nettoyage
Supprimez les conteneurs (les noms sont explicites, et `--ignore` ignore ceux qui n'existent déjà plus), l'image que vous avez construite et le dossier du lab :

```bash
podman rm -f -t 0 --ignore lab-virt-demo lab-virt-limited lab-virt-oom lab-virt-hello
podman rmi lab-virt-hello:1.0
cd ~ && rm -r ~/virt-lab
```

Sortie attendue (les identifiants diffèrent ; la première commande affiche le nom de chaque conteneur qu'elle supprime, et rien s'il n'en reste aucun) :

```text
Untagged: localhost/lab-virt-hello:1.0
Deleted: de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
Deleted: 964fed8bd61ca0b105dcbf80de33b5c8eb7bab12ab5f96fa46d4d98e2830587a
Deleted: c76c408b748b1e099ea7e4d5e1350499b7d405187fe91f6d497e686e4688fba6
Deleted: b1be2b84c1863941b122d42738aeef7356b81e3f2704e6db0b2faa6f099e28f3
```

Si vous n'avez récupéré l'image de base que pour ce lab, supprimez-la aussi. Ignorez cette étape si vous utilisez Alpine 3.20.10 pour autre chose ; Podman refuse de supprimer une image encore utilisée par un conteneur :

```bash
podman rmi docker.io/library/alpine:3.20.10
```

Vérifiez qu'il ne reste rien :

```bash
podman ps -a --filter name=lab-virt-
podman images lab-virt-hello
ls ~/virt-lab
```

Les deux premières commandes n'affichent que leurs lignes d'en-tête (ou rien), et `ls` indique que le dossier n'existe pas.

## Ce que vous avez appris
- Un `Containerfile` devient une image OCI faite de couches : chaque `RUN` et `COPY` en ajoute une, et `CMD` et `LABEL` n'ajoutent que des métadonnées. Épingler l'image de base sur un tag exact garde les constructions reproductibles.
- Un conteneur est un processus ordinaire de l'hôte : `podman top` montre son PID sur l'hôte, `/proc/<pid>/ns` montre qu'il se trouve dans ses propres namespaces pid, net, mnt, uts, ipc, user et cgroup, et `uname -r` montre qu'il partage le noyau de l'hôte.
- Dans un conteneur rootless, le root de l'intérieur est votre propre utilisateur non privilégié à l'extérieur, grâce à l'association du namespace user.
- `--memory` et `--cpus` deviennent `memory.max` et `cpu.max` dans le cgroup du conteneur ; dépasser la limite de CPU bride, et dépasser la limite de mémoire fait intervenir l'OOM killer.
- Le code de sortie 137 signifie `SIGKILL` ; `OOMKilled=true`, la ligne du journal du noyau et `memory.events` indiquent si c'est l'OOM killer qui a agi, et la solution consiste à comprendre le besoin réel en mémoire, pas seulement à relever la limite.