---
title: "Lab : construire un switch gérant les VLAN avec des namespaces Linux"
domain: networking
level: beginner
duration: "60 min"
cost: "gratuit"
environment: "machine Linux locale ou VM avec sudo (network namespaces, bridge Linux)"
lang: fr
source_hash: 14b155c590c5
---

# Lab : construire un switch gérant les VLAN avec des namespaces Linux

## Objectif
Vous construisez un petit réseau commuté sur une seule machine Linux : un bridge Linux gérant les VLAN joue le rôle du switch, et des network namespaces jouent le rôle de trois PC et d'un routeur. Vous observez le switch apprendre des adresses MAC et inonder les trames inconnues, vous répartissez les PC dans deux VLAN, vous transportez les deux VLAN sur un trunk, vous voyez les balises 802.1Q dans une capture, et vous routez entre les VLAN avec un router-on-a-stick.

## Objectifs
- Observer l'apprentissage des adresses MAC et l'inondation dans la base de transmission d'un switch.
- Configurer des ports d'accès dans deux VLAN et montrer que des hôtes de VLAN différents ne peuvent pas se joindre en couche 2, même dans le même sous-réseau.
- Configurer un port trunk qui transporte les VLAN 10 et 20 balisés et lire les balises 802.1Q dans une capture de paquets.
- Router entre les VLAN avec un router-on-a-stick construit à partir de sous-interfaces VLAN.

## Prérequis
- Une machine Linux ou une VM où vous pouvez utiliser `sudo`. Toute distribution récente convient (testé sur Fedora avec Linux 6.x).
- iproute2 5.0 ou plus récent, qui fournit les commandes `ip` et `bridge` (testé avec 6.17). Vérifiez avec `ip -V`.
- tcpdump 4.9 ou plus récent (testé avec 4.99.6). Installez-le avec votre gestionnaire de paquets si `tcpdump --version` échoue, par exemple `sudo dnf install tcpdump` ou `sudo apt install tcpdump`.
- Deux fenêtres de terminal : vous lancez les captures dans la seconde.
- La [leçon](lesson.fr.md) de ce module, en particulier l'apprentissage des MAC, les ports d'accès et trunk, et le router-on-a-stick.

