---
title: "Virtualizzazione e container: due modi di condividere una stessa macchina"
domain: cloud-computing
level: beginner
duration: "50 min"
objectives:
  - "Spiegare come funziona la virtualizzazione hardware e confrontare gli hypervisor di tipo 1 e di tipo 2."
  - "Confrontare macchine virtuali e container per isolamento, tempo di avvio, densità e overhead."
  - "Spiegare come i namespace e i gruppi di controllo (cgroup) di Linux isolano e limitano un container."
  - "Costruire un'immagine di container e spiegarne i livelli e i formati della Open Container Initiative (OCI)."
  - "Configurare i limiti di risorse di un container e diagnosticare un container fermato per aver superato la memoria."
lang: it
source_hash: 4bf9ebf7179f
---

# Virtualizzazione e container: due modi di condividere una stessa macchina

## Perché è importante
Avvii un server «piccolo» nel cloud ed è pronto in meno di un minuto. Dietro quel pulsante, il provider non ha cablato un nuovo computer per te. Ha ritagliato una fetta di una macchina molto più grande, e decine di altri clienti condividono lo stesso hardware. Due tecniche rendono possibile questa condivisione: la **virtualizzazione**, che dà a ogni cliente un computer finto completo, e i **container**, che danno a ogni applicazione la propria vista privata di un unico sistema operativo condiviso.

La scelta conta ogni giorno. Una macchina virtuale (VM) è un muro robusto ma pesante. Un container è leggero e veloce ma condivide il kernel del suo host, quindi il muro è più sottile. Un container che si mangia tutta la memoria può essere terminato nel mezzo di una richiesta, e un container avviato come root con le opzioni sbagliate può mettere a rischio l'intero host. Per scegliere lo strumento giusto, dimensionarlo correttamente ed eseguirlo in sicurezza, devi sapere che cosa è davvero ciascuno e che cosa separa realmente un container dalla macchina su cui gira. Questa lezione spiega entrambe le cose.

## Obiettivi di apprendimento
- Spiegare come funziona la virtualizzazione hardware e confrontare gli hypervisor di tipo 1 e di tipo 2.
- Confrontare macchine virtuali e container per isolamento, tempo di avvio, densità e overhead.
- Spiegare come i namespace e i gruppi di controllo (cgroup) di Linux isolano e limitano un container.
- Costruire un'immagine di container e spiegarne i livelli e i formati della Open Container Initiative (OCI).
- Configurare i limiti di risorse di un container e diagnosticare un container fermato per aver superato la memoria.

## Concetti chiave

### Virtualizzazione hardware e hypervisor
Pensa a un grande edificio di uffici. Un'opzione è affittare a ogni azienda un piano con le sue pareti, porte e tubature. Un'altra è affittare scrivanie in un unico piano open space condiviso, separate da pannelli. La prima è la virtualizzazione: ogni inquilino riceve un intero «edificio» tutto per sé. La seconda, che arriva più avanti in questa lezione, sono i container.

**Virtualizzazione** significa eseguire più computer virtuali isolati su un unico computer fisico, l'**host**. Ogni computer virtuale è una **macchina virtuale (VM)**, detta anche **guest**. Un guest ha le proprie CPU virtuali, memoria, disco e schede di rete, ed esegue un proprio sistema operativo (SO) completo con un proprio **kernel**, il nucleo del SO che dialoga con l'hardware. Il guest crede di possedere hardware reale.

Il software che crea ed esegue le VM è l'**hypervisor**, o monitor di macchine virtuali (VMM, *virtual machine monitor*). Ha tre compiti:
- **Condividere l'hardware.** Pianifica le CPU virtuali di tutti i guest sui core reali della CPU e dà a ogni guest la propria fetta di memoria reale.
- **Isolare i guest.** Un guest non può leggere la memoria di un altro guest né prendere il controllo dell'host, perché l'hypervisor controlla che cosa ciascuno può toccare.
- **Presentare dispositivi virtuali.** Il guest vede un disco virtuale e una scheda di rete virtuale, che l'hypervisor associa a file, storage e porte di rete reali.

La prima virtualizzazione era lenta perché il kernel di un guest si aspetta di girare nella modalità più privilegiata della CPU, e solo un kernel può occuparla. Trucchi software (tradurre o intercettare le istruzioni privilegiate) la fecero funzionare, ma costavano prestazioni. Le CPU moderne hanno risolto il problema con la **virtualizzazione assistita dall'hardware**: **Intel VT-x** e **AMD-V** (flag `vmx` e `svm` in `/proc/cpuinfo` su Linux). Aggiungono una nuova modalità di CPU per i guest: il kernel guest gira con pieni privilegi, ma in una modalità in cui la CPU restituisce il controllo all'hypervisor, il cosiddetto **VM exit**, ogni volta che il guest fa qualcosa che deve essere controllato, come toccare un dispositivo. Altre estensioni accelerano la memoria (traduzione degli indirizzi di secondo livello, chiamata EPT su Intel e NPT su AMD) e permettono a un hypervisor di dare a un guest un accesso diretto e sicuro a un dispositivo (una unità di gestione della memoria di input-output, IOMMU: Intel VT-d, AMD-Vi). Sulla maggior parte dei computer queste funzioni possono essere disattivate nelle impostazioni del firmware, ed è per questo che un hypervisor a volte segnala che la virtualizzazione non è disponibile.

Un guest può anche andare più veloce quando sa di essere virtuale. I driver **paravirtualizzati**, come la famiglia `virtio` usata da KVM, sostituiscono un finto disco o una finta scheda di rete «reali» con una semplice interfaccia pensata per le macchine virtuali.

Gli hypervisor esistono in due progetti:

