---
title: "Lab : trois routeurs avec routes statiques, puis OSPF"
domain: networking
level: intermediate
duration: "75 min"
cost: "gratuit"
environment: "machine Linux locale ou VM avec sudo (network namespaces) ; partie facultative avec des conteneurs Podman ou Docker"
lang: fr
source_hash: efae97614681
---

# Lab : trois routeurs avec routes statiques, puis OSPF

## Objectif
Vous construisez sur une seule machine Linux le réseau de l'[exemple concret](lesson.fr.md#exemple-concret) de la leçon : deux hôtes et trois routeurs alignés, chacun étant un network namespace. Vous le faites fonctionner avec des routes statiques et des routes par défaut, vous le mettez en panne de manière réaliste, puis vous le dépannez avec `ping`, `ip route get` et `traceroute`. Dans une partie facultative, vous remplacez les routes statiques par le protocole Open Shortest Path First (OSPF), exécuté dans des conteneurs FRRouting.

## Objectifs
- Transformer un network namespace Linux en routeur en activant le routage IP (IP forwarding).
- Configurer des routes statiques et des routes par défaut afin que le trafic circule dans les deux sens.
- Diagnostiquer une route retour manquante, une route aller manquante et un saut de traceroute sans réponse avec `ip route get` et `traceroute`.
- Observer la correspondance du préfixe le plus long départager une route par défaut, une `/24` et une `/32`.
- (Facultatif) Exécuter OSPF entre trois routeurs FRRouting, lire les voisins et les routes qu'il construit, et observer sa réaction à la panne d'un lien.

## Prérequis
- Une machine Linux ou une VM où vous pouvez utiliser `sudo`. Le lab a été testé sur Fedora avec le noyau 7.2.
- iproute2 (la commande `ip`) 5.0 ou plus récent. Vérifiez avec `ip -V` (testé avec 6.17).
- `ping` (iputils) et `traceroute` (testé avec « Modern traceroute for Linux » 2.1.6). Si `traceroute` est absent, installez-le avec `sudo dnf install traceroute` ou `sudo apt install traceroute`.
- La [leçon](lesson.fr.md) de ce module, et [06 — Subnetting](../06-subnetting/README.fr.md) pour les préfixes.
- Partie facultative uniquement : Podman 4 ou plus récent (testé avec 5.8) ou Docker 24 ou plus récent, et un accès à Internet pour télécharger l'image FRRouting (environ 95 Mo). La partie A dure environ 50 minutes et la partie B environ 25.

> [!WARNING]
> Exécutez ce lab uniquement sur votre propre machine ou sur une VM que vous contrôlez, jamais sur un serveur partagé ou de production. Tout se passe dans des network namespaces et des conteneurs que vous créez : le lab ne modifie ni vos interfaces ni vos routes réelles, et il n'envoie de trafic à aucun autre système. Les adresses appartiennent à des plages privées RFC 1918 (`10.0.0.0/8`) et à la plage de documentation `198.51.100.0/24` (RFC 5737). Si votre propre réseau utilise déjà `10.1.1.0/24`, `10.3.3.0/24`, `10.0.12.0/24` ou `10.0.23.0/24`, le lab fonctionne quand même, car les namespaces sont isolés, mais les réseaux de conteneurs facultatifs peuvent entrer en conflit : voir [Dépannage](#dépannage). Exécutez toujours la section [Nettoyage](#nettoyage) à la fin.

## Architecture
Cinq **network namespaces** représentent cinq appareils. Chaque namespace possède ses propres interfaces, adresses, table de routage et paramètres, exactement comme une machine distincte. Des paires Ethernet virtuelles (veth) jouent le rôle de câbles entre eux.

![Cinq network namespaces alignés, reliés par des paires veth. lab-h1 a eth0 10.1.1.10/24 et une route par défaut via 10.1.1.1. lab-r1 a to-h1 10.1.1.1/24 et to-r2 10.0.12.1/30. lab-r2 a to-r1 10.0.12.2/30 et to-r3 10.0.23.1/30. lab-r3 a to-r2 10.0.23.2/30 et to-h2 10.3.3.1/24. lab-h2 a eth0 10.3.3.10/24 et une route par défaut via 10.3.3.1. Les réseaux sont 10.1.1.0/24, 10.0.12.0/30, 10.0.23.0/30 et 10.3.3.0/24. Les trois routeurs ont le routage IP activé](../../../assets/diagrams/routing-lab-architecture.fr.svg)

*Figure 1. La topologie du lab. Les noms d'interface indiquent où va chaque câble : `to-r2` sur `lab-r1` mène à `lab-r2`.*

| Namespace | Rôle | Interface → adresse |
|---|---|---|
| `lab-h1` | Hôte | `eth0` → `10.1.1.10/24` |
| `lab-r1` | Routeur | `to-h1` → `10.1.1.1/24`, `to-r2` → `10.0.12.1/30` |
| `lab-r2` | Routeur | `to-r1` → `10.0.12.2/30`, `to-r3` → `10.0.23.1/30` |
| `lab-r3` | Routeur | `to-r2` → `10.0.23.2/30`, `to-h2` → `10.3.3.1/24` |
| `lab-h2` | Hôte | `eth0` → `10.3.3.10/24` |

Deux commandes permettent d'exécuter des opérations dans un namespace :
- `sudo ip -n <namespace> <commande ip>` y exécute une commande `ip`, par exemple `sudo ip -n lab-r1 route`.
- `sudo ip netns exec <namespace> <commande>` y exécute toute autre commande, par exemple `ping` ou `sysctl`.

`<namespace>` est l'un des cinq noms du tableau.

## Étapes

