Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.
## Obiettivo
Costruirai una piccola immagine di container da un `Containerfile` con un'immagine di base fissata e ne ispezionerai i livelli. Poi la eseguirai e osserverai il container dall'host: i suoi processi, i suoi namespace e il suo cgroup. Infine imposterai limiti di CPU e memoria, li leggerai nei file del cgroup e provocherai di proposito una terminazione per memoria esaurita (OOM, out-of-memory) per poterla diagnosticare.
## Obiettivi
- Costruire un'immagine da un `Containerfile` con un'immagine di base fissata e spiegarne i livelli (obiettivo 4).
- Mostrare che un container è un normale processo dell'host nei propri namespace: confrontare hostname, elenco dei processi e ID dei namespace dentro e fuori (obiettivo 3).
- Impostare i limiti `--cpus` e `--memory` e leggerli come `cpu.max` e `memory.max` nei file cgroup v2 (obiettivi 3 e 5).
- Provocare una terminazione per OOM e diagnosticarla con `OOMKilled`, l'exit code 137 e il log del kernel (obiettivo 5).
## Prerequisiti
- Una macchina Linux, o una VM Linux, con Podman 4 o successivo (testato con Podman 5.8.7, rootless, cgroups v2, `crun`, senza `sudo`). Docker funziona con piccole modifiche: vedi la NOTA più sotto.
- Una shell utente (non `root`). Tutto in questo lab gira senza `sudo`.
- Accesso a Internet per scaricare l'immagine di base `docker.io/library/alpine:3.20.10` (circa 8 MB) e per scaricare un piccolo pacchetto (`procps-ng`) durante la build.
- Circa 30 MB di spazio su disco.
- [La lezione](lesson.it.md) di questo modulo.
> [!WARNING]
> Il lab è gratuito ed esegue solo container che avvii tu sulla tua macchina, come utente normale e senza `--privileged`. Ogni container si chiama `lab-virt-...`, e i comandi che rimuovono cose li nominano esplicitamente, così non toccano i tuoi altri container. Un passo fa usare a un container più memoria del suo limite di proposito; può danneggiare solo quel container, non la tua macchina. Il lab non cambia nulla sul tuo sistema al di fuori di una cartella (`~/virt-lab`) e di un'immagine locale, entrambe rimosse alla fine.
> [!NOTE]
> Gli output qui sotto sono stati catturati su Linux basato su Fedora a novembre 2026. ID, PID, numeri dei namespace, orari e nome dell'host saranno diversi sulla tua macchina; ciò che devi confrontare è la struttura e i valori che derivano dai tuoi comandi (come `67108864`).
>
> **Docker:** sostituisci `podman` con `docker`; il nome `Containerfile` resta valido (`docker build -f Containerfile` se la tua versione non lo trova). Due differenze: con il Docker predefinito, che gira come root, i processi del container appartengono a `root`, quindi leggere `/proc/<pid>/ns` e il log OOM può richiedere `sudo`, e `podman top ... hpid huser` non ha un equivalente in Docker. Non è stato testato con Docker.
## Architettura
<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-it-title virt-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="virt-lab-architecture-it-title">Architettura del lab: un Containerfile, un'immagine, tre container rootless e il kernel dell'host</title>
<desc id="virt-lab-architecture-it-desc">Sulla tua macchina Linux, con Podman rootless e senza sudo, la cartella ~/virt-lab contiene un Containerfile e app.sh. Podman li compila nell'immagine localhost/lab-virt-hello:1.0, che ha tre livelli e pesa circa 9.4 MB. L'immagine di base proviene da un registry su Internet, docker.io/library/alpine, tag 3.20.10. L'immagine gira come tre container i cui nomi iniziano con lab-virt-: lab-virt-demo, che esegue sleep 3600 senza limiti; lab-virt-limited, con limite di CPU 0.5 e limite di memoria 64 MB; e lab-virt-oom, con un limite di memoria di 64 MB che alloca 200 MB e viene terminato. I container sono isolati e limitati dal kernel Linux dell'host, che ispezioni dall'host: /proc/<pid>/ns per i namespace, /sys/fs/cgroup per memory.max, cpu.max e pids.max, e il log del kernel per l'OOM killer e l'exit code 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">La tua macchina Linux: Podman rootless, senza 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">Container (nomi che iniziano con 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">Kernel Linux dell'host: ciò che ispezioni</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">Registry</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">Immagine</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 livelli · circa 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 · senza limiti</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 · alloca 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/<pid>/ns</text></g>
<text x="330" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">namespace visti dall'host</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">Log del kernel</text></g>
<text x="822" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">OOM killer: exit code 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="760.16" y="364" width="159.68" 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">isolati e limitati dal</text></g>
</svg></figure>
*Figura 1. Costruisci un'immagine da una cartella, la esegui come tre container e leggi che cosa ha fatto il kernel dell'host per isolarli e limitarli.*
## Passaggi
### Passo 1 — Controlla gli strumenti e crea una cartella di lavoro
Per prima cosa, controlla di avere Podman, che giri senza root e che il tuo sistema usi i cgroups v2. Tieni tutti i file del lab in una cartella così la pulizia è semplice.
```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
```
Output atteso (la versione può essere più recente; il runtime può essere `runc`):
```text
podman version 5.8.7
rootless=true cgroups=v2 runtime=crun
cgroup2fs
```
`cgroup2fs` significa che il file system cgroup v2 è montato in `/sys/fs/cgroup`. Se vedi `tmpfs`, il tuo sistema usa i cgroups v1 e i passi sui limiti non coincideranno; vedi Risoluzione dei problemi.
> [!WARNING]
> Esegui tutti i comandi seguenti da `~/virt-lab`, salvo diversa indicazione di un passo.
### Passo 2 — Scrivi l'applicazione e il Containerfile
L'applicazione è un minuscolo script di shell. Il `Containerfile` elenca i passi di build; ogni passo che cambia file aggiunge un livello. Fissa l'immagine di base a un tag di versione esatto (`3.20.10`), non a `latest`, così la build è ripetibile.
```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
```
Che cosa fa ogni riga:
- `FROM` sceglie l'immagine di base e i suoi livelli.
- `LABEL` aggiunge metadati alla configurazione dell'immagine (nessun nuovo livello).
- `RUN` esegue un comando in un container temporaneo e conserva le modifiche ai file come un nuovo livello.
- `COPY` aggiunge un file dalla tua cartella come un nuovo livello.
- `CMD` imposta il comando predefinito (solo metadati).
> [!NOTE]
> La riga `RUN` serve a dare all'immagine un livello che puoi vedere. Per essa durante la build serve l'accesso alla rete.
### Passo 3 — Compila l'immagine
```bash
podman build -t lab-virt-hello:1.0 .
```
`-t` dà all'immagine il nome `lab-virt-hello` con il tag `1.0`, e `.` è il contesto di build (questa cartella).
Output atteso (gli ID differiscono; le righe di download di `apk` sono tagliate):
```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 prima volta, Podman stampa anche `Trying to pull docker.io/library/alpine:3.20.10...` e le righe di download dei blob. Controlla l'immagine:
```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
```
### Passo 4 — Ispeziona i livelli
`podman history` elenca una riga per istruzione di build, con la dimensione del livello aggiunto.
```bash
podman history lab-virt-hello:1.0
```
Output atteso (tagliato per farlo stare; orari e ID differiscono):
```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...
```
Leggilo dal basso: il file system root dell'immagine di base (8.09 MB), il tuo `RUN` (1.27 MB), il tuo `COPY` (3.58 kB). `CMD` e `LABEL` sono 0 B: cambiano solo la configurazione. Ora chiedi direttamente i livelli e il formato:
```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}}'
```
Output atteso (il primo livello, Alpine, è uguale sulla tua macchina; gli altri due differiscono, perché il loro contenuto include gli orari di build):
```text
Layers: 3 Cmd: [/usr/local/bin/app.sh] Format: application/vnd.oci.image.manifest.v1+json
sha256:08bc4e534116aa76b16015484b82eac51f9a593416feae9296c8a2d4bb7aa4a2
sha256:f55ed2bae43c665dab4e7586118f8ad3e837d47e4f580dbc8c6ae63b55ac8f5e
sha256:df259c8f1ca6356b3feac01c6d60efbe8439114afa5442ddbcfba2f5286d92c7
```
Tre livelli (la base, `RUN`, `COPY`), ciascuno nominato dal digest SHA-256 del suo contenuto, e un'immagine nel formato di immagine OCI (`application/vnd.oci.image.manifest.v1+json`).
> [!NOTE]
> I digest qui sopra sono gli ID di contenuto non compresso (`diff_id` nella configurazione dell'immagine). I digest dei livelli compressi nel manifest, che un registry usa, sono valori diversi.
### Passo 5 — Esegui il container
Eseguilo una volta in primo piano. `--rm` elimina il container quando termina, e `--name` segue la regola `lab-virt-`.
```bash
podman run --rm --name lab-virt-hello lab-virt-hello:1.0
```
Output atteso (l'hostname sono i primi 12 caratteri dell'ID del container, quindi il tuo differisce):
```text
Hello from 5088d1aeb13f, running as root (PID 1)
```
Nota tre cose: l'hostname non è quello del tuo computer (namespace uts), lo script è il **PID 1** (namespace pid) e l'utente è `root` (un namespace user, come vedrai nel Passo 7).
### Passo 6 — Confronta la vista del container con quella dell'host
Questa volta avvia un container che resti in esecuzione, così puoi osservarlo da entrambi i lati.
```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}}'
```
Output atteso (la prima riga è l'ID completo del container):
```text
9f26995a174db194e15e4322e83b28bdfb0928df0ed9f5be2a803f0607cc6b50
NAMES STATUS COMMAND
lab-virt-demo Up Less than a second sleep 3600
```
Chiedi a Podman i processi del container, con la vista dell'host accanto a quella del container:
```bash
podman top lab-virt-demo user pid hpid huser comm
```
```text
USER PID HPID HUSER COMMAND
root 1 41390 1000 sleep
```
`PID` è il numero dentro il container (1); `HPID` è il PID dello stesso processo sull'host (qui 41390, il tuo differisce); `USER` è `root` dentro, e `HUSER` è `1000` sull'host: il tuo ID utente. Il «root» del container sei tu. Ora confronta le viste con comandi eseguiti dentro e fuori:
```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
```
Output atteso:
```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
```
Dentro vedi un hostname diverso e solo due processi (`sleep` come PID 1 e il `ps` che hai appena avviato), mentre l'host ne ha centinaia. Ma `uname -r` stampa **la stessa versione del kernel**: non c'è un kernel guest, il container condivide quello dell'host. Questa è la differenza principale rispetto a una VM.
### Passo 7 — Guarda i namespace dall'host
Ogni processo ha un link per namespace in `/proc/<pid>/ns/`. Due processi sono nello stesso namespace quando il numero nel link è lo stesso. Confronta la tua shell con il `sleep` del container, usando il suo PID sull'host:
```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
```
Output atteso (i numeri differiscono sulla tua macchina; confrontali a coppie):
```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]
```
Sette namespace sono diversi. Il namespace `time` è lo stesso: i container non ne hanno uno proprio per impostazione predefinita. Se `lsns` è installato (pacchetto `util-linux`), elenca le stesse informazioni:
```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 prima riga è il namespace `time` che condividi con l'host (il `COMMAND` mostrato è solo il processo più vecchio al suo interno). La riga `user` ha più di un processo: Podman rootless mantiene un solo namespace user per tutti i tuoi container, tenuto da un piccolo helper (`catatonit`).
Ora il namespace user. Dentro il container sei l'UID 0. Quale utente pensa di essere l'host, e com'è fatta la mappatura?
```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
```
Leggi ogni riga di `uid_map` come `<primo UID dentro> <primo UID fuori> <quanti>`: l'UID 0 del container è l'UID 1000 dell'host (tu; un conteggio di 1), e gli UID da 1 a 65536 del container sono mappati su un intervallo di UID riservato a te in `/etc/subuid`. Il processo sull'host appartiene al tuo nome utente (`user` qui; il tuo sarà diverso). Un bug che permettesse al processo di evadere troverebbe solo i tuoi diritti, non quelli di root.
### Passo 8 — Imposta i limiti e leggili nel cgroup
Avvia un secondo container con un limite di mezza CPU e 64 MB di memoria:
```bash
podman run -d --name lab-virt-limited --cpus 0.5 --memory 64m lab-virt-hello:1.0 sleep 3600
```
Il cgroup del container è una directory sotto `/sys/fs/cgroup`. Trovala a partire dal PID dell'host e leggi i file dei limiti:
```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
```
Output atteso (l'ID del container nel percorso differisce, abbreviato qui come `<id>`; `memory.current` varia):
```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` è `67108864`: 64 × 1024 × 1024 byte, da `--memory 64m`.
- `cpu.max` è `50000 100000`: 50.000 µs di tempo CPU in ogni periodo di 100.000 µs, cioè 0.5 CPU, da `--cpus 0.5`.
- `pids.max` è un valore predefinito impostato da Podman (2048 qui; il tuo può differire).
Confronta con il container senza limiti, `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` significa «nessun limite». Il container può anche leggere i propri limiti, perché ha il proprio namespace cgroup, in cui il suo cgroup appare come la radice:
```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
```
### Passo 9 — Osserva il limite di CPU rallentare un container occupato
Avvia un ciclo infinito dentro il container limitato. Senza limite userebbe una CPU intera; con `--cpus 0.5` dovrebbe ottenerne circa la metà.
```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
```
Output atteso (le percentuali e i contatori variano):
```text
NAME CPU % MEM USAGE / LIMIT
lab-virt-limited 48.63% 450.6kB / 67.11MB
nr_periods 83
nr_throttled 78
throttled_usec 3373263
```
Il ciclo vorrebbe il 100% di una CPU ma ne ottiene circa il 50%. `nr_throttled` conta i periodi in cui il cgroup ha esaurito la quota ed è stato messo in pausa fino al periodo successivo: quasi tutti (78 su 83). CPU oltre il limite significa **più lento**, non terminato.
Rimuovi i due container. `sleep` come PID 1 ignora il segnale di stop (`SIGTERM`), quindi `-t 0` salta l'attesa di 10 secondi:
```bash
podman rm -f -t 0 lab-virt-limited lab-virt-demo
```
```text
lab-virt-demo
lab-virt-limited
```
### Passo 10 — Provoca di proposito una terminazione per OOM
Ora dai 64 MB a un container e chiedi alla sua shell di tenere in memoria una stringa da 200 MB. Il comando `head -c 200000000 /dev/zero | tr "\0" a` produce 200 MB della lettera `a`, e la shell li tiene tutti nella variabile `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: $?"
```
Output atteso:
```text
exit code: 137
```
Non c'è la riga «allocated»: la shell è stata terminata prima di poterla stampare. Il nome non ha `--rm`, così puoi ispezionare il container fermato. L'exit code 137 è 128 + 9, cioè `SIGKILL`. Ma è stato l'OOM killer? Chiedi al motore:
```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` conferma che l'OOM killer del cgroup di memoria lo ha fermato. Il log del kernel dà i dettagli:
```bash
journalctl -k --since "-2min" --no-pager | grep "Memory cgroup out of memory"
```
Output atteso (abbreviato; PID e dimensioni variano):
```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
```
Il processo usava circa 62 MB di memoria residente (`anon-rss`) quando ha raggiunto il limite di 64 MB, ed è allora che è stato terminato.
> [!NOTE]
> Leggere il log del kernel richiede l'accesso al journal: su molti sistemi un utente normale deve appartenere al gruppo `systemd-journal` (o `adm`), oppure usare `dmesg` se il sistema lo permette (`sysctl kernel.dmesg_restrict` è `0`). Senza accesso, `podman inspect` e l'exit code 137 bastano per completare il lab; la riga del kernel è una conferma.
> [!NOTE]
> Se il processo che esaurisce la memoria viene avviato con `podman exec` in un container il cui processo principale sta bene, viene terminato solo quel processo lanciato con `exec`: il container continua a girare e `OOMKilled` resta `false`. Il file `memory.events` del cgroup lo mostra comunque, come contatore `oom_kill 1`. Quando diagnostichi un riavvio o una terminazione, guarda `memory.events` oltre a `OOMKilled`.
Ora correggilo. Il lavoro ha bisogno di circa 200 MB, quindi alza il limite a 512 MB. Questa volta usa `--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
```
Lo stesso comando riesce quando il limite è adeguato al fabbisogno reale. La prima riga è l'output di `podman rm`, che stampa il nome del container rimosso.
## Verifica
Controlla ogni risultato. Tutto quanto segue deve essere vero:
- `podman history lab-virt-hello:1.0` mostra un livello di base di circa 8 MB, un livello `RUN` di circa 1 MB e un livello `COPY` di pochi kB; `CMD` e `LABEL` mostrano `0B`.
- Dentro un container, `hostname` differisce da quello dell'host, `ps` mostra `sleep` come PID 1 e `uname -r` è uguale alla versione del kernel dell'host.
- `readlink /proc/<pid>/ns/...` dà numeri diversi per `cgroup`, `ipc`, `mnt`, `net`, `pid`, `user` e `uts`, e lo stesso numero per `time`.
- `memory.max` è `67108864` e `cpu.max` è `50000 100000` per `lab-virt-limited`.
- L'esecuzione con OOM termina con `OOMKilled=true` e exit code 137, e il nuovo tentativo con `--memory 512m` termina con `allocated 200000000 bytes`.
Autoverifica rapida:
```bash
podman ps -a --filter name=lab-virt- --format '{{.Names}} {{.Status}}'
```
Dopo il Passo 10 questo non stampa nulla, perché l'ultimo container usava `--rm` e i precedenti sono stati rimossi.
## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `stat -fc %T /sys/fs/cgroup` stampa `tmpfs` | Il sistema usa i cgroups v1, dove i limiti rootless non sono supportati | Usa una distribuzione con cgroups v2 (Fedora, Ubuntu 22.04 o successiva, Debian 11 o successiva) o una VM. Podman avvisa: `Resource limits are not supported and ignored on cgroups V1 rootless systems`. |
| `podman run --cpus 0.5` fallisce o il file `cpu.max` resta a `max` | Il controller `cpu` non è delegato al tuo utente | Esegui `cat /sys/fs/cgroup/user.slice/user-$(id -u).slice/user@$(id -u).service/cgroup.controllers`; dovrebbe elencare `cpu`, `memory` e `pids`. Sui sistemi più vecchi un amministratore deve abilitare la delega (un drop-in di systemd con `Delegate=cpu cpuset io memory pids`). |
| `Error: pulling image ... connection refused` o timeout | Niente Internet o un proxy | Imposta la variabile `HTTPS_PROXY`, oppure scarica da un registry raggiungibile e cambia la riga `FROM`. |
| `apk add` fallisce durante la build | Il container non ha DNS o rete | Controlla che `podman run --rm docker.io/library/alpine:3.20.10 nslookup example.com` funzioni; controlla firewall e VPN. |
| `cannot clone: Operation not permitted` o errori di namespace user | Il rootless richiede voci in `/etc/subuid` e `/etc/subgid` e namespace user non privilegiati | `grep $USER /etc/subuid /etc/subgid`; un amministratore può aggiungerle (`usermod --add-subuids ...`). |
| Il container gira ma `OOMKilled` è `false` e l'exit code è 137 | Terminato per un altro motivo (per esempio il timeout di uno stop), o il limite di memoria non è stato applicato | Controlla `memory.max` nel cgroup; vedi il Passo 10. |
| Nessuna riga OOM in `journalctl -k` | Nessun permesso di leggere il log del kernel, o la voce è più vecchia della finestra `--since` | Vedi la NOTA del Passo 10; usa `--since "-10min"`. |
| `/proc/<pid>/ns` o il percorso del cgroup non esiste | Il container si è già fermato, o il PID è obsoleto | Esegui `podman ps` e rileggi il PID. |
| `Error: creating container storage: the container name "lab-virt-oom" is already in use` | È rimasto un container fermato con quel nome | `podman rm lab-virt-oom` |
## Sfida (facoltativa)
Usali senza istruzioni passo passo:
1. Avvia un container con `--pids-limit 20` e prova ad avviare più di 20 processi al suo interno (per esempio con un ciclo di shell che esegue `sleep 300 &`). Che errore ottieni, e quale file e contatore del cgroup sono cambiati? Rimuovi poi il container.
2. Avvia un container con `--uts=host`, poi con `--pid=host`, e confronta `hostname` e `ps` con quelli predefiniti. Quale isolamento hai tolto in ciascun caso? Perché raramente lo vorresti?
3. Ricostruisci l'immagine con `FROM docker.io/library/alpine:3.20.10@sha256:<digest>` (ottieni il digest con `podman image inspect docker.io/library/alpine:3.20.10 --format '{{.Digest}}'`). Che cosa garantisce il digest che il tag non garantisce?
## Pulizia
Rimuovi i container (i nomi sono espliciti, e `--ignore` salta quelli già spariti), l'immagine che hai costruito e la cartella del 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
```
Output atteso (gli ID differiscono; il primo comando stampa il nome di ogni container che rimuove, e nulla se non ne resta nessuno):
```text
Untagged: localhost/lab-virt-hello:1.0
Deleted: de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
Deleted: 964fed8bd61ca0b105dcbf80de33b5c8eb7bab12ab5f96fa46d4d98e2830587a
Deleted: c76c408b748b1e099ea7e4d5e1350499b7d405187fe91f6d497e686e4688fba6
Deleted: b1be2b84c1863941b122d42738aeef7356b81e3f2704e6db0b2faa6f099e28f3
```
Se hai scaricato l'immagine di base solo per questo lab, rimuovila. Salta questo passo se usi Alpine 3.20.10 per altro; Podman rifiuta di rimuovere un'immagine che un container sta ancora usando:
```bash
podman rmi docker.io/library/alpine:3.20.10
```
Controlla che non resti nulla:
```bash
podman ps -a --filter name=lab-virt-
podman images lab-virt-hello
ls ~/virt-lab
```
I primi due comandi stampano solo le righe di intestazione (o nulla), e `ls` segnala che la cartella non esiste.
## Cosa hai imparato
- Un `Containerfile` diventa un'immagine OCI fatta di livelli: ogni `RUN` e `COPY` ne aggiunge uno, e `CMD` e `LABEL` aggiungono solo metadati. Fissare l'immagine di base a un tag esatto mantiene le build ripetibili.
- Un container è un normale processo dell'host: `podman top` mostra il suo PID sull'host, `/proc/<pid>/ns` mostra che sta nei propri namespace pid, net, mnt, uts, ipc, user e cgroup, e `uname -r` mostra che condivide il kernel dell'host.
- In un container rootless, il root all'interno è il tuo utente senza privilegi all'esterno, grazie alla mappatura del namespace user.
- `--memory` e `--cpus` diventano `memory.max` e `cpu.max` nel cgroup del container; superare il limite di CPU rallenta, e superare il limite di memoria invoca l'OOM killer.
- L'exit code 137 significa `SIGKILL`; `OOMKilled=true`, la riga del log del kernel e `memory.events` ti dicono se è stato l'OOM killer, e la soluzione è capire il fabbisogno reale di memoria, non solo alzare il limite.