---
title: "Lab : construire un réseau virtuel sur votre machine"
domain: cloud-computing
level: intermediate
duration: "90 min"
cost: "gratuit"
environment: "conteneurs (Podman sans privilèges root sur une machine Linux locale)"
lang: fr
source_hash: e5f0b827179b
---

# Lab : construire un réseau virtuel sur votre machine

## Objectif
Vous construisez un VPC miniature avec Podman : un sous-réseau « public », un sous-réseau « privé » et un conteneur passerelle qui route entre eux, fait du NAT pour le sous-réseau privé et applique des règles de type groupe de sécurité (avec état) et de type ACL réseau (sans état). Vous le testez, vous le cassez de trois façons réalistes et vous le dépannez avec `curl`, `ping` et les compteurs de paquets du pare-feu.

## Objectifs
- Construire des sous-réseaux avec des plages privées qui ne se chevauchent pas et leur donner des routes passant par une passerelle.
- Montrer qu'une passerelle NAT fait fonctionner les connexions sortantes et garde le sous-réseau privé injoignable de l'extérieur.
- Écrire avec nftables un jeu de règles avec état façon groupe de sécurité et un jeu sans état façon ACL, et montrer la différence avec le trafic retour et les ports éphémères.
- Montrer que la première règle d'ACL qui correspond l'emporte.
- Diagnostiquer une route manquante, une règle NAT manquante et une règle d'ACL manquante à partir des symptômes et des compteurs.