| | Tipo 1 (bare metal) | Tipo 2 (hosted) |
|---|---|---|
| **Gira** | Direttamente sull'hardware | Come applicazione su un normale SO host |
| **Esempi** | KVM, Xen, VMware ESXi, Microsoft Hyper-V | Oracle VirtualBox, VMware Workstation, Parallels Desktop |
| **Livelli** tra un guest e l'hardware | Hypervisor | Applicazione hypervisor, poi SO host |
| **Overhead e controllo** | Overhead minore, controllo diretto dell'hardware | Più overhead, il SO host resta al comando dell'hardware |
| **Uso tipico** | Data center e cloud pubblici | Portatili, macchine di sviluppo, test |

![Due stack disegnati dall'hardware verso l'alto. Tipo 1, bare metal, con gli esempi KVM, Xen, ESXi e Hyper-V: l'hardware (CPU con VT-x o AMD-V, RAM, dischi, schede di rete) sostiene direttamente l'hypervisor e, sopra, tre macchine virtuali, ciascuna con il proprio sistema operativo guest e kernel e un'applicazione. Una nota dice che ha meno livelli e meno overhead ed è la scelta abituale nei data center e nei cloud. Tipo 2, hosted, con gli esempi VirtualBox, VMware Workstation e Parallels: l'hardware sostiene un sistema operativo host come Windows, macOS o Linux; sull'host gira un'applicazione hypervisor, che chiede CPU, memoria e disco al SO host, accanto ad altre app; l'applicazione hypervisor sostiene tre macchine virtuali con SO guest e applicazione. Una nota dice che ha un livello in più ma è facile da installare su un portatile.](../../../assets/diagrams/virt-hypervisor-types.it.svg)

*Figura 1. Un hypervisor di tipo 1 sta direttamente sull'hardware; un hypervisor di tipo 2 è un'applicazione in più sopra un sistema operativo host.*

> [!NOTE]
> Il confine tra i due tipi è sfumato, e gli esempi sopra sono solo esempi. KVM è un modulo dentro il kernel Linux: trasforma Linux stesso in un hypervisor, con un programma come QEMU che fornisce i dispositivi virtuali, quindi di solito viene contato come tipo 1 anche se Linux è anche un SO generico. Hyper-V si installa sopra Windows, ma poi gira sotto di esso, e Windows diventa una VM speciale. Ciò che conta è quanto c'è tra il guest e l'hardware, non l'etichetta.

> [!CHECK]
> Perché le CPU moderne hanno estensioni come Intel VT-x e AMD-V?
>
> - [ ] Permettono a una VM guest di aggirare l'hypervisor e usare i dispositivi fisici senza alcun controllo
> - [x] Danno ai kernel guest una modalità sicura in cui la maggior parte delle istruzioni gira direttamente sulla CPU e l'hypervisor riprende il controllo solo quando serve
> - [ ] Permettono a più VM di condividere un kernel, il che le rende leggere quanto i container
> - [ ] Cifrano il disco di ogni VM in modo che l'host non possa leggerlo
>
> Con l'assistenza hardware il guest esegue il proprio kernel a piena velocità e la CPU passa all'hypervisor solo con un VM exit. Questo elimina gran parte della lenta traduzione software di cui avevano bisogno i vecchi hypervisor. Non elimina il controllo dell'hypervisor.

### Macchine virtuali e container a confronto
Una VM virtualizza l'**hardware**: ogni guest porta il proprio kernel. Un **container** virtualizza il **sistema operativo**: è un normale processo (o gruppo di processi) sull'host, avviato con una vista ristretta del sistema. Tutti i container di un host condividono l'unico kernel dell'host. Non c'è un SO guest da avviare, né hardware virtuale, né un hypervisor sul percorso.

![A sinistra, le macchine virtuali: l'hardware sostiene un hypervisor, che sostiene tre macchine virtuali, ciascuna con il proprio kernel guest, librerie e app. Etichette: kernel proprio per ogni VM, confine a livello hardware. Fatti: parte in secondi o minuti perché avvia un sistema operativo, di solito gigabyte per immagine, meno per host. A destra, i container: l'hardware sostiene un sistema operativo host con un solo kernel condiviso, i cui namespace e cgroup isolano ogni container; sopra, un runtime dei container come Podman o containerd con runc o crun esegue tre container, ciascuno con le sole librerie e la propria app. Etichette: un solo kernel condiviso, confine a livello kernel. Fatti: parte in millisecondi o secondi, di solito megabyte per immagine, molti di più per host.](../../../assets/diagrams/virt-vm-vs-container.it.svg)

*Figura 2. Ogni VM porta il proprio kernel guest; tutti i container condividono il kernel dell'host, quindi un container contiene solo l'applicazione e le sue librerie.*

Questa singola differenza spiega ogni riga del confronto:

| | Macchina virtuale | Container |
|---|---|---|
| **Che cosa è virtualizzato** | L'hardware | La vista del SO (processi, rete, file) |
| **Kernel** | Uno per VM | Condiviso con l'host e con gli altri container |
| **Confine di isolamento** | Hypervisor ed estensioni di virtualizzazione della CPU | Funzioni del kernel: namespace, cgroup, capability, seccomp |
| **Robustezza dell'isolamento** | Forte: la superficie di attacco è l'hypervisor | Più debole: la superficie di attacco è l'intero kernel condiviso |
| **Tempo di avvio** | Da secondi a minuti (avvia un SO) | Da millisecondi a pochi secondi (avvia un processo) |
| **Dimensione tipica dell'immagine** | Gigabyte (un SO completo) | Megabyte (app e librerie) |
| **Overhead** | Un SO guest per VM: memoria, disco, CPU per i servizi in background | Vicino a quello di un normale processo |
| **Densità** | Meno per host (decine) | Molti di più per host (centinaia) |
| **SO guest** | Qualsiasi cosa l'hardware possa eseguire: Linux, Windows, BSD | Lo stesso tipo di kernel dell'host: i container Linux hanno bisogno di un kernel Linux |
| **Uso tipico** | Sistemi operativi diversi, forte separazione tra tenant, software legacy | Microservizi, scalabilità rapida, deployment ripetibile |

I numeri della tabella sono ordini di grandezza tipici, non garanzie; dipendono dal carico di lavoro e dalla piattaforma.

Vale la pena ricordare due conseguenze pratiche:
- **I container su Windows o macOS** usano una VM Linux nascosta, perché quei sistemi non hanno un kernel Linux da condividere. Lo strumento per container del tuo portatile è una VM più dei container.
- **I sistemi reali mescolano entrambi.** I cloud pubblici eseguono i tuoi container dentro VM, così un bug del kernel nel container di un cliente non raggiunge un altro cliente. Esistono opzioni leggere tra i due: le **microVM** (come Firecracker) danno a ogni carico di lavoro una VM minuscola che si avvia in fretta, e i runtime con sandbox (come gVisor e Kata Containers) aggiungono uno strato di isolamento extra attorno ai container.

> [!CHECK]
> Devi eseguire un'applicazione Windows e un'applicazione Linux sullo stesso server, con forte separazione tra loro. Qual è la soluzione migliore?
>
> - [ ] Due container, perché i container si avviano più in fretta delle VM
> - [ ] Un container Linux per entrambe, perché i container possono eseguire qualsiasi applicazione
> - [x] Due VM, ciascuna con il proprio SO guest
> - [ ] Un hypervisor di tipo 2, perché non ha bisogno di un SO host
>
> I container condividono il kernel dell'host, quindi un host Linux può eseguire solo container Linux. Le VM portano il proprio kernel, quindi ciascuna può eseguire un SO diverso. Un hypervisor di tipo 2 ha invece bisogno di un SO host.

### Namespace Linux: che cosa può vedere un container
Come può un normale processo credere di essere solo su una macchina? Il kernel Linux può dare a un processo una propria copia privata di una risorsa di sistema. Ogni tipo di copia privata è un **namespace** (spazio dei nomi). Un processo vive in un namespace di ciascun tipo, e i processi dello stesso namespace vedono la stessa cosa. I namespace alla base di un container sono:

| Namespace | Isola | Effetto dentro un container |
|---|---|---|
| **pid** | ID dei processi | Il primo processo è il PID 1 e il container vede solo i propri processi. |
| **net** | Interfacce di rete, rotte, regole firewall, porte | La propria interfaccia di rete e il proprio indirizzo IP, e i propri numeri di porta. |
| **mnt** | Punti di mount | Il proprio file system root (l'immagine) invece di quello dell'host. |
| **uts** | Hostname e nome di dominio | Il proprio hostname. |
| **ipc** | Memoria condivisa e code di messaggi | I processi non possono usare la memoria condivisa di un altro container. |
| **user** | ID di utente e di gruppo | Root (UID 0) all'interno può corrispondere a un normale utente senza privilegi sull'host. |
| **cgroup** | La vista dell'albero dei cgroup | Il container vede il proprio cgroup come la radice dell'albero. |

I kernel più recenti hanno anche un namespace **time**, che i container non usano per impostazione predefinita. Un processo di norma parte nei namespace dell'host; un runtime di container ne crea di nuovi con le chiamate di sistema `clone()` e `unshare()`, come descritto in `namespaces(7)`. Puoi vedere in quali namespace si trova un processo come link in `/proc/<pid>/ns/`: due processi condividono un namespace quando il numero nel link è lo stesso.

I namespace danno **isolamento della vista**, non **limiti**. Un processo nel proprio namespace pid non può vedere altri processi, ma può comunque usare tutta la CPU e tutta la memoria. Di questo si occupa il meccanismo successivo.

### Gruppi di controllo (cgroup): che cosa può usare un container
Un **gruppo di controllo (cgroup)** è una funzione del kernel che raggruppa processi e controlla quanta parte della macchina possono usare. Linux moderno usa i **cgroup versione 2 (v2)**, con una **gerarchia unificata** montata in `/sys/fs/cgroup`. Ogni gruppo è una directory, e i suoi limiti si leggono e si impostano leggendo e scrivendo file al suo interno. Ogni file appartiene a un **controller**:

| File | Controller | Significato |
|---|---|---|
| `memory.max` | memory | Limite rigido di memoria in byte (o `max` per nessuno). Oltre, il kernel prima recupera memoria e poi attiva l'OOM killer dentro il gruppo. |
| `memory.high` | memory | Limite morbido: oltre, il gruppo viene rallentato dal recupero di memoria ma non terminato. |
| `memory.current`, `memory.events` | memory | Uso corrente e contatori, come quante volte è avvenuto `oom_kill`. |
| `cpu.max` | cpu | Una quota e un periodo in microsecondi: `50000 100000` significa «50 ms di CPU ogni 100 ms», ovvero mezza CPU. `max 100000` significa nessun limite. |
| `cpu.weight` | cpu | Quota relativa quando le CPU sono occupate (predefinito 100). |
| `pids.max` | pids | Massimo di processi e thread nel gruppo: una protezione contro le fork bomb. |
| `io.max` | io | Limiti di banda del disco e di operazioni al secondo per dispositivo. |

![Un processo di container, sleep 3600, è il PID 1 dentro il suo container e un normale PID dell'host fuori. Da esso partono due frecce. A sinistra, i namespace decidono ciò che può vedere: pid, il proprio albero dei processi; net, proprie interfacce, rotte e porte; mnt, propria tabella dei mount e file system root; uts, proprio hostname; ipc, propria memoria condivisa e code; user, root dentro corrisponde a un utente senza privilegi; cgroup, propria vista dell'albero dei cgroup. A destra, i cgroup versione 2 decidono ciò che può usare: memory.max, un limite di RAM oltre il quale interviene l'OOM killer; cpu.max, una quota CPU come 50000 100000, mezza CPU; pids.max, il massimo di processi; io.max, limiti del disco. Una nota dice che sono funzioni del kernel, non un hypervisor: il processo gira direttamente sul kernel dell'host.](../../../assets/diagrams/virt-namespaces-cgroups.it.svg)

*Figura 3. I namespace limitano ciò che un container può vedere; i cgroup limitano ciò che può usare. Insieme alle altre funzioni di sicurezza del kernel, è questo un «container».*

Quindi un container non è una cosa che il kernel conosca. È un normale processo, avviato dentro un insieme di namespace e un cgroup, con un file system root diverso. Per questo parte in millisecondi e ha quasi zero overhead. È anche il motivo per cui l'isolamento è robusto solo quanto il kernel.

Superare i limiti si comporta in modo diverso per ogni risorsa:
- La **CPU** è *comprimibile*: un gruppo che esaurisce la quota viene **rallentato** (*throttled*, messo in pausa fino al periodo successivo), non terminato.
- La **memoria** *non* lo è: se un gruppo ha bisogno di più di `memory.max` e il kernel non riesce a recuperarne abbastanza (per esempio scartando la cache dei file), l'**OOM killer** (out-of-memory, memoria esaurita) sceglie un processo di quel gruppo e gli invia `SIGKILL`.

> [!CHECK]
> Un container gira con un limite di CPU di 0.5 CPU e un limite di memoria di 256 MB. Continua a provare a usare una CPU intera e 300 MB. Che cosa succede?
>
> - [ ] Il kernel ferma subito il container, perché ha provato a superare un limite
> - [ ] Entrambi i limiti si limitano a rallentare il container; non viene mai terminato
> - [x] L'uso della CPU viene rallentato a circa mezza CPU, e l'uso della memoria attiva l'OOM killer
> - [ ] I limiti sono solo suggerimenti per lo scheduler; il container ottiene ciò che gli serve
>
> La CPU è comprimibile, quindi il cgroup la rallenta. La memoria non si può togliere a un processo in esecuzione, quindi oltre `memory.max` l'OOM killer termina un processo del gruppo.

### Immagini di container, livelli e formati OCI
Un container parte da un'**immagine**: un pacchetto di sola lettura che contiene un file system root più metadati (quale comando eseguire, variabili d'ambiente, l'utente). L'immagine è un modello; il **container** in esecuzione ne è un'istanza. Pensa a una classe e un oggetto, o a una ricetta e un piatto.

Per rendere le immagini piccole e rapide da condividere, un'immagine è costruita a **livelli**. Ogni istruzione di un file di build (un `Containerfile`, o `Dockerfile` in Docker) che modifica il file system, come `RUN` e `COPY`, aggiunge un livello: un archivio compresso che contiene solo i file cambiati. Le istruzioni che cambiano solo i metadati, come `CMD` e `LABEL`, non aggiungono alcun livello. I livelli sono **indirizzati per contenuto**: ciascuno è nominato dal **digest** del suo contenuto, `sha256:` seguito da 64 cifre esadecimali. I livelli identici vengono memorizzati una sola volta e condivisi, quindi dieci immagini basate sulla stessa immagine di base conservano quella base su disco una volta sola, e scaricare un'immagine aggiornata scarica solo i livelli cambiati.

Quando avvii un container, il runtime impila i livelli dell'immagine con un file system a unione (di solito **overlayfs**) e aggiunge in cima un sottile **livello scrivibile**, così il container vede un unico file system. Funziona con il **copy-on-write** (copia alla scrittura): un livello inferiore non viene mai modificato. Se il container modifica un file che si trova in un livello inferiore, il file viene prima copiato in alto nel livello scrivibile e modificato lì; se ne cancella uno, un marcatore (un «whiteout») lo nasconde. Quando il container viene rimosso, il suo livello scrivibile se ne va con lui. Tutto ciò che deve sopravvivere al container va in un **volume**, una directory memorizzata fuori dal container.

![A sinistra, l'immagine lab-virt-hello:1.0 come tre livelli di sola lettura impilati e condivisi da ogni container: livello 1, il file system root di Alpine da alpine:3.20.10, 8.09 MB; livello 2, RUN apk add procps-ng, 1.27 MB; livello 3, COPY app.sh, 3.58 kB. Una nota dice che CMD e LABEL cambiano solo la configurazione dell'immagine e non aggiungono livelli. Sopra l'immagine ci sono due container, A e B, ciascuno con il proprio livello scrivibile copy-on-write, eliminato con il container. Una nota spiega che scrivere in un file di un livello inferiore lo copia prima in alto e che cancellarlo lascia un marcatore whiteout. A destra, il manifest dell'immagine elenca la config (l'ID dell'immagine) e i tre livelli con il loro digest sha256, e una scheda mette a confronto un tag, un nome che può spostarsi, con un digest, esattamente questo contenuto per sempre.](../../../assets/diagrams/virt-image-layers.it.svg)

*Figura 4. I livelli sono di sola lettura e condivisi; ogni container aggiunge solo un sottile livello scrivibile in cima. Le dimensioni provengono dall'immagine che costruisci nel lab.*

La **Open Container Initiative (OCI)**, un progetto neutrale rispetto ai fornitori sotto la Linux Foundation, definisce gli standard che permettono a strumenti di fornitori diversi di lavorare insieme. Per questo un'immagine costruita con Podman gira su Docker, containerd o un cluster Kubernetes, e viceversa. Le specifiche sono tre:

| Specifica | Definisce |
|---|---|
| **Specifica dell'immagine** | Il formato dell'immagine: un **manifest** (elenca la configurazione e i livelli per digest), una **configurazione** (comando, ambiente, cronologia) e gli archivi dei livelli. |
| **Specifica del runtime** | Come eseguire un'immagine decompressa: un file system root e un `config.json` che elenca i namespace, i limiti dei cgroup, i mount e le capability. **runc** è il runtime di riferimento; **crun** è un altro. |
| **Specifica di distribuzione** | L'API HTTP che un **registry** usa per inviare e scaricare immagini. |

Un **registry** memorizza e serve immagini (esempi: Docker Hub, Quay.io, GitHub Container Registry e i registry dei cloud pubblici). Un riferimento a un'immagine ha la forma `registry/repository:tag`, per esempio `docker.io/library/alpine:3.20.10`. Due modi di nominare un'immagine si comportano in modo molto diverso:
- Un **tag** (`3.20.10`, `latest`) è un'etichetta comoda per le persone che chi pubblica può **spostare** su un'altra immagine in qualsiasi momento. `latest` è solo il nome di un tag predefinito; non significa «la più recente».
- Un **digest** (`alpine@sha256:<64 cifre esadecimali>`) identifica un contenuto esatto. Non può mai puntare a qualcos'altro.

Per build ripetibili, fissa l'immagine di base a un tag di versione esatto (`alpine:3.20.10`, non `alpine` né `alpine:latest`), e fissa per digest dove ti serve la garanzia che il contenuto non sia cambiato.

> [!CHECK]
> Un `Containerfile` ha `FROM alpine:3.20.10`, poi `RUN apk add --no-cache curl`, poi `COPY app.sh /app.sh` e `CMD ["/app.sh"]`. Quanti nuovi livelli aggiunge la build sopra l'immagine di base?
>
> - [ ] Quattro, uno per istruzione
> - [x] Due: il `RUN` e il `COPY`
> - [ ] Uno, perché la build fonde tutto in un unico livello
> - [ ] Tre: `RUN`, `COPY` e `CMD`
>
> Solo le istruzioni che modificano il file system aggiungono un livello. `CMD` (come `LABEL`) cambia solo la configurazione dell'immagine, e `FROM` seleziona i livelli di base invece di aggiungerne uno.

### Eseguire container in sicurezza: modalità rootless, limiti e OOM killer
Per impostazione predefinita, molti motori di container girano come root. Se qualcosa evade dal container, atterra sull'host come root. Due funzioni riducono questo rischio.

I **container rootless** eseguono il motore e il container come utente normale. Con un **namespace user**, l'UID 0 *dentro* il container è mappato sul tuo UID senza privilegi *fuori*, e gli altri UID del container sono mappati su un intervallo di UID subordinati riservato a te in `/etc/subuid`. Il container pensa di essere root, ma sull'host ha solo i tuoi diritti. Podman rootless funziona così, e anche Docker supporta una modalità rootless. Podman non ha un demone centrale; ogni container è avviato dal processo dell'utente stesso. I compromessi: un container rootless non può fare ciò che richiede un vero root, come associarsi a porte sotto la 1024 per impostazione predefinita, caricare moduli del kernel o cambiare la rete dell'host, e la sua rete passa da un helper in user space (come `pasta` o `slirp4netns`), più lento di una configurazione di rete come root.

I **limiti di risorse** proteggono l'host e i vicini da un container fuori controllo. In Podman e Docker sono opzioni di `run`:

| Opzione | Imposta |
|---|---|
| `--memory 64m` | `memory.max` (Podman imposta anche `memory.swap.max` allo stesso valore) |
| `--cpus 0.5` | `cpu.max` (quota 50000 per periodo di 100000) |
| `--pids-limit 100` | `pids.max` |

Un container fermato dall'OOM killer termina con **exit code 137**, cioè 128 più il segnale 9 (`SIGKILL`). L'exit code 137 da solo non prova un evento di memoria esaurita: qualunque `SIGKILL` lo produce, per esempio quando `stop` va in timeout e il motore uccide il container. Per diagnosticarlo:
1. Controlla il motore: `podman inspect <nome> --format '{{.State.OOMKilled}}'` vale `true` quando è intervenuto l'OOM killer del cgroup.
2. Controlla il log del kernel (`journalctl -k` o `dmesg`) per la riga `Memory cgroup out of memory: Killed process ...`.
3. Controlla il `memory.events` del cgroup: il contatore `oom_kill`.
4. Correggi: scopri perché il processo ha bisogno di tanta memoria (una perdita, una cache grande o una stima di dimensione sbagliata), poi correggi il codice o alza il limite. Un limite troppo basso per il carico reale trasforma solo la lentezza in crash.

> [!CHECK]
> Un container è terminato con codice 137. `podman inspect` mostra `OOMKilled=false`. Qual è la spiegazione più probabile?
>
> - [ ] Il container ha usato troppa CPU ed è stato rallentato fino alla morte
> - [ ] Il kernel usa sempre 137 quando un container termina normalmente
> - [x] Un processo gli ha inviato `SIGKILL` per un altro motivo, per esempio il motore dopo il timeout di uno stop
> - [ ] L'immagine ha troppi livelli
>
> L'exit code 137 significa «terminato dal segnale 9». L'OOM killer è solo uno dei possibili mittenti. `OOMKilled=false` dice che non è stato il cgroup di memoria. I limiti di CPU rallentano, non uccidono mai.

## Come funziona
Ecco che cosa succede quando digiti `podman run --memory 64m alpine:3.20.10 sleep 3600` come utente normale:

1. **Risolvere l'immagine.** Il motore cerca `alpine:3.20.10` nello store locale. Se non c'è, chiede il manifest al registry (specifica di distribuzione), poi scarica la configurazione e ogni livello per digest, saltando quelli che ha già, e verifica ogni digest.
2. **Decomprimere i livelli.** Il runtime impila i livelli con overlayfs e aggiunge un nuovo livello scrivibile vuoto.
3. **Scrivere la configurazione del runtime.** Il motore produce un `config.json` del runtime OCI: il comando, i namespace da creare, i limiti dei cgroup (`memory.max` = 67108864), i mount e le capability da rimuovere.
4. **Creare il processo isolato.** Un runtime a basso livello (`crun` o `runc`) crea i namespace, mette il processo in una nuova directory di cgroup sotto `/sys/fs/cgroup`, applica i limiti, cambia il file system root, rimuove i privilegi ed esegue `exec` di `sleep 3600`. In modalità rootless un namespace user viene per primo, così i passi successivi sono permessi senza vero root.
5. **Eseguire.** Da qui in poi, `sleep` è un normale processo, pianificato dal kernel dell'host. È il PID 1 nel proprio namespace pid, e ha un normale PID sull'host.
6. **Fermare.** Quando il processo termina, il runtime rimuove i namespace e il cgroup. Quando il container viene rimosso, il suo livello scrivibile viene eliminato; l'immagine resta nello store.

L'avvio di una VM, al contrario, deve avviare l'hardware virtuale dell'hypervisor, eseguire il firmware, avviare un intero kernel e far partire i servizi di sistema prima ancora che la tua applicazione inizi. Questa è la differenza di tempo di avvio che hai visto nella tabella.

## Esempio pratico
Per prima cosa, controlla se la tua CPU supporta la virtualizzazione hardware e se Linux espone il dispositivo KVM (output di una macchina AMD; una macchina Intel mostra `vmx` e `VT-x`):

```bash
grep -o -m1 -w -E 'vmx|svm' /proc/cpuinfo
lscpu | grep -i virtualization
ls -l /dev/kvm
```

```text
svm
Virtualization:                          AMD-V
crw-rw-rw-. 1 root kvm 10, 232 Nov  7 19:11 /dev/kvm
```

Se `grep` non stampa nulla, o la CPU non ha le estensioni o sono disattivate nel firmware; dentro una VM, la virtualizzazione annidata deve essere abilitata dall'host.

Ora, come diventano valori di cgroup i limiti che passi a `podman run`?

| Chiedi | Il kernel memorizza | Calcolo |
|---|---|---|
| `--memory 64m` | `memory.max` = `67108864` | 64 × 1024 × 1024 byte |
| `--cpus 0.5` | `cpu.max` = `50000 100000` | 0.5 × periodo di 100.000 µs = 50.000 µs di CPU per periodo |
| `--pids-limit 20` | `pids.max` = `20` | il numero così com'è |

Infine, una diagnosi. Un team esegue un container con `--memory 64m` che costruisce in memoria una stringa da 200 MB. Muore dopo circa un secondo:

```text
$ podman inspect report-job --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}}'
OOMKilled=true ExitCode=137
```

```text
kernel: Memory cgroup out of memory: Killed process 18629 (sh) total-vm:136808kB, anon-rss:60812kB ...
```

`OOMKilled=true` più la riga del log del kernel provano che la causa era il limite di memoria: il processo aveva circa 60 MB residenti quando ha raggiunto il limite di 64 MB (che conta anche un po' di memoria del kernel). La correzione è elaborare i dati in streaming invece di tenerli tutti in memoria o, se servono davvero 200 MB, alzare il limite (per esempio `--memory 512m`) *e* verificare che l'host abbia quella memoria da dare. Riproduci questo caso esatto nel lab.

## Errori comuni
- **Trattare un container come una piccola VM.** Un container è un processo con una vista ristretta. Non ha un kernel proprio: `uname -r` all'interno mostra il kernel dell'host, e una vulnerabilità del kernel colpisce tutti i container dell'host.
- **Usare `latest` o un tag corto.** `alpine` e `latest` cambiano sotto i tuoi piedi, e una ricostruzione il mese prossimo può dare un'immagine diversa. Fissa un tag di versione esatto, o un digest.
- **Salvare dati nel livello scrivibile.** Scompare con il container. Usa un volume per i dati che devono sopravvivere.
- **Dimenticare che l'exit code 137 non è una diagnosi.** Significa «SIGKILL»; conferma la memoria esaurita con `OOMKilled` e il log del kernel prima di cambiare qualsiasi cosa.
- **Non impostare limiti.** Un container senza `--memory` può usare tutta la memoria dell'host, e l'OOM killer può allora scegliere un processo che appartiene a qualcun altro.
- **Leggere i «limiti» di CPU come riserve.** `--cpus 0.5` mette un tetto al container; non gli garantisce mezza CPU quando l'host è occupato. Usa i pesi (o le request dello scheduler in un orchestratore) per ottenere garanzie.
- **Eseguire come root dentro il container «perché funziona».** Aggiungi un `USER` non root nell'immagine e rimuovi ciò di cui l'app non ha bisogno.

## Considerazioni sulla sicurezza
Virtualizzazione e container sono strumenti di isolamento, e ognuno ha una diversa superficie di attacco. **NIST SP 800-125** tratta la sicurezza della virtualizzazione completa (hypervisor, guest e gestione), e **NIST SP 800-190**, l'Application Container Security Guide, tratta i container. Questa sezione segue la struttura di SP 800-190: immagini, registry, orchestratori, container e SO host.

**Robustezza dell'isolamento.** Una VM escape (un guest che evade attraverso un bug dell'hypervisor) è rara e grave, perché l'hypervisor è un'interfaccia piccola e ben testata. Una container escape ha un bersaglio più grande: l'intera interfaccia del kernel che tutti i container condividono. Bug del kernel e del runtime, come la falla di `runc` CVE-2019-5736, hanno permesso a un container di sovrascrivere il runtime dell'host. Per carichi di lavoro di tenant diversi che non si fidano l'uno dell'altro, usa VM o microVM, oppure circonda i container con runtime con sandbox.

**Immagini.** I rischi di SP 800-190 iniziano qui:
- *Vulnerabilità nell'immagine.* Un'immagine include un livello di SO e librerie che invecchiano. Ricostruisci regolarmente, analizza le immagini con uno scanner di vulnerabilità e mantienile piccole (un'immagine di base minima ha meno pacchetti da aggiornare).
- *Segreti incorporati.* Password, token e chiavi copiati in un livello ci restano per sempre, anche se un livello successivo cancella il file. Passa i segreti a runtime tramite un meccanismo per i segreti.
- *Immagini non attendibili o manomesse.* Usa immagini da fonti di cui ti fidi, fissa versioni o digest e verifica le firme (per esempio con `cosign` di Sigstore) dove il tuo registry lo supporta.

**Registry.** Usa TLS per ogni connessione, richiedi l'autenticazione, limita chi può fare push e rimuovi le immagini obsolete che mantengono disponibili vecchie vulnerabilità.

**Container e host.** I valori predefiniti del runtime già aiutano: un insieme ristretto di capability Linux, un profilo seccomp predefinito (un filtro sulle chiamate di sistema) e, sui sistemi della famiglia Fedora e della famiglia Debian, profili SELinux o AppArmor. Non disattivarli senza un buon motivo:
- Evita `--privileged`: rimuove quasi tutto l'isolamento. Evita `--cap-add` oltre il minimo.
- Non montare mai il socket del motore (`/var/run/docker.sock`) in un container: chi lo controlla controlla l'host.
- Non montare in un container i percorsi sensibili dell'host (`/`, `/etc`, `/proc`), e monta i volumi in sola lettura quando puoi (`:ro`). Usa `--read-only` per il file system root quando l'app lo permette.
- Preferisci motori **rootless** e un `USER` non root nell'immagine: così anche un'evasione riuscita atterra come utente normale.
- Imposta limiti di memoria, CPU e PID perché un container non affami gli altri.
- Esegui un SO host minimale, aggiornato regolarmente e dedicato ai container, perché ogni container ne condivide il kernel.

**Rete.** I container possono comunicare tra loro e con la rete per impostazione predefinita. Pubblica solo le porte che ti servono e fai il bind su `127.0.0.1` quando un servizio è a uso locale.

> [!IMPORTANT]
> Il lab esegue solo container che avvii tu stesso, sulla tua macchina, con nomi che iniziano con `lab-virt-`, senza root e senza `--privileged`. Non esercitarti con tecniche di evasione su host condivisi o su sistemi che non possiedi.

## Riepilogo
- La virtualizzazione hardware esegue sistemi operativi guest completi su un host; l'hypervisor condivide e isola l'hardware, e le estensioni della CPU (Intel VT-x, AMD-V) la rendono veloce. Gli hypervisor di tipo 1 girano sull'hardware, quelli di tipo 2 su un SO host.
- Una VM virtualizza l'hardware e ha il proprio kernel: isolamento forte, avvio più lento, più overhead. Un container virtualizza la vista del SO e condivide il kernel dell'host: veloce e denso, ma isolato solo quanto quel kernel.
- I namespace (pid, net, mnt, uts, ipc, user, cgroup) decidono ciò che un container può vedere; i cgroup v2 (`memory.max`, `cpu.max`, `pids.max`) decidono ciò che può usare. Un container è un normale processo dentro entrambi.
- Un'immagine è una pila di livelli di sola lettura indirizzati per contenuto più una configurazione; un container aggiunge un livello scrivibile copy-on-write. OCI standardizza i formati di immagine, runtime e distribuzione. I tag possono spostarsi, i digest no.
- La memoria oltre il limite attiva l'OOM killer (exit code 137, `OOMKilled=true`); la CPU oltre il limite viene solo rallentata. Esegui in rootless, imposta i limiti e segui NIST SP 800-190.

## Glossario
| Termine | Definizione |
|---|---|
| Virtualizzazione | Eseguire più computer virtuali isolati su un unico computer fisico. |
| Host | La macchina fisica (o il SO che vi gira) che esegue guest o container. |
| Guest | Una macchina virtuale e il sistema operativo che vi gira. |
| Macchina virtuale (VM) | Un computer definito dal software con CPU virtuali, memoria, dischi e schede di rete, che esegue un proprio SO e kernel. |
| Hypervisor | Software che crea ed esegue VM e condivide e isola l'hardware tra di esse; detto anche monitor di macchine virtuali (VMM). |
| Hypervisor di tipo 1 | Un hypervisor che gira direttamente sull'hardware (bare metal), per esempio KVM, Xen, ESXi, Hyper-V. |
| Hypervisor di tipo 2 | Un hypervisor che gira come applicazione su un SO host, per esempio VirtualBox, VMware Workstation. |
| Intel VT-x, AMD-V | Estensioni della CPU per la virtualizzazione assistita dall'hardware; flag `vmx` e `svm`. |
| VM exit | Il momento in cui la CPU smette di eseguire un guest e restituisce il controllo all'hypervisor. |
| EPT, NPT | Supporto hardware di Intel e AMD per tradurre gli indirizzi di memoria del guest in indirizzi reali (traduzione degli indirizzi di secondo livello). |
| IOMMU | Hardware che controlla e traduce l'accesso dei dispositivi alla memoria, usato per dare a un guest accesso diretto e sicuro a un dispositivo (Intel VT-d, AMD-Vi). |
| Paravirtualizzazione | Driver del guest pensati per l'hardware virtuale (per esempio virtio) più veloci del fingere di essere dispositivi reali. |
| Kernel | Il nucleo di un sistema operativo, che gestisce hardware, processi e memoria. |
| Container | Un processo, o gruppo di processi, che gira sul kernel dell'host con propri namespace, cgroup e file system root. |
| Namespace | Una funzione del kernel che dà ai processi una vista privata di una risorsa (pid, net, mnt, uts, ipc, user, cgroup, time). |
| Gruppo di controllo (cgroup) | Una funzione del kernel che raggruppa processi e limita o contabilizza le risorse che usano. |
| cgroup v2 | L'attuale progetto dei cgroup, con una gerarchia unificata in `/sys/fs/cgroup` e un file di controllo per ogni impostazione. |
| Controller | Un componente del cgroup che gestisce una risorsa: memory, cpu, io, pids. |
| Throttling (rallentamento) | Mettere in pausa un cgroup che ha esaurito la quota di CPU fino al periodo successivo. |
| OOM killer | La funzione del kernel che uccide un processo quando la memoria finisce, o quando un cgroup di memoria raggiunge `memory.max` e non riesce a recuperare memoria. |
| Exit code 137 | 128 + 9: il processo è stato terminato da `SIGKILL`; con `OOMKilled=true` è stato l'OOM killer. |
| Immagine | Un pacchetto di sola lettura con un file system root e metadati, usato come modello per avviare container. |
| Livello (layer) | Un archivio indirizzato per contenuto con i file cambiati da un passo di build; i livelli si impilano per formare un'immagine. |
| Containerfile (Dockerfile) | Un file di testo con i passi di build di un'immagine. |
| Digest | L'hash SHA-256 di un manifest o di un livello (`sha256:…`); identifica un contenuto esatto. |
| Tag | Un'etichetta mobile e comoda per le persone di una versione di immagine, come `3.20.10` o `latest`. |
| Copy-on-write | Modificare un file di un livello inferiore di sola lettura copiandolo prima nel livello scrivibile. |
| overlayfs | Il file system a unione che impila i livelli dell'immagine e un livello scrivibile in un'unica vista. |
| Volume | Storage fuori dal livello scrivibile del container che sopravvive al container. |
| Registry | Un server che memorizza e distribuisce immagini (per esempio Docker Hub, Quay.io). |
| Open Container Initiative (OCI) | Il progetto neutrale rispetto ai fornitori che definisce le specifiche di immagine, runtime e distribuzione. |
| runc, crun | Runtime OCI a basso livello che creano i namespace e i cgroup e avviano il processo del container. |
| Container rootless | Un container eseguito da un utente normale, con un namespace user che mappa il root del container su un utente host senza privilegi. |
| Capability | Uno dei pezzi a grana fine del potere di root in Linux, che un container può mantenere o rimuovere. |
| seccomp | Un filtro del kernel che restringe quali chiamate di sistema un processo può usare. |
| microVM | Una VM molto piccola e a rapido avvio usata per isolare un singolo carico di lavoro (per esempio Firecracker). |

## Verifica la comprensione
1. Spiega con parole tue perché una VM parte in secondi o minuti e un container in millisecondi. Che cosa deve avviare ciascuno?
2. Un collega dice «i container sono solo VM leggere». Indica due cose diverse, una sul kernel e una sulla sicurezza.
3. Due container eseguono la stessa immagine. Il container A scrive un file da 50 MB dentro il proprio file system. Il container B lo vede? Dove vive il file e quando viene cancellato?
4. Il tuo `Containerfile` inizia con `FROM python`. Indica due modi in cui questo può rompere una build che funzionava il mese scorso, e riscrivi la riga per evitarli entrambi.
5. Un container viene avviato con `--memory 128m --cpus 1`. Quali valori di `memory.max` e `cpu.max` ti aspetti nei file del cgroup? Che cosa succede quando ha bisogno di 200 MB di memoria? E quando ha bisogno di due CPU?
6. Un container di database termina con codice 137. Elenca i passi che segui per scoprire se ha esaurito la memoria e indica due possibili correzioni.
7. Un team vuole eseguire codice di clienti diversi sullo stesso server. Confronta VM, container e container con sandbox per questo scopo, e dì quali controlli di NIST SP 800-190 richiederesti.

## Riferimenti
- [NIST SP 800-125](https://csrc.nist.gov/pubs/sp/800/125/final) — Guide to Security for Full Virtualization Technologies.
- [NIST SP 800-190](https://csrc.nist.gov/pubs/sp/800/190/final) — Application Container Security Guide.
- [OCI Image Format Specification](https://github.com/opencontainers/image-spec).
- [OCI Runtime Specification](https://github.com/opencontainers/runtime-spec).
- [OCI Distribution Specification](https://github.com/opencontainers/distribution-spec).
- [namespaces(7)](https://man7.org/linux/man-pages/man7/namespaces.7.html) — pagina del manuale di Linux.
- [cgroups(7)](https://man7.org/linux/man-pages/man7/cgroups.7.html) — pagina del manuale di Linux.
- [Control Group v2](https://docs.kernel.org/admin-guide/cgroup-v2.html) — documentazione del kernel Linux.
- [Podman documentation](https://docs.podman.io/).
- [CVE-2019-5736](https://nvd.nist.gov/vuln/detail/CVE-2019-5736) — vulnerabilità di evasione da container in runc.
