# [COURS] GUIDE COMPLET SUR LE ROUTING (ROUTAGE) - ULTRA DÉTAILLÉ POUR DÉBUTANTS ABSOLUS

---

## * AVANT DE COMMENCER : COMPRENDRE LES BASES

### Qu'est-ce que le routage (routing) ?

**Analogie du système postal :**

Imagine que tu veux envoyer une lettre depuis ta maison :

```
[EMAIL] COMMENT UNE LETTRE ARRIVE À DESTINATION ?

Toi (Expéditeur) -> Tu déposes la lettre dans ta boîte
                    v
              Bureau de poste LOCAL
                    v
         (Regarde l'adresse de destination)
                    v
    ┌───────────────┴───────────────┐
    │                               │
    v                               v
Quartier LOCAL ?              Autre ville ?
(même code postal)         (code postal différent)
    │                               │
    v                               v
Distribution directe      Centre de tri RÉGIONAL
                                    v
                          Centre de tri NATIONAL
                                    v
                          Centre de tri de la ville
                                    v
                          Bureau de poste local
                                    v
                              Destinataire [OBJECTIF]
```

**C'est EXACTEMENT pareil pour les données sur un réseau !**

---

### Qu'est-ce qu'une route réseau ?

**Route = Instruction qui dit : "Pour aller à [DESTINATION], passe par [CHEMIN]"**

**Analogie de la ville :**

```
[HOUSE_BUILDINGS] TON QUARTIER (RÉSEAU LOCAL)
│
├─ Maison 1 (192.168.1.1) <- Box/Routeur (la "Poste locale")
├─ Maison 51 (192.168.1.51) <- Ton PC
├─ Maison 100 (192.168.1.100) <- Ta VM
│
└─ SORTIE DU QUARTIER -> Autoroute vers le monde extérieur (Internet)
   Cette sortie = la "PASSERELLE" (Gateway)
```

**Questions qu'un ordinateur se pose quand il veut envoyer des données :**

1. **"Où je veux aller ?"**
   - Destination : 192.168.1.51 -> C'est dans mon quartier !
   - Destination : 8.8.8.8 -> C'est ailleurs, je ne connais pas ce quartier

2. **"Comment j'y vais ?"**
   - Si c'est dans mon quartier (192.168.1.X) -> J'y vais directement
   - Si c'est ailleurs -> Je passe par la sortie du quartier (passerelle)

**C'est ça, le routage ! [OBJECTIF]**

---

### Les types de routes

**Il existe 3 types principaux de routes :**

```
┌────────────────────────────────────────────────────┐
│ 1⃣ ROUTE DIRECTE (Connected Route)                │
│                                                    │
│ Pour : Les appareils du même réseau               │
│ Action : Communique DIRECTEMENT                   │
│                                                    │
│ Exemple :                                          │
│ 192.168.1.51 veut parler à 192.168.1.100         │
│ -> Pas besoin de passer par un routeur            │
│ -> Communication directe [OK]                         │
└────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────┐
│ 2⃣ ROUTE PAR DÉFAUT (Default Route)               │
│                                                    │
│ Pour : TOUT ce qui n'est pas dans le réseau local │
│ Action : Passe par la PASSERELLE                  │
│                                                    │
│ Exemple :                                          │
│ Tu veux aller sur google.com (8.8.8.8)           │
│ -> Ce n'est pas dans 192.168.1.X                  │
│ -> Passe par la Box (192.168.1.1) [OK]               │
└────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────┐
│ 3⃣ ROUTE STATIQUE (Static Route)                  │
│                                                    │
│ Pour : Atteindre un réseau SPÉCIFIQUE             │
│ Action : Passe par un routeur SPÉCIFIQUE          │
│                                                    │
│ Exemple :                                          │
│ Réseau entreprise : 10.20.30.0/24                │
│ -> Passe par le VPN gateway : 192.168.1.200       │
└────────────────────────────────────────────────────┘
```

---

### Qu'est-ce qu'une passerelle (Gateway) ?

**Gateway = Passerelle = Routeur = Porte de sortie vers l'extérieur**

**Analogie complète :**

```
[HOUSE_BUILDINGS] TON QUARTIER = RÉSEAU LOCAL (192.168.1.0/24)
│
│ Tous les habitants se connaissent
│ Ils peuvent se rendre visite directement
│
├─ [ACCUEIL] Maison 1   (192.168.1.1)   <- Box/Routeur
├─ [ACCUEIL] Maison 51  (192.168.1.51)  <- Ton PC
├─ [ACCUEIL] Maison 100 (192.168.1.100) <- Ta VM
│
└─ [SORTIE] PORTE DU QUARTIER (GATEWAY)
   │
   │ C'est la Box (192.168.1.1)
   │
   └─ [MOTORWAY] AUTOROUTE VERS LE MONDE (INTERNET)
      │
      ├─ Autre ville (8.8.8.8 - Google DNS)
      ├─ Autre pays (1.1.1.1 - Cloudflare)
      └─ Partout ailleurs
```

**Rôle de la passerelle :**

1. **Recevoir** les paquets qui vont "ailleurs"
2. **Connaître** le chemin vers Internet
3. **Transférer** les paquets au bon endroit
4. **Recevoir** les réponses
5. **Renvoyer** les réponses à l'émetteur d'origine

**Sans passerelle :**
- [OK] Tu peux communiquer avec les appareils du réseau local
- [X] Tu ne peux PAS accéder à Internet
- [X] Tu ne peux PAS accéder à d'autres réseaux

---

### Comment un ordinateur choisit sa route ?