## Prérequis
- Une machine Linux avec **Podman 4 ou version ultérieure** exécuté **sans privilèges root** (en utilisateur normal ; vous n'avez jamais besoin de `sudo`) et le backend réseau netavark. Testé avec Podman 5.8.7 sous Fedora avec le noyau 7.2. Vérifiez avec `podman info --format '{{.Host.NetworkBackend}}'` : il doit afficher `netavark`.
- Un accès à Internet une seule fois, pour télécharger l'image Alpine Linux (environ 8 Mo) et quelques paquets (environ 18 Mo au total). Ensuite, rien dans le lab n'a besoin d'Internet.
- Environ 300 Mo d'espace disque libre.
- La [leçon](lesson.fr.md) de ce module, [Réseaux 06 — Sous-réseaux (subnetting)](../../networking/06-subnetting/README.fr.md) et [Réseaux 10 — Notions de base du routage](../../networking/10-routing-fundamentals/README.fr.md). Le lab de routage de ce module construisait des routeurs à partir d'espaces de noms réseau avec `sudo` ; ici, vous utilisez des conteneurs et pas de `sudo`.

> [!WARNING]
> Tout s'exécute sur votre propre machine, dans des conteneurs et des réseaux dont les noms commencent par `lab-vnet-`. Les trois réseaux sont créés avec `--internal` : rien dans le lab ne peut donc atteindre votre vrai réseau ni Internet, et rien ne peut l'atteindre de l'extérieur. Les adresses sont des plages privées (`10.30.0.0/16`, RFC 1918) et la plage de documentation `198.51.100.0/24` (RFC 5737). Si votre propre réseau utilise déjà `10.30.1.0/24` ou `10.30.2.0/24`, changez de façon cohérente l'avant-dernier nombre de toutes les adresses, ou choisissez une plage libre. Le conteneur passerelle reçoit la capacité `NET_ADMIN`, qui lui permet de modifier ses propres paramètres réseau ; avec Podman sans privilèges root, ce pouvoir ne s'applique qu'à l'intérieur de l'espace de noms de votre utilisateur, pas à l'hôte. Ne réutilisez pas ces options pour des conteneurs qui exécutent des logiciels non fiables. Exécutez la section [Nettoyage](#nettoyage) à la fin.

## Architecture
![Trois réseaux Podman internes se rejoignent dans le conteneur passerelle lab-vnet-gw, qui possède les interfaces pub0 10.30.1.254, priv0 10.30.2.254 et out0 198.51.100.254, plus 198.51.100.50. Le sous-réseau public 10.30.1.0/24 contient lab-vnet-bastion 10.30.1.10 avec une route par défaut via 10.30.1.254. Le sous-réseau privé 10.30.2.0/24 contient lab-vnet-web 10.30.2.10 sur tcp 8080 avec une route par défaut via 10.30.2.254. Le réseau extérieur 198.51.100.0/24 contient lab-vnet-internet 198.51.100.10 sur tcp 8000, qui représente Internet. La passerelle applique trois tables nftables : lab_nat, lab_sg et lab_acl.](../../../assets/diagrams/vnet-lab-architecture.fr.svg)

*Figure 1. Un seul conteneur passerelle joue les rôles de routeur, de passerelle Internet, de passerelle NAT et de pare-feu. « Internet » est un serveur web sur un troisième réseau isolé.*

| Conteneur | Réseau et adresse | Rôle dans un vrai VPC |
|---|---|---|
| `lab-vnet-bastion` | `lab-vnet-public`, `10.30.1.10` | Une instance dans un sous-réseau public, avec une IP élastique |
| `lab-vnet-web` | `lab-vnet-private`, `10.30.2.10` | Une instance dans un sous-réseau privé, servant HTTP sur TCP 8080 |
| `lab-vnet-internet` | `lab-vnet-outside`, `198.51.100.10` | Internet : un serveur web sur TCP 8000 |
| `lab-vnet-gw` | `10.30.1.254`, `10.30.2.254`, `198.51.100.254` et `198.51.100.50` | Prochain saut des tables de routage, passerelle Internet, passerelle NAT et pare-feu |

> [!NOTE]
> Un vrai cloud répartit le travail de la passerelle entre plusieurs éléments gérés et applique des filtres sur chaque interface. Ici, un seul conteneur fait tout, et le groupe de sécurité et l'ACL sont des règles de ce conteneur, écrites pour une destination ou un sous-réseau. Le comportement que vous observez (routage, NAT, filtrage avec état ou sans état) est le vrai ; l'emballage est une simplification. Notez aussi qu'un sous-réseau « public » et un sous-réseau « privé » sont tous deux des réseaux `--internal` : ce qui les rend publics ou privés, ce sont les règles de la passerelle, comme dans un vrai VPC où ce sont la table de routage et la passerelle.

Podman exécute une commande dans un conteneur avec `podman exec lab-vnet-<nom> <commande>`. Le lab l'utilise en permanence, donc chaque commande est écrite en entier.

## Étapes

### Étape 1 — Vérifiez vos outils et créez un dossier de travail (3 min)
Assurez-vous que Podman est exécuté sans privilèges root et utilise netavark, et qu'il ne reste rien d'une tentative précédente.

```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
```

Sortie attendue (votre version peut différer) :
```text
podman version 5.8.7
netavark rootless=true
```

Les deux commandes `ls` n'affichent rien. Si elles listent des noms `lab-vnet-`, exécutez d'abord le [Nettoyage](#nettoyage). Tous les fichiers et commandes qui suivent supposent que vous êtes dans `~/vnet-lab`.

### Étape 2 — Construisez l'image d'outils (5 min)
Alpine Linux est minuscule, mais n'inclut pas les outils dont vous avez besoin. Vous construisez une image avec `nftables` (le pare-feu de Linux), `curl`, la commande `ip` complète et un petit serveur web (`httpd`, de `busybox-extras`). L'étiquette de l'image est figée sur Alpine 3.20, vous obtenez donc le même résultat que dans les sorties ci-dessous.

```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'
```

Sortie attendue (la fin de la construction et les versions ; les versions des paquets peuvent différer légèrement) :
```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
```

### Étape 3 — Créez les trois réseaux (4 min)
Chaque réseau Podman est un sous-réseau : un pont avec son propre bloc CIDR. `--internal` signifie que Podman n'ajoute ni route vers l'extérieur ni NAT vers votre hôte : rien à l'intérieur ne peut donc sortir autrement que par la passerelle que vous construisez. Deux sous-réseaux sont dans la plage du VPC `10.30.0.0/16` et ne se chevauchent pas. Le troisième, de la plage de documentation, représente 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}}'
```

Sortie attendue :
```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
```

### Étape 4 — Démarrez la passerelle (6 min)
La passerelle a une interface dans chaque réseau, avec une adresse fixe : la dernière utilisable (`.254`) de chaque sous-réseau, comme l'adresse du « routeur » d'un cloud. `interface_name` donne des noms lisibles aux interfaces. `--cap-add NET_ADMIN` lui permet de modifier son propre pare-feu et ses adresses, et `--sysctl net.ipv4.ip_forward=1` en fait un routeur, comme vous l'avez fait avec les espaces de noms dans le lab de routage. `sleep infinity` la maintient en fonctionnement.

```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
```

Sortie attendue (l'ID du conteneur, l'ordre des interfaces, les numéros `@if` et les adresses `fe80::` varient) :
```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 table de routage de la passerelle ne contient que les trois **routes connectées**, une par sous-réseau : l'équivalent de la route locale implicite. Elle n'a pas de route par défaut et n'en a pas besoin : elle est directement connectée aux trois réseaux.

La passerelle a aussi besoin d'une seconde adresse publique, l'« IP élastique » du bastion. Vous l'ajoutez à l'interface extérieure :

```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
```

Sortie attendue :
```text
out0@if6         UP             198.51.100.254/24 198.51.100.50/24 fe80::fc55:f5ff:fef6:ab65/64 
```

### Étape 5 — Lancez les instances et donnez-leur des routes (6 min)
Chaque instance rejoint un sous-réseau. Un réseau interne ne donne aucune route par défaut à un conteneur, comme un sous-réseau dont la table de routage est vide. Chaque instance ajoute une route par défaut via la passerelle (`ip route add default via ...`) : c'est la table de routage de son sous-réseau. `NET_ADMIN` est nécessaire dans les conteneurs qui exécutent la commande `ip route add`. Le serveur web et « Internet » publient chacun une page d'une ligne avec le `httpd` intégré ; `-v` lui fait journaliser chaque connexion dans le journal du conteneur.

```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}}'
```

Sortie attendue (d'abord trois ID de conteneur ; les durées varient) :
```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
```

Lisez maintenant les « tables de routage » :

```bash
podman exec lab-vnet-web ip route
podman exec lab-vnet-bastion ip route
podman exec lab-vnet-internet ip route
```

Sortie attendue :
```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'hôte « Internet » n'a ni route par défaut ni route vers vos plages privées : comme le vrai Internet, il ne sait rien de `10.30.0.0/16`, car les adresses de la RFC 1918 n'y sont pas routées.

### Étape 6 — Le routage seul : tout est ouvert (8 min)
Avec le transfert activé et aucune règle de filtrage pour l'instant, la passerelle laisse tout passer entre les deux sous-réseaux privés. Testez depuis le 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=$?"
```

Sortie attendue (les temps du ping varient) :
```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
```

Deux leçons. Le chemin fonctionne parce que la route du bastion envoie `10.30.2.10` à la passerelle, qui le transfère. Et rien n'arrête le port 22 : il échoue seulement parce que **rien n'écoute** là, et l'hôte répond aussitôt par un refus (`rc=7`, « refused »). Retenez-le : c'est le contraire d'une expiration de délai.

Ensuite, le serveur web privé tente d'atteindre Internet, et le bastion aussi :

```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=$?"
```

Sortie attendue (les durées en millisecondes peuvent varier) :
```text
curl: (28) Connection timed out after 3002 milliseconds
rc=28
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Les deux expirent. Les requêtes atteignent l'hôte « Internet », mais il ne peut pas répondre : la source est `10.30.2.10` ou `10.30.1.10`, et l'hôte Internet n'a pas de route vers ces plages privées. La réponse est abandonnée silencieusement. C'est pourquoi les sous-réseaux privés ont besoin du NAT.

### Étape 7 — La passerelle NAT et l'IP élastique (10 min)
Vous ajoutez une table `nat` à la passerelle avec le pare-feu Linux, **nftables**. Une règle de NAT source dans le hook `postrouting` réécrit l'adresse source des paquets qui partent vers « Internet » :
- Tout le sous-réseau privé est **masqueradé** (masquerade) avec l'adresse propre de la passerelle, `198.51.100.254` : NAT plusieurs-à-un, comme fonctionne une passerelle NAT. Les réponses sont retraduites automatiquement.
- Le bastion reçoit une adresse publique fixe, `198.51.100.50` : une correspondance un-à-un, comme fonctionne une IP publique ou élastique pour une instance.

Écrivez les règles dans un fichier. Les deux premières lignes permettent de le recharger sans danger : elles créent la table si elle n'existe pas puis la suppriment, de sorte que chaque chargement part d'une base propre.

```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 -` lit les règles sur l'entrée standard, donc le fichier reste sur votre machine. Le chargement n'affiche rien. Sortie attendue des deux requêtes :
```text
hello from the Internet
hello from the Internet
```

Les deux fonctionnent maintenant. Regardez le journal du serveur « Internet », qui montre qui il croit voir se connecter, ainsi que la table NAT et le suivi de connexions de la passerelle :

```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 //'"
```

Sortie attendue (les numéros de port varient) :
```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
```

Le serveur web a journalisé `198.51.100.254` (la passerelle NAT) pour l'instance privée et `198.51.100.50` (l'IP élastique) pour le bastion. Aucune adresse privée n'est jamais sortie. Chaque ligne de suivi montre les deux sens : l'original (`src=10.30.2.10`) et la réponse que la passerelle attend (`dst=198.51.100.254`). Cette table permet à la passerelle NAT de savoir où va chaque réponse, et explique pourquoi elle est sortante uniquement. Essayez maintenant le sens opposé, d'« Internet » vers le serveur web privé :

```bash
podman exec lab-vnet-internet curl -sS -m 3 http://10.30.2.10:8080; echo "rc=$?"
```

Sortie attendue :
```text
curl: (7) Failed to connect to 10.30.2.10 port 8080 after 0 ms: Could not connect to server
rc=7
```

Il échoue aussitôt : l'hôte Internet n'a pas de route vers une adresse privée. Même avec une route, la passerelle NAT n'a aucune entrée de connexion pour un nouveau flux entrant.

### Étape 8 — Le groupe de sécurité : règles avec état (12 min)
Un groupe de sécurité est avec état et en autorisation seule. Dans nftables, on obtient le même comportement avec le suivi de connexions (`ct state`) et une politique de **rejet par défaut** sur le hook `forward`, le chemin que suit le trafic à travers la passerelle. Les règles sont celles de l'exemple concret de la leçon, réduites à ce dont le lab a besoin :

- La première règle accepte les paquets `established,related` : les réponses de toute connexion qui a été autorisée. Cette seule ligne est la partie « avec état ».
- `sg-web` accepte les nouvelles connexions vers `10.30.2.10` uniquement depuis le sous-réseau public, uniquement sur TCP 8080, plus le ping.
- Les deux sous-réseaux peuvent initier des connexions vers « Internet ».
- Tout le reste tombe sur la dernière règle, qui compte et abandonne.

```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
```

Testez. Les trois premiers sont autorisés, les deux derniers doivent échouer :

```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
```

Sortie attendue (les temps du ping varient) :
```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
```

Comparez le port 22 avec l'Étape 6. Avant le pare-feu, il était **refusé** aussitôt (`rc=7`) : le paquet arrivait. Maintenant il **expire** (`rc=28`) : la passerelle a abandonné le paquet sans aucune réponse. Et le serveur web privé, qui pouvait répondre au bastion, ne peut pas initier de connexion vers lui : rien n'autorise ce sens.

Regardez les compteurs :

```bash
podman exec lab-vnet-gw nft list chain ip lab_sg forward
```

Sortie attendue (les nombres de paquets diffèrent sur votre machine) :
```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"
	}
}
```

Chaque connexion acceptée a utilisé exactement une règle « nouvelle », pour son premier paquet (le SYN TCP ou la requête ping). Tous les autres paquets, dans les deux sens, ont correspondu à la ligne `established,related` : les réponses n'ont pas eu besoin de règle. La ligne `drop` a compté les paquets SYN bloqués (plusieurs, car `curl` a réessayé) et le ping vers le bastion.

> [!NOTE]
> Le curl vers le port 22 est retenté pendant l'attente, donc le compteur d'abandons augmente de plus d'une unité. Les chiffres exacts dépendent du timing.

### Étape 9 — L'ACL réseau : règles sans état et ordonnées (12 min)
Voici maintenant un second filtre pour le **sous-réseau privé** `10.30.2.0/24`, dans sa propre table à une priorité antérieure (`-10`), de sorte qu'il s'exécute avant le groupe de sécurité. Un paquet doit passer les deux. Cette ACL suit les règles d'une ACL réseau de cloud :

- Elle n'utilise jamais `ct state` : chaque paquet est jugé isolément, elle est donc **sans état**.
- Les règles sont dans l'ordre et la première correspondance l'emporte. Les commentaires indiquent les numéros de règle « in 100 », « out 100 », etc.
- Elle a à la fois autorisation et refus, avec un refus final `*` dans chaque sens.
- Le trafic retour a besoin de règles explicites, avec la **plage de ports éphémères** `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
```

Faites attention à l'ordre des événements à l'intérieur de la passerelle. Les paquets sortants ont encore leur adresse source privée quand le hook `forward` s'exécute, car le NAT source intervient plus tard, dans `postrouting`. Les réponses d'Internet ont déjà été retraduites vers l'adresse privée quand elles arrivent à `forward`. L'ACL voit donc toujours les adresses privées, et c'est pourquoi ses règles mentionnent `10.30.2.0/24`.

Refaites les tests :

```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=$?"
```

Sortie attendue :
```text
hello from the private web tier
hello from the Internet
curl: (28) Connection timed out after 3002 milliseconds
rc=28
```

Les deux premiers passent les deux filtres. Le troisième va vers TCP 80 sur l'hôte Internet : le groupe de sécurité autorise toute nouvelle connexion vers Internet, mais la règle sortante 120 de l'ACL n'autorise que TCP 8000, donc l'ACL l'abandonne. Deux couches, et un paquet doit passer les deux.

### Étape 10 — Sans état et avec état : supprimez la règle de retour (10 min)
C'est l'expérience de la leçon. Supprimez la règle « out 100 », celle qui laisse repartir vers le sous-réseau public les réponses du serveur web. Le groupe de sécurité a toujours sa règle avec état `established,related` et la règle entrante de l'ACL laisse toujours entrer la requête. Trouvez d'abord le handle de la règle (son numéro dans nftables) :

```bash
podman exec lab-vnet-gw nft -a list chain ip lab_acl forward | grep -E "out 100|out \*"
```

Sortie attendue (les numéros de handle peuvent différer) :
```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
```

Notez que « out 100 » a déjà compté 6 paquets : les réponses de la requête HTTP de l'Étape 9. Le refus final a compté 0. Supprimez maintenant la règle avec son handle (`6` ici ; utilisez le vôtre) et répétez la requête :

```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"
```

Sortie attendue (les nombres varient) :
```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"
```

Le serveur web a reçu la requête et a répondu, mais la réponse est un nouveau paquet pour l'ACL sans état, et `out *: deny` l'a abandonnée. Le compteur de refus est passé de 0 à 4 : la première réponse et ses retransmissions. Le groupe de sécurité, qui est avec état, n'est pas le problème : la même requête fonctionnait avant. La règle que vous avez supprimée était le chemin retour manquant. Restaurez l'ACL en rechargeant le fichier (il recrée la table avec toutes les règles) et testez :

```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
```

Sortie attendue :
```text
hello from the private web tier
```

### Étape 11 — L'ordre des règles : la première correspondance l'emporte (5 min)
Une ACL est évaluée dans l'ordre. Insérez une règle de refus pour le bastion **avant** la règle « in 100 ». La commande `insert` place la règle en tête de chaîne :

```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=$?"
```

Sortie attendue (les numéros de handle et les compteurs peuvent différer) :
```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 règle « in 100 » autorise toujours TCP 8080 depuis le sous-réseau public, mais la règle de refus passe en premier, et la première correspondance l'emporte. Supprimez-la avec son handle (`10` ici ; utilisez le vôtre) :

```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
```

Sortie attendue :
```text
hello from the private web tier
```

> [!NOTE]
> Un groupe de sécurité n'a pas un tel ordre : n'importe quelle règle d'autorisation qui correspond suffit, et il n'y a pas de règles de refus. C'est une raison d'utiliser les groupes de sécurité pour le contrôle d'accès normal et les ACL seulement pour des blocages grossiers.

### Étape 12 — Cassez et réparez une route et une règle NAT (8 min)
Dépanner, c'est lire des symptômes. Vous provoquez deux pannes et les comparez aux expirations de délai déjà vues. D'abord, supprimez la route par défaut du serveur web privé, comme si sa table de routage avait perdu la route vers la passerelle :

```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=$?"
```

Sortie attendue :
```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
```

L'échec est **immédiat** et `ip route get` dit « Network unreachable » : aucune route ne correspond, donc le paquet ne quitte jamais l'instance. C'est la signature d'un problème de routage, pas d'un filtre. Réparez, puis testez de nouveau :

```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
```

Sortie attendue :
```text
hello from the Internet
```

Passons à la seconde panne : videz la table NAT, comme si la passerelle NAT avait disparu ou que sa règle avait été supprimée. Regardez ensuite les compteurs des filtres, qui montrent que les paquets sont bien sortis :

```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"
```

Sortie attendue (le compteur varie) :
```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"
```

Cette fois, le symptôme est une **expiration de délai**, comme un abandon par un filtre. Mais les filtres ont accepté les paquets (le compteur « private out » a augmenté), et ni le groupe de sécurité ni l'ACL n'ont rien abandonné de nouveau. Les paquets sont partis avec l'adresse source privée, et la réponse n'a pas pu revenir : la même panne qu'à l'Étape 6. Voici la méthode de la leçon : une expiration signifie un abandon silencieux ; vérifiez les compteurs des filtres et, s'ils acceptent le paquet, vérifiez le chemin retour et le NAT. Réparez en rechargeant le fichier 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
```

Sortie attendue :
```text
hello from the Internet
```

### Étape 13 — Lisez les compteurs d'abandons (4 min)
Chaque règle de filtrage a un compteur. Quand un flux ne fonctionne pas, le moyen le plus rapide de trouver la couche est de demander quelle règle d'abandon compte. Listez toutes les règles d'abandon qui ont un commentaire :

```bash
podman exec lab-vnet-gw nft list ruleset | grep "drop comment" | sed 's/^\t*//'
```

Sortie attendue (vos compteurs dépendent de ce que vous avez fait, et sont plus élevés si vous avez d'abord exécuté le script de vérification) :
```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"
```

Les abandons de l'ACL (`in *` et `out *`) ont compté des paquets, mais le `default deny` du groupe de sécurité affiche 0 ici. C'est parce que l'ACL s'exécute en premier (priorité `-10`) et a abandonné ces paquets avant que le groupe de sécurité ne les voie. Une règle qui compte des paquets a correspondu. Une règle d'abandon qui compte est celle qui vous bloque. Une règle qui reste à 0 n'est pas celle qui s'applique.

## Vérification
Enregistrez ce script et exécutez-le. Il teste six comportements et affiche PASS ou FAIL pour chacun :

```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
```

Sortie attendue :
```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
```

Les six doivent passer. Le script prend environ 10 secondes, car les trois vérifications « fail » attendent une expiration de délai.

## Dépannage
| Symptôme | Cause probable | Correction |
|---|---|---|
| `podman network create` échoue avec « subnet already used » ou similaire | Un autre réseau Podman ou une tentative précédente utilise la même plage | Exécutez `podman network ls`, supprimez les anciens réseaux `lab-vnet-` avec le [Nettoyage](#nettoyage), ou choisissez une autre plage libre |
| `unknown flag` ou `interface_name` est rejeté à l'Étape 4 | Podman antérieur à 4.x, ou backend CNI au lieu de netavark | Vérifiez `podman --version` et `podman info --format '{{.Host.NetworkBackend}}'` ; utilisez Podman 4+ avec netavark |
| `nft` affiche `Operation not permitted` | La passerelle a été démarrée sans `--cap-add NET_ADMIN` | Supprimez-la avec `podman rm -f -t 0 lab-vnet-gw` et refaites l'Étape 4 |
| Tout expire, même le premier test de l'Étape 6 | Le transfert IP est désactivé dans la passerelle, ou une instance n'a pas de route par défaut | `podman exec lab-vnet-gw sysctl net.ipv4.ip_forward` doit afficher `1` ; vérifiez `ip route` dans l'instance |
| `podman build` ne peut pas télécharger les paquets | Pas d'accès à Internet ou présence d'un proxy | La construction a besoin d'Internet une fois ; configurez votre proxy pour Podman, ou construisez sur une machine connectée |
| `curl` dans un conteneur dit `Could not resolve host` | Vous avez utilisé un nom au lieu d'une adresse | Le lab n'a pas de DNS : utilisez toujours les adresses IP du tableau |
| Une étape fonctionne mais les compteurs restent à 0 | Le paquet a correspondu à une règle antérieure, ou passe par une autre table | Lisez la chaîne depuis le haut : les règles s'appliquent dans l'ordre ; le premier `accept` ou `drop` y met fin pour cette table |
| `Error: No such file or directory` en chargeant un fichier avec `nft -f -` | Vous avez lancé la commande hors de `~/vnet-lab`, donc le shell ne trouve pas le fichier `.nft` | `cd ~/vnet-lab` puis relancez |
| Les conteneurs sont lents à s'arrêter | `sleep infinity` ignore le signal d'arrêt poli | Utilisez `podman rm -f -t 0 ...` comme dans le Nettoyage |

## Défi (facultatif)
Rendez le bastion joignable **depuis Internet** sur son IP élastique, comme une instance publique. Démarrez un second serveur web dans le 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'`) et faites en sorte que `podman exec lab-vnet-internet curl -sS -m 3 http://198.51.100.50:8081` affiche sa page. Il vous faut trois choses, et chacune est un concept de la leçon :
1. Une règle de **NAT de destination** qui traduit `198.51.100.50` port 8081 en `10.30.1.10`. Utilisez une nouvelle chaîne dans `lab_nat` avec `type nat hook prerouting priority dstnat; policy accept;`.
2. Une règle dans `lab_sg` qui autorise la nouvelle connexion vers `10.30.1.10` sur TCP 8081. Elle doit venir avant le `drop` final : utilisez `nft insert rule` pour la placer en tête.
3. Un coup d'œil aux compteurs de paquets, pour voir si la traduction et le filtre ont tous deux correspondu.