> [!WARNING]
> Exécutez ce lab uniquement sur votre propre machine ou sur une VM que vous contrôlez, de préférence une VM de test plutôt qu'un serveur de production. Tout se passe dans de nouveaux network namespaces, donc vos interfaces, adresses et routes réelles ne sont pas touchées. Le lab utilise la plage privée `192.168.0.0/16` (RFC 1918) dans les namespaces ; même si votre réseau domestique utilise les mêmes adresses, il n'y a pas de conflit, car les namespaces en sont isolés. Exécutez toujours la section [Nettoyage](#nettoyage) à la fin.

## Architecture
Un **network namespace** est une copie indépendante de la pile réseau de Linux, avec ses propres interfaces, adresses et table de routage. Vous en créez cinq. L'un, `sw1`, contient le switch : un bridge Linux appelé `br0` avec le filtrage VLAN activé. Les autres sont des hôtes. Chaque hôte est relié à un port du bridge par une **paire veth**, un câble Ethernet virtuel dont les deux extrémités peuvent se trouver dans des namespaces différents.

![Architecture du lab : le namespace sw1 contient br0, un bridge Linux avec vlan_filtering 1. Le namespace pc1 (eth0, 00:00:5e:00:53:01, 192.168.10.11/24) se connecte au port p1, un port d'accès dans le VLAN 10. Le namespace pc2 (eth0, 00:00:5e:00:53:02, 192.168.20.12/24) se connecte à p2, un port d'accès dans le VLAN 20. Le namespace pc3 (eth0, 00:00:5e:00:53:03, 192.168.10.13/24) se connecte à p3, un port d'accès dans le VLAN 10. Le namespace r1 (eth0, 00:00:5e:00:53:fe) se connecte à p4, un trunk balisé avec les VLAN 10 et 20, et route entre eux avec les sous-interfaces eth0.10 (192.168.10.1/24) et eth0.20 (192.168.20.1/24)](../../../assets/diagrams/vlan-lab-architecture.fr.svg)

*Figure 1. Le lab terminé. Les liens bleus sont le VLAN 10, les orange le VLAN 20, et le trunk vert transporte les deux. pc2 commence dans `192.168.10.0/24` et passe dans `192.168.20.0/24` à l'Étape 8.*

Les hôtes utilisent des adresses MAC du bloc de documentation de la RFC 7042 (`00:00:5e:00:53:xx`), de sorte que les sorties que vous verrez correspondent à ce guide.

| Namespace | Rôle | Interface | MAC | Adresse IP (finale) | Port du bridge |
|---|---|---|---|---|---|
| `pc1` | Hôte, VLAN 10 | `eth0` | `00:00:5e:00:53:01` | `192.168.10.11/24` | `p1`, accès VLAN 10 |
| `pc2` | Hôte, VLAN 20 | `eth0` | `00:00:5e:00:53:02` | `192.168.20.12/24` | `p2`, accès VLAN 20 |
| `pc3` | Hôte, VLAN 10 | `eth0` | `00:00:5e:00:53:03` | `192.168.10.13/24` | `p3`, accès VLAN 10 |
| `r1` | Router-on-a-stick | `eth0`, `eth0.10`, `eth0.20` | `00:00:5e:00:53:fe` | `192.168.10.1/24`, `192.168.20.1/24` | `p4`, trunk 10, 20 |
| `sw1` | Switch | `br0`, `p1`–`p4` | aléatoire | aucune | — |

## Étapes

> [!NOTE]
> Exécutez chaque commande dans le premier terminal, sauf si l'étape indique « terminal 2 ». Les sorties affichées proviennent d'iproute2 6.17, tcpdump 4.99.6 et iputils 20250605. Les horodatages, les durées et les numéros d'index d'interface (comme `@if4`) seront différents sur votre machine. Une locale autre que l'anglais traduit certains messages : lancez les deux terminaux avec `export LC_ALL=C` pour obtenir les mêmes termes que dans ce guide.

### Étape 1 — Vérifiez vos outils
Assurez-vous que les commandes existent et sont assez récentes avant de construire quoi que ce soit.

```bash
ip -V
bridge -V
tcpdump --version
```

Sortie attendue (vos versions peuvent être plus récentes) :
```text
ip utility, iproute2-6.17.0, libbpf 1.6.3
bridge utility, 6.17.0
tcpdump version 4.99.6
libpcap version 1.10.7 (64-bit time_t, with TPACKET_V3)
...
```

### Étape 2 — Créez les namespaces
Chaque namespace est un appareil de votre réseau : un switch, trois PC et un routeur. Vous y désactivez aussi IPv6. Ce n'est pas nécessaire au fonctionnement des VLAN, mais cela empêche les hôtes d'envoyer des messages de découverte IPv6, de sorte que la table MAC et les captures ne montrent que le trafic que vous générez.

```bash
for ns in sw1 pc1 pc2 pc3 r1; do
  sudo ip netns add $ns
  sudo ip netns exec $ns sysctl -qw net.ipv6.conf.all.disable_ipv6=1 net.ipv6.conf.default.disable_ipv6=1
done
ip netns list
```

Sortie attendue :
```text
r1
pc3
pc2
pc1
sw1
```

### Étape 3 — Créez le switch
Un **bridge** Linux est un switch logiciel : il apprend les adresses MAC et transmet les trames exactement comme le décrit la leçon. Avec `vlan_filtering 1`, il suit aussi les VLAN par port, comme un switch administrable. Vous le créez dans `sw1` avec l'option `-n sw1`, qui exécute une commande `ip` ou `bridge` dans ce namespace.

```bash
sudo ip -n sw1 link add br0 type bridge vlan_filtering 1
sudo ip -n sw1 link set br0 up
sudo ip -n sw1 -d link show br0 | grep -o -E 'vlan_filtering [0-9]+|ageing_time [0-9]+'
sudo bridge -n sw1 vlan show
```

Sortie attendue :
```text
ageing_time 30000
vlan_filtering 1
port              vlan-id  
br0               1 PVID Egress Untagged
```

- `ageing_time 30000` est la durée d'expiration de la table MAC en centièmes de seconde : 300 secondes, la valeur par défaut courante vue dans la leçon.
- `bridge vlan show` liste les VLAN de chaque port. Pour l'instant, seul `br0` lui-même existe, dans le VLAN 1. **PVID** (port VLAN ID) est le VLAN que rejoignent les trames entrantes sans balise, et **Egress Untagged** signifie que les trames de ce VLAN sortent du port sans balise. Ensemble, ils font d'un port un port d'accès de ce VLAN.

### Étape 4 — Reliez trois PC
Vous branchez maintenant les PC au switch. Pour chaque PC, une commande crée une paire veth : l'extrémité appelée `p1` (ou `p2`, `p3`) reste dans `sw1` et l'extrémité appelée `eth0` va dans le namespace du PC. Vous réglez ensuite l'adresse MAC du PC, rattachez l'extrémité côté switch à `br0` et activez les deux extrémités. Au départ, les trois PC partagent un sous-réseau, `192.168.10.0/24`.

```bash
for i in 1 2 3; do
  sudo ip -n sw1 link add p$i type veth peer name eth0 netns pc$i
  sudo ip -n pc$i link set eth0 address 00:00:5e:00:53:0$i
  sudo ip -n sw1 link set p$i master br0
  sudo ip -n sw1 link set p$i up
  sudo ip -n pc$i link set eth0 up
done
sudo ip -n pc1 addr add 192.168.10.11/24 dev eth0
sudo ip -n pc2 addr add 192.168.10.12/24 dev eth0
sudo ip -n pc3 addr add 192.168.10.13/24 dev eth0
sudo bridge -n sw1 vlan show
sudo ip -n pc2 -br addr
```

Sortie attendue :
```text
port              vlan-id  
br0               1 PVID Egress Untagged
p1                1 PVID Egress Untagged
p2                1 PVID Egress Untagged
p3                1 PVID Egress Untagged
lo               DOWN           
eth0@if4         UP             192.168.10.12/24 
```

Chaque nouveau port rejoint le VLAN 1 comme port d'accès, exactement comme un switch matériel neuf. Les trois PC sont dans un seul domaine de diffusion.


### Étape 5 — Regardez le switch apprendre et inonder
Commencez par regarder la **base de transmission** (FDB, forwarding database) du switch, le nom que Linux donne à la table d'adresses MAC. Le mot-clé `dynamic` n'affiche que les entrées apprises et masque les entrées permanentes du bridge lui-même.

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Sortie attendue : rien. Aucun PC n'a encore envoyé de trame, donc le switch n'a rien appris.

> [!TIP]
> Si votre commande `bridge` n'accepte pas `dynamic`, exécutez plutôt `sudo bridge -n sw1 fdb show br br0 | grep -v permanent`.

Lancez maintenant une capture sur pc3, qui ne participe pas à la conversation que vous allez démarrer. Dans le **terminal 2** :

```bash
sudo ip netns exec pc3 tcpdump -e -n -i eth0 arp or icmp
```

`ip netns exec pc3` exécute tcpdump à l'intérieur de pc3. `-e` affiche les adresses MAC de chaque trame, `-n` désactive la résolution de noms, et `arp or icmp` n'affiche que le trafic ARP et ping.

Dans le **terminal 1**, faites un ping de pc1 vers pc2 :

```bash
sudo ip netns exec pc1 ping -c 2 192.168.10.12
```

Sortie attendue (les durées varient) :
```text
PING 192.168.10.12 (192.168.10.12) 56(84) bytes of data.
64 bytes from 192.168.10.12: icmp_seq=1 ttl=64 time=0.054 ms
64 bytes from 192.168.10.12: icmp_seq=2 ttl=64 time=0.056 ms

--- 192.168.10.12 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1037ms
rtt min/avg/max/mdev = 0.054/0.055/0.056/0.001 ms
```

Arrêtez la capture dans le terminal 2 avec Ctrl+C. Sortie attendue dans le terminal 2 :
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
22:16:36.485926 00:00:5e:00:53:01 > Broadcast, ethertype ARP (0x0806), length 42: Request who-has 192.168.10.12 tell 192.168.10.11, length 28
^C
1 packet captured
1 packet received by filter
0 packets dropped by kernel
```

pc3 a vu exactement une trame : la requête ARP de pc1, envoyée à l'adresse de broadcast et donc inondée sur tous les ports. Il n'a **pas** vu la réponse ARP ni les quatre paquets ping. Quand pc2 a répondu, le switch connaissait déjà le port de pc1 (appris à partir de la source de la requête ARP), donc il a transmis la réponse à `p1` seulement, et en a appris le port de pc2.

Consultez de nouveau la table :

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Sortie attendue :
```text
00:00:5e:00:53:01 dev p1 vlan 1 master br0 
00:00:5e:00:53:02 dev p2 vlan 1 master br0 
```

Le switch a appris pc1 sur `p1` et pc2 sur `p2`, tous deux dans le VLAN 1. pc3 n'a rien envoyé, donc il n'est pas encore dans la table.

### Étape 6 — Répartissez les PC dans deux VLAN
Vous faites maintenant de `p1` et `p3` des ports d'accès du VLAN 10, et de `p2` un port d'accès du VLAN 20. `pvid untagged` fait du VLAN le VLAN d'accès du port. Vous retirez ensuite le VLAN 1 des trois ports, pour que chaque port appartienne à un seul VLAN.

```bash
sudo bridge -n sw1 vlan add dev p1 vid 10 pvid untagged
sudo bridge -n sw1 vlan add dev p3 vid 10 pvid untagged
sudo bridge -n sw1 vlan add dev p2 vid 20 pvid untagged
sudo bridge -n sw1 vlan del dev p1 vid 1
sudo bridge -n sw1 vlan del dev p2 vid 1
sudo bridge -n sw1 vlan del dev p3 vid 1
sudo bridge -n sw1 vlan show
```

Sortie attendue :
```text
port              vlan-id  
br0               1 PVID Egress Untagged
p1                10 PVID Egress Untagged
p2                20 PVID Egress Untagged
p3                10 PVID Egress Untagged
```

pc2 a toujours l'adresse `192.168.10.12/24`, dans le même sous-réseau que pc1. Videz le cache ARP de pc1, pour qu'il doive redemander, puis faites un ping vers pc3 (même VLAN) et pc2 (autre VLAN) :

```bash
sudo ip -n pc1 neigh flush all
sudo ip netns exec pc1 ping -c 2 192.168.10.13
sudo ip netns exec pc1 ping -c 2 192.168.10.12
sudo ip -n pc1 neigh show
```

Sortie attendue (les durées varient) :
```text
PING 192.168.10.13 (192.168.10.13) 56(84) bytes of data.
64 bytes from 192.168.10.13: icmp_seq=1 ttl=64 time=0.038 ms
64 bytes from 192.168.10.13: icmp_seq=2 ttl=64 time=0.051 ms

--- 192.168.10.13 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1009ms
rtt min/avg/max/mdev = 0.038/0.044/0.051/0.006 ms
PING 192.168.10.12 (192.168.10.12) 56(84) bytes of data.

--- 192.168.10.12 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1019ms

192.168.10.12 dev eth0 FAILED 
192.168.10.13 dev eth0 lladdr 00:00:5e:00:53:03 REACHABLE 
```

pc1 et pc2 ont des adresses dans le même sous-réseau, et pourtant pc1 ne parvient même pas à résoudre l'adresse MAC de pc2 : l'entrée ARP est `FAILED`. Le switch garde le broadcast de pc1 dans le VLAN 10, donc il n'atteint jamais le port de pc2. C'est la frontière du VLAN à l'œuvre. Même sous-réseau ou non, des VLAN différents sont des domaines de diffusion différents.

Regardez la table encore une fois :

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Sortie attendue :
```text
00:00:5e:00:53:01 dev p1 vlan 10 master br0 
00:00:5e:00:53:03 dev p3 vlan 10 master br0 
00:00:5e:00:53:02 dev p2 vlan 20 master br0 
```

Les entrées portent maintenant le VLAN : le switch tient une table par VLAN. Retirer le VLAN 1 des ports a aussi supprimé leurs anciennes entrées du VLAN 1. La ligne de pc2 dans le VLAN 20 n'apparaît qu'une fois que pc2 a envoyé une trame dans son nouveau VLAN (par exemple, une sonde ARP) ; si elle manque sur votre machine, ce n'est pas grave.

### Étape 7 — Ajoutez un port trunk pour le routeur
Le routeur doit atteindre les deux VLAN par un seul câble, donc son port de switch est un trunk. Ajoutez une quatrième paire veth : `p4` dans le switch, `eth0` dans `r1`. Faites ensuite de `p4` un membre balisé des VLAN 10 et 20. Sans les mots-clés `pvid untagged`, les trames de ces VLAN sortent de `p4` avec une balise 802.1Q. Retirer le VLAN 1 signifie que `p4` n'a pas de VLAN natif : les trames sans balise qui y arrivent sont rejetées.

```bash
sudo ip -n sw1 link add p4 type veth peer name eth0 netns r1
sudo ip -n r1 link set eth0 address 00:00:5e:00:53:fe
sudo ip -n sw1 link set p4 master br0
sudo ip -n sw1 link set p4 up
sudo bridge -n sw1 vlan add dev p4 vid 10
sudo bridge -n sw1 vlan add dev p4 vid 20
sudo bridge -n sw1 vlan del dev p4 vid 1
sudo bridge -n sw1 vlan show dev p4
```

Sortie attendue :
```text
port              vlan-id  
p4                10
                  20
```

Ni `PVID` ni `Egress Untagged` : `p4` transporte les deux VLAN, balisés. C'est un trunk.


### Étape 8 — Configurez le router-on-a-stick
Dans `r1`, vous créez une **sous-interface VLAN** par VLAN au-dessus d'`eth0`. `eth0.10` envoie et reçoit des trames balisées VLAN 10, et `eth0.20` des trames balisées VLAN 20. Chacune reçoit l'adresse de passerelle de son VLAN. Activer le routage IP permet à `r1` de router entre elles.

```bash
sudo ip -n r1 link set eth0 up
sudo ip -n r1 link add link eth0 name eth0.10 type vlan id 10
sudo ip -n r1 link add link eth0 name eth0.20 type vlan id 20
sudo ip -n r1 addr add 192.168.10.1/24 dev eth0.10
sudo ip -n r1 addr add 192.168.20.1/24 dev eth0.20
sudo ip -n r1 link set eth0.10 up
sudo ip -n r1 link set eth0.20 up
sudo ip netns exec r1 sysctl -w net.ipv4.ip_forward=1
sudo ip -n r1 -d link show eth0.20 | grep -o 'vlan protocol [^ ]* id [0-9]*'
sudo ip -n r1 -br addr
```

Sortie attendue :
```text
net.ipv4.ip_forward = 1
vlan protocol 802.1Q id 20
lo               DOWN           
eth0@if6         UP             
eth0.10@eth0     UP             192.168.10.1/24 
eth0.20@eth0     UP             192.168.20.1/24 
```

`eth0` n'a pas d'adresse elle-même : c'est seulement le lien physique qui transporte les trames balisées.

Donnez maintenant à pc2 une adresse dans le sous-réseau du VLAN 20, et donnez à chaque PC une passerelle par défaut dans son propre VLAN :

```bash
sudo ip -n pc2 addr flush dev eth0
sudo ip -n pc2 addr add 192.168.20.12/24 dev eth0
sudo ip -n pc1 route add default via 192.168.10.1
sudo ip -n pc3 route add default via 192.168.10.1
sudo ip -n pc2 route add default via 192.168.20.1
sudo ip -n pc1 route
```

Sortie attendue :
```text
default via 192.168.10.1 dev eth0 
192.168.10.0/24 dev eth0 proto kernel scope link src 192.168.10.11 
```

### Étape 9 — Voyez les balises 802.1Q sur le trunk
Capturez sur le port trunk `p4`, à l'intérieur du switch, pendant que pc1 envoie un ping à pc2 à travers les VLAN. Dans le **terminal 2** :

```bash
sudo ip netns exec sw1 tcpdump -e -n -i p4 -c 8 vlan
```

Le filtre `vlan` ne garde que les trames balisées, et `-c 8` s'arrête après huit paquets.

Dans le **terminal 1** :

```bash
sudo ip netns exec pc1 ping -c 1 192.168.20.12
```

Sortie attendue dans le terminal 1 (les durées varient) :
```text
PING 192.168.20.12 (192.168.20.12) 56(84) bytes of data.
64 bytes from 192.168.20.12: icmp_seq=1 ttl=63 time=0.082 ms

--- 192.168.20.12 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.082/0.082/0.082/0.000 ms
```

Sortie attendue dans le terminal 2 :
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on p4, link-type EN10MB (Ethernet), snapshot length 262144 bytes
22:16:53.622170 00:00:5e:00:53:01 > Broadcast, ethertype 802.1Q (0x8100), length 46: vlan 10, p 0, ethertype ARP (0x0806), Request who-has 192.168.10.1 tell 192.168.10.11, length 28
22:16:53.622187 00:00:5e:00:53:fe > 00:00:5e:00:53:01, ethertype 802.1Q (0x8100), length 46: vlan 10, p 0, ethertype ARP (0x0806), Reply 192.168.10.1 is-at 00:00:5e:00:53:fe, length 28
22:16:53.622198 00:00:5e:00:53:01 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 102: vlan 10, p 0, ethertype IPv4 (0x0800), 192.168.10.11 > 192.168.20.12: ICMP echo request, id 29489, seq 1, length 64
22:16:53.622204 00:00:5e:00:53:fe > Broadcast, ethertype 802.1Q (0x8100), length 46: vlan 20, p 0, ethertype ARP (0x0806), Request who-has 192.168.20.12 tell 192.168.20.1, length 28
22:16:53.622214 00:00:5e:00:53:02 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 46: vlan 20, p 0, ethertype ARP (0x0806), Reply 192.168.20.12 is-at 00:00:5e:00:53:02, length 28
22:16:53.622216 00:00:5e:00:53:fe > 00:00:5e:00:53:02, ethertype 802.1Q (0x8100), length 102: vlan 20, p 0, ethertype IPv4 (0x0800), 192.168.10.11 > 192.168.20.12: ICMP echo request, id 29489, seq 1, length 64
22:16:53.622224 00:00:5e:00:53:02 > 00:00:5e:00:53:fe, ethertype 802.1Q (0x8100), length 102: vlan 20, p 0, ethertype IPv4 (0x0800), 192.168.20.12 > 192.168.10.11: ICMP echo reply, id 29489, seq 1, length 64
22:16:53.622226 00:00:5e:00:53:fe > 00:00:5e:00:53:01, ethertype 802.1Q (0x8100), length 102: vlan 10, p 0, ethertype IPv4 (0x0800), 192.168.20.12 > 192.168.10.11: ICMP echo reply, id 29489, seq 1, length 64
8 packets captured
8 packets received by filter
0 packets dropped by kernel
```

Lisez-la ligne par ligne. C'est la Figure 4 de la leçon, capturée en direct :

- `ethertype 802.1Q (0x8100)` est le TPID ; `vlan 10` est le VID ; `p 0` est la priorité PCP. Vient ensuite l'EtherType réel des données.
- **Lignes 1–3, VLAN 10 :** pc1 demande la MAC de sa passerelle (ARP), r1 répond depuis `eth0.10`, et pc1 envoie le ping à la MAC de r1.
- **Lignes 4–6, VLAN 20 :** r1 route le paquet. Il demande la MAC de pc2 dans le VLAN 20 et envoie le ping par le même câble, maintenant balisé 20, de sa propre MAC vers celle de pc2.
- **Lignes 7–8 :** la réponse emprunte le chemin inverse.
- Le `ttl=63` du ping dans le terminal 1 (au lieu de 64) montre qu'un routeur a traité le paquet.

Les adresses IP (`192.168.10.11 > 192.168.20.12`) ne changent jamais. Ce sont les adresses MAC et la balise VLAN qui changent. pc1 et pc2 n'ont jamais vu de balise : le bridge les a ajoutées et retirées sur `p4`.

Enfin, regardez la table du switch :

```bash
sudo bridge -n sw1 fdb show br br0 dynamic
```

Sortie attendue :
```text
00:00:5e:00:53:01 dev p1 vlan 10 master br0 
00:00:5e:00:53:02 dev p2 vlan 20 master br0 
00:00:5e:00:53:03 dev p3 vlan 10 master br0 
00:00:5e:00:53:fe dev p4 vlan 20 master br0 
00:00:5e:00:53:fe dev p4 vlan 10 master br0 
```

La MAC de r1 apparaît deux fois sur le port trunk, une par VLAN, car chaque VLAN a sa propre table.

## Vérification
Vous avez terminé le lab quand toutes ces conditions sont réunies :

1. `sudo bridge -n sw1 vlan show` liste `p1` et `p3` comme `10 PVID Egress Untagged`, `p2` comme `20 PVID Egress Untagged`, et `p4` avec `10` et `20` et sans `PVID`.
2. Même VLAN, en direct : `sudo ip netns exec pc1 ping -c 1 192.168.10.13` indique `1 received`.
3. VLAN différents, via le routeur : `sudo ip netns exec pc1 ping -c 1 192.168.20.12` et `sudo ip netns exec pc3 ping -c 1 192.168.20.12` indiquent tous deux `1 received`, avec `ttl=63`.
4. Le chemin passe par r1 :
   ```bash
   sudo ip netns exec pc1 tracepath -n 192.168.20.12
   ```
   Sortie attendue (les durées varient ; `tracepath` fait partie d'iputils) :
   ```text
    1?: [LOCALHOST]                      pmtu 1500
    1:  192.168.10.1                                          0.104ms 
    1:  192.168.10.1                                          0.022ms 
    2:  192.168.20.12                                         0.020ms reached
        Resume: pmtu 1500 hops 2 back 2 
   ```
5. Vous pouvez expliquer, à partir de votre capture de l'Étape 9, où la balise est ajoutée et retirée et pourquoi les adresses MAC changent au niveau de r1.

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `RTNETLINK answers: Operation not permitted` ou `mkdir /var/run/netns failed: Permission denied` | Vous avez lancé une commande qui modifie le réseau sans `sudo`. | Faites précéder la commande de `sudo`. |
| `RTNETLINK answers: File exists` ou `Cannot create namespace file "/var/run/netns/sw1": File exists` | Restes d'une tentative précédente. | Exécutez le [Nettoyage](#nettoyage), puis recommencez à l'Étape 2. |
| `Cannot open network namespace "pc1": No such file or directory` | Une étape a été sautée, ou le nettoyage a déjà été exécuté. | Lancez `ip netns list` et répétez les commandes de création manquantes. |
| Les pings dans le même VLAN échouent après l'Étape 6 | Un port est encore dans le VLAN 1, ou son VLAN n'a pas `pvid untagged`. | Comparez `sudo bridge -n sw1 vlan show` avec le point 1 de la Vérification et corrigez le port avec `bridge vlan add` / `del`. |
| Les pings entre VLAN échouent, mais les pings à l'intérieur de chaque VLAN fonctionnent | Le routage IP est désactivé dans r1, une sous-interface est inactive, un PC n'a pas de route par défaut, ou il manque un VLAN sur `p4`. | Vérifiez `sudo ip netns exec r1 sysctl net.ipv4.ip_forward` (doit valoir `1`), `sudo ip -n r1 -br addr` (les deux sous-interfaces `UP`), `sudo ip -n pc2 route` et `sudo bridge -n sw1 vlan show dev p4`. |
| La capture de l'Étape 9 n'affiche rien | Vous avez capturé sur la mauvaise interface ou le mauvais namespace, ou les entrées ARP étaient déjà en cache et vous avez manqué les premiers paquets. | Capturez avec `-i p4` dans `sw1`, lancez tcpdump avant le ping, et exécutez `sudo ip -n pc1 neigh flush all` et `sudo ip -n r1 neigh flush all` pour revoir l'échange ARP. |
| `tcpdump: command not found` | tcpdump n'est pas installé. | Installez-le (`sudo dnf install tcpdump` ou `sudo apt install tcpdump`). |
| `bridge fdb show ... dynamic` échoue avec une erreur de syntaxe ou d'utilisation | iproute2 ancien sans le mot-clé `dynamic`. | Utilisez `sudo bridge -n sw1 fdb show br br0 \| grep -v permanent`. |

## Défi (facultatif)
Construisez une boucle de commutation et laissez Spanning Tree la rompre. Créez un second namespace de switch `sw2` avec son propre bridge, et reliez `sw1` et `sw2` par **deux** paires veth. Avant de brancher le second câble, activez STP sur les deux bridges (`ip link set br0 type bridge stp_state 1`). Attendez environ 30 secondes (deux délais de transmission de 15 secondes), puis utilisez `bridge -n sw2 link show` pour trouver le port à l'état `blocking`. Quel switch est devenu le pont racine, et pourquoi ? (Indice : `ip -d link show br0` affiche `root_id` et `bridge_id`.) Que change-t-il si vous abaissez la priorité de `sw2` avec `ip link set br0 type bridge priority 4096` ?

> [!NOTE]
> Le bridge du noyau Linux implémente le STP 802.1D classique, c'est pourquoi cela prend environ 30 secondes. RSTP sous Linux nécessite un démon séparé en espace utilisateur (tel que `mstpd`), ce qui dépasse le cadre de ce lab. Ne faites le défi que dans des namespaces, jamais en mettant en bridge vos vraies interfaces réseau : une boucle sur un vrai réseau peut le mettre à terre.

## Nettoyage
Supprimez le bridge, puis tous les namespaces. Supprimer un namespace supprime aussi toutes les interfaces qu'il contient, et supprimer une extrémité d'une paire veth supprime aussi l'autre extrémité, donc aucun veth ne reste.

```bash
sudo ip -n sw1 link del br0
for ns in sw1 pc1 pc2 pc3 r1; do sudo ip netns del $ns; done
sudo ip netns del sw2 2>/dev/null   # only if you did the challenge
ip netns list
```

Sortie attendue : `ip netns list` n'affiche rien (ou du moins ne liste ni `sw1`, ni `sw2`, ni `pc1`, `pc2`, `pc3` ou `r1`).

Rien d'autre n'a été modifié sur votre machine : les réglages IPv6 et de routage IP que vous avez changés vivaient dans les namespaces et ont disparu avec eux.

## Ce que vous avez appris
- Un switch apprend les adresses MAC à partir de la source de chaque trame, inonde les broadcasts et transmet l'unicast connu sur un seul port, donc les autres hôtes ne le voient jamais.
- Les VLAN divisent un switch en domaines de diffusion séparés : des hôtes de VLAN différents ne peuvent pas communiquer en couche 2, même avec des adresses du même sous-réseau.
- Un port d'accès transporte un VLAN sans balise ; un port trunk transporte plusieurs VLAN avec des balises 802.1Q (`ethertype 802.1Q (0x8100)`, `vlan <id>`), que vous pouvez lire dans une capture.
- Le router-on-a-stick route entre VLAN sur un seul trunk grâce à des sous-interfaces VLAN ; chaque paquet routé traverse deux fois le trunk, avec un nouvel en-tête MAC et une balise différente.
- Le switch tient une table MAC distincte par VLAN, donc la même MAC peut apparaître dans plusieurs VLAN sur un port trunk.