**Processus de décision (automatique) :**

```
┌─────────────────────────────────────────────────┐
│ ÉTAPE 1 : Quel est le réseau de destination ?   │
└─────────────┬───────────────────────────────────┘
              │
              v
    ┌─────────────────────┐
    │ Destination :       │
    │ 192.168.1.51        │
    └─────────┬───────────┘
              │
              v
┌─────────────────────────────────────────────────┐
│ ÉTAPE 2 : Consulter la TABLE DE ROUTAGE         │
│                                                 │
│ Table de routage = Liste de toutes les routes   │
│ disponibles sur l'ordinateur                    │
└─────────────┬───────────────────────────────────┘
              │
              v
    ┌─────────────────────┐
    │ Recherche :         │
    │ • Route directe ?   │
    │ • Route statique ?  │
    │ • Route par défaut ?│
    └─────────┬───────────┘
              │
              v
┌─────────────────────────────────────────────────┐
│ ÉTAPE 3 : CORRESPONDANCE TROUVÉE !              │
│                                                 │
│ Destination : 192.168.1.51                      │
│ Correspond à : 192.168.1.0/24 (réseau local)    │
│ Action : Envoi DIRECT [OK]                        │
└─────────────────────────────────────────────────┘
```

**Exemple avec destination Internet :**

```
┌─────────────────────────────────────────────────┐
│ ÉTAPE 1 : Destination = 8.8.8.8 (Google DNS)    │
└─────────────┬───────────────────────────────────┘
              │
              v
┌───────────────────────────────────────────────────────┐
│ ÉTAPE 2 : Consulter la table de routage               │
│                                                       │
│ • 192.168.1.0/24 -> Direct [X] (pas une correspondance) │
│ • 0.0.0.0/0 -> Gateway [OK] (route par défaut)           │
└─────────────┬─────────────────────────────────────────┘
              │
              v
┌─────────────────────────────────────────────────┐
│ ÉTAPE 3 : Utiliser la route par défaut         │
│                                                 │
│ Destination : 8.8.8.8                          │
│ Pas de route spécifique -> Route par défaut     │
│ Action : Envoyer à la passerelle (192.168.1.1) │
└─────────────────────────────────────────────────┘
```

---

## [OBJECTIF] OBJECTIF DU PROJET

### Ce qu'on va faire aujourd'hui

**On va apprendre à :**

1. [OK] **Voir** la table de routage actuelle
2. [OK] **Comprendre** chaque route
3. [OK] **Configurer** une route par défaut (accès Internet)
4. [OK] **Ajouter** des routes statiques (réseaux spécifiques)
5. [OK] **Tester** que tout fonctionne
6. [OK] **Dépanner** les problèmes courants

---

### Schéma de ce qu'on va construire

```
[WEB] INTERNET
│
├─ 8.8.8.8 (Google DNS)
├─ 1.1.1.1 (Cloudflare)
└─ Tout le reste du monde
      ^
      │
      │ Route par défaut
      │ via 192.168.1.1
      │
┌─────┴──────────────────────────────────────────┐
│  [RESEAU] BOX/ROUTEUR (192.168.1.1)                  │
│     = PASSERELLE                               │
└─────┬──────────────────────────────────────────┘
      │
      │ Réseau local : 192.168.1.0/24
      │
      ├─ [ECRAN] PC Windows (192.168.1.51)
      │   Table de routage :
      │   • 192.168.1.0/24 -> Direct
      │   • 0.0.0.0/0 -> via 192.168.1.1
      │
      └─ [CODE] VM Linux (192.168.1.100)
          Table de routage :
          • 192.168.1.0/24 -> Direct
          • 0.0.0.0/0 -> via 192.168.1.1
          • 10.20.30.0/24 -> via 192.168.1.200 (route statique)
```

---

## [DOCS] ÉTAPE 1 : COMPRENDRE LA TABLE DE ROUTAGE

### Qu'est-ce qu'une table de routage ?

**Table de routage = Carnet d'adresses pour les données**

**Analogie :**

```
[GUIDE] CARNET D'ADRESSES POSTAL

┌──────────────────────────────────────────────┐
│ Destination      │ Comment y aller ?         │
├──────────────────────────────────────────────┤
│ Même rue         │ Y aller à pied            │
│ Même quartier    │ Y aller à vélo            │
│ Autre ville      │ Prendre l'autoroute       │
│ N'importe où     │ Aller à la gare centrale  │
└──────────────────────────────────────────────┘
```

**En réseau :**

```
[GRAPHIQUE] TABLE DE ROUTAGE

┌──────────────────────────────────────────────────────────┐
│ Destination          │ Passerelle    │ Interface         │
├──────────────────────────────────────────────────────────┤
│ 192.168.1.0/24       │ 0.0.0.0       │ enp0s3 (Direct)   │
│ 0.0.0.0/0 (Défaut)   │ 192.168.1.1   │ enp0s3            │
│ 10.20.30.0/24        │ 192.168.1.200 │ enp0s3 (Statique) │
└──────────────────────────────────────────────────────────┘
```

---

### [LINUX] Voir la table de routage sur LINUX

**Commande moderne (recommandée) :**

```bash
ip route show
```

**Commande ancienne (toujours fonctionnelle) :**

```bash
route -n
```

**Résultat attendu (exemple) :**

```bash
$ ip route show

default via 192.168.1.1 dev enp0s3 proto static metric 100
192.168.1.0/24 dev enp0s3 proto kernel scope link src 192.168.1.100 metric 100
```

---

