Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.
## Obiettivo
Costruisci una VPC in miniatura con Podman: una subnet "pubblica", una subnet "privata" e un container gateway che instrada il traffico tra le due, fa NAT per la subnet privata e applica regole simili a quelle dei security group (stateful) e delle ACL di rete (stateless). La provi, la rompi in tre modi realistici e risolvi i problemi con `curl`, `ping` e i contatori di pacchetti del firewall.
## Obiettivi
- Costruire subnet con intervalli privati che non si sovrappongono e assegnare loro le route attraverso un gateway.
- Dimostrare che un NAT gateway fa funzionare le connessioni in uscita e mantiene la subnet privata irraggiungibile dall'esterno.
- Scrivere con nftables un insieme di regole stateful in stile security group e uno di regole stateless in stile ACL, e mostrare la differenza per quanto riguarda il traffico di ritorno e le porte effimere.
- Dimostrare che vince la prima regola ACL che corrisponde.
- Diagnosticare una route mancante, una regola NAT mancante e una regola ACL mancante a partire dai sintomi e dai contatori.
## Prerequisiti
- Una macchina Linux con **Podman 4 o successivo** in esecuzione **rootless** (come utente normale; non ti serve mai `sudo`) e il backend di rete netavark. Testato con Podman 5.8.7 su Fedora con kernel 7.2. Controlla con `podman info --format '{{.Host.NetworkBackend}}'`: deve stampare `netavark`.
- Accesso a Internet una sola volta, per scaricare l'immagine di Alpine Linux (circa 8 MB) e alcuni pacchetti (circa 18 MB in totale). Dopo, nel laboratorio nulla richiede più Internet.
- Circa 300 MB di spazio libero su disco.
- La [lezione](lesson.it.md) di questo modulo, [Networking 06 — Subnetting](../../networking/06-subnetting/README.it.md) e [Networking 10 — Fondamenti di routing](../../networking/10-routing-fundamentals/README.it.md). Il laboratorio di routing di quel modulo costruiva router con i network namespace usando `sudo`; qui usi container e nessun `sudo`.
> [!WARNING]
> Tutto gira sulla tua macchina, in container e reti i cui nomi iniziano con `lab-vnet-`. Tutte e tre le reti sono create con `--internal`, quindi nulla nel laboratorio può raggiungere la tua rete reale o Internet, e nulla può raggiungerlo dall'esterno. Gli indirizzi sono intervalli privati (`10.30.0.0/16`, RFC 1918) e l'intervallo di documentazione `198.51.100.0/24` (RFC 5737). Se la tua rete usa già `10.30.1.0/24` o `10.30.2.0/24`, cambia in modo coerente il penultimo numero in ogni indirizzo, oppure scegli un intervallo libero. Al container gateway viene data la capability `NET_ADMIN`, che gli permette di modificare le proprie impostazioni di rete; in Podman rootless questo potere vale solo dentro il namespace del tuo utente, non per l'host. Non riutilizzare queste opzioni per container che eseguono software non fidato. Esegui la sezione [Pulizia](#pulizia) alla fine.
## Architettura
<figure class="diagram" style="--dg-w: 1180px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1180 470" width="1180" height="470" role="img" aria-labelledby="vnet-lab-architecture-it-title vnet-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="vnet-lab-architecture-it-title">Architettura del laboratorio: una rete virtuale emulata con Podman</title>
<desc id="vnet-lab-architecture-it-desc">Tre reti Podman, tutte interne, si incontrano in un unico container gateway, lab-vnet-gw, che ha tre interfacce: pub0 10.30.1.254, priv0 10.30.2.254 e out0 198.51.100.254, più l'indirizzo extra 198.51.100.50. La subnet pubblica lab-vnet-public 10.30.1.0/24 contiene lab-vnet-bastion a 10.30.1.10, la cui route predefinita passa da 10.30.1.254. La subnet privata lab-vnet-private 10.30.2.0/24 contiene lab-vnet-web a 10.30.2.10, che esegue un server web sulla porta 8080 e la cui route predefinita passa da 10.30.2.254. La rete esterna lab-vnet-outside 198.51.100.0/24 contiene lab-vnet-internet a 198.51.100.10, un server web sulla porta 8000 che rappresenta Internet. Il gateway applica tre tabelle nftables: lab_nat (NAT di origine), lab_sg (stateful, regole di tipo security group) e lab_acl (stateless, regole di tipo ACL). Il bastion esce con l'IP elastico 198.51.100.50 e il server web privato con l'indirizzo del gateway, 198.51.100.254.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1179" height="469" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="360" height="190" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" 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="#15803d" font-weight="700">lab-vnet-public · 10.30.1.0/24</text></g>
<g class="dg-l7"><rect class="dg-tint" x="20" y="240" width="360" height="190" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 253) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g>
<text x="62" y="267" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">lab-vnet-private · 10.30.2.0/24</text></g>
<g class="dg-l1"><rect class="dg-tint" x="870" y="130" width="290" height="210" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(886 143) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g>
<text x="912" y="157" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-vnet-outside · 198.51.100.0/24</text></g>
<g class="dg-l2"><path class="dg-stroke" d="M280 130H470" stroke="#15803d" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M280 350H470" stroke="#6d28d9" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M800 235H930" stroke="#0369a1" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<rect class="dg-card" x="40" y="70" width="320" height="124" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(56 86) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" 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></g>
<g class="dg-l2"><text x="98" y="107" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">lab-vnet-bastion</text></g>
<text x="58" y="138" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.30.1.10/24</text>
<text x="58" y="158" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.30.1.254</text>
<text x="58" y="178" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Istanza pubblica</text>
<rect class="dg-card" x="40" y="290" width="320" height="124" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(56 306) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" 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></g>
<g class="dg-l7"><text x="98" y="327" font-size="14" class="dg-ink" fill="#6d28d9" font-weight="700">lab-vnet-web</text></g>
<text x="58" y="358" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.30.2.10/24 · tcp 8080</text>
<text x="58" y="378" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.30.2.254</text>
<text x="58" y="398" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Istanza privata</text>
<rect class="dg-card" x="890" y="175" width="250" height="124" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(906 191) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" 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></g>
<g class="dg-l1"><text x="948" y="212" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">lab-vnet-internet</text></g>
<text x="908" y="243" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 198.51.100.10/24</text>
<text x="908" y="263" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">tcp 8000</text>
<text x="908" y="283" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Rappresenta Internet</text>
<rect class="dg-card" x="470" y="100" width="330" height="270" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(486 116) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6.01 18H6"/><path d="M10.01 18H10"/><path d="M15 10v4"/><path d="M17.84 7.17a4 4 0 0 0-5.66 0"/><path d="M20.66 4.34a8 8 0 0 0-11.31 0"/></g></g>
<g class="dg-l3"><text x="528" y="137" font-size="15" class="dg-ink" fill="#b45309" font-weight="700">lab-vnet-gw</text></g>
<text x="488" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">pub0 10.30.1.254</text>
<text x="488" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">priv0 10.30.2.254</text>
<text x="488" y="208" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">out0 198.51.100.254</text>
<text x="488" y="228" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace"> + 198.51.100.50</text>
<text x="488" y="248" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Router, NAT, firewall</text>
<text x="488" y="290" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">Tabelle nftables</text>
<g class="dg-l3"><rect class="dg-tint" x="488" y="302" width="74" height="26" rx="13" fill="#f8eee6" stroke="#ddb290" stroke-width="1.2"/><text x="525" y="319.5" font-size="12" class="dg-ink" fill="#b45309" font-weight="700" text-anchor="middle">lab_nat</text></g>
<g class="dg-l2"><rect class="dg-tint" x="570" y="302" width="67" height="26" rx="13" fill="#e8f2ec" stroke="#96c6a8" stroke-width="1.2"/><text x="603.5" y="319.5" font-size="12" class="dg-ink" fill="#15803d" font-weight="700" text-anchor="middle">lab_sg</text></g>
<g class="dg-l4"><rect class="dg-tint" x="645" y="302" width="74" height="26" rx="13" fill="#f9ece7" stroke="#e4aa92" stroke-width="1.2"/><text x="682" y="319.5" font-size="12" class="dg-ink" fill="#c2410c" font-weight="700" text-anchor="middle">lab_acl</text></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="402.58" y="118" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="425" y="134.5" font-size="11" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">pub0</text></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="399.225" y="338" width="51.55" height="24" rx="12" fill="#ffffff"/><text x="425" y="354.5" font-size="11" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">priv0</text></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="812.58" y="223" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="835" y="239.5" font-size="11" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">out0</text></g>
<g class="dg-l1"><rect class="dg-tint" x="351" y="438" width="478" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="455.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Le tre reti Podman sono --internal: nulla esce dal tuo computer</text></g>
</svg></figure>
*Figura 1. Un solo container gateway svolge i ruoli di router, Internet gateway, NAT gateway e firewall. "Internet" è un web server su una terza rete isolata.*
| Container | Rete e indirizzo | Ruolo in una VPC reale |
|---|---|---|
| `lab-vnet-bastion` | `lab-vnet-public`, `10.30.1.10` | Un'istanza in una subnet pubblica, con un elastic IP |
| `lab-vnet-web` | `lab-vnet-private`, `10.30.2.10` | Un'istanza in una subnet privata, che serve HTTP su TCP 8080 |
| `lab-vnet-internet` | `lab-vnet-outside`, `198.51.100.10` | Internet: un web server su TCP 8000 |
| `lab-vnet-gw` | `10.30.1.254`, `10.30.2.254`, `198.51.100.254` e `198.51.100.50` | Next hop delle tabelle di routing, Internet gateway, NAT gateway e firewall |
> [!NOTE]
> Un cloud reale divide il lavoro del gateway in più componenti gestiti e applica i filtri a ogni interfaccia. Qui un solo container fa tutto, e il security group e l'ACL sono regole su quel container, scritte per una destinazione o una subnet. Il comportamento che osservi (routing, NAT, filtraggio stateful rispetto a stateless) è quello reale; è la sua implementazione a essere semplificata. Nota anche che una subnet "pubblica" e una "privata" sono entrambe reti `--internal`: ciò che le rende pubbliche o private sono le regole del gateway, come in una VPC reale dove è la tabella di routing insieme al gateway.
Podman esegue un comando in un container con `podman exec lab-vnet-<name> <command>`. Il laboratorio lo usa di continuo, quindi ogni comando è scritto per intero.
## Passaggi
### Passo 1 — Controlla gli strumenti e crea una cartella di lavoro (3 min)
Assicurati che Podman sia rootless e usi netavark, e che non sia rimasto nulla di un tentativo precedente.
```bash
podman --version
podman info --format '{{.Host.NetworkBackend}} rootless={{.Host.Security.Rootless}}'
podman ps -a --filter name=lab-vnet --format '{{.Names}}'
podman network ls --filter name=lab-vnet --format '{{.Name}}'
mkdir -p ~/vnet-lab && cd ~/vnet-lab
```
Output atteso (la tua versione può essere diversa):
```text
podman version 5.8.7
netavark rootless=true
```
I due comandi `ls` non stampano nulla. Se elencano nomi che iniziano con `lab-vnet-`, esegui prima la [Pulizia](#pulizia). Tutti i file e i comandi che seguono presuppongono che tu sia in `~/vnet-lab`.
### Passo 2 — Costruisci l'immagine degli strumenti (5 min)
Alpine Linux è minuscola, ma non include gli strumenti che ti servono. Costruisci un'immagine con `nftables` (il firewall di Linux), `curl`, il comando `ip` completo e un piccolo web server (`httpd`, da `busybox-extras`). Il tag dell'immagine è fissato ad Alpine 3.20, così ottieni lo stesso risultato degli output qui sotto.
```bash
cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache nftables curl iproute2 busybox-extras
EOF
podman build -t lab-vnet-tools:1 .
podman run --rm lab-vnet-tools:1 sh -c 'nft --version; curl --version | head -1; ip -V; cat /etc/alpine-release'
```
Output atteso (la fine della compilazione e le versioni; le versioni dei pacchetti possono differire leggermente):
```text
OK: 18 MiB in 40 packages
COMMIT lab-vnet-tools:1
Successfully tagged localhost/lab-vnet-tools:1
nftables v1.0.9 (Old Doc Yak #3)
curl 8.14.1 (x86_64-alpine-linux-musl) libcurl/8.14.1 OpenSSL/3.3.7 zlib/1.3.2 brotli/1.1.0 zstd/1.5.6 c-ares/1.33.1 libidn2/2.3.7 libpsl/0.21.5 nghttp2/1.62.1
ip utility, iproute2-6.9.0
3.20.10
```
### Passo 3 — Crea le tre reti (4 min)
Ogni rete Podman è una subnet: un bridge con il proprio blocco CIDR. `--internal` significa che Podman non aggiunge alcuna route verso il mondo esterno né NAT verso il tuo host, quindi nulla all'interno può uscire se non attraverso il gateway che costruisci. Due subnet sono dentro l'intervallo della VPC `10.30.0.0/16` e non si sovrappongono. La terza, presa dall'intervallo di documentazione, rappresenta Internet.
```bash
podman network create --internal --subnet 10.30.1.0/24 lab-vnet-public
podman network create --internal --subnet 10.30.2.0/24 lab-vnet-private
podman network create --internal --subnet 198.51.100.0/24 lab-vnet-outside
podman network inspect lab-vnet-public lab-vnet-private lab-vnet-outside \
--format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
```
Output atteso:
```text
lab-vnet-public
lab-vnet-private
lab-vnet-outside
lab-vnet-public subnet=10.30.1.0/24 internal=true
lab-vnet-private subnet=10.30.2.0/24 internal=true
lab-vnet-outside subnet=198.51.100.0/24 internal=true
```
### Passo 4 — Avvia il gateway (6 min)
Il gateway ha un'interfaccia in ciascuna rete, con un indirizzo fisso: l'ultimo utilizzabile (`.254`) di ogni subnet, come l'indirizzo "router" di un cloud. `interface_name` dà alle interfacce nomi leggibili. `--cap-add NET_ADMIN` gli permette di modificare il proprio firewall e i propri indirizzi, e `--sysctl net.ipv4.ip_forward=1` lo trasforma in un router, come hai fatto con i namespace nel laboratorio di routing. `sleep infinity` lo tiene in esecuzione.
```bash
podman run -d --name lab-vnet-gw \
--network lab-vnet-public:ip=10.30.1.254,interface_name=pub0 \
--network lab-vnet-private:ip=10.30.2.254,interface_name=priv0 \
--network lab-vnet-outside:ip=198.51.100.254,interface_name=out0 \
--cap-add NET_ADMIN --sysctl net.ipv4.ip_forward=1 \
lab-vnet-tools:1 sleep infinity
podman exec lab-vnet-gw ip -br addr
podman exec lab-vnet-gw sysctl net.ipv4.ip_forward
podman exec lab-vnet-gw ip route
```
Output atteso (l'ID del container, l'ordine delle interfacce, i numeri `@if` e gli indirizzi `fe80::` variano):
```text
aefbd0e9520a9e36dd5b2e54f5d4799ecc592e6ee97c80d9ff1663484a52dda8
lo UNKNOWN 127.0.0.1/8 ::1/128
priv0@if4 UP 10.30.2.254/24 fe80::e8e5:faff:fe8d:8e43/64
out0@if6 UP 198.51.100.254/24 fe80::fc55:f5ff:fef6:ab65/64
pub0@if8 UP 10.30.1.254/24 fe80::647e:b8ff:fe3d:9f28/64
net.ipv4.ip_forward = 1
10.30.1.0/24 dev pub0 proto kernel scope link src 10.30.1.254
10.30.2.0/24 dev priv0 proto kernel scope link src 10.30.2.254
198.51.100.0/24 dev out0 proto kernel scope link src 198.51.100.254
```
La tabella di routing del gateway contiene solo le tre **route connesse**, una per subnet: l'equivalente della route locale implicita. Non ha una route predefinita e non gli serve: è collegato direttamente a tutte e tre le reti.
Al gateway serve anche un secondo indirizzo pubblico, l'"elastic IP" del bastion. Lo aggiungi all'interfaccia esterna:
```bash
podman exec lab-vnet-gw ip addr add 198.51.100.50/24 dev out0
podman exec lab-vnet-gw ip -br addr show out0
```
Output atteso:
```text
out0@if6 UP 198.51.100.254/24 198.51.100.50/24 fe80::fc55:f5ff:fef6:ab65/64
```
### Passo 5 — Avvia le istanze e dai loro le route (6 min)
Ogni istanza entra in una subnet. Una rete interna non dà al container alcuna route predefinita, come una subnet con la tabella di routing vuota. Ogni istanza aggiunge una route predefinita attraverso il gateway (`ip route add default via ...`): quella è la tabella di routing della sua subnet. `NET_ADMIN` serve nei container che eseguono il comando `ip route add`. Il web server e "Internet" pubblicano ciascuno una pagina di una riga con il `httpd` integrato; `-v` lo fa registrare ogni connessione nel log del container.
```bash
I=lab-vnet-tools:1
podman run -d --name lab-vnet-web --network lab-vnet-private:ip=10.30.2.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add default via 10.30.2.254; mkdir -p /www; echo "hello from the private web tier" > /www/index.html; exec httpd -f -v -p 8080 -h /www'
podman run -d --name lab-vnet-bastion --network lab-vnet-public:ip=10.30.1.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add default via 10.30.1.254; exec sleep infinity'
podman run -d --name lab-vnet-internet --network lab-vnet-outside:ip=198.51.100.10 $I \
sh -c 'mkdir -p /www; echo "hello from the Internet" > /www/index.html; exec httpd -f -v -p 8000 -h /www'
podman ps --filter name=lab-vnet --format 'table {{.Names}}\t{{.Status}}'
```
Output atteso (prima tre ID di container; i tempi variano):
```text
NAMES STATUS
lab-vnet-gw Up 8 seconds
lab-vnet-web Up 1 second
lab-vnet-bastion Up 1 second
lab-vnet-internet Up 1 second
```
Ora leggi le "tabelle di routing":
```bash
podman exec lab-vnet-web ip route
podman exec lab-vnet-bastion ip route
podman exec lab-vnet-internet ip route
```
Output atteso:
```text
default via 10.30.2.254 dev eth0
10.30.2.0/24 dev eth0 proto kernel scope link src 10.30.2.10
default via 10.30.1.254 dev eth0
10.30.1.0/24 dev eth0 proto kernel scope link src 10.30.1.10
198.51.100.0/24 dev eth0 proto kernel scope link src 198.51.100.10
```
L'host "Internet" non ha una route predefinita né una route verso i tuoi intervalli privati: come la vera Internet, non sa nulla di `10.30.0.0/16`, perché gli indirizzi RFC 1918 non vengono instradati lì.
### Passo 6 — Solo routing: tutto è aperto (8 min)
Con l'inoltro attivo e nessuna regola di filtraggio, il gateway lascia passare tutto tra le due subnet private. Prova dal bastion:
```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-bastion ping -c 2 10.30.2.10 | tail -3
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:22; echo "rc=$?"
```
Output atteso (i tempi del ping variano):
```text
hello from the private web tier
--- 10.30.2.10 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.050/0.055/0.061 ms
curl: (7) Failed to connect to 10.30.2.10 port 22 after 0 ms: Could not connect to server
rc=7
```
Due lezioni. Il percorso funziona perché la route del bastion manda `10.30.2.10` al gateway, che lo inoltra. E nulla blocca la porta 22: fallisce solo perché **nessuno è in ascolto** lì, e l'host risponde subito con un rifiuto (`rc=7`, "refused"). Ricordalo: è l'opposto di un timeout.
Poi il web server privato prova a raggiungere Internet, e lo stesso fa il bastion:
```bash
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-bastion curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
```
Output atteso (i tempi in millisecondi possono variare):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```
Vanno entrambi in timeout. Le richieste raggiungono l'host "Internet", ma questo non può rispondere: l'origine è `10.30.2.10` o `10.30.1.10`, e l'host Internet non ha una route verso quegli intervalli privati. La risposta viene scartata in silenzio. Ecco perché le subnet private hanno bisogno del NAT.
### Passo 7 — Il NAT gateway e l'elastic IP (10 min)
Aggiungi al gateway una tabella `nat` con il firewall di Linux, **nftables**. Una regola di source NAT nell'hook `postrouting` riscrive l'indirizzo di origine dei pacchetti che escono verso "Internet":
- L'intera subnet privata viene **mascherata** (*masqueraded*) con l'indirizzo del gateway stesso, `198.51.100.254`: NAT molti-a-uno, il modo in cui funziona un NAT gateway. Le risposte vengono ritradotte automaticamente.
- Il bastion ottiene un indirizzo pubblico fisso, `198.51.100.50`: una mappatura uno-a-uno, il modo in cui funziona un IP pubblico o elastic IP per un'istanza.
Scrivi le regole in un file. Le prime due righe rendono il file sicuro da ricaricare: creano la tabella se non esiste e poi la eliminano, così ogni caricamento parte da zero.
```bash
cat > nat.nft <<'EOF'
table ip lab_nat
delete table ip lab_nat
table ip lab_nat {
chain postrouting {
type nat hook postrouting priority srcnat; policy accept;
ip saddr 10.30.1.10 ip daddr 198.51.100.0/24 counter snat to 198.51.100.50 comment "elastic IP of the bastion"
ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter snat to 198.51.100.254 comment "NAT gateway for the private subnet"
}
}
EOF
podman exec -i lab-vnet-gw nft -f - < nat.nft
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-bastion curl -sS -m 3 http://198.51.100.10:8000
```
`podman exec -i ... nft -f -` legge le regole dallo standard input, quindi il file resta sulla tua macchina. Il caricamento non stampa nulla. Output atteso delle due richieste:
```text
hello from the Internet
hello from the Internet
```
Ora funzionano entrambe. Guarda il log del server "Internet", che mostra chi pensa si stia collegando, la tabella NAT e il connection tracking del gateway:
```bash
podman logs lab-vnet-internet
podman exec lab-vnet-gw nft list table ip lab_nat
podman exec lab-vnet-gw sh -c "grep 198.51.100.10 /proc/net/nf_conntrack | sed 's/ \[ASSURED\].*//; s/^ipv4 *2 //'"
```
Output atteso (i numeri di porta variano):
```text
[::ffff:198.51.100.254]:52550: response:200
[::ffff:198.51.100.50]:43524: response:200
table ip lab_nat {
chain postrouting {
type nat hook postrouting priority srcnat; policy accept;
ip saddr 10.30.1.10 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 snat to 198.51.100.50 comment "elastic IP of the bastion"
ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 snat to 198.51.100.254 comment "NAT gateway for the private subnet"
}
}
tcp 6 119 TIME_WAIT src=10.30.2.10 dst=198.51.100.10 sport=52550 dport=8000 src=198.51.100.10 dst=198.51.100.254 sport=8000 dport=52550
tcp 6 119 TIME_WAIT src=10.30.1.10 dst=198.51.100.10 sport=43524 dport=8000 src=198.51.100.10 dst=198.51.100.50 sport=8000 dport=43524
```
Il web server ha registrato `198.51.100.254` (il NAT gateway) per l'istanza privata e `198.51.100.50` (l'elastic IP) per il bastion. Nessuno dei due indirizzi privati è mai uscito. Ogni riga del tracking mostra entrambe le direzioni: l'originale (`src=10.30.2.10`) e la risposta che il gateway si aspetta (`dst=198.51.100.254`). Quella tabella è il modo in cui il NAT gateway sa dove va ogni risposta, ed è il motivo per cui funziona solo in uscita. Ora prova la direzione opposta, da "Internet" verso il web server privato:
```bash
podman exec lab-vnet-internet curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
```
Output atteso:
```text
curl: (7) Failed to connect to 10.30.2.10 port 8080 after 0 ms: Could not connect to server
rc=7
```
Fallisce subito: l'host Internet non ha una route verso un indirizzo privato. Anche con una route, il NAT gateway non ha alcuna voce di connessione per un nuovo flusso in ingresso.
### Passo 8 — Il security group: regole stateful (12 min)
Un security group è stateful e solo-allow. In nftables ottieni lo stesso comportamento con il connection tracking (`ct state`) e una **policy di drop predefinita** sull'hook `forward`, il percorso che il traffico segue attraverso il gateway. Le regole sono quelle dell'esempio pratico della lezione, ridotte a ciò che serve al laboratorio:
- La prima regola accetta i pacchetti `established,related`: le risposte di qualsiasi connessione che era stata consentita. Quella riga è la parte "stateful".
- `sg-web` accetta nuove connessioni verso `10.30.2.10` solo dalla subnet pubblica, solo su TCP 8080, più il ping.
- Entrambe le subnet possono avviare connessioni verso "Internet".
- Tutto il resto finisce nell'ultima regola, che conta e scarta.
```bash
cat > sg.nft <<'EOF'
table ip lab_sg
delete table ip lab_sg
table ip lab_sg {
chain forward {
type filter hook forward priority 0; policy drop;
ct state invalid drop
ct state established,related counter accept comment "replies are automatic (stateful)"
# sg-web, inbound: only the public subnet, only TCP 8080 and ping
ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter accept comment "sg-web in: TCP 8080 from public"
ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 icmp type echo-request counter accept comment "sg-web in: ping from public"
# outbound to the Internet
ip saddr 10.30.1.0/24 ip daddr 198.51.100.0/24 counter accept comment "public out: Internet"
ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter accept comment "private out: Internet"
counter drop comment "default deny"
}
}
EOF
podman exec -i lab-vnet-gw nft -f - < sg.nft
```
Provalo. I primi tre sono consentiti, gli ultimi due devono fallire:
```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-bastion ping -c 2 10.30.2.10 | tail -3
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:22; echo "rc=$?"
podman exec lab-vnet-web ping -c 1 -W 2 10.30.1.10 | tail -2
```
Output atteso (i tempi del ping variano):
```text
hello from the private web tier
--- 10.30.2.10 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.082/0.088/0.094 ms
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
--- 10.30.1.10 ping statistics ---
1 packets transmitted, 0 packets received, 100% packet loss
```
Confronta la porta 22 con il Passo 6. Prima del firewall veniva **rifiutata** subito (`rc=7`): il pacchetto arrivava. Ora va in **timeout** (`rc=28`): il gateway ha scartato il pacchetto senza alcuna risposta. E il web server privato, che poteva rispondere al bastion, non può avviare una connessione verso di esso: nulla consente quella direzione.
Guarda i contatori:
```bash
podman exec lab-vnet-gw nft list chain ip lab_sg forward
```
Output atteso (il numero di pacchetti sulla tua macchina è diverso):
```text
table ip lab_sg {
chain forward {
type filter hook forward priority filter; policy drop;
ct state invalid drop
ct state established,related counter packets 25 bytes 2047 accept comment "replies are automatic (stateful)"
ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter packets 1 bytes 60 accept comment "sg-web in: TCP 8080 from public"
ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 icmp type echo-request counter packets 1 bytes 84 accept comment "sg-web in: ping from public"
ip saddr 10.30.1.0/24 ip daddr 198.51.100.0/24 counter packets 0 bytes 0 accept comment "public out: Internet"
ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 1 bytes 60 accept comment "private out: Internet"
counter packets 4 bytes 264 drop comment "default deny"
}
}
```
Ogni connessione accettata ha usato esattamente una regola "new", per il suo primo pacchetto (il SYN TCP o la richiesta di ping). Ogni altro pacchetto, in entrambe le direzioni, ha corrisposto alla riga `established,related`: le risposte non hanno richiesto alcuna regola. La riga `drop` ha contato i pacchetti SYN bloccati (diversi, perché `curl` ha ritentato) e il ping verso il bastion.
> [!NOTE]
> Il curl verso la porta 22 viene ritentato mentre aspetta, quindi il contatore dei drop sale di più di uno. I numeri esatti dipendono dai tempi.
### Passo 9 — L'ACL di rete: regole stateless e ordinate (12 min)
Ora un secondo filtro per la **subnet privata** `10.30.2.0/24`, in una tabella a sé con una priorità precedente (`-10`), così viene eseguito prima del security group. Un pacchetto deve superarli entrambi. Questa ACL segue le regole di una ACL di rete del cloud:
- Non usa mai `ct state`: ogni pacchetto viene giudicato da solo, quindi è **stateless**.
- Le regole sono in ordine e vince la prima che corrisponde. I commenti mostrano i numeri di regola "in 100", "out 100" e così via.
- Ha sia allow sia deny, con un deny finale `*` in ciascuna direzione.
- Il traffico di ritorno richiede regole esplicite, con l'**intervallo di porte effimere** `1024-65535`.
```bash
cat > acl.nft <<'EOF'
table ip lab_acl
delete table ip lab_acl
table ip lab_acl {
chain forward {
type filter hook forward priority -10; policy accept;
# Network ACL of the private subnet 10.30.2.0/24: ordered, first match wins, no "ct state" anywhere
# Inbound (packets entering the subnet)
ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 tcp dport 8080 counter accept comment "in 100: TCP 8080 from public"
ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 icmp type echo-request counter accept comment "in 110: ping from public"
ip daddr 10.30.2.0/24 ip saddr 198.51.100.0/24 tcp dport 1024-65535 counter accept comment "in 120: replies from the Internet"
ip daddr 10.30.2.0/24 counter drop comment "in *: deny"
# Outbound (packets leaving the subnet)
ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 tcp sport 8080 tcp dport 1024-65535 counter accept comment "out 100: replies to public"
ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 icmp type echo-reply counter accept comment "out 110: ping replies"
ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 tcp dport 8000 counter accept comment "out 120: HTTP to the Internet"
ip saddr 10.30.2.0/24 counter drop comment "out *: deny"
}
}
EOF
podman exec -i lab-vnet-gw nft -f - < acl.nft
```
Fai attenzione all'ordine degli eventi dentro il gateway. I pacchetti in uscita hanno ancora il loro indirizzo di origine privato quando viene eseguito l'hook `forward`, perché il source NAT avviene dopo, in `postrouting`. Le risposte da Internet sono già state ritradotte nell'indirizzo privato quando arrivano a `forward`. Quindi l'ACL vede sempre gli indirizzi privati, ed ecco perché le sue regole citano `10.30.2.0/24`.
Ripeti i test:
```bash
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:80; echo "rc=$?"
```
Output atteso:
```text
hello from the private web tier
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```
I primi due superano entrambi i filtri. Il terzo va sulla porta TCP 80 dell'host Internet: il security group consente qualsiasi nuova connessione verso Internet, ma la regola in uscita 120 dell'ACL consente solo TCP 8000, quindi l'ACL lo scarta. Due livelli, e un pacchetto deve superarli entrambi.
### Passo 10 — Stateless contro stateful: rimuovi la regola di ritorno (10 min)
Questo è l'esperimento della lezione. Rimuovi la regola "out 100", quella che permette alle risposte del web server di tornare alla subnet pubblica. Il security group ha ancora la sua regola stateful `established,related` e la regola in ingresso dell'ACL lascia ancora entrare la richiesta. Trova prima l'handle della regola (il suo numero dentro nftables):
```bash
podman exec lab-vnet-gw nft -a list chain ip lab_acl forward | grep -E "out 100|out \*"
```
Output atteso (i numeri degli handle possono differire):
```text
ip saddr 10.30.2.0/24 ip daddr 10.30.1.0/24 tcp sport 8080 tcp dport 1024-65535 counter packets 6 bytes 561 accept comment "out 100: replies to public" # handle 6
ip saddr 10.30.2.0/24 counter packets 0 bytes 0 drop comment "out *: deny" # handle 9
```
Nota che "out 100" ha già contato 6 pacchetti: le risposte della richiesta HTTP del Passo 9. Il deny finale ne ha contati 0. Ora elimina la regola usando il suo handle (qui `6`; usa il tuo) e ripeti la richiesta:
```bash
podman exec lab-vnet-gw nft delete rule ip lab_acl forward handle 6
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
podman exec lab-vnet-gw nft list chain ip lab_acl forward | grep "out \*"
podman exec lab-vnet-gw nft list chain ip lab_sg forward | grep "TCP 8080"
```
Output atteso (i conteggi variano):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
ip saddr 10.30.2.0/24 counter packets 4 bytes 240 drop comment "out *: deny"
ip saddr 10.30.1.0/24 ip daddr 10.30.2.10 tcp dport 8080 counter packets 2 bytes 120 accept comment "sg-web in: TCP 8080 from public"
```
Il web server ha ricevuto la richiesta e ha risposto, ma la risposta è un nuovo pacchetto per l'ACL stateless, e `out *: deny` l'ha scartata. Il contatore del deny è passato da 0 a 4: la prima risposta e le sue ritrasmissioni. Il security group, che è stateful, non è il problema: la stessa richiesta andava bene prima. La regola che hai rimosso era il percorso di ritorno mancante. Ripristina l'ACL ricaricando il file (ricrea la tabella con tutte le regole) e prova:
```bash
podman exec -i lab-vnet-gw nft -f - < acl.nft
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
```
Output atteso:
```text
hello from the private web tier
```
### Passo 11 — L'ordine delle regole: vince la prima che corrisponde (5 min)
Una ACL viene valutata in ordine. Inserisci una regola di deny per il bastion **prima** della regola "in 100". Il comando `insert` mette la regola in cima alla chain:
```bash
podman exec lab-vnet-gw nft insert rule ip lab_acl forward ip saddr 10.30.1.10 ip daddr 10.30.2.0/24 counter drop comment \"in 90: deny bastion\"
podman exec lab-vnet-gw nft -a list chain ip lab_acl forward | sed -n 3,5p
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
```
Output atteso (i numeri degli handle e i contatori possono differire):
```text
type filter hook forward priority filter - 10; policy accept;
ip saddr 10.30.1.10 ip daddr 10.30.2.0/24 counter packets 0 bytes 0 drop comment "in 90: deny bastion" # handle 10
ip daddr 10.30.2.0/24 ip saddr 10.30.1.0/24 tcp dport 8080 counter packets 6 bytes 399 accept comment "in 100: TCP 8080 from public" # handle 2
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```
La regola "in 100" consente ancora TCP 8080 dalla subnet pubblica, ma la regola di deny viene prima, e vince la prima che corrisponde. Rimuovila con il suo handle (qui `10`; usa il tuo):
```bash
podman exec lab-vnet-gw nft delete rule ip lab_acl forward handle 10
podman exec lab-vnet-bastion curl -sS -m 3 http://10.30.2.10:8080
```
Output atteso:
```text
hello from the private web tier
```
> [!NOTE]
> Un security group non ha un ordine simile: basta una qualsiasi regola allow che corrisponda, e non esistono regole di deny. È uno dei motivi per usare i security group per il normale controllo degli accessi e le ACL solo per blocchi grossolani.
### Passo 12 — Rompi e ripara una route e una regola NAT (8 min)
Risolvere i problemi significa interpretare i sintomi. Provochi due guasti e li confronti con i timeout che hai già visto. Per prima cosa, elimina la route predefinita del web server privato, come se la sua tabella di routing avesse perso la route verso il gateway:
```bash
podman exec lab-vnet-web ip route del default
podman exec lab-vnet-web ip route
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-web ip route get 198.51.100.10; echo "rc=$?"
```
Output atteso:
```text
10.30.2.0/24 dev eth0 proto kernel scope link src 10.30.2.10
curl: (7) Failed to connect to 198.51.100.10 port 8000 after 0 ms: Could not connect to server
rc=7
RTNETLINK answers: Network unreachable
rc=2
```
Il fallimento è **immediato** e `ip route get` dice "Network unreachable": nessuna route corrisponde, quindi il pacchetto non lascia mai l'istanza. Questa è la firma di un problema di routing, non di un filtro. Ripara e prova di nuovo:
```bash
podman exec lab-vnet-web ip route add default via 10.30.2.254
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
```
Output atteso:
```text
hello from the Internet
```
Ora il secondo guasto: svuota la tabella NAT, come se il NAT gateway non ci fosse più o la sua regola fosse stata rimossa. Poi guarda i contatori dei filtri, che mostrano che i pacchetti sono usciti:
```bash
podman exec lab-vnet-gw nft flush chain ip lab_nat postrouting
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000; echo "rc=$?"
podman exec lab-vnet-gw nft list chain ip lab_sg forward | grep "private out"
```
Output atteso (il contatore varia):
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
ip saddr 10.30.2.0/24 ip daddr 198.51.100.0/24 counter packets 6 bytes 360 accept comment "private out: Internet"
```
Questa volta il sintomo è un **timeout**, come un drop del filtro. Ma i filtri hanno accettato i pacchetti (il contatore "private out" è salito), e né l'SG né l'ACL hanno scartato nulla di nuovo. I pacchetti sono usciti con l'indirizzo di origine privato, e la risposta non ha potuto tornare: lo stesso guasto del Passo 6. Ecco il metodo della lezione: un timeout significa un drop silenzioso; controlla i contatori dei filtri e, se accettano il pacchetto, controlla il percorso di ritorno e il NAT. Ripara ricaricando il file NAT:
```bash
podman exec -i lab-vnet-gw nft -f - < nat.nft
podman exec lab-vnet-web curl -sS -m 3 http://198.51.100.10:8000
```
Output atteso:
```text
hello from the Internet
```
### Passo 13 — Leggi i contatori dei drop (4 min)
Ogni regola di filtraggio ha un contatore. Quando un flusso non funziona, il modo più rapido per trovare il livello è chiedere quale regola di drop sta contando. Elenca tutte le regole di drop con un commento:
```bash
podman exec lab-vnet-gw nft list ruleset | grep "drop comment" | sed 's/^\t*//'
```
Output atteso (i tuoi conteggi dipendono da ciò che hai fatto, e sono più alti se hai eseguito prima lo script di verifica):
```text
counter packets 0 bytes 0 drop comment "default deny"
ip daddr 10.30.2.0/24 counter packets 9 bytes 540 drop comment "in *: deny"
ip saddr 10.30.2.0/24 counter packets 2 bytes 168 drop comment "out *: deny"
```
I drop dell'ACL (`in *` e `out *`) hanno contato pacchetti, ma il `default deny` del security group qui mostra 0. Questo accade perché l'ACL viene eseguita per prima (priorità `-10`) e ha scartato quei pacchetti prima che il security group li vedesse. Una regola che conta pacchetti ha corrisposto. Una regola di drop che conta è quella che ti sta bloccando. Una regola che resta a 0 non è quella che si applica.
## Verifica
Salva questo script ed eseguilo. Testa sei comportamenti e stampa PASS o FAIL per ciascuno:
```bash
cat > verify.sh <<'EOF'
#!/bin/sh
# Prints PASS or FAIL for each expected behaviour of the virtual network.
check() { # check <description> <expected: ok|fail> <command...>
desc=$1; want=$2; shift 2
if "$@" >/dev/null 2>&1; then got=ok; else got=fail; fi
if [ "$got" = "$want" ]; then echo "PASS $desc"; else echo "FAIL $desc (expected $want, got $got)"; fi
}
check "bastion reaches the web tier on TCP 8080" ok podman exec lab-vnet-bastion curl -s -m 3 http://10.30.2.10:8080
check "bastion cannot reach the web tier on TCP 22" fail podman exec lab-vnet-bastion curl -s -m 3 http://10.30.2.10:22
check "bastion can ping the web tier" ok podman exec lab-vnet-bastion ping -c 1 -W 2 10.30.2.10
check "web tier reaches the Internet through NAT" ok podman exec lab-vnet-web curl -s -m 3 http://198.51.100.10:8000
check "web tier cannot start a connection to the bastion" fail podman exec lab-vnet-web ping -c 1 -W 2 10.30.1.10
check "the Internet cannot reach the web tier" fail podman exec lab-vnet-internet curl -s -m 3 http://10.30.2.10:8080
EOF
sh verify.sh
```
Output atteso:
```text
PASS bastion reaches the web tier on TCP 8080
PASS bastion cannot reach the web tier on TCP 22
PASS bastion can ping the web tier
PASS web tier reaches the Internet through NAT
PASS web tier cannot start a connection to the bastion
PASS the Internet cannot reach the web tier
```
Tutti e sei devono passare. Lo script impiega circa 10 secondi, perché i tre controlli "fail" aspettano un timeout.
## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `podman network create` fallisce con "subnet already used" o simile | Un'altra rete Podman o un tentativo precedente usa lo stesso intervallo | Esegui `podman network ls`, rimuovi le vecchie reti `lab-vnet-` con la [Pulizia](#pulizia), oppure scegli un altro intervallo libero |
| `unknown flag` oppure `interface_name` viene rifiutato al Passo 4 | Podman precedente alla 4.x, oppure il backend CNI invece di netavark | Controlla `podman --version` e `podman info --format '{{.Host.NetworkBackend}}'`; usa Podman 4+ con netavark |
| `nft` stampa `Operation not permitted` | Il gateway è stato avviato senza `--cap-add NET_ADMIN` | Rimuovilo con `podman rm -f -t 0 lab-vnet-gw` ed esegui di nuovo il Passo 4 |
| Tutto va in timeout, anche il primo test del Passo 6 | L'inoltro IP è disattivato nel gateway, oppure un'istanza non ha una route predefinita | `podman exec lab-vnet-gw sysctl net.ipv4.ip_forward` deve stampare `1`; controlla `ip route` nell'istanza |
| `podman build` non riesce a scaricare i pacchetti | Nessun accesso a Internet o un proxy | La compilazione richiede Internet una volta; configura il tuo proxy per Podman, oppure compila su una macchina connessa |
| `curl` in un container dice `Could not resolve host` | Hai usato un nome invece di un indirizzo | Il laboratorio non ha DNS: usa sempre gli indirizzi IP della tabella |
| Un passo funziona ma i contatori restano a 0 | Il pacchetto ha corrisposto a una regola precedente, oppure passa per un'altra tabella | Leggi la chain dall'alto: le regole si applicano in ordine; il primo `accept` o `drop` la conclude per quella tabella |
| `Error: No such file or directory` caricando un file con `nft -f -` | Hai eseguito il comando fuori da `~/vnet-lab`, quindi la shell non trova il file `.nft` | Fai `cd ~/vnet-lab` ed eseguilo di nuovo |
| I container sono lenti a fermarsi | `sleep infinity` ignora il segnale di arresto cortese | Usa `podman rm -f -t 0 ...` come nella Pulizia |
## Sfida (facoltativa)
Rendi il bastion raggiungibile **da Internet** sul suo elastic IP, come un'istanza pubblica. Avvia un secondo web server nel bastion (`podman exec -d lab-vnet-bastion sh -c 'mkdir -p /srv && echo "hello from the bastion" > /srv/index.html && exec httpd -f -p 8081 -h /srv'`) e fai in modo che `podman exec lab-vnet-internet curl -sS -m 3 http://198.51.100.50:8081` stampi la sua pagina. Ti servono tre cose, e ognuna è un concetto della lezione:
1. Una regola di **destination NAT** che traduce `198.51.100.50` porta 8081 in `10.30.1.10`. Usa una nuova chain in `lab_nat` con `type nat hook prerouting priority dstnat; policy accept;`.
2. Una regola in `lab_sg` che consente la nuova connessione verso `10.30.1.10` su TCP 8081. Deve venire prima del `drop` finale: usa `nft insert rule` per metterla in cima.
3. Uno sguardo ai contatori dei pacchetti, per vedere se la traduzione e il filtro hanno entrambi corrisposto.
Poi verifica che il web server privato sia ancora irraggiungibile da Internet. Perché lo è, pur usando lo stesso gateway?
## Pulizia
Questo rimuove ogni container, rete e immagine del laboratorio, e la cartella di lavoro. L'opzione `-t 0` salta l'attesa prima dell'arresto.
```bash
podman rm -f -t 0 lab-vnet-gw lab-vnet-web lab-vnet-bastion lab-vnet-internet
podman network rm lab-vnet-public lab-vnet-private lab-vnet-outside
podman rmi lab-vnet-tools:1
cd ~ && rm -rf ~/vnet-lab
```
Controlla che non sia rimasto nulla. I tre comandi non devono stampare nulla:
```bash
podman ps -a --filter name=lab-vnet --format '{{.Names}}'
podman network ls --filter name=lab-vnet --format '{{.Name}}'
podman images --filter reference='lab-vnet*' --format '{{.Repository}}'
```
`podman rmi` rimuove solo l'immagine che hai costruito. L'immagine di base di Alpine scaricata resta nella tua cache, e altri container potrebbero usarla. Se vuoi eliminarla, esegui `podman rmi docker.io/library/alpine:3.20.10`.
## Cosa hai imparato
- Una VPC è un insieme di subnet collegate da un router; una subnet è pubblica o privata per le sue route e per le regole del suo gateway, non per il suo intervallo di indirizzi.
- Un NAT gateway riscrive l'origine delle connessioni in uscita e le tiene traccia, così le risposte tornano e nulla di nuovo può entrare; un IP pubblico o elastic IP è una mappatura uno-a-uno.
- Un security group stateful ha bisogno solo della regola che avvia la connessione; una ACL stateless ha bisogno di regole per entrambe le direzioni, comprese le porte effimere.
- Le regole delle ACL sono ordinate e vince la prima che corrisponde; le regole dei security group non sono ordinate.
- "Network unreachable" indica un problema di routing, "refused" indica che l'host ha risposto, e un "timeout" è un drop silenzioso che può venire da un filtro, da un percorso di ritorno mancante o da un NAT mancante.
- I contatori ti dicono quale regola ha visto il tuo pacchetto.