Vérifiez ensuite que le serveur web privé reste injoignable depuis Internet. Pourquoi l'est-il, alors que la même passerelle est utilisée ?

## Nettoyage
Cela supprime tous les conteneurs, réseaux et images du lab, ainsi que le dossier de travail. L'option `-t 0` évite le délai d'arrêt.

```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
```

Vérifiez qu'il ne reste rien. Les trois commandes ne doivent rien afficher :

```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` ne supprime que l'image que vous avez construite. L'image de base Alpine téléchargée reste dans votre cache, et d'autres conteneurs peuvent l'utiliser. Si vous voulez la supprimer, exécutez `podman rmi docker.io/library/alpine:3.20.10`.

## Ce que vous avez appris
- Un VPC est un ensemble de sous-réseaux reliés par un routeur ; un sous-réseau est public ou privé à cause de ses routes et des règles de sa passerelle, pas de sa plage d'adresses.
- Une passerelle NAT réécrit la source des connexions sortantes et les suit, de sorte que les réponses reviennent et que rien de nouveau ne peut entrer ; une IP publique ou élastique est une correspondance un-à-un.
- Un groupe de sécurité avec état n'a besoin que de la règle qui initie la connexion ; une ACL sans état a besoin de règles pour les deux sens, y compris les ports éphémères.
- Les règles d'une ACL sont ordonnées et la première correspondance l'emporte ; les règles d'un groupe de sécurité ne sont pas ordonnées.
- « Network unreachable » signifie routage, « refused » signifie que l'hôte a répondu, et un « timeout » est un abandon silencieux qui peut venir d'un filtre, d'un chemin retour manquant ou d'un NAT manquant.
- Les compteurs vous disent quelle règle a vu votre paquet.