### [GUIDE] Décryptage LIGNE PAR LIGNE

#### **Ligne 1 : Route par défaut**

```
default via 192.168.1.1 dev enp0s3 proto static metric 100
```

**Décortiquons chaque élément :**

```
default
   ^
   Signifie : 0.0.0.0/0
   = TOUTES les destinations qui ne correspondent à aucune autre route
   = Route "fourre-tout" pour Internet
```

```
via 192.168.1.1
    ^
    = "par l'intermédiaire de"
    = Passerelle à utiliser
    = L'IP de la Box/Routeur
```

```
dev enp0s3
    ^
    = "device" (périphérique)
    = Interface réseau à utiliser
    = Le nom de ta carte réseau
```

```
proto static
      ^
      = "protocol" (protocole)
      = Comment cette route a été ajoutée
      
      Valeurs possibles :
      • static = Ajoutée manuellement (configuration fixe)
      • kernel = Ajoutée automatiquement par le système
      • dhcp = Ajoutée par le serveur DHCP
      • boot = Ajoutée au démarrage
```

```
metric 100
       ^
       = Priorité de la route (plus le chiffre est BAS, plus la priorité est HAUTE)
       
       Exemple :
       Route A : metric 50
       Route B : metric 100
       -> Route A sera utilisée en priorité
       
       Utile quand il y a plusieurs routes vers la même destination
       (exemple : connexion Ethernet + WiFi en même temps)
```

**En résumé :**
```
"Pour aller N'IMPORTE OÙ (default),
passe par la Box (via 192.168.1.1),
en utilisant la carte réseau enp0s3 (dev enp0s3),
route configurée manuellement (proto static),
avec une priorité de 100 (metric 100)"
```

---

#### **Ligne 2 : Route directe (réseau local)**

```
192.168.1.0/24 dev enp0s3 proto kernel scope link src 192.168.1.100 metric 100
```

**Décortiquons :**

```
192.168.1.0/24
     ^
     = Réseau de destination
     
     Décryptage :
     192.168.1.0 = Adresse du réseau
     /24 = Masque de sous-réseau (255.255.255.0)
     
     Signifie : Toutes les IPs de 192.168.1.1 à 192.168.1.254
```

```
dev enp0s3
    ^
    = Interface à utiliser (ta carte réseau)
```

```
proto kernel
      ^
      = Ajoutée automatiquement par le noyau Linux
      
      Pourquoi ?
      Quand tu configures une IP (192.168.1.100/24),
      Linux comprend automatiquement :
      "Ah, je suis dans le réseau 192.168.1.0/24,
      donc toutes les IPs de ce réseau sont accessibles directement"
```

```
scope link
      ^
      = Portée de la route
      
      Valeurs possibles :
      • link = Réseau local (lien direct, même câble/WiFi)
      • host = Uniquement cet ordinateur (127.0.0.1)
      • global = Accessible de partout (Internet)
```

```
src 192.168.1.100
    ^
    = "source"
    = Adresse IP source à utiliser pour ce réseau
    
    Quand tu envoies un paquet vers 192.168.1.X,
    l'adresse IP d'expéditeur sera 192.168.1.100
```

```
metric 100
       ^
       = Priorité (même principe que pour la route par défaut)
```

**En résumé :**
```
"Pour aller vers 192.168.1.0/24 (réseau local),
utilise directement la carte enp0s3 (dev enp0s3),
route ajoutée automatiquement par le système (proto kernel),
c'est un réseau local direct (scope link),
utilise 192.168.1.100 comme adresse source (src 192.168.1.100),
avec une priorité de 100 (metric 100)"
```

---

### [WINDOW] Voir la table de routage sur WINDOWS

**Ouvre l'Invite de commandes et tape :**

```cmd
route print
```

**Résultat attendu (extrait) :**

```
===========================================================================
Liste d'itinéraires actifs :
Destination réseau    Masque réseau      Adr. passerelle   Adr. interface Métrique
          0.0.0.0          0.0.0.0      192.168.1.1      192.168.1.51      25
        192.168.1.0    255.255.255.0         On-link       192.168.1.51     281
       192.168.1.51  255.255.255.255         On-link       192.168.1.51     281
      192.168.1.255  255.255.255.255         On-link       192.168.1.51     281
===========================================================================
```

**Décryptage :**

| Colonne | Signification |
|---------|---------------|
| **Destination réseau** | Réseau de destination (0.0.0.0 = partout) |
| **Masque réseau** | Masque de sous-réseau |
| **Adr. passerelle** | Passerelle à utiliser (0.0.0.0 = direct) |
| **Adr. interface** | Interface réseau utilisée |
| **Métrique** | Priorité (plus bas = prioritaire) |

**Ligne importante :**

```
0.0.0.0          0.0.0.0      192.168.1.1      192.168.1.51      25
  ^                ^               ^                 ^           ^
Partout      Tout masque    Via la Box    Interface utilisée  Priorité
```

**Traduction :**
```
"Pour aller n'importe où (0.0.0.0),
passe par la passerelle 192.168.1.1,
en utilisant l'interface 192.168.1.51,
avec une métrique (priorité) de 25"
```

---

### [ITEM] Voir la table de routage sur MAC

**Ouvre le Terminal et tape :**

```bash
netstat -nr
```

**Résultat attendu :**

```
Routing tables

Internet:
Destination        Gateway            Flags        Netif Expire
default            192.168.1.1        UGSc           en0
192.168.1.0/24     link#4             UCS            en0      !
192.168.1.51       link#4             UHW            en0      !
```

**Décryptage des Flags :**

| Flag | Signification |
|------|---------------|
| **U** | Up (route active) |
| **G** | Gateway (passe par une passerelle) |
| **S** | Static (route statique) |
| **C** | Cloning (génère de nouvelles routes) |
| **H** | Host (route vers un hôte spécifique) |
| **W** | WasCloned (générée automatiquement) |

---

## [CONFIG] ÉTAPE 2 : CONFIGURER LA ROUTE PAR DÉFAUT

### Pourquoi une route par défaut ?

**Sans route par défaut :**
- [OK] Tu peux communiquer avec le réseau local (192.168.1.X)
- [X] Tu ne peux PAS accéder à Internet
- [X] Tu ne peux PAS accéder à d'autres réseaux

**Avec route par défaut :**
- [OK] Tu peux communiquer avec le réseau local
- [OK] Tu peux accéder à Internet *
- [OK] Tu peux accéder à d'autres réseaux

---

### [LINUX] Configuration sur LINUX avec Netplan

**On va utiliser le fichier Netplan qu'on a déjà vu dans le guide DHCP.**

#### **1. Ouvre le fichier de configuration**

```bash
sudo nano /etc/netplan/01-netcfg.yaml
```

[ATTENTION] **Remplace `01-netcfg.yaml` par le nom exact de TON fichier !**

Pour trouver le nom :
```bash
ls /etc/netplan/
```

---

#### **2. Configuration complète avec route par défaut**

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
```

---

#### **3. Explication DÉTAILLÉE de la section `routes`**

```yaml
routes:
  - to: default
    via: 192.168.1.1
```

**Décortiquons :**

```yaml
routes:
  ^
  Section qui définit les routes
  C'est une LISTE (peut contenir plusieurs routes)
```

```yaml
- to: default
  ^   ^
  │   Destination = "default" = 0.0.0.0/0 = partout
  │
  Le tiret (-) indique un élément de liste
  Chaque route commence par un tiret
```

```yaml
via: 192.168.1.1
 ^       ^
 │       IP de la passerelle (Box/Routeur)
 │
 "par l'intermédiaire de"
```

**En résumé :**
```
"Pour aller n'importe où (to: default),
passe par la Box à l'adresse 192.168.1.1 (via: 192.168.1.1)"
```

---

#### **4. Vérifier que 192.168.1.1 est bien ton routeur**

**Sur ton PC Windows :**

```cmd
ipconfig
```

Cherche :
```
Passerelle par défaut. . . . . . . . . : 192.168.1.1
                                         ^^^^^^^^^^^
                                    C'est ça ton routeur !
```

**Sur Linux/Mac :**

```bash
ip route | grep default
```

Résultat :
```
default via 192.168.1.1 dev enp0s3
            ^^^^^^^^^^^
       C'est l'IP de ton routeur
```

---

#### **5. Appliquer la configuration**

```bash
sudo netplan apply
```

**Si tu vois une erreur :**

Commande de test (annule automatiquement après 120s) :
```bash
sudo netplan try
```

---

#### **6. Vérifier que la route est bien ajoutée**

```bash
ip route show
```

**Résultat attendu :**

```
default via 192.168.1.1 dev enp0s3 proto static metric 100
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LA ROUTE PAR DÉFAUT EST LÀ ! [OK]

192.168.1.0/24 dev enp0s3 proto kernel scope link src 192.168.1.100 metric 100
```

---

#### **7. Tester la connexion Internet**

```bash
ping -c 4 8.8.8.8
```

**Résultat attendu :**

```
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=115 time=15.2 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=115 time=14.8 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=115 time=15.1 ms
64 bytes from 8.8.8.8: icmp_seq=4 ttl=115 time=15.0 ms