### Partie A — Routage statique
Vous construisez le réseau, vous le faites fonctionner avec des routes statiques et des routes par défaut, puis vous le mettez en panne et le réparez. Cette partie dure environ 50 minutes.

### Étape 1 — Vérifiez vos outils (2 min)
Assurez-vous que les commandes existent avant de construire quoi que ce soit, et qu'aucun namespace portant ces noms ne subsiste d'une tentative précédente.

```bash
ip -V
traceroute --version
ip netns list
```

Sortie attendue (les versions peuvent différer) :
```text
ip utility, iproute2-6.17.0, libbpf 1.6.3
Modern traceroute for Linux, version 2.1.6
Copyright (c) 2016  Dmitry Butskoy,   License: GPL v2 or any later
```

`ip netns list` ne doit rien afficher. S'il liste `lab-h1` ou tout autre namespace `lab-`, exécutez d'abord le [Nettoyage](#nettoyage).

> [!TIP]
> Si la langue de votre système n'est pas l'anglais, certains messages apparaissent traduits. Leur sens est le même que dans les sorties présentées ici.

### Étape 2 — Créez les cinq namespaces (2 min)
Chaque namespace démarre vide, avec seulement une interface de bouclage (loopback) désactivée. Vous activez le bouclage pour que les outils locaux se comportent normalement.

```bash
for ns in lab-h1 lab-r1 lab-r2 lab-r3 lab-h2; do
  sudo ip netns add $ns
  sudo ip -n $ns link set lo up
done
ip netns list
```

Sortie attendue (l'ordre peut différer) :
```text
lab-h2
lab-r3
lab-r2
lab-r1
lab-h1
```

### Étape 3 — Câblez les appareils et attribuez les adresses (6 min)
Chaque paire veth est créée avec une extrémité dans chaque namespace. Ensuite, chaque interface reçoit son adresse d'après le tableau et est activée.

```bash
# Cables: one veth pair per link
sudo ip link add eth0  netns lab-h1 type veth peer name to-h1 netns lab-r1
sudo ip link add to-r2 netns lab-r1 type veth peer name to-r1 netns lab-r2
sudo ip link add to-r3 netns lab-r2 type veth peer name to-r2 netns lab-r3
sudo ip link add to-h2 netns lab-r3 type veth peer name eth0  netns lab-h2

# Addresses
sudo ip -n lab-h1 addr add 10.1.1.10/24  dev eth0
sudo ip -n lab-r1 addr add 10.1.1.1/24   dev to-h1
sudo ip -n lab-r1 addr add 10.0.12.1/30  dev to-r2
sudo ip -n lab-r2 addr add 10.0.12.2/30  dev to-r1
sudo ip -n lab-r2 addr add 10.0.23.1/30  dev to-r3
sudo ip -n lab-r3 addr add 10.0.23.2/30  dev to-r2
sudo ip -n lab-r3 addr add 10.3.3.1/24   dev to-h2
sudo ip -n lab-h2 addr add 10.3.3.10/24  dev eth0

# Bring every interface up
sudo ip -n lab-h1 link set eth0 up
sudo ip -n lab-r1 link set to-h1 up
sudo ip -n lab-r1 link set to-r2 up
sudo ip -n lab-r2 link set to-r1 up
sudo ip -n lab-r2 link set to-r3 up
sudo ip -n lab-r3 link set to-r2 up
sudo ip -n lab-r3 link set to-h2 up
sudo ip -n lab-h2 link set eth0 up

sudo ip -n lab-r2 -br addr
```

Sortie attendue (vos numéros `@if` et vos adresses de lien local `fe80::` seront différents) :
```text
lo               UNKNOWN        127.0.0.1/8 ::1/128
to-r1@if3        UP             10.0.12.2/30 fe80::9c1d:9ff:fee0:e853/64
to-r3@if2        UP             10.0.23.1/30 fe80::508d:83ff:fecf:55ce/64
```

Les deux interfaces de `lab-r2` sont `UP` avec les bonnes adresses.

### Étape 4 — Lisez les routes connectées (4 min)
Ajouter une adresse crée une route connectée pour son sous-réseau. C'est tout ce que chaque appareil connaît pour l'instant.

```bash
sudo ip -n lab-h1 route
sudo ip -n lab-r2 route
```

Sortie attendue :
```text
10.1.1.0/24 dev eth0 proto kernel scope link src 10.1.1.10
10.0.12.0/30 dev to-r1 proto kernel scope link src 10.0.12.2
10.0.23.0/30 dev to-r3 proto kernel scope link src 10.0.23.1
```

`h1` ne connaît que son propre réseau local (LAN, Local Area Network), et `r2` ne connaît que ses deux liens. Testez un voisin du même sous-réseau, puis l'hôte distant :

```bash
sudo ip netns exec lab-h1 ping -c 2 10.1.1.1
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

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

--- 10.1.1.1 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1035ms
rtt min/avg/max/mdev = 0.028/0.037/0.047/0.009 ms
ping: connect: Network is unreachable
```

Le voisin répond : il se trouve sur un réseau connecté. Pour `10.3.3.10`, `h1` n'a ni route correspondante ni route par défaut, donc le noyau refuse purement et simplement d'envoyer le paquet.

### Étape 5 — Transformez trois namespaces en routeurs (2 min)
Une machine Linux ne transmet les paquets destinés à d'autres hôtes que si le routage IP est activé. Il est désactivé par défaut, et chaque namespace possède son propre paramètre.

```bash
sudo ip netns exec lab-r1 sysctl net.ipv4.ip_forward
for r in lab-r1 lab-r2 lab-r3; do
  sudo ip netns exec $r sysctl -w net.ipv4.ip_forward=1
done
```

Sortie attendue :
```text
net.ipv4.ip_forward = 0
net.ipv4.ip_forward = 1
net.ipv4.ip_forward = 1
net.ipv4.ip_forward = 1
```

La première ligne montre la valeur par défaut, 0. Le paramètre est propre à chaque namespace, donc celui de votre hôte ne change pas.

### Étape 6 — Donnez une passerelle par défaut aux hôtes (4 min)
Les hôtes envoient tout ce qui sort de leur sous-réseau à leur passerelle par défaut. Faites pointer chaque hôte vers le routeur de son réseau local.

```bash
sudo ip -n lab-h1 route add default via 10.1.1.1
sudo ip -n lab-h2 route add default via 10.3.3.1
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Sortie attendue :
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
From 10.1.1.1 icmp_seq=1 Destination Net Unreachable
From 10.1.1.1 icmp_seq=2 Destination Net Unreachable

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1006ms
```

Progrès : le paquet quitte maintenant `h1` et atteint `r1`. `r1` n'a pas de route vers `10.3.3.0/24`, donc il rejette le paquet et renvoie un message *Destination Unreachable* de l'Internet Control Message Protocol (ICMP). Confirmez-le du point de vue de `r1` :

```bash
sudo ip -n lab-r1 route get 10.3.3.10
```

Sortie attendue :
```text
RTNETLINK answers: Network is unreachable
```

`ip route get` demande au noyau quelle route il utiliserait. « Network is unreachable » signifie qu'aucune route ne correspond, pas même une route par défaut.

### Étape 7 — Ajoutez le chemin aller (4 min)
Donnez à chaque routeur situé sur le chemin vers `10.3.3.0/24` une route vers ce réseau. `r3` n'en a pas besoin, car `10.3.3.0/24` lui est directement connecté.

```bash
sudo ip -n lab-r1 route add 10.3.3.0/24 via 10.0.12.2
sudo ip -n lab-r2 route add 10.3.3.0/24 via 10.0.23.2
sudo ip netns exec lab-h1 ping -c 2 -W 1 10.3.3.10
```

Sortie attendue :
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1062ms
```

Toujours 100 % de perte, mais cette fois *sans* aucun message d'erreur. Quelque chose rejette les paquets en silence. `-W 1` fait attendre `ping` une seconde seulement pour chaque réponse.

### Étape 8 — Trouvez et corrigez la route retour manquante (8 min)
Suivez le chemin saut par saut avec `ip route get`, d'abord vers la destination, puis en sens inverse vers la source.

```bash
sudo ip -n lab-r2 route get 10.3.3.10
sudo ip -n lab-r3 route get 10.3.3.10
sudo ip -n lab-r3 route get 10.1.1.10
```

Sortie attendue :
```text
10.3.3.10 via 10.0.23.2 dev to-r3 src 10.0.23.1 uid 0
    cache
10.3.3.10 dev to-h2 src 10.3.3.1 uid 0
    cache
RTNETLINK answers: Network is unreachable
```

Le chemin aller est complet : `r2` envoie à `r3`, et `r3` livre directement sur `to-h2`. Les requêtes echo atteignent `h2`, et `h2` répond à sa passerelle `r3`. Mais `r3` n'a pas de route vers `10.1.1.10`, donc il rejette chaque réponse.

![L'Echo Request de h1 (10.1.1.10) traverse R1, R2 et R3, qui ont chacun une route vers 10.3.3.0/24, et atteint h2 (10.3.3.10). L'Echo Reply vers 10.1.1.10 revient à R3, qui n'a pas de route vers 10.1.1.0/24 et la rejette](../../../assets/diagrams/routing-lab-asymmetric.fr.svg)

*Figure 2. Les requêtes arrivent, les réponses meurent au premier routeur sans route retour. Vu de `h1`, c'est simplement le silence.*

`r3` est un routeur d'extrémité (*stub*) qui n'a qu'une seule sortie, donc une route par défaut vers `r2` est la bonne correction :

```bash
sudo ip -n lab-r3 route add default via 10.0.23.1
sudo ip netns exec lab-h1 ping -c 2 -W 1 10.3.3.10
```

Sortie attendue :
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, 100% packet loss, time 1039ms
```

Toujours en échec. Continuez à suivre le chemin retour : la réponse atteint maintenant `r2`.

```bash
sudo ip -n lab-r2 route get 10.1.1.10
```

Sortie attendue :
```text
RTNETLINK answers: Network is unreachable
```

`r2` se trouve au milieu, donc il lui faut une route spécifique de retour vers le réseau local de `h1` :

```bash
sudo ip -n lab-r2 route add 10.1.1.0/24 via 10.0.12.1
sudo ip netns exec lab-h1 ping -c 3 10.3.3.10
```

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

--- 10.3.3.10 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2064ms
rtt min/avg/max/mdev = 0.052/0.058/0.068/0.007 ms
```

Cela fonctionne. `ttl=61` confirme le chemin : `h2` a envoyé la réponse avec un Time to Live (TTL, durée de vie) de 64, et trois routeurs l'ont chacun décrémenté une fois. `r1` connaît déjà `10.1.1.0/24`, car ce réseau lui est connecté.

### Étape 9 — Tracez le chemin et expliquez un saut silencieux (7 min)
Traceroute montre chaque routeur du chemin aller.

```bash
sudo ip netns exec lab-h1 traceroute -n 10.3.3.10
```

Sortie attendue :
```text
traceroute to 10.3.3.10 (10.3.3.10), 30 hops max, 60 byte packets
 1  10.1.1.1  0.022 ms  0.005 ms  0.005 ms
 2  10.0.12.2  0.017 ms  0.006 ms  0.007 ms
 3  * * *
 4  10.3.3.10  0.013 ms  0.009 ms  0.009 ms
```

`-n` affiche les adresses sans tenter de résoudre les noms. Le saut 4, la destination, répond, donc le saut 3 (`r3`) transmet bien le trafic. Pourquoi `r3` ne répond-il pas pour son propre compte ? Ses messages *Time Exceeded* proviennent de son adresse sur le lien vers `r2`, `10.0.23.2`. Vérifiez si `r1` connaît le chemin de retour vers cette adresse :

```bash
sudo ip -n lab-r1 route get 10.0.23.2
sudo ip netns exec lab-r1 sysctl net.ipv4.conf.to-r2.rp_filter
```

Sortie attendue :
```text
RTNETLINK answers: Network is unreachable
net.ipv4.conf.to-r2.rp_filter = 2
```

`r1` a des routes pour `10.1.1.0/24`, `10.0.12.0/30` et `10.3.3.0/24`, mais pas pour le lien `10.0.23.0/30`. Son **filtre de chemin inverse** (*reverse path filter*, `rp_filter`, la forme Linux de l'Unicast reverse path forwarding (uRPF) vu dans la leçon) vérifie l'adresse source de chaque paquet entrant. En mode souple (*loose*, `2`), il rejette les paquets dont la source n'est absolument pas joignable d'après la table de routage. Les messages de `r3` meurent donc sur `r1`.

> [!NOTE]
> La plupart des distributions règlent `rp_filter` sur 2 (mode souple) par défaut, et les nouveaux namespaces en héritent. Si le vôtre affiche `0` (désactivé), `r1` transmet quand même les messages de `r3`. Ils atteignent alors `h1` et le saut 3 affiche déjà `10.0.23.2`. Lisez tout de même l'explication et appliquez la correction : un routeur sans route de retour vers une partie du réseau est un vrai problème, même si un filtre ne le révèle pas.

Comme `r3`, `r1` est un routeur d'extrémité. Donnez-lui une route par défaut vers `r2`, conformément à la conception de la leçon :

```bash
sudo ip -n lab-r1 route add default via 10.0.12.2
sudo ip netns exec lab-h1 traceroute -n 10.3.3.10
```

Sortie attendue :
```text
traceroute to 10.3.3.10 (10.3.3.10), 30 hops max, 60 byte packets
 1  10.1.1.1  0.040 ms  0.006 ms  0.004 ms
 2  10.0.12.2  0.015 ms  0.008 ms  0.006 ms
 3  10.0.23.2  0.018 ms  0.008 ms  0.007 ms
 4  10.3.3.10  0.019 ms  0.010 ms *
```

Les quatre sauts répondent maintenant. Un seul `*` parmi les réponses (comme le dernier ici) est normal : Linux limite le débit des erreurs ICMP qu'il envoie (`net.ipv4.icmp_ratelimit`), donc si vous lancez traceroute plusieurs fois de suite rapidement, certaines sondes restent sans réponse. Attendez quelques secondes entre deux exécutions.

### Étape 10 — Observez la correspondance du préfixe le plus long trancher (6 min)
`r1` possède maintenant une route `/24` et une route par défaut qui pointent dans la même direction. Ajoutez une troisième route, plus spécifique, pour constater que la correspondance la plus longue l'emporte, quel que soit l'ordre d'ajout des routes.

```bash
sudo ip -n lab-r1 route
sudo ip -n lab-r1 route get 10.3.3.10
sudo ip -n lab-r1 route get 198.51.100.7
```

Sortie attendue :
```text
default via 10.0.12.2 dev to-r2
10.0.12.0/30 dev to-r2 proto kernel scope link src 10.0.12.1
10.1.1.0/24 dev to-h1 proto kernel scope link src 10.1.1.1
10.3.3.0/24 via 10.0.12.2 dev to-r2
10.3.3.10 via 10.0.12.2 dev to-r2 src 10.0.12.1 uid 0
    cache
198.51.100.7 via 10.0.12.2 dev to-r2 src 10.0.12.1 uid 0
    cache
```

`10.3.3.10` correspond à la `/24`, et `198.51.100.7` (une adresse de documentation) ne correspond qu'à la route par défaut. Les deux vont vers `10.0.12.2`, donc on ne peut pas encore les distinguer. Ajoutez maintenant une route **prohibit** pour une seule adresse. C'est une route qui rejette les paquets au lieu de les transmettre, ce qui rend visible la route gagnante :

```bash
sudo ip -n lab-r1 route add prohibit 10.3.3.10/32
sudo ip -n lab-r1 route get 10.3.3.10
sudo ip -n lab-r1 route get 10.3.3.20
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Sortie attendue :
```text
RTNETLINK answers: Permission denied
10.3.3.20 via 10.0.12.2 dev to-r2 src 10.0.12.1 uid 0
    cache
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
From 10.1.1.1 icmp_seq=1 Packet filtered
From 10.1.1.1 icmp_seq=2 Packet filtered

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1061ms
```

Pour `10.3.3.10`, la `/32` l'emporte sur la `/24` et sur la route par défaut. Le noyau rejette le paquet et `r1` envoie un message ICMP *administratively prohibited* (interdit administrativement), que `ping` affiche sous la forme `Packet filtered`. Son voisin `10.3.3.20` ne correspond qu'à la `/24`, donc il passe toujours par `r2`. Supprimez la route de test :

```bash
sudo ip -n lab-r1 route del prohibit 10.3.3.10/32
```

Il n'y a aucune sortie quand la commande réussit.

### Étape 11 — Cassez une route aller et localisez la panne (5 min)
Un collègue « fait le ménage » sur `r2` et supprime sa route vers `10.3.3.0/24`. Jouez le rôle du collègue, puis dépannez comme si vous n'étiez au courant de rien.

```bash
sudo ip -n lab-r2 route del 10.3.3.0/24
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Sortie attendue :
```text
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
From 10.0.12.2 icmp_seq=1 Destination Net Unreachable
From 10.0.12.2 icmp_seq=2 Destination Net Unreachable

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 0 received, +2 errors, 100% packet loss, time 1064ms
```

L'erreur désigne le coupable : `10.0.12.2` est `r2`. Traceroute montre la même chose :

```bash
sudo ip netns exec lab-h1 traceroute -n 10.3.3.10
```

Sortie attendue :
```text
traceroute to 10.3.3.10 (10.3.3.10), 30 hops max, 60 byte packets
 1  10.1.1.1  0.026 ms  0.005 ms  0.004 ms
 2  10.0.12.2  0.010 ms !N  0.006 ms !N *
```

`!N` signifie *network unreachable* (réseau inaccessible) : le saut 2 a répondu qu'il n'a pas de route. Comparez avec l'Étape 7 : une route *aller* manquante produit généralement une erreur venant du routeur qui en est dépourvu, alors qu'une route *retour* manquante produit du silence. Confirmez sur `r2` et corrigez :

```bash
sudo ip -n lab-r2 route get 10.3.3.10
sudo ip -n lab-r2 route add 10.3.3.0/24 via 10.0.23.2
sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
```

Sortie attendue :
```text
RTNETLINK answers: Network is unreachable
PING 10.3.3.10 (10.3.3.10) 56(84) bytes of data.
64 bytes from 10.3.3.10: icmp_seq=1 ttl=61 time=0.073 ms
64 bytes from 10.3.3.10: icmp_seq=2 ttl=61 time=0.045 ms

--- 10.3.3.10 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1056ms
rtt min/avg/max/mdev = 0.045/0.059/0.073/0.014 ms
```

> [!NOTE]
> Les sorties de la partie A proviennent d'une exécution réelle avec iproute2 6.17, iputils 20250605 et traceroute 2.1.6 sous Linux 7.2. Elle a été effectuée dans un user namespace et un network namespace non privilégiés (`unshare -rn`) plutôt qu'avec `sudo`, ce qui ne change pas le comportement du routage. D'autres versions peuvent formuler les messages légèrement différemment.

### Partie B (facultative) — Remplacez les routes statiques par OSPF
Dans la partie A, vous avez saisi sept routes et traqué trois pannes à la main. Ici, trois routeurs apprennent eux-mêmes les mêmes réseaux grâce à OSPF. Vous exécutez **FRRouting** (FRR), une suite de routage open source, dans trois conteneurs. Cette partie est facultative et dure environ 25 minutes.

![Partie facultative : trois conteneurs FRRouting dans l'aire OSPF 0. lab-ospf-r1 (ID de routeur 10.255.0.1) a eth0 10.1.1.11 sur ospf-lan1 (10.1.1.0/24) et eth1 10.0.12.11 sur ospf-r1r2 (10.0.12.0/24). lab-ospf-r2 (10.255.0.2) a eth0 10.0.12.12 et eth1 10.0.23.12 sur ospf-r2r3 (10.0.23.0/24). lab-ospf-r3 (10.255.0.3) a eth0 10.3.3.13 sur ospf-lan3 (10.3.3.0/24) et eth1 10.0.23.13. Les messages Hello OSPF sont envoyés toutes les 10 secondes à 224.0.0.5 sur chaque interface OSPF](../../../assets/diagrams/routing-lab-ospf.fr.svg)

*Figure 3. La même ligne de trois routeurs, cette fois sous forme de conteneurs. Les réseaux de conteneurs reprennent les préfixes de la partie A, mais les liens sont des /24 et les routeurs utilisent les numéros d'hôte 11, 12 et 13.*

> [!NOTE]
> Les moteurs de conteneurs réservent la première adresse de chaque réseau (`.1`) à leur propre bridge, c'est pourquoi les routeurs utilisent `.11`, `.12` et `.13`. Les commandes ont été testées avec Podman 5.8 sans privilèges (rootless) et l'image `quay.io/frrouting/frr:10.7.1`. Docker utilise les mêmes commandes, mais elles n'ont pas été testées avec Docker pour ce lab. Avec Docker, vous aurez peut-être besoin de `sudo` ou de l'appartenance au groupe `docker`.

### Étape 12 — Préparez la configuration de FRR (5 min)
Chaque routeur a besoin de trois fichiers dans son propre dossier : `daemons` (quels démons FRR démarrer), `vtysh.conf` (paramètres de l'interpréteur de commandes de FRR) et `frr.conf` (la configuration du routage). Choisissez d'abord votre moteur de conteneurs et récupérez le fichier `daemons` par défaut de l'image :

```bash
CT=podman          # or: CT=docker
IMG=quay.io/frrouting/frr:10.7.1
mkdir -p ~/ospf-lab && cd ~/ospf-lab
$CT run --rm --entrypoint cat $IMG /etc/frr/daemons > daemons.orig
for n in 1 2 3; do
  mkdir -p r$n
  sed 's/^ospfd=no/ospfd=yes/' daemons.orig > r$n/daemons
  echo 'service integrated-vtysh-config' > r$n/vtysh.conf
done
grep '^ospfd' r1/daemons
```

Sortie attendue (après les messages de téléchargement de l'image) :
```text
ospfd=yes
ospfd_options="  -A 127.0.0.1"
```

`CT` contient le moteur de conteneurs et `IMG` l'image exacte. La commande `sed` active le démon OSPF, que l'image fournit désactivé. Écrivez maintenant la configuration OSPF de chaque routeur. Une instruction `network` active OSPF dans l'aire 0 sur chaque interface dont l'adresse appartient à ce préfixe, et annonce le préfixe.

```bash
cat > r1/frr.conf <<'EOF'
frr defaults traditional
hostname r1
!
router ospf
 ospf router-id 10.255.0.1
 network 10.1.1.0/24 area 0
 network 10.0.12.0/24 area 0
!
EOF
cat > r2/frr.conf <<'EOF'
frr defaults traditional
hostname r2
!
router ospf
 ospf router-id 10.255.0.2
 network 10.0.12.0/24 area 0
 network 10.0.23.0/24 area 0
!
EOF
cat > r3/frr.conf <<'EOF'
frr defaults traditional
hostname r3
!
router ospf
 ospf router-id 10.255.0.3
 network 10.0.23.0/24 area 0
 network 10.3.3.0/24 area 0
!
EOF
```

Il n'y a aucune sortie. L'**ID de routeur** (*router ID*) est un nombre de 32 bits, écrit comme une adresse IPv4, qui désigne chaque routeur dans la base de données d'états de lien (LSDB, Link-State Database). Il doit être unique.

### Étape 13 — Créez les réseaux et démarrez les routeurs (4 min)
Chaque lien devient un réseau de conteneurs interne (sans accès à Internet). Chaque routeur démarre sur un réseau, puis est connecté à son second réseau.

```bash
$CT network create --internal --subnet 10.1.1.0/24  ospf-lan1
$CT network create --internal --subnet 10.0.12.0/24 ospf-r1r2
$CT network create --internal --subnet 10.0.23.0/24 ospf-r2r3
$CT network create --internal --subnet 10.3.3.0/24  ospf-lan3

for spec in "r1 ospf-lan1 10.1.1.11" "r2 ospf-r1r2 10.0.12.12" "r3 ospf-lan3 10.3.3.13"; do
  set -- $spec
  $CT run -d --name lab-ospf-$1 --hostname $1 \
    --network $2 --ip $3 \
    --cap-add NET_ADMIN --cap-add NET_RAW --cap-add SYS_ADMIN \
    --sysctl net.ipv4.ip_forward=1 \
    -v "$PWD/$1:/etc/frr:Z" $IMG
done

$CT network connect --ip 10.0.12.11 ospf-r1r2 lab-ospf-r1
$CT network connect --ip 10.0.23.12 ospf-r2r3 lab-ospf-r2
$CT network connect --ip 10.0.23.13 ospf-r2r3 lab-ospf-r3
$CT ps --filter name=lab-ospf --format '{{.Names}} {{.Status}}'
```

Sortie attendue (les noms des réseaux, puis trois longs identifiants de conteneur, puis) :
```text
lab-ospf-r1 Up Less than a second
lab-ospf-r2 Up Less than a second
lab-ospf-r3 Up Less than a second
```

Rôle des options :
- `--cap-add NET_ADMIN` permet à FRR d'installer des routes dans la table de routage du conteneur, `NET_RAW` lui permet d'envoyer des paquets OSPF (protocole IP 89). `SYS_ADMIN` est également nécessaire : les démons de FRR le demandent au démarrage (il sert à la prise en charge des network namespaces), et sans lui ils s'arrêtent avec `privs_init: initial cap_set_proc failed: Operation not permitted`.

> [!WARNING]
> `SYS_ADMIN` est la capacité Linux la plus étendue. Ne l'accordez qu'à ces conteneurs de lab, qui se trouvent sur des réseaux internes sans accès à Internet, et privilégiez Podman sans privilèges : la capacité s'y applique à l'intérieur de votre user namespace, pas à l'hôte. Ne réutilisez jamais ces options pour des conteneurs qui exécutent des logiciels non fiables.
- `--sysctl net.ipv4.ip_forward=1` transforme chaque conteneur en routeur, comme à l'Étape 5.
- `-v "$PWD/$1:/etc/frr:Z"` monte le dossier de configuration du routeur. `:Z` le réétiquette pour SELinux, lorsque celui-ci est activé.

### Étape 14 — Regardez les voisins s'établir (4 min)
Les routeurs OSPF se découvrent par des messages Hello envoyés toutes les 10 secondes. Sur un réseau de type Ethernet, ils attendent en outre jusqu'à 40 secondes pour élire un routeur désigné (DR, Designated Router) avant de se synchroniser. Attendez environ une minute, puis examinez `r2`, qui a deux voisins :

```bash
sleep 60
$CT exec lab-ospf-r2 vtysh -c 'show ip ospf neighbor'
```

Sortie attendue (les durées varient) :
```text
Neighbor ID     Pri State           Up Time         Dead Time Address         Interface                        RXmtL RqstL DBsmL
10.255.0.1        1 Full/Backup     10.206s           39.735s 10.0.12.11      eth0:10.0.12.12                      0     0     0
10.255.0.3        1 Full/DR         10.108s           39.894s 10.0.23.13      eth1:10.0.23.12                      0     0     0
```

Les deux voisins sont **Full** : leurs bases de données sont synchronisées. `DR` et `Backup` indiquent quel routeur a été élu routeur désigné et routeur désigné de secours sur chaque lien. Si vous regardez trop tôt, vous verrez des états tels que `Init` ou `2-Way`.

### Étape 15 — Lisez les routes construites par OSPF (5 min)
Regardez la table de routage de `r1` dans FRR, puis dans le noyau Linux :

```bash
$CT exec lab-ospf-r1 vtysh -c 'show ip route'
$CT exec lab-ospf-r1 ip route
```

Sortie attendue (après une légende des codes de route ; les durées varient) :
```text
IPv4 unicast VRF default:
C>* 10.0.12.0/24 is directly connected, eth1, weight 1, 00:00:50
L>* 10.0.12.11/32 is directly connected, eth1, weight 1, 00:00:50
O>* 10.0.23.0/24 [110/20] via 10.0.12.12, eth1, weight 1, 00:00:05
C>* 10.1.1.0/24 is directly connected, eth0, weight 1, 00:00:50
L>* 10.1.1.11/32 is directly connected, eth0, weight 1, 00:00:50
O>* 10.3.3.0/24 [110/30] via 10.0.12.12, eth1, weight 1, 00:00:05
10.0.12.0/24 dev eth1 proto kernel scope link src 10.0.12.11
10.0.23.0/24 nhid 10 via 10.0.12.12 dev eth1 proto ospf metric 20
10.1.1.0/24 dev eth0 proto kernel scope link src 10.1.1.11
10.3.3.0/24 nhid 10 via 10.0.12.12 dev eth1 proto ospf metric 20
```

Comment la lire :
- `O` marque les routes apprises par OSPF, `C` les routes connectées et `L` les adresses propres du routeur. `>*` signifie « sélectionnée et installée ».
- `[110/30]` se lit *[distance administrative/métrique]*. FRR attribue à OSPF une distance de 110, comme Cisco IOS. Le coût vers `10.3.3.0/24` est de 30 : trois interfaces d'un coût de 10 chacune (`r1`→`r2`, `r2`→`r3` et le réseau local de `r3`).
- Dans la table du noyau, les mêmes routes apparaissent avec `proto ospf`. Le noyau Linux n'a pas de distance administrative, donc FRR choisit lui-même la meilleure route et n'installe que celle-là.

Vous n'avez saisi aucune route, mais `r1` connaît `10.3.3.0/24` et le lien `10.0.23.0/24`, donc les problèmes de chemin retour et de saut silencieux de la partie A ne peuvent pas se produire ici.

### Étape 16 — Faites tomber un lien et observez la réaction d'OSPF (4 min)
Déconnectez `r2` du lien `r2`–`r3`, comme si quelqu'un avait débranché le câble :

```bash
$CT network disconnect ospf-r2r3 lab-ospf-r2
sleep 3
$CT exec lab-ospf-r1 vtysh -c 'show ip route ospf'
$CT exec lab-ospf-r1 ping -c 2 -W 1 10.3.3.13
```

Sortie attendue :
```text
PING 10.3.3.13 (10.3.3.13): 56 data bytes
ping: sendto: Network unreachable
```

`show ip route ospf` n'affiche rien : en quelques secondes, `r2` a diffusé le changement et `r1` a retiré les deux routes situées derrière le lien rompu. Le `ping` à l'intérieur du conteneur est celui de BusyBox, dont le message d'erreur est formulé différemment de celui de la partie A. Reconnectez le lien et attendez l'adjacence :

```bash
$CT network connect --ip 10.0.23.12 ospf-r2r3 lab-ospf-r2
sleep 60
$CT exec lab-ospf-r1 vtysh -c 'show ip route ospf'
```

Sortie attendue (après la légende ; les durées varient) :
```text
IPv4 unicast VRF default:
O>* 10.0.23.0/24 [110/20] via 10.0.12.12, eth1, weight 1, 00:00:50
O>* 10.3.3.0/24 [110/30] via 10.0.12.12, eth1, weight 1, 00:00:39
```

Les routes sont revenues sans que personne ne les saisisse. Avec un seul chemin, OSPF ne peut pas contourner la panne, mais il retire les routes mortes et les rétablit automatiquement. Avec un lien redondant, il basculerait sur l'autre chemin. C'est l'objet du défi ci-dessous.

> [!NOTE]
> Les sorties de la partie B proviennent d'une exécution réelle avec Podman 5.8.7 sans privilèges et FRR 10.7.1 (`quay.io/frrouting/frr:10.7.1`, environ 94 Mo compressés). Elle n'a pas été testée avec Docker.

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

1. Les deux hôtes se joignent à travers trois routeurs :
   ```bash
   sudo ip netns exec lab-h1 ping -c 2 10.3.3.10
   sudo ip netns exec lab-h2 ping -c 2 10.1.1.10
   ```
   Les deux indiquent `0% packet loss` et `ttl=61`.
2. La trace inverse liste chaque routeur :
   ```bash
   sudo ip netns exec lab-h2 traceroute -n 10.1.1.10
   ```
   Sortie attendue (les durées varient) :
   ```text
   traceroute to 10.1.1.10 (10.1.1.10), 30 hops max, 60 byte packets
    1  10.3.3.1  0.042 ms  0.006 ms  0.005 ms
    2  10.0.23.1  0.018 ms  0.008 ms  0.006 ms
    3  10.0.12.1  0.017 ms  0.008 ms  0.007 ms
    4  10.1.1.10  0.017 ms  0.010 ms  0.009 ms
   ```
3. Vous pouvez expliquer, pour chacun de ces symptômes, quelle route manquait et sur quel routeur : `Destination Net Unreachable` depuis `10.1.1.1` (Étape 6), perte de 100 % silencieuse (Étapes 7–8), `* * *` au saut 3 (Étape 9) et `!N` au saut 2 (Étape 11).
4. (Partie B facultative) `show ip ospf neighbor` sur `lab-ospf-r2` affiche deux voisins à l'état `Full`, et `r1` possède des routes `O` vers `10.0.23.0/24` et `10.3.3.0/24`.

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `RTNETLINK answers: Operation not permitted` | Vous avez lancé sans `sudo` une commande qui modifie le réseau. | Faites précéder la commande de `sudo`. |
| `Cannot open network namespace "lab-r1": No such file or directory` | Le namespace n'existe pas : une étape a été sautée, il y a une faute de frappe, ou le nettoyage a déjà été exécuté. | Lancez `ip netns list` et créez ce qui manque (Étape 2). |
| `RTNETLINK answers: File exists` | La route, l'adresse ou l'interface existe déjà, par exemple parce qu'une étape a été exécutée deux fois. | Vérifiez avec `ip -n <namespace> route`. Utilisez `ip route replace` pour modifier une route, ou supprimez-la d'abord. |
| `Error: Nexthop has invalid gateway.` | Le prochain saut ne se trouve pas sur un sous-réseau connecté de ce routeur, souvent à cause d'une faute de frappe ou d'un mauvais routeur. | Utilisez l'adresse du voisin sur le lien partagé, par exemple `10.0.12.2` depuis `r1`. |
| Le ping vers le voisin d'un routeur fonctionne, mais au-delà il y a 100 % de perte sans erreur, et traceroute affiche `* * *` à partir du saut suivant | Le routage IP est désactivé sur ce routeur (`sysctl net.ipv4.ip_forward` affiche 0). Il rejette les paquets sans aucun message ICMP. | Refaites l'Étape 5 pour ce routeur. |
| 100 % de perte sans erreur, le routage IP est activé | Une route retour manque quelque part sur le chemin de retour. | Exécutez `ip route get <adresse source>` sur chaque routeur, de la destination vers la source (Étape 8). |
| `From <routeur> Destination Net Unreachable` ou `!N` dans traceroute | Ce routeur n'a pas de route vers la destination. | Ajoutez la route aller sur ce routeur (Étapes 7 et 11). |
| `traceroute: command not found` | Le paquet `traceroute` n'est pas installé. | Installez-le (voir Prérequis), ou utilisez `tracepath -n`, qui fait partie d'iputils. |
| (Partie B) `Error: ... subnet ... is already used` ou `Pool overlaps with other one on this address space` | Un autre réseau de conteneurs ou une route de l'hôte utilise déjà l'un des sous-réseaux. | Supprimez le réseau en conflit, ou modifiez les préfixes de façon cohérente dans les commandes de création des réseaux et dans les fichiers `frr.conf`. |
| (Partie B) Voisins bloqués à l'état `Init` ou `2-Way`, ou aucune route `O` | Vous avez regardé avant la fin de l'attente de 40 secondes, ou la configuration contient une erreur. | Attendez une minute et vérifiez de nouveau. Lisez le journal avec `$CT logs lab-ospf-r2`, et vérifiez les instructions `network` et les ID de routeur. |

## Défi (facultatif)
1. **Route statique flottante.** Sur `lab-h1`, ajoutez une seconde route par défaut avec une métrique plus élevée (`metric 200`) passant par l'adresse d'un routeur qui n'existe pas encore. Prédisez quelle route `ip route get 198.51.100.7` utilise, vérifiez, puis supprimez la route par défaut principale pour voir la route de secours prendre le relais.
2. **Chemin OSPF redondant.** Dans la partie B, créez un cinquième réseau `ospf-r1r3` (`10.0.13.0/24`), connectez-y `r1` et `r3` et ajoutez-le à leur configuration OSPF (`network 10.0.13.0/24 area 0` ; rechargez avec `$CT restart`). Quel chemin `r1` utilise-t-il maintenant vers `10.3.3.0/24`, et avec quel coût ? Déconnectez le nouveau lien et mesurez le temps que met `r1` à rebasculer.
3. **Protéger OSPF.** Activez l'authentification cryptographique OSPF sur un lien, en vous appuyant sur la documentation de FRR pour `ip ospf authentication message-digest` ou les chaînes de clés. Configurez-la d'abord d'un seul côté et observez la chute de l'adjacence.

## Nettoyage
Supprimez les cinq namespaces. Supprimer un namespace supprime aussi les interfaces veth qu'il contient, et supprimer une extrémité d'une paire veth supprime l'autre.

```bash
for ns in lab-h1 lab-r1 lab-r2 lab-r3 lab-h2; do
  sudo ip netns del $ns
done
ip netns list
```

Sortie attendue : `ip netns list` n'affiche rien (ou du moins aucun namespace `lab-`).

Si vous avez fait la partie B, supprimez les conteneurs, les réseaux, le dossier de configuration et l'image. Redéfinissez `CT` si vous avez ouvert un nouveau terminal.

```bash
CT=podman          # or: CT=docker
$CT rm -f lab-ospf-r1 lab-ospf-r2 lab-ospf-r3
$CT network rm ospf-lan1 ospf-r1r2 ospf-r2r3 ospf-lan3
$CT rmi quay.io/frrouting/frr:10.7.1
cd ~ && rm -r ~/ospf-lab
$CT ps -a --filter name=lab-ospf
$CT network ls --filter name=ospf-
```

Sortie attendue : les deux dernières commandes n'affichent que leurs lignes d'en-tête, sans conteneur `lab-ospf` ni réseau `ospf-`.

## Ce que vous avez appris
- Un network namespace Linux avec `net.ipv4.ip_forward=1` est un routeur. Sa table de routage ne contient au départ que des routes connectées.
- Le routage fonctionne séparément dans chaque sens : une route aller manquante produit une erreur ICMP venant du routeur qui en est dépourvu, alors qu'une route retour manquante produit souvent du silence.
- `ip route get` sur chaque saut, vers la destination puis en sens inverse vers la source, permet de trouver rapidement le routeur auquel manque une route.
- Un saut `* * *` peut très bien transmettre le trafic. Ici, ses réponses étaient rejetées par un filtre de chemin inverse, parce qu'un routeur n'avait pas de route de retour vers une partie du réseau.
- La correspondance du préfixe le plus long choisit la route la plus spécifique, quel que soit l'ordre d'ajout des routes.
- (Facultatif) OSPF construit automatiquement les mêmes routes à partir de messages Hello et d'une base de données partagée, les affiche avec la distance 110 et une métrique de coût, et les retire puis les rétablit lorsqu'un lien tombe.