--- 8.8.8.8 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss
^^^^^^^^^^^^^^
PARFAIT ! [OK]
```

**Tester avec un nom de domaine :**

```bash
ping -c 4 google.com
```

**Si ça marche :**
```
PING google.com (142.250.185.78) 56(84) bytes of data.
64 bytes from ... [OK]
```

**Si ça ne marche pas :**
```
ping: google.com: Name or service not known
```

-> Problème DNS, vérifie la section `nameservers` dans ton fichier Netplan.

---

### [RECHERCHE] Tracer le chemin des paquets (traceroute)

**Commande pour voir par où passent tes paquets :**

```bash
traceroute google.com
```

**Résultat (exemple) :**

```
traceroute to google.com (142.250.185.78), 30 hops max, 60 byte packets
 1  192.168.1.1 (192.168.1.1)  0.892 ms  0.856 ms  0.832 ms
    ^^^^^^^^^^^^
    Premier saut = Ta Box (passerelle) [OK]
    
 2  10.50.0.1 (10.50.0.1)  5.234 ms  5.201 ms  5.189 ms
    ^^^^^^^^^^
    Routeur de ton FAI
    
 3  80.10.224.134 (80.10.224.134)  12.456 ms  12.423 ms  12.401 ms
    ^
    Routeur régional FAI
    
 4  * * *
    ^
    Routeur qui ne répond pas (normal, c'est pour la sécurité)
    
 ...
 
10  par21s12-in-f14.1e100.net (142.250.185.78)  15.234 ms  15.201 ms  15.189 ms
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    DESTINATION ATTEINTE ! Serveur de Google [OK]
```

**Explication :**

Chaque ligne = Un "saut" (hop) = Un routeur traversé

Le paquet voyage :
```
Ton PC -> Box -> FAI local -> FAI régional -> FAI national -> Internet mondial -> Google
```

C'est comme tracer le chemin d'une lettre de ta boîte jusqu'au destinataire !

---

## [RAILWAY_TRACK] ÉTAPE 3 : AJOUTER DES ROUTES STATIQUES

### Qu'est-ce qu'une route statique ?

**Route statique = Route vers un réseau SPÉCIFIQUE qui n'est pas directement connecté**

**Cas d'usage courants :**

1. **Accès à un réseau d'entreprise via VPN**
2. **Accès à un sous-réseau isolé**
3. **Réseau dans une autre VM VirtualBox**
4. **Laboratoire de test avec plusieurs réseaux**

---

### Exemple pratique : Réseau d'entreprise

**Scénario :**

```
[WEB] INTERNET
│
├─ Via passerelle : 192.168.1.1
│
┌─────┴──────────────────────────────────────────┐
│  [RESEAU] BOX/ROUTEUR (192.168.1.1)                  │
└─────┬──────────────────────────────────────────┘
      │
      │ Réseau local : 192.168.1.0/24
      │
      ├─ [ECRAN] Ton PC (192.168.1.51)
      │
      ├─ [CODE] Ta VM (192.168.1.100)
      │
      └─ [SECURISE] Serveur VPN (192.168.1.200)
             │
             │ Tunnel VPN svers réseau entreprise
             │
             └─ [ENTREPRISE] RÉSEAU ENTREPRISE (10.20.30.0/24)
                  │
                  ├─ Serveur fichiers (10.20.30.10)
                  ├─ Base de données (10.20.30.20)
                  └─ Imprimante (10.20.30.30)
```

**Problème :**

Sans route statique, ton PC ne sait pas comment atteindre 10.20.30.X

**Solution :**

Ajouter une route statique qui dit :
```
"Pour aller vers 10.20.30.0/24,
passe par le serveur VPN (192.168.1.200)"
```

---

### [LINUX] Ajouter une route statique sur LINUX (Netplan)

#### **1. Édite le fichier Netplan**

```bash
sudo nano /etc/netplan/01-netcfg.yaml
```

---

#### **2. Ajoute la route statique**

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
        - to: 10.20.30.0/24
          via: 192.168.1.200
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
```

**Nouvelle section ajoutée :**

```yaml
- to: 10.20.30.0/24
  via: 192.168.1.200
```

**Explication :**

```yaml
- to: 10.20.30.0/24
      ^^^^^^^^^^^
      Réseau de destination (réseau entreprise)
      
      10.20.30.0 = Adresse du réseau
      /24 = Masque (255.255.255.0)
      
      Signifie : Toutes les IPs de 10.20.30.1 à 10.20.30.254
```

```yaml
via: 192.168.1.200
     ^^^^^^^^^^^^^
     Passerelle spécifique pour ce réseau
     = IP du serveur VPN
```

---

#### **3. Configuration avec PLUSIEURS routes statiques**

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
        - to: 10.20.30.0/24
          via: 192.168.1.200
        - to: 172.16.0.0/16
          via: 192.168.1.201
        - to: 10.10.10.0/24
          via: 192.168.1.202
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
```

**Résultat :**

| Destination | Passerelle | Signification |
|-------------|------------|---------------|
| `default` | `192.168.1.1` | Internet (tout le reste) |
| `10.20.30.0/24` | `192.168.1.200` | Réseau entreprise A via VPN1 |
| `172.16.0.0/16` | `192.168.1.201` | Réseau entreprise B via VPN2 |
| `10.10.10.0/24` | `192.168.1.202` | Laboratoire de test via routeur dédié |

---

#### **4. Appliquer la configuration**

```bash
sudo netplan apply
```

---

#### **5. Vérifier les routes**

```bash
ip route show
```

**Résultat attendu :**

```
default via 192.168.1.1 dev enp0s3 proto static metric 100
10.20.30.0/24 via 192.168.1.200 dev enp0s3 proto static metric 100
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ROUTE STATIQUE AJOUTÉE ! [OK]

172.16.0.0/16 via 192.168.1.201 dev enp0s3 proto static metric 100
10.10.10.0/24 via 192.168.1.202 dev enp0s3 proto static metric 100
192.168.1.0/24 dev enp0s3 proto kernel scope link src 192.168.1.100 metric 100
```

---

#### **6. Tester la route**

```bash
ping -c 4 10.20.30.10
```

**Si ça marche :**
```
PING 10.20.30.10 (10.20.30.10) 56(84) bytes of data.
64 bytes from 10.20.30.10: icmp_seq=1 ttl=64 time=2.5 ms
64 bytes from 10.20.30.10: icmp_seq=2 ttl=64 time=2.3 ms
64 bytes from 10.20.30.10: icmp_seq=3 ttl=64 time=2.4 ms
64 bytes from 10.20.30.10: icmp_seq=4 ttl=64 time=2.6 ms

--- 10.20.30.10 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss [OK]
```

**Si ça ne marche pas :**
```
From 192.168.1.100 icmp_seq=1 Destination Host Unreachable
```

**Causes possibles :**
1. [X] La passerelle (192.168.1.200) n'est pas accessible
2. [X] Le serveur VPN n'est pas configuré
3. [X] Le réseau 10.20.30.0/24 n'existe pas

**Déboguer :**

```bash
# Vérifier que la passerelle est accessible
ping -c 4 192.168.1.200

# Tracer le chemin
traceroute 10.20.30.10
```

---

### [WINDOW] Ajouter une route statique sur WINDOWS

#### **Méthode temporaire (perdue au redémarrage)**

```cmd
route add 10.20.30.0 mask 255.255.255.0 192.168.1.200
```

**Décryptage :**

```
route add
  ^
  Commande pour ajouter une route
```

```
10.20.30.0
  ^
  Réseau de destination
```

```
mask 255.255.255.0
     ^
     Masque de sous-réseau
     (équivalent de /24)
```

```
192.168.1.200
  ^
  Passerelle à utiliser
```

---

#### **Méthode permanente (survit au redémarrage)**

```cmd
route add 10.20.30.0 mask 255.255.255.0 192.168.1.200 -p
                                                        ^
                                                "persistent" (permanent)
```

---

#### **Vérifier la route**

```cmd
route print
```

**Cherche dans le résultat :**

```
Destination réseau    Masque réseau      Adr. passerelle   Adr. interface Métrique
       10.20.30.0    255.255.255.0      192.168.1.200     192.168.1.51      1
       ^^^^^^^^^        ^^^^^^^^^^^^^        ^^^^^^^^^^^^^
    Destination        Masque              Passerelle
```

---

#### **Supprimer une route**

```cmd
route delete 10.20.30.0
```

---

### [ITEM] Ajouter une route statique sur MAC

#### **Méthode temporaire**

```bash
sudo route add -net 10.20.30.0/24 192.168.1.200
```

---

#### **Méthode permanente**

Créer un script qui s'exécute au démarrage :

```bash
sudo nano /Library/LaunchDaemons/com.user.route.plist
```

**Contenu :**

```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.route</string>
    <key>ProgramArguments</key>
    <array>
        <string>/sbin/route</string>
        <string>add</string>
        <string>-net</string>
        <string>10.20.30.0/24</string>
        <string>192.168.1.200</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
</dict>
</plist>
```

**Activer :**

```bash
sudo launchctl load /Library/LaunchDaemons/com.user.route.plist
```

---

#### **Vérifier la route**

```bash
netstat -nr | grep 10.20.30
```

**Résultat :**

```
10.20.30.0/24      192.168.1.200      UGSc          en0
```

---

## [RECHERCHE] ÉTAPE 4 : AJOUTER DES ROUTES TEMPORAIRES (Tests)

### Pourquoi des routes temporaires ?

**Avant de rendre une route permanente, tu peux la tester !**

Avantages :
- [OK] Si tu te trompes, la route disparaît au redémarrage
- [OK] Pas de risque de casser ta config
- [OK] Parfait pour expérimenter

---

### [LINUX] Route temporaire sur LINUX

```bash
sudo ip route add 10.20.30.0/24 via 192.168.1.200
```

**Explication :**

```
ip route add
   ^
   Ajoute une route (temporaire, perdue au redémarrage)
```

```
10.20.30.0/24
   ^
   Réseau de destination
```

```
via 192.168.1.200
    ^
    Passerelle
```

---

**Vérifier :**

```bash
ip route show | grep 10.20.30
```

**Résultat :**

```
10.20.30.0/24 via 192.168.1.200 dev enp0s3
```

---

**Supprimer la route temporaire :**

```bash
sudo ip route del 10.20.30.0/24
```

---

**Tester puis rendre permanente :**

```bash
# 1. Ajouter temporairement
sudo ip route add 10.20.30.0/24 via 192.168.1.200

# 2. Tester
ping -c 4 10.20.30.10

# 3. Si ça marche, rendre permanent en éditant Netplan
sudo nano /etc/netplan/01-netcfg.yaml
# Ajouter la route comme vu précédemment
```

---

## [GRAPHIQUE] ÉTAPE 5 : COMMANDES UTILES POUR DÉPANNER

### [RECHERCHE] Diagnostic réseau complet

#### **1. Voir TOUTES les interfaces réseau**

```bash
ip a
```

**Résultat :**

```
1: lo: <LOOPBACK,UP,LOWER_UP>
   inet 127.0.0.1/8 scope host lo
   
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP>
   inet 192.168.1.100/24 brd 192.168.1.255 scope global enp0s3
   ^^^                                      ^^^^^
   Interface active                          IP configurée
```

---

#### **2. Voir TOUTES les routes**

```bash
ip route show
```

ou (avec plus de détails) :

```bash
ip -4 route show table all
```

---

#### **3. Tester la connectivité vers la passerelle**

```bash
ping -c 4 192.168.1.1
```

**Si ça ne marche pas :**
- [X] La passerelle n'est pas accessible
- [X] Problème de câble/WiFi
- [X] Mauvaise IP de passerelle

---

#### **4. Tester la résolution DNS**

```bash
nslookup google.com
```

**Résultat attendu :**

```
Server:         192.168.1.100
Address:        192.168.1.100#53

Non-authoritative answer:
Name:   google.com
Address: 142.250.185.78
```

**Si ça ne marche pas :**
```
;; connection timed out; no servers could be reached
```

-> Problème DNS, vérifie la section `nameservers` dans Netplan.

---

#### **5. Tracer le chemin complet**

```bash
traceroute -n 8.8.8.8
```

**Option `-n` = Pas de résolution DNS (plus rapide)**

**Résultat :**

```
traceroute to 8.8.8.8 (8.8.8.8), 30 hops max, 60 byte packets
 1  192.168.1.1  0.892 ms  0.856 ms  0.832 ms  <- Box (premier saut [OK])
 2  10.50.0.1  5.234 ms  5.201 ms  5.189 ms    <- FAI
 3  80.10.224.134  12.456 ms  12.423 ms  12.401 ms
 ...
```

**Si le premier saut n'est PAS ta passerelle :**
- [X] Route par défaut incorrecte

---

#### **6. Voir quelle route sera utilisée pour une destination**

```bash
ip route get 8.8.8.8
```

**Résultat :**

```
8.8.8.8 via 192.168.1.1 dev enp0s3 src 192.168.1.100 uid 1000
        ^^^^^^^^^^^^^^
    Passerelle utilisée [OK]
```

**Tester pour un réseau spécifique :**

```bash
ip route get 10.20.30.10
```

**Résultat :**

```
10.20.30.10 via 192.168.1.200 dev enp0s3 src 192.168.1.100 uid 1000
            ^^^^^^^^^^^^^^^
        Route statique utilisée [OK]
```

---

### [OUTILS] Problèmes courants et solutions

#### **Problème 1 : Pas d'Internet**

**Symptômes :**
```bash
ping 8.8.8.8
connect: Network is unreachable
```

**Causes et solutions :**

| Cause | Vérification | Solution |
|-------|--------------|----------|
| Pas de route par défaut | `ip route show \| grep default` | Ajouter route par défaut |
| Mauvaise passerelle | `ping 192.168.1.1` | Corriger l'IP de passerelle |
| Interface down | `ip a` (chercher UP) | `sudo ip link set enp0s3 up` |

---

#### **Problème 2 : Réseau local OK, Internet KO**

**Symptômes :**
```bash
ping 192.168.1.1  # [OK] Marche
ping 8.8.8.8      # [X] Ne marche pas
```

**Cause :** Route par défaut manquante ou incorrecte

**Vérification :**
```bash
ip route show | grep default
```

**Si vide :** Pas de route par défaut

**Solution :**
```bash
# Temporaire
sudo ip route add default via 192.168.1.1

# Permanent : éditer Netplan
```

---

#### **Problème 3 : Ping par IP OK, ping par nom KO**

**Symptômes :**
```bash
ping 8.8.8.8        # [OK] Marche
ping google.com     # [X] Ne marche pas
```

**Cause :** Problème DNS

**Vérification :**
```bash
cat /etc/resolv.conf
```

**Résultat attendu :**
```
nameserver 8.8.8.8
nameserver 8.8.4.4
```

**Si vide ou incorrect :** Mauvaise config DNS

**Solution :** Éditer Netplan, section `nameservers`

---

#### **Problème 4 : Route statique ne marche pas**

**Symptômes :**
```bash
ping 10.20.30.10
From 192.168.1.100 icmp_seq=1 Destination Host Unreachable
```

**Vérifications :**

**1. La route existe-t-elle ?**
```bash
ip route show | grep 10.20.30
```

**2. La passerelle est-elle accessible ?**
```bash
ping 192.168.1.200
```

**3. Le routage IP est-il activé sur la passerelle ?**

Sur la passerelle (si c'est un serveur Linux) :
```bash
cat /proc/sys/net/ipv4/ip_forward
```

**Résultat :**
- `1` = Routage activé [OK]
- `0` = Routage désactivé [X]

**Activer le routage :**
```bash
sudo sysctl -w net.ipv4.ip_forward=1
```

---

## [COURS] ÉTAPE 6 : CONCEPTS AVANCÉS

### Comprendre les métriques (priorités)

**Métrique = Priorité d'une route**

**Règle : Plus la métrique est BASSE, plus la priorité est HAUTE**

**Exemple :**

```
default via 192.168.1.1 dev enp0s3 metric 100
default via 192.168.1.1 dev wlan0 metric 200
```

**Signification :**

- Route 1 (Ethernet, metric 100) = Priorité HAUTE
- Route 2 (WiFi, metric 200) = Priorité BASSE

**Résultat :**

Si les deux interfaces sont actives, le système utilisera l'Ethernet (metric plus faible).

**Cas d'usage :**

- Ethernet + WiFi en même temps
- Plusieurs VPN actifs
- Basculement automatique (failover)

---

### Routes spécifiques vs Route par défaut

**Principe : La route la PLUS SPÉCIFIQUE gagne**

**Exemple :**

```
10.0.0.0/8 via 192.168.1.200
10.20.0.0/16 via 192.168.1.201
10.20.30.0/24 via 192.168.1.202
default via 192.168.1.1
```

**Question : Où va un paquet vers 10.20.30.50 ?**

**Réponse :**

```
10.0.0.0/8        -> Correspond [OK] (masque /8)
10.20.0.0/16      -> Correspond [OK] (masque /16, plus spécifique)
10.20.30.0/24     -> Correspond [OK] (masque /24, ENCORE plus spécifique) [OBJECTIF]
default           -> Correspond [OK] (correspond à tout)

Le paquet ira via 192.168.1.202 (route la plus spécifique)
```

**Ordre de priorité :**

1. Route /32 (hôte unique)
2. Route /24 (sous-réseau petit)
3. Route /16 (sous-réseau moyen)
4. Route /8 (sous-réseau grand)
5. Route default (tout le reste)

---

### Activer le routage IP (devenir un routeur)

**Si tu veux que ta VM Linux ROUTE des paquets entre différents réseaux :**

**1. Activer le routage IP**

```bash
sudo sysctl -w net.ipv4.ip_forward=1
```

**Vérifier :**
```bash
cat /proc/sys/net/ipv4/ip_forward
```

**Résultat :** `1` = Activé [OK]

---

**2. Rendre permanent**

```bash
sudo nano /etc/sysctl.conf
```

**Ajouter ou décommenter :**
```
net.ipv4.ip_forward=1
```

**Appliquer :**
```bash
sudo sysctl -p
```

---

**3. Configurer le NAT (si besoin)**

Si tu veux que les clients derrière ta VM accèdent à Internet :

```bash
sudo iptables -t nat -A POSTROUTING -o enp0s3 -j MASQUERADE
```

**Explication :**

- `-t nat` = Table NAT
- `-A POSTROUTING` = Après le routage
- `-o enp0s3` = Interface de sortie
- `-j MASQUERADE` = Masquer l'IP source (NAT)

---

## [BRAVO] RÉCAPITULATIF FINAL

### Ce qu'on a appris

[OK] **Comprendre le routage :**
- Ce qu'est une route
- Comment les paquets trouvent leur chemin
- Le rôle de la passerelle

[OK] **Voir et comprendre la table de routage :**
- Sur Linux : `ip route show`
- Sur Windows : `route print`
- Sur Mac : `netstat -nr`

[OK] **Configurer une route par défaut :**
- Accès à Internet
- Via Netplan sur Linux

[OK] **Ajouter des routes statiques :**
- Accès à des réseaux spécifiques
- Routes permanentes et temporaires

[OK] **Diagnostiquer et dépanner :**
- `ping`, `traceroute`, `ip route get`
- Résoudre les problèmes courants

---

### Commandes essentielles à retenir

```bash
# Voir toutes les routes
ip route show

# Ajouter route temporaire
sudo ip route add 10.20.30.0/24 via 192.168.1.200

# Supprimer route
sudo ip route del 10.20.30.0/24

# Tester connectivité
ping -c 4 8.8.8.8

# Tracer le chemin
traceroute google.com

# Voir quelle route sera utilisée
ip route get 10.20.30.10

# Appliquer config Netplan
sudo netplan apply
```

---

### Architecture réseau complète

```
[WEB] INTERNET (0.0.0.0/0)
│
│ via default route -> 192.168.1.1
│
┌─────┴──────────────────────────────────────────┐
│  [RESEAU] BOX/ROUTEUR (192.168.1.1)                  │
│     PASSERELLE PRINCIPALE                      │
└─────┬──────────────────────────────────────────┘
      │
      │ Réseau local : 192.168.1.0/24
      │ Route : Automatique (kernel)
      │
      ├─ [ECRAN] PC (192.168.1.51)
      │   • Route default -> 192.168.1.1
      │   • Route 192.168.1.0/24 -> direct
      │
      ├─ [CODE] VM (192.168.1.100)
      │   • Route default -> 192.168.1.1
      │   • Route 192.168.1.0/24 -> direct
      │   • Route 10.20.30.0/24 -> via 192.168.1.200
      │   • Route 172.16.0.0/16 -> via 192.168.1.201
      │
      ├─ [SECURISE] VPN Server 1 (192.168.1.200)
      │   └─ [ENTREPRISE] Réseau A (10.20.30.0/24)
      │
      └─ [SECURISE] VPN Server 2 (192.168.1.201)
          └─ [ENTREPRISE] Réseau B (172.16.0.0/16)
```

---

### Checklist de vérification

**Pour chaque route configurée, vérifie :**

- [ ] La route apparaît dans `ip route show`
- [ ] La passerelle est accessible (`ping PASSERELLE`)
- [ ] La destination est accessible (`ping DESTINATION`)
- [ ] Le traceroute montre le bon chemin
- [ ] La configuration survit au redémarrage (si permanente)

---

## [COURS] EXERCICES PRATIQUES

### Exercice 1 : Configuration basique

**Objectif :** Configurer une VM avec accès Internet

**Tâches :**
1. Configurer IP fixe : 192.168.1.100
2. Ajouter route par défaut via 192.168.1.1
3. Tester avec `ping 8.8.8.8`
4. Tester avec `ping google.com`

---

### Exercice 2 : Routes multiples

**Objectif :** Configurer plusieurs routes statiques

**Tâches :**
1. Route vers 10.20.30.0/24 via 192.168.1.200
2. Route vers 172.16.0.0/16 via 192.168.1.201
3. Vérifier avec `ip route show`
4. Tester avec `ip route get 10.20.30.10`

---

### Exercice 3 : Diagnostic

**Objectif :** Identifier et corriger un problème

**Scénario :** Internet ne marche pas

**Tâches :**
1. Vérifier l'IP : `ip a`
2. Vérifier les routes : `ip route show`
3. Tester la passerelle : `ping 192.168.1.1`
4. Corriger le problème
5. Valider avec `ping 8.8.8.8`

---

## [CHEQUERED_FLAG] CONCLUSION

**Le routage est la base de TOUS les réseaux !**

Sans routage :
- [X] Pas d'Internet
- [X] Pas d'accès aux autres réseaux
- [X] Communication limitée au réseau local

Avec routage :
- [OK] Accès à Internet
- [OK] Accès à des réseaux distants
- [OK] Communication globale

**Tu maîtrises maintenant :**
- [OBJECTIF] Les concepts du routage
- [OBJECTIF] La configuration des routes
- [OBJECTIF] Le diagnostic réseau
- [OBJECTIF] La résolution de problèmes

**Bravo ! Tu es prêt pour des configurations réseau avancées ! [BRAVO]**

---

### Pour aller plus loin

**Sujets avancés à explorer :**

1. **Routage dynamique** (OSPF, BGP)
2. **Tunnels VPN** (OpenVPN, WireGuard)
3. **Load balancing** (répartition de charge)
4. **Policy-based routing** (routage par politique)
5. **IPv6 routing** (routage IPv6)

**Bonne continuation dans ton apprentissage ! [RAPIDE]**