# [COURS] GUIDE BONDING / LAG SUR LINUX - ULTRA DÉTAILLÉ POUR DÉBUTANTS ABSOLUS

## * AVANT DE COMMENCER : COMPRENDRE LES BASES

### Qu'est-ce que le Bonding / LAG ?

**Bonding** = Link Aggregation = Agrégation de liens = LAG

Imagine que tu dois transporter de l'eau d'un point A à un point B :

**SANS Bonding (situation normale) :**
```
Point A ─────[1 tuyau]────-> Point B
         (débit : 1L/sec)
```

**AVEC Bonding (agrégation) :**
```
Point A ─────[tuyau 1]────-> Point B
        \────[tuyau 2]────->
         \───[tuyau 3]────->
          \──[tuyau 4]────->
         (débit : 4L/sec)
```

C'est EXACTEMENT pareil avec les câbles réseau !

### Analogie du camion de déménagement

**Sans Bonding :**
```
[ACCUEIL] Maison ────[1 camion]────-> [ACCUEIL] Nouvelle maison
     [PACKAGE][PACKAGE][PACKAGE]                         [PACKAGE][PACKAGE][PACKAGE]
     (3 allers-retours nécessaires)
```

**Avec Bonding :**
```
[ACCUEIL] Maison ────[camion 1]────-> [ACCUEIL] Nouvelle maison
          \───[camion 2]────->
           \──[camion 3]────->
     [PACKAGE][PACKAGE][PACKAGE]                         [PACKAGE][PACKAGE][PACKAGE]
     (1 seul aller-retour !)
```

### Pourquoi utiliser le Bonding ?

**Raison 1 : Plus de vitesse (bande passante)**

1 câble Ethernet = 1 Gbps (1000 Mbps)
2 câbles en bonding = 2 Gbps (2000 Mbps)
4 câbles en bonding = 4 Gbps (4000 Mbps)

**Raison 2 : Tolérance de panne (redondance)**

Si un câble se débranche ou tombe en panne :
- Sans bonding : [X] Connexion perdue totalement
- Avec bonding : [OK] Les autres câbles continuent de fonctionner

**Raison 3 : Équilibrage de charge**

Plusieurs appareils peuvent communiquer simultanément via différents câbles.

### Les termes à connaître

|------------------------|------------------------------------------------|--------------------------------|
| Terme                  | Explication                                    | Analogie                       |
|------------------------|------------------------------------------------|--------------------------------|
| **Bonding**            | Terme Linux pour l'agrégation                  | Les tuyaux attachés ensemble   |
| **LAG**                | Link Aggregation Group                         | Le groupe de camions           |
| **Interface esclave**  | Un câble individuel (eth0, eth1...)            | Un camion individuel           |
| **Interface maître**   | L'interface virtuelle qui regroupe tout (bond0)| Le chef d'équipe qui coordonne |
| **Mode**               | Comment les câbles travaillent ensemble        | La stratégie de déménagement   |
|------------------------|------------------------------------------------|--------------------------------|

---

## [OBJECTIF] OBJECTIF DU PROJET

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

Transformer 2 (ou plus) cartes réseau physiques en UNE seule interface logique super-puissante.

```
┌─────────────────────────────────────────────┐
│ [ECRAN] TON SERVEUR LINUX                        │
│                                             │
│  ┌─────────────────────────────────────┐   │
│  │ [LIEN] bond0 (Interface virtuelle)      │   │
│  │    IP : 192.168.1.100               │   │
│  │    Débit : 2 Gbps (2x1Gbps)         │   │
│  └──────────────┬──────────────────────┘   │
│                 │                           │
│        ┌────────┴────────┐                  │
│        │                 │                  │
│  ┌─────[BLACK_DOWN-POINTING_TRIANGLE]─────┐    ┌─────[BLACK_DOWN-POINTING_TRIANGLE]─────┐            │
│  │ eth0      │    │ eth1      │            │
│  │ (esclave) │    │ (esclave) │            │
│  └─────┬─────┘    └─────┬─────┘            │
└────────┼────────────────┼──────────────────┘
         │                │
    [Câble 1]        [Câble 2]
         │                │
         └────────┬───────┘
                  │
         ┌────────[BLACK_DOWN-POINTING_TRIANGLE]────────┐
         │   [PLUGIN] Switch     │
         │   (compatible   │
         │    LACP/802.3ad)│
         └─────────────────┘
```

### Situation AVANT (normale)

```
Serveur Linux
├─ eth0 : 192.168.1.100 (1 Gbps)
└─ eth1 : Inutilisée
```

### Situation APRÈS (avec bonding)

```
Serveur Linux
├─ bond0 : 192.168.1.100 (2 Gbps)
│   ├─ eth0 (esclave, 1 Gbps)
│   └─ eth1 (esclave, 1 Gbps)
│
└─ Débit total : 2 Gbps
   Redondance : Si eth0 tombe, eth1 continue [OK]
```

---

## [DOCS] ÉTAPE 0 : COMPRENDRE LES MODES DE BONDING

Linux propose **7 modes différents** de bonding. Chaque mode a un usage spécifique.

### [RECHERCHE] Les 7 modes expliqués simplement

#### **Mode 0 : balance-rr (Round-Robin)**

**Comment ça marche :**
Les paquets sont envoyés à tour de rôle sur chaque interface.

```
Paquet 1 -> eth0
Paquet 2 -> eth1
Paquet 3 -> eth0
Paquet 4 -> eth1
...
```

**Analogie :**
Tu as 2 caisses au supermarché. Tu envoies alternativement les clients :
- Client 1 -> Caisse A
- Client 2 -> Caisse B
- Client 3 -> Caisse A
- Client 4 -> Caisse B

**Avantages :**
- [OK] Équilibrage de charge parfait
- [OK] Utilise 100% de la bande passante totale
- [OK] Simple à configurer

**Inconvénients :**
- [X] Les paquets peuvent arriver dans le désordre
- [X] Problèmes possibles avec certains protocoles (TCP)
- [X] Ne fonctionne pas bien avec tous les switches

**Quand l'utiliser :**
- Connexions locales uniquement (pas via switch)
- Transferts de fichiers volumineux
- PAS pour un réseau de production

---

#### **Mode 1 : active-backup (Sauvegarde active)**

**Comment ça marche :**
Une seule interface est active à la fois. Les autres sont en veille et prennent le relais si l'active tombe.

```
eth0 : ACTIVE [OK] (tout le trafic passe par ici)
eth1 : STANDBY [DOUBLE_VERTICAL_BAR] (en attente, prête à prendre le relais)

Si eth0 tombe :
eth0 : DOWN [X]
eth1 : ACTIVE [OK] (prend le relais immédiatement)
```

**Analogie :**
Tu as 2 pilotes d'avion :
- Le capitaine pilote (eth0 active)
- Le copilote surveille (eth1 en veille)
- Si le capitaine a un problème, le copilote prend les commandes instantanément

**Avantages :**
- [OK] Tolérance de panne maximale
- [OK] Compatible avec TOUS les switches (aucune config nécessaire)
- [OK] Pas de désordre de paquets
- [OK] Très fiable

**Inconvénients :**
- [X] Pas d'augmentation de bande passante (1 seule interface à la fois)
- [X] Les interfaces en veille sont inutilisées

**Quand l'utiliser :**
- Serveurs critiques nécessitant une haute disponibilité
- Environnements où la redondance est plus importante que la vitesse
- **C'EST LE MODE LE PLUS UTILISÉ EN PRODUCTION** *

---

#### **Mode 2 : balance-xor (Équilibrage XOR)**

**Comment ça marche :**
Utilise une formule mathématique (XOR) basée sur les adresses MAC source et destination pour choisir l'interface.

```
Connexion A <-> B -> Toujours eth0
Connexion A <-> C -> Toujours eth1
Connexion A <-> D -> Toujours eth0
```

**Analogie :**
Dans un immeuble avec 2 ascenseurs :
- Les appartements pairs -> Ascenseur A
- Les appartements impairs -> Ascenseur B
- Chaque appartement utilise toujours le même ascenseur

**Avantages :**
- [OK] Équilibrage de charge
- [OK] Pas de désordre de paquets (une connexion = toujours la même interface)
- [OK] Compatible avec la plupart des switches

**Inconvénients :**
- [X] Nécessite plusieurs connexions simultanées pour être efficace
- [X] Une seule connexion n'utilisera qu'une seule interface

**Quand l'utiliser :**
- Serveurs avec beaucoup de clients différents
- Serveurs web, serveurs de fichiers
- Bon compromis entre vitesse et compatibilité

---

#### **Mode 3 : broadcast (Diffusion)**

**Comment ça marche :**
TOUS les paquets sont envoyés sur TOUTES les interfaces simultanément.

```
Paquet 1 -> eth0 ET eth1 ET eth2 (en même temps)
Paquet 2 -> eth0 ET eth1 ET eth2 (en même temps)
```

**Analogie :**
Tu envoies 3 copies de la même lettre par 3 facteurs différents pour être SÛR qu'au moins une arrive.

**Avantages :**
- [OK] Tolérance de panne maximale
- [OK] Utile pour certains protocoles réseau spécifiques

**Inconvénients :**
- [X] Gaspillage énorme de bande passante (x3 pour 3 interfaces)
- [X] Augmente le trafic réseau inutilement
- [X] Aucune augmentation de débit

**Quand l'utiliser :**
- Presque JAMAIS en pratique
- Cas d'usage très spécifiques (réseaux de contrôle industriel)

---

#### **Mode 4 : 802.3ad (LACP - Link Aggregation Control Protocol)**

**Comment ça marche :**
Protocole standardisé (IEEE 802.3ad) qui négocie automatiquement avec le switch pour créer un lien agrégé.

```
Serveur <--> Protocole LACP <--> Switch
        (négociation automatique)

Résultat : Lien agrégé intelligent
```

**Analogie :**
Tu appelles plusieurs compagnies de livraison et elles se coordonnent automatiquement entre elles pour optimiser les livraisons.

**Avantages :**
- [OK] Standardisé (fonctionne avec tous les équipements compatibles)
- [OK] Détection automatique des pannes
- [OK] Équilibrage de charge intelligent
- [OK] Augmentation de la bande passante
- [OK] **MODE RECOMMANDÉ EN PRODUCTION** *

**Inconvénients :**
- [X] Nécessite un switch compatible LACP
- [X] Configuration requise sur le switch
- [X] Un peu plus complexe à mettre en place

**Quand l'utiliser :**
- Environnements professionnels avec switches managés
- Serveurs de production nécessitant haute disponibilité ET haute performance
- Datacenters

---

#### **Mode 5 : balance-tlb (Adaptive Transmit Load Balancing)**

**Comment ça marche :**
Équilibre le trafic SORTANT selon la charge de chaque interface.

```
Trafic sortant :
- eth0 : 60% utilisé -> Envoie plus de paquets ici
- eth1 : 30% utilisé -> Envoie moins de paquets

Trafic entrant :
- Uniquement sur l'interface primaire
```

**Analogie :**
Tu as 2 serveurs dans un restaurant :
- Le serveur rapide prend plus de tables
- Le serveur lent prend moins de tables
- Mais tous les clients paient à la même caisse (trafic entrant)

**Avantages :**
- [OK] Pas de configuration switch nécessaire
- [OK] Équilibrage intelligent du trafic sortant
- [OK] Bonne performance pour serveurs (uploads)

**Inconvénients :**
- [X] Trafic entrant non équilibré
- [X] Moins performant que le mode 4 pour trafic bidirectionnel

**Quand l'utiliser :**
- Serveurs avec beaucoup de trafic sortant (backups, uploads)
- Quand tu n'as pas de switch compatible LACP

---

#### **Mode 6 : balance-alb (Adaptive Load Balancing)**

**Comment ça marche :**
Comme le mode 5, MAIS équilibre AUSSI le trafic entrant en utilisant ARP (Address Resolution Protocol).

```
Trafic sortant : Équilibré intelligemment [OK]
Trafic entrant : Équilibré intelligemment [OK]
```

**Analogie :**
Même chose que le mode 5, mais maintenant les clients peuvent payer à 2 caisses différentes (trafic entrant aussi équilibré).

**Avantages :**
- [OK] Pas de configuration switch nécessaire
- [OK] Équilibrage du trafic entrant ET sortant
- [OK] Meilleure performance que le mode 5
- [OK] **BON CHOIX SI PAS DE SWITCH MANAGÉ** *

**Inconvénients :**
- [X] Légèrement plus complexe
- [X] Peut causer des problèmes avec certains switches "intelligents"

**Quand l'utiliser :**
- Serveurs nécessitant performance bidirectionnelle
- Pas de switch compatible LACP disponible
- Alternative au mode 4 pour petit réseau

---

### [OBJECTIF] Récapitulatif : Quel mode choisir ?

| Mode | Nom | Bande passante | Redondance | Config switch | Usage recommandé |
|------|-----|---------------|------------|---------------|------------------|
| **0** | balance-rr | *** | * | Aucune | Tests seulement |
| **1** | active-backup | * | *** | Aucune | **Production (redondance)** |
| **2** | balance-xor | ** | ** | Aucune | Multi-clients |
| **3** | broadcast | [X] | *** | Aucune | Cas spécifiques |
| **4** | 802.3ad (LACP) | *** | *** | **Requise** | **Production (performance)** |
| **5** | balance-tlb | ** | ** | Aucune | Serveurs uploads |
| **6** | balance-alb | *** | ** | Aucune | **Sans switch managé** |

**Mes recommandations selon ton cas :**

- **Tu as un switch managé compatible LACP ?**
  -> **Mode 4 (802.3ad)** * LE MEILLEUR

- **Tu n'as pas de switch managé ?**
  -> **Mode 6 (balance-alb)** ou **Mode 1 (active-backup)**

- **Tu veux juste de la redondance (pas plus de vitesse) ?**
  -> **Mode 1 (active-backup)** * LE PLUS SIMPLE

- **Tu veux apprendre / tester ?**
  -> **Mode 1 (active-backup)** pour commencer

---

## [OUTIL] ÉTAPE 1 : VÉRIFIER TON MATÉRIEL

### [LISTE] Prérequis absolus

Avant de commencer, tu DOIS avoir :

[OK] **Au moins 2 cartes réseau Ethernet physiques**
[OK] **2 câbles Ethernet (ou plus selon le nombre de cartes)**
[OK] **Un switch réseau**
[OK] **Linux installé** (Ubuntu, Debian, CentOS, etc.)
[OK] **Accès root/sudo**

### [RECHERCHE] Vérifier tes cartes réseau

Dans ton terminal Linux, tape :

```bash
ip link show
```

**Explication :**
- `ip` = Programme pour gérer le réseau
- `link` = Concerne les interfaces réseau physiques
- `show` = Affiche la liste

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

```
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP
    link/ether 08:00:27:3b:5c:a1 brd ff:ff:ff:ff:ff:ff
    ^^^^
    PREMIÈRE CARTE [OK]
    
3: eth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN
    link/ether 08:00:27:7d:9e:b2 brd ff:ff:ff:ff:ff:ff
    ^^^^
    DEUXIÈME CARTE [OK]
    
4: eth2: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN
    link/ether 08:00:27:8f:a3:c4 brd ff:ff:ff:ff:ff:ff
    ^^^^
    TROISIÈME CARTE (optionnelle) [OK]
```

**Décryptage :**

```
2: eth0:
│  ^
│  └─ Nom de l'interface (peut aussi être enp0s3, ens33, eno1...)
└──── Numéro de l'interface

<BROADCAST,MULTICAST,UP,LOWER_UP>
 ^                    ^   ^
 │                    │   └─ Liaison physique active
 │                    └───── Interface activée
 └──────────────────────────── Type d'interface

link/ether 08:00:27:3b:5c:a1
           ^^^^^^^^^^^^^^^^^
           ADRESSE MAC (identifiant unique)
```

**[ATTENTION] IMPORTANT : Note les noms de tes interfaces !**

Dans cet exemple :
- Première carte : `eth0`
- Deuxième carte : `eth1`

**Chez toi, les noms peuvent être différents :**
- `enp0s3`, `enp0s8` (VirtualBox, VMware)
- `ens33`, `ens34` (certains Linux)
- `eno1`, `eno2` (serveurs Dell, HP)
- `eth0`, `eth1` (nommage classique)

### [PLUGIN] Vérifier que les câbles sont branchés

```bash
ip link show eth0
ip link show eth1
```

**Cherche dans le résultat :**

```
state UP
^^^^^
Câble branché [OK]
```

ou

```
state DOWN
^^^^^^
Câble NON branché [X]
```

**Si "state DOWN" :**
- Vérifie que le câble est bien branché
- Vérifie que le switch est allumé
- Essaie de changer de port sur le switch
- Essaie un autre câble

### [WEB] Vérifier les IPs actuelles

```bash
ip addr show
```

**Tu verras quelque chose comme :**

```
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP>
    inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0
    ^^^^ ^^^^^^^^^^^^^
    IPv4  IP actuelle

3: eth1: <BROADCAST,MULTICAST>
    (pas d'IP configurée)
```

**C'est NORMAL si eth1 n'a pas d'IP !** On va tout configurer à l'étape suivante.

---

## [CONFIG] ÉTAPE 2 : INSTALLER LE MODULE BONDING

### [PACKAGE] Installer les outils nécessaires

**Sur Ubuntu/Debian :**

```bash
# Mise à jour de la liste des paquets
sudo apt update

# Installation du paquet ifenslave (outils bonding)
sudo apt install ifenslave -y
```

**Sur CentOS/RHEL/Rocky Linux :**

```bash
# Installation des outils réseau
sudo yum install network-scripts -y
```

**Explication :**
- `ifenslave` = Outils pour gérer les interfaces "esclaves" du bonding
- `network-scripts` = Scripts de gestion réseau (CentOS/RHEL)

### [PLUGIN] Charger le module bonding

```bash
# Charger le module dans le noyau
sudo modprobe bonding
```

**Explication :**
- `modprobe` = Charge un module du noyau Linux
- `bonding` = Le module qui gère l'agrégation de liens

### [OK] Vérifier que le module est chargé

```bash
lsmod | grep bonding
```

**Résultat attendu :**

```
bonding               151552  0
^^^^^^^
Module chargé [OK]
```

**Si tu ne vois rien :**
- Le `modprobe` a échoué
- Ton noyau ne supporte pas le bonding (très rare)

### [SYNC] Charger le module automatiquement au démarrage

**Pour qu'il se charge automatiquement à chaque démarrage :**

```bash
# Créer le fichier de configuration
echo "bonding" | sudo tee /etc/modules-load.d/bonding.conf
```

**Explication :**
- Ce fichier dit au système : "Charge le module `bonding` au démarrage"
- `tee` = Écrit dans un fichier avec sudo

**Vérifier le fichier :**

```bash
cat /etc/modules-load.d/bonding.conf
```

**Résultat :**
```
bonding
```

[OK] Parfait !

---

## [NOTE] ÉTAPE 3 : CONFIGURER LE BONDING (NETPLAN - Ubuntu 18.04+)

### [REFLEXION] Comprendre Netplan

**Netplan** = Outil moderne de configuration réseau sous Ubuntu/Debian récents.

- Utilise des fichiers YAML (format texte structuré)
- Remplace les anciens fichiers `/etc/network/interfaces`
- Plus simple et plus clair

### [DOSSIER] Trouver le fichier de configuration

```bash
ls /etc/netplan/
```

**Résultat possible :**
```
00-installer-config.yaml
01-netcfg.yaml
50-cloud-init.yaml
```

**Note le nom exact de TON fichier !**

### [SAUVEGARDE] Sauvegarder l'ancienne configuration

**TOUJOURS faire une sauvegarde avant de modifier !**

```bash
sudo cp /etc/netplan/01-netcfg.yaml /etc/netplan/01-netcfg.yaml.backup
```

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

### [EDIT] Éditer la configuration

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

### [FICHIER] Configuration complète (MODE 1 : active-backup)

**SUPPRIME tout le contenu et remplace par ceci :**

```yaml
network:
  version: 2
  renderer: networkd
  
  ethernets:
    eth0:
      dhcp4: no
      dhcp6: no
    eth1:
      dhcp4: no
      dhcp6: no
  
  bonds:
    bond0:
      interfaces:
        - eth0
        - eth1
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
      parameters:
        mode: active-backup
        primary: eth0
        mii-monitor-interval: 100
```

### [RECHERCHE] Explication LIGNE PAR LIGNE (TRÈS DÉTAILLÉE)

#### **Section ethernets**

```yaml
ethernets:
  eth0:
    dhcp4: no
    dhcp6: no
  eth1:
    dhcp4: no
    dhcp6: no
```

**Explication :**
- On déclare les interfaces physiques `eth0` et `eth1`
- `dhcp4: no` = Désactive DHCP IPv4 (on veut une config manuelle)
- `dhcp6: no` = Désactive DHCP IPv6

**Pourquoi désactiver DHCP ?**
- Les interfaces "esclaves" ne doivent PAS avoir d'IP propre
- Seule l'interface `bond0` (maître) aura une IP
- Les esclaves sont juste des "tuyaux" physiques

**Analogie :**
Les camions individuels (eth0, eth1) n'ont pas besoin d'adresse de livraison. Seul le chef d'équipe (bond0) en a une.

#### **Section bonds**

```yaml
bonds:
  bond0:
    interfaces:
      - eth0
      - eth1
```

**Explication :**
- `bonds:` = Section pour définir les interfaces bonding
- `bond0:` = Nom de l'interface bonding (peut être bond1, bond2, etc.)
- `interfaces:` = Liste des interfaces esclaves

**[ATTENTION] CHANGE `eth0` et `eth1` si tes interfaces ont d'autres noms !**

#### **Adresse IP**

```yaml
    addresses:
      - 192.168.1.100/24
```

**Explication :**
- `192.168.1.100` = L'IP fixe du serveur
- `/24` = Masque de sous-réseau (équivalent de 255.255.255.0)

**[ATTENTION] ADAPTE cette IP à TON réseau !**

Comment choisir l'IP ?
- Elle doit être dans la plage de ton réseau (ex: 192.168.1.X)
- Elle ne doit PAS être utilisée par un autre appareil
- Évite les IPs en début de plage (souvent réservées pour routeurs/Box)

#### **Route par défaut (Passerelle)**

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

**Explication :**
- `to: default` = Pour toutes les destinations (Internet)
- `via: 192.168.1.1` = Passe par cette IP (ta Box/Routeur)

**[ATTENTION] VÉRIFIE l'IP de ta Box !**

**Sur Windows :**
```cmd
ipconfig
```
Cherche "Passerelle par défaut"

**Sur Linux/Mac :**
```bash
ip route | grep default
```

#### **Serveurs DNS**

```yaml
    nameservers:
      addresses:
        - 8.8.8.8
        - 8.8.4.4
```

**Explication :**
- `8.8.8.8` et `8.8.4.4` = DNS de Google (gratuits, rapides, fiables)

**Alternatives :**
```yaml
# Cloudflare DNS (rapide, focus vie privée)
- 1.1.1.1
- 1.0.0.1

# Quad9 DNS (bloque malware)
- 9.9.9.9
- 149.112.112.112
```

#### **Paramètres du bonding (LE PLUS IMPORTANT)**

```yaml
    parameters:
      mode: active-backup
      primary: eth0
      mii-monitor-interval: 100
```

##### **mode: active-backup**

**C'est le MODE de bonding !**

Modes possibles :
- `active-backup` (mode 1) * Redondance maximale
- `balance-rr` (mode 0)
- `balance-xor` (mode 2)
- `broadcast` (mode 3)
- `802.3ad` (mode 4) * Performance maximale avec switch compatible
- `balance-tlb` (mode 5)
- `balance-alb` (mode 6) * Bon compromis sans switch managé

**On utilise `active-backup` car :**
- [OK] Pas de configuration switch nécessaire
- [OK] Compatible avec TOUS les switches
- [OK] Redondance maximale
- [OK] Simple à mettre en place
- [OK] Fiable en production


### **primary: eth0**

**Explication :**
- En mode `active-backup`, cette interface sera utilisée PAR DÉFAUT
- Si `eth0` tombe, `eth1` prend automatiquement le relais
- Si `eth0` revient, elle redevient l'interface active

**Analogie :**
C'est le pilote principal. Le copilote ne prend les commandes que si nécessaire.

**[ATTENTION] CHANGE `eth0` si ton interface principale a un autre nom !**

### **mii-monitor-interval: 100**

**Explication :**
- `mii` = Media Independent Interface (détection de liaison)
- `100` = Vérifie l'état du câble toutes les 100 millisecondes (0.1 seconde)

**Comment ça marche :**
```
Toutes les 100ms :
├─ Le système vérifie : "eth0 est-il toujours connecté ?"
├─ Oui -> Continue normalement
└─ Non -> Bascule immédiatement sur eth1 !
```

**Valeurs possibles :**
- `100` = Très réactif [RAPIDE] (bascule en 0.1s) <- **RECOMMANDÉ**
- `1000` = Moins réactif (bascule en 1s)
- `500` = Compromis (bascule en 0.5s)

**Plus la valeur est basse :**
- [OK] Détection de panne plus rapide
- [X] Utilise un peu plus de ressources CPU (négligeable)

---

### [FICHIER] Configuration pour MODE 4 (802.3ad LACP) avec switch managé

**Si tu as un switch compatible LACP :**

```yaml
network:
  version: 2
  renderer: networkd
  
  ethernets:
    eth0:
      dhcp4: no
      dhcp6: no
    eth1:
      dhcp4: no
      dhcp6: no
  
  bonds:
    bond0:
      interfaces:
        - eth0
        - eth1
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
      parameters:
        mode: 802.3ad
        lacp-rate: fast
        mii-monitor-interval: 100
        transmit-hash-policy: layer2+3
```

**Nouveaux paramètres expliqués :**

#### **lacp-rate: fast**

**Explication :**
- Vitesse de négociation LACP avec le switch
- `fast` = Échange de paquets LACP toutes les 1 seconde (détection panne rapide)
- `slow` = Échange toutes les 30 secondes (par défaut)

**Analogie :**
`fast` = Tu appelles ton collègue chaque minute pour vérifier qu'il est là
`slow` = Tu appelles seulement toutes les 30 minutes

**Choisis `fast` pour :**
- [OK] Détection de panne ultra-rapide (1 seconde)
- [OK] Environnements critiques

**Choisis `slow` pour :**
- Réduire le trafic réseau (switches anciens)

#### **transmit-hash-policy: layer2+3**

**Explication :**
- Définit comment les paquets sont distribués entre les interfaces
- `layer2+3` = Utilise les adresses MAC (couche 2) + IP (couche 3)

**Options disponibles :**

|---------------|--------------|-----------------------|------------------|
|   Politique   | Utilise      | Avantages             | Inconvénients    |
|---------------|--------------|-----------------------|------------------|
| `layer2`      | Adresses MAC |       Simple          | Moins équilibré  |
| `layer3+4`    | IP + Ports   | Excellent équilibrage | Complexe         |
| `layer2+3`    | MAC + IP     | Bon compromis *      |          -       |
|---------------|--------------|-----------------------|------------------|

**Recommandation : `layer2+3`** (bon équilibre pour la plupart des cas)

---

### [FICHIER] Configuration pour MODE 6 (balance-alb) sans switch managé

**Si tu n'as PAS de switch compatible LACP :**

```yaml
network:
  version: 2
  renderer: networkd
  
  ethernets:
    eth0:
      dhcp4: no
      dhcp6: no
    eth1:
      dhcp4: no
      dhcp6: no
  
  bonds:
    bond0:
      interfaces:
        - eth0
        - eth1
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
      parameters:
        mode: balance-alb
        mii-monitor-interval: 100
```

**Avantages du mode balance-alb :**
- [OK] Pas de config switch nécessaire
- [OK] Équilibrage entrant ET sortant
- [OK] Bonnes performances
- [OK] Redondance

---

## [SAUVEGARDE] ÉTAPE 4 : APPLIQUER LA CONFIGURATION

### [ATTENTION] ATTENTION CRITIQUE

**Si tu fais ça à distance (SSH) :**
- Tu VAS perdre la connexion temporairement
- Assure-toi d'avoir un accès physique ou console
- Ou utilise `netplan try` (auto-annulation)

### [OK] Tester la configuration avant de l'appliquer

```bash
sudo netplan try
```

**Explication :**
- Applique la configuration pendant 120 secondes
- Si tu ne confirmes pas, elle s'annule automatiquement
- **PARFAIT pour tester sans risque de te bloquer !**

**Résultat attendu :**

```
Warning: Stopping systemd-networkd.service, but it can still be activated by:
  systemd-networkd.socket
Do you want to keep these settings?

Press ENTER before the timeout to accept the new configuration

Changes will revert in 120 seconds
```

**Teste rapidement :**

1. Ouvre un AUTRE terminal (ou fenêtre SSH)
2. Vérifie la connexion :
   ```bash
   ping 192.168.1.100
   ```
3. Si ça marche -> Appuie sur **ENTRÉE** dans le premier terminal
4. Si ça ne marche pas -> Attends 120 secondes, l'ancienne config sera restaurée

### [OK] Appliquer définitivement

**Si le test a marché :**

```bash
sudo netplan apply
```

**Explication :**
- Applique la configuration de façon permanente
- Au prochain redémarrage, cette config sera utilisée

---

## [RECHERCHE] ÉTAPE 5 : VÉRIFIER QUE LE BONDING FONCTIONNE

### [GRAPHIQUE] Vérifier l'interface bond0

```bash
ip addr show bond0
```

**Résultat attendu :**

```
4: bond0: <BROADCAST,MULTICAST,MASTER,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP
    link/ether 08:00:27:3b:5c:a1 brd ff:ff:ff:ff:ff:ff
    inet 192.168.1.100/24 brd 192.168.1.255 scope global bond0
    ^^^^ ^^^^^^^^^^^^^^
    IPv4  TON IP [OK]
```

**Points à vérifier :**
- [OK] `state UP` = Interface active
- [OK] `MASTER` = C'est bien l'interface maître
- [OK] IP correcte (192.168.1.100 dans notre exemple)

### [LIEN] Vérifier les interfaces esclaves

```bash
ip addr show eth0
ip addr show eth1
```

**Résultat attendu :**

```
2: eth0: <BROADCAST,MULTICAST,SLAVE,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast master bond0 state UP
    ^^^^^               ^^^^^^^^^^
    Esclave de bond0    État actif
    link/ether 08:00:27:3b:5c:a1 brd ff:ff:ff:ff:ff:ff

3: eth1: <BROADCAST,MULTICAST,SLAVE,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast master bond0 state UP
    ^^^^^               ^^^^^^^^^^
    Esclave de bond0    État actif
    link/ether 08:00:27:3b:5c:a1 brd ff:ff:ff:ff:ff:ff
```

**Points importants :**
- [OK] `SLAVE` = L'interface est esclave
- [OK] `master bond0` = Maître = bond0
- [OK] `state UP` = Active et câble branché
- [OK] Même adresse MAC pour toutes les interfaces (normal en bonding)

### [LISTE] Voir les détails du bonding

**Commande magique pour voir TOUT :**

```bash
cat /proc/net/bonding/bond0
```

**Résultat détaillé (exemple en mode active-backup) :**

```
Ethernet Channel Bonding Driver: v5.15.0

Bonding Mode: fault-tolerance (active-backup)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
MODE ACTIF [OK]

Primary Slave: eth0 (primary_reselect always)
^^^^^^^^^^^^^
Interface principale

Currently Active Slave: eth0
^^^^^^^^^^^^^^^^^^^^
Celle qui est utilisée MAINTENANT

MII Status: up
^^^^^^^^^^
Détection de liaison active

MII Polling Interval (ms): 100
^^^^^^^^^^^^^^^^^^^^
Vérifie toutes les 100ms

Up Delay (ms): 0
Down Delay (ms): 0

Peer Notification Delay (ms): 0

Slave Interface: eth0
^^^^^^^^^^^^^
PREMIÈRE INTERFACE ESCLAVE

MII Status: up
^^^^^^^^^^
Câble branché, fonctionne [OK]

Speed: 1000 Mbps
^^^^^^^^^^
1 Gbps (Gigabit)

Duplex: full
^^^^^^^^
Communication bidirectionnelle

Link Failure Count: 0
^^^^^^^^^^^^^^^^
Aucune panne détectée [OK]

Permanent HW addr: 08:00:27:3b:5c:a1
Slave queue ID: 0

Slave Interface: eth1
^^^^^^^^^^^^^
DEUXIÈME INTERFACE ESCLAVE

MII Status: up
^^^^^^^^^^
Câble branché, en veille [OK]

Speed: 1000 Mbps
Duplex: full
Link Failure Count: 0
Permanent HW addr: 08:00:27:7d:9e:b2
Slave queue ID: 0
```

### [RECHERCHE] Décryptage ligne par ligne

#### **Bonding Mode**

```
Bonding Mode: fault-tolerance (active-backup)
```

- `fault-tolerance` = Tolérance de panne
- `active-backup` = Mode 1

**Autres valeurs possibles selon le mode :**
- `load balancing (round-robin)` = Mode 0
- `load balancing (xor)` = Mode 2
- `IEEE 802.3ad Dynamic link aggregation` = Mode 4 (LACP)

#### **Currently Active Slave**

```
Currently Active Slave: eth0
```

**C'est l'interface qui transporte TOUT le trafic actuellement.**

En mode active-backup :
- Une seule interface est active à la fois
- Si `eth0` tombe, ce sera `eth1`

#### **MII Status: up**

```
MII Status: up
```

- `up` = [OK] Câble branché, liaison active
- `down` = [X] Câble débranché ou problème

#### **Speed: 1000 Mbps**

```
Speed: 1000 Mbps
```

Vitesses possibles :
- `10 Mbps` = Ethernet ancien (années 90)
- `100 Mbps` = Fast Ethernet
- `1000 Mbps` = Gigabit Ethernet * (le plus courant)
- `10000 Mbps` = 10 Gigabit (serveurs haut de gamme)

#### **Link Failure Count**

```
Link Failure Count: 0
```

**Compteur de pannes détectées depuis le démarrage.**

- `0` = [OK] Aucune panne (parfait)
- `> 0` = Pannes détectées (câble instable, switch défectueux)

Si ce nombre augmente :
- Problème de câble (le changer)
- Problème de port switch (changer de port)
- Problème de carte réseau (matériel défectueux)

---

## [TEST] ÉTAPE 6 : TESTER LA REDONDANCE (FAILOVER)

### [OBJECTIF] Test de basculement automatique

**On va débrancher virtuellement `eth0` pour voir si `eth1` prend le relais !**

#### **Préparation du test**

**Terminal 1 : Surveillance en temps réel**

```bash
watch -n 1 'cat /proc/net/bonding/bond0 | grep -A 3 "Currently Active"'
```

**Explication :**
- `watch -n 1` = Répète la commande toutes les 1 seconde
- Affiche quelle interface est active

**Tu verras :**
```
Currently Active Slave: eth0
```

**Terminal 2 : Ping continu**

```bash
ping 192.168.1.100
```

**Laisse tourner pour voir si la connexion est interrompue.**

#### **Exécution du test**

**Terminal 3 : Désactiver eth0**

```bash
sudo ip link set eth0 down
```

**Explication :**
- Simule un câble débranché ou une panne de carte réseau

#### **Observer les résultats**

**Terminal 1 devrait afficher :**

```
Currently Active Slave: eth1
^^^^
BASCULEMENT ! [OK]
```

**Terminal 2 (ping) :**

```
64 bytes from 192.168.1.100: icmp_seq=145 time=0.8 ms
64 bytes from 192.168.1.100: icmp_seq=146 time=0.7 ms
[INTERRUPTION POSSIBLE : 0.1 à 0.5 seconde]
64 bytes from 192.168.1.100: icmp_seq=147 time=0.8 ms
64 bytes from 192.168.1.100: icmp_seq=148 time=0.7 ms
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
RETOUR IMMÉDIAT SUR eth1 ! [OK]
```

**Temps d'interruption attendu :**
- Avec `mii-monitor-interval: 100` -> environ **100-200 ms**
- C'est imperceptible pour la plupart des applications

#### **Réactiver eth0**

```bash
sudo ip link set eth0 up
```

**Terminal 1 devrait afficher :**

```
Currently Active Slave: eth0
^^^^
RETOUR SUR eth0 (interface primaire) [OK]
```

### [GRAPHIQUE] Test de performance

**Vérifier le débit réel avec iperf3**

#### **Installer iperf3**

**Sur les 2 machines (serveur et client) :**

```bash
sudo apt install iperf3 -y
```

#### **Sur le serveur (machine avec bonding) :**

```bash
iperf3 -s
```

**Explication :**
- `-s` = Mode serveur (écoute)

#### **Sur le client (autre machine) :**

```bash
iperf3 -c 192.168.1.100 -t 30
```

**Explication :**
- `-c 192.168.1.100` = Se connecte au serveur
- `-t 30` = Test pendant 30 secondes

**Résultat attendu :**

**Mode 1 (active-backup) :**
```
[ ID] Interval           Transfer     Bitrate
[  5]   0.00-30.00  sec  3.52 GBytes   1.01 Gbits/sec
^^^^^^^^^^
Environ 1 Gbps (une seule interface)
```

**Mode 4 (802.3ad) ou Mode 6 (balance-alb) :**
```
[ ID] Interval           Transfer     Bitrate
[  5]   0.00-30.00  sec  7.05 GBytes   2.02 Gbits/sec
^^^^^^^^^^
Environ 2 Gbps (agrégation réelle) [OK]
```

---

## [OUTIL] ÉTAPE 7 : CONFIGURATION DU SWITCH (MODE 4 UNIQUEMENT)

**Si tu utilises le mode 802.3ad (LACP), tu DOIS configurer le switch.**

### [CONTROL_KNOBS] Configuration générique switch managé

**Accès à l'interface du switch :**

1. Connecte-toi à l'interface web du switch
   - Adresse typique : `http://192.168.1.1` ou `http://192.168.1.254`
   - Consulte le manuel de ton switch

2. **Trouve la section "Link Aggregation" ou "LAG" ou "Port Trunking"**

3. **Crée un nouveau LAG :**
   - Nom : `LAG1` (ou `bond0`)
   - Mode : **LACP (802.3ad)**
   - Ports : Sélectionne les 2 ports où sont branchés les câbles
   - LACP mode : **Active**

4. **Active LACP sur les ports :**
   - Port 1 : LACP = Enabled
   - Port 2 : LACP = Enabled

5. **Sauvegarde la configuration**

### [RECHERCHE] Vérifier la négociation LACP

**Sur le serveur Linux :**

```bash
cat /proc/net/bonding/bond0 | grep "Aggregator ID"
```

**Résultat attendu :**

```
Aggregator ID: 1
^^^^^^^^^^
Même ID pour les 2 interfaces = Agrégation active [OK]
```

**Détails complets :**

```bash
cat /proc/net/bonding/bond0
```

**Cherche :**
```
802.3ad info
Aggregator selection policy (ad_select): stable
System priority: 65535
System MAC address: 08:00:27:3b:5c:a1
Active Aggregator Info:
	Aggregator ID: 1
	Number of ports: 2
	^^^^^^^^^^^
	2 PORTS AGRÉGÉS ! [OK]
	Actor Key: 13
	Partner Key: 13
	Partner Mac Address: 00:1a:2b:3c:4d:5e
```

---

## [ALERTE] DÉPANNAGE : PROBLÈMES COURANTS

### [X] Problème 1 : "bond0" n'existe pas

**Symptôme :**
```bash
ip addr show bond0
Device "bond0" does not exist.
```

**Causes possibles :**

1. **Le module bonding n'est pas chargé**
   ```bash
   sudo modprobe bonding
   ```

2. **Erreur dans la configuration Netplan**
   ```bash
   sudo netplan --debug apply
   ```
   Lis les erreurs affichées

3. **Mauvaise indentation YAML**
   - Vérifie que tu utilises des ESPACES, pas des TABULATIONS
   - Compte les espaces (2, 4, 6, 8...)

### [X] Problème 2 : Pas d'IP sur bond0

**Symptôme :**
```bash
ip addr show bond0
# Pas d'inet 192.168.1.100
```

**Solution :**

```bash
# Réappliquer la configuration
sudo netplan apply

# Ou redémarrer le service réseau
sudo systemctl restart systemd-networkd
```

### [X] Problème 3 : eth0 ou eth1 non trouvés

**Symptôme :**
```
Cannot find device "eth0"
```

**Solution :**

1. **Vérifie le nom réel de tes interfaces**
   ```bash
   ip link show
   ```

2. **Modifie la config Netplan avec les bons noms**
   ```bash
   sudo nano /etc/netplan/01-netcfg.yaml
   ```

### [X] Problème 4 : LACP ne fonctionne pas

**Symptôme :**
```
Number of ports: 1
(devrait être 2)
```

**Causes possibles :**

1. **Switch pas configuré en LACP**
   - Vérifie la config du switch

2. **Câbles branchés sur des ports différents**
   - Les 2 câbles doivent être sur le MÊME switch
   - Pas de câble vers 2 switches différents

3. **Mode LACP incorrect sur le switch**
   - Doit être en mode "Active" (pas "Passive")

### [X] Problème 5 : Perte de connexion SSH

**Symptôme :**
Tu as appliqué la config et tu es déconnecté

**Prévention :**
```bash
# TOUJOURS utiliser netplan try
sudo netplan try
```

**Si c'est trop tard :**
- Accès physique à la machine
- Console virtuelle (VirtualBox, VMware)
- Attendre le redémarrage automatique de la config (avec `netplan try`)

---

## [GRAPHIQUE] SURVEILLANCE ET MAINTENANCE

### [HAUSSE] Script de monitoring automatique

**Créer un script pour surveiller le bonding :**

```bash
sudo nano /usr/local/bin/check-bonding.sh
```

**Contenu du script :**

```bash
#!/bin/bash
# Script de surveillance bonding

BOND_INTERFACE="bond0"
LOG_FILE="/var/log/bonding-monitor.log"

# Fonction de log
log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}

# Vérifier si bond0 existe
if ! ip link show "$BOND_INTERFACE" &>/dev/null; then
    log_message "ERREUR: Interface $BOND_INTERFACE introuvable!"
    exit 1
fi

# Récupérer l'interface active
ACTIVE_SLAVE=$(cat /proc/net/bonding/"$BOND_INTERFACE" | grep "Currently Active Slave" | awk '{print $4}')

# Récupérer le nombre de pannes
FAILURES=$(cat /proc/net/bonding/"$BOND_INTERFACE" | grep "Link Failure Count" | awk '{sum+=$4} END {print sum}')

# Logger l'état
log_message "Interface active: $ACTIVE_SLAVE | Pannes totales: $FAILURES"

# Alerte si plus de 5 pannes
if [ "$FAILURES" -gt 5 ]; then
    log_message "ALERTE: Nombre élevé de pannes détecté ($FAILURES)"
fi
```

**Rendre le script exécutable :**

```bash
sudo chmod +x /usr/local/bin/check-bonding.sh
```

**Tester le script :**

```bash
sudo /usr/local/bin/check-bonding.sh
```

**Automatiser l'exécution (toutes les 5 minutes) :**

```bash
# Éditer la crontab
sudo crontab -e

# Ajouter cette ligne :
*/5 * * * * /usr/local/bin/check-bonding.sh
```

### [DOC] Consulter les logs

```bash
# Logs du bonding
sudo tail -f /var/log/bonding-monitor.log

# Logs système réseau
sudo journalctl -u systemd-networkd -f
```

---

## [BRAVO] RÉCAPITULATIF FINAL

### [OK] Ce qu'on a accompli

1. [OK] **Compris** les concepts de bonding/LAG
2. [OK] **Installé** le module bonding Linux
3. [OK] **Configuré** une interface bond0 avec 2 cartes réseau
4. [OK] **Testé** la redondance (failover automatique)
5. [OK] **Vérifié** le bon fonctionnement
6. [OK] **Mis en place** une surveillance

### [OBJECTIF] Avantages obtenus

**Mode 1 (active-backup) :**
- [OK] Redondance totale (si un câble tombe, l'autre prend le relais)
- [OK] Temps de bascule < 0.2 seconde
- [OK] Compatible avec tous les switches

**Mode 4 (802.3ad LACP) :**
- [OK] Bande passante doublée (2 Gbps au lieu de 1 Gbps)
- [OK] Redondance totale
- [OK] Équilibrage de charge automatique
- [OK] Standardisé et fiable

### [DOCS] Commandes essentielles à retenir

```bash
# Voir l'état du bonding
cat /proc/net/bonding/bond0

# Voir les interfaces
ip link show

# Voir les IPs
ip addr show

# Voir les baux DHCP
cat /proc/net/bonding/bond0

# Désactiver/activer une interface
sudo ip link set eth0 down
sudo ip link set eth0 up

# Appliquer config Netplan
sudo netplan apply

# Tester config Netplan (auto-annulation)
sudo netplan try
```

### [RAPIDE] Aller plus loin

**Configurations avancées possibles :**

1. **Bonding avec 4 cartes réseau :**
   ```yaml
   interfaces:
     - eth0
     - eth1
     - eth2
     - eth3
   ```

2. **VLAN sur interface bonding :**
   - Créer des sous-réseaux virtuels
   - Isoler différents types de trafic

3. **Monitoring avec Zabbix ou Nagios :**
   - Surveillance professionnelle
   - Alertes automatiques

4. **Bonding + Firewall (iptables) :**
   - Sécuriser le serveur
   - Filtrer le trafic

---

## [REFLEXION] Questions fréquentes (FAQ)

### **Q1 : Puis-je utiliser des cartes réseau de vitesses différentes ?**

**R :** Oui, mais la vitesse sera limitée par la carte la plus lente.

Exemple :
- eth0 : 1 Gbps
- eth1 : 100 Mbps
-> Vitesse effective : 100 Mbps sur eth1

**Recommandation : Utilise des cartes identiques.**

---

### **Q2 : Combien de cartes puis-je agréger ?**

**R :** Linux supporte jusqu'à **8 interfaces** par bond.

Exemple :
```yaml
interfaces:
  - eth0
  - eth1
  - eth2
  - eth3
  - eth4
  - eth5
  - eth6
  - eth7
```

Avec 8 cartes Gigabit = **8 Gbps théoriques** !

---

### **Q3 : Puis-je utiliser WiFi + Ethernet en bonding ?**

**R :** **Non recommandé.**

Problèmes :
- Latences très différentes (WiFi plus lent)
- Instabilité du WiFi
- Complexité de configuration

**Solution alternative : Utilise uniquement Ethernet en bonding.**

---

### **Q4 : Le bonding fonctionne-t-il avec VirtualBox ?**

**R :** **Oui !**

Configuration VirtualBox :
1. Ajoute plusieurs cartes réseau à ta VM (Adapter 1, Adapter 2...)
2. Mode : "Accès par pont" (Bridged)
3. Configure le bonding normalement dans la VM

---

### **Q5 : Dois-je redémarrer après la configuration ?**

**R :** **Non** si tu utilises `netplan apply`.

**Oui** si :
- Tu modifies `/etc/network/interfaces` (ancienne méthode)
- Tu as des problèmes

Commande de redémarrage :
```bash
sudo reboot
```

---

### **Q6 : Puis-je mixer bonding avec DHCP au lieu d'IP fixe ?**

**R :** **Oui, c'est possible.**

Configuration DHCP pour bond0 :

```yaml
bonds:
  bond0:
    interfaces:
      - eth0
      - eth1
    dhcp4: yes
    dhcp6: no
    parameters:
      mode: active-backup
      primary: eth0
      mii-monitor-interval: 100
```

**Quand utiliser DHCP sur bonding :**
- [OK] Poste de travail / Desktop
- [X] Serveur (préfère IP fixe pour la stabilité)

---

### **Q7 : Que se passe-t-il si je branche les 2 câbles sur 2 switches différents ?**

**R :** **Ça dépend du mode.**

**Mode 1 (active-backup) :**
- [OK] Fonctionne parfaitement
- C'est même recommandé pour la redondance maximale
- Si un switch tombe, l'autre prend le relais

**Mode 4 (802.3ad LACP) :**
- [X] Ne fonctionne PAS
- LACP nécessite que les 2 câbles soient sur le MÊME switch
- Ou sur 2 switches configurés en stack/cluster

**Recommandation pour redondance switch :**
```
Serveur
├─ eth0 -> Switch A (mode active-backup)
└─ eth1 -> Switch B
```

---

### **Q8 : Comment désactiver le bonding et revenir à la config normale ?**

**R :** Restaure l'ancienne configuration.

```bash
# Restaurer la sauvegarde
sudo cp /etc/netplan/01-netcfg.yaml.backup /etc/netplan/01-netcfg.yaml

# Appliquer
sudo netplan apply

# Ou créer une config simple
sudo nano /etc/netplan/01-netcfg.yaml
```

Configuration normale (sans bonding) :

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: yes
```

---

## [SECURISE] SÉCURITÉ ET BONNES PRATIQUES

### [OK] Checklist de sécurité

**Avant de mettre en production :**

- [ ] [OK] Tester le failover (débrancher un câble)
- [ ] [OK] Vérifier les logs (pas d'erreurs)
- [ ] [OK] Documenter la configuration
- [ ] [OK] Sauvegarder les fichiers de config
- [ ] [OK] Tester depuis un autre appareil
- [ ] [OK] Configurer le monitoring
- [ ] [OK] Informer l'équipe des changements

### [VERROUILLE] Recommandations de production

**1. Utilise toujours des câbles identiques**
- Même longueur
- Même catégorie (Cat5e, Cat6, Cat6a)
- Même fabricant si possible

**2. Étiquette les câbles**
```
Serveur-01 -> Switch-Port-10 (eth0)
Serveur-01 -> Switch-Port-11 (eth1)
```

**3. Documente la configuration**

Crée un fichier de documentation :

```bash
sudo nano /root/bonding-config.txt
```

Contenu :

```
=== Configuration Bonding Serveur-01 ===
Date : 2024-12-06
Administrateur : [Ton nom]

Interfaces :
- bond0 : 192.168.1.100/24
  - eth0 (08:00:27:3b:5c:a1) -> Switch-A Port 10
  - eth1 (08:00:27:7d:9e:b2) -> Switch-A Port 11

Mode : active-backup (Mode 1)
Passerelle : 192.168.1.1
DNS : 8.8.8.8, 8.8.4.4

Tests effectués :
[x] Failover eth0 -> eth1
[x] Failover eth1 -> eth0
[x] Performance réseau
[x] Redémarrage serveur

Notes :
- MII monitoring : 100ms
- Interface primaire : eth0
```

**4. Planifie les maintenances**

Avant de toucher à la config :
- Prévenir les utilisateurs
- Faire un snapshot/backup
- Tester sur environnement de dev d'abord

---

## [GRAPHIQUE] TABLEAUX DE RÉFÉRENCE RAPIDE

### Modes de bonding - Comparaison complète

| Critère | Mode 0 | Mode 1 | Mode 2 | Mode 3 | Mode 4 | Mode 5 | Mode 6 |
|---------|--------|--------|--------|--------|--------|--------|--------|
| **Nom** | balance-rr | active-backup | balance-xor | broadcast | 802.3ad | balance-tlb | balance-alb |
| **Bande passante** | *** | * | ** | * | *** | ** | *** |
| **Redondance** | * | *** | ** | *** | *** | ** | ** |
| **Config switch** | Non | Non | Non | Non | **OUI** | Non | Non |
| **Complexité** | Simple | Simple | Moyenne | Simple | Élevée | Moyenne | Élevée |
| **Production** | [X] | [OK] | [OK] | [X] | [OK] | [OK] | [OK] |

### Compatibilité switches

| Fabricant | Modèle | LACP (802.3ad) | Configuration |
|-----------|--------|----------------|---------------|
| **Cisco** | Catalyst 2960+ | [OK] | Port-channel |
| **HP/Aruba** | ProCurve | [OK] | Trunk/LACP |
| **Netgear** | GS108Tv3+ | [OK] | LAG |
| **TP-Link** | T1600G+ | [OK] | LAG |
| **Ubiquiti** | UniFi Switch | [OK] | Link Aggregation |
| **Mikrotik** | CRS series | [OK] | Bonding |
| **D-Link** | DGS-1210+ | [OK] | Port Trunking |

### Vitesses réseau - Référence

| Type | Débit théorique | Débit réel | Câble | Distance max |
|------|-----------------|------------|-------|--------------|
| Fast Ethernet | 100 Mbps | ~94 Mbps | Cat5 | 100m |
| Gigabit | 1 Gbps | ~940 Mbps | Cat5e+ | 100m |
| 2.5G Ethernet | 2.5 Gbps | ~2.35 Gbps | Cat5e+ | 100m |
| 5G Ethernet | 5 Gbps | ~4.7 Gbps | Cat6+ | 100m |
| 10G Ethernet | 10 Gbps | ~9.4 Gbps | Cat6a+ | 100m |

### Exemple : Bonding 2x1Gbps

**Mode active-backup (Mode 1) :**
- Débit : **1 Gbps** (une seule interface active)
- Redondance : **Oui**

**Mode 802.3ad (Mode 4) :**
- Débit : **2 Gbps** (agrégation réelle)
- Redondance : **Oui**

---

## [OUTILS] CONFIGURATIONS ALTERNATIVES

### Configuration avec /etc/network/interfaces (Debian/Ubuntu ancien)

**Si tu n'utilises PAS Netplan (Ubuntu < 18.04) :**

```bash
sudo nano /etc/network/interfaces
```

**Contenu :**

```bash
# Interface loopback
auto lo
iface lo inet loopback

# Interfaces esclaves
auto eth0
iface eth0 inet manual
    bond-master bond0

auto eth1
iface eth1 inet manual
    bond-master bond0

# Interface bonding
auto bond0
iface bond0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    dns-nameservers 8.8.8.8 8.8.4.4
    bond-mode active-backup
    bond-miimon 100
    bond-slaves eth0 eth1
    bond-primary eth0
```

**Appliquer :**

```bash
sudo systemctl restart networking
```

---

### Configuration avec NetworkManager (RedHat/CentOS/Fedora)

**Créer le bond :**

```bash
# Créer l'interface bond0
sudo nmcli connection add type bond con-name bond0 ifname bond0 mode active-backup

# Ajouter eth0 comme esclave
sudo nmcli connection add type ethernet slave-type bond con-name bond0-slave1 ifname eth0 master bond0

# Ajouter eth1 comme esclave
sudo nmcli connection add type ethernet slave-type bond con-name bond0-slave2 ifname eth1 master bond0

# Configurer l'IP
sudo nmcli connection modify bond0 ipv4.addresses 192.168.1.100/24
sudo nmcli connection modify bond0 ipv4.gateway 192.168.1.1
sudo nmcli connection modify bond0 ipv4.dns "8.8.8.8 8.8.4.4"
sudo nmcli connection modify bond0 ipv4.method manual

# Activer
sudo nmcli connection up bond0
```

**Vérifier :**

```bash
sudo nmcli connection show
sudo nmcli device status
```

---

## [COURS] EXERCICES PRATIQUES

### Exercice 1 : Configuration de base (Débutant)

**Objectif : Créer un bonding en mode active-backup**

**Étapes :**
1. [ ] Identifier 2 interfaces réseau disponibles
2. [ ] Créer la configuration Netplan
3. [ ] Appliquer avec `netplan try`
4. [ ] Vérifier avec `cat /proc/net/bonding/bond0`
5. [ ] Tester un ping vers Google

**Temps estimé : 15 minutes**

---

### Exercice 2 : Test de redondance (Intermédiaire)

**Objectif : Vérifier le failover automatique**

**Étapes :**
1. [ ] Lancer un ping continu vers le serveur
2. [ ] Surveiller `/proc/net/bonding/bond0`
3. [ ] Désactiver eth0 avec `ip link set eth0 down`
4. [ ] Observer le basculement vers eth1
5. [ ] Réactiver eth0
6. [ ] Noter le temps de bascule

**Temps estimé : 10 minutes**

---

### Exercice 3 : Configuration LACP (Avancé)

**Objectif : Mettre en place le mode 802.3ad avec un switch**

**Prérequis : Switch managé compatible LACP**

**Étapes :**
1. [ ] Configurer le switch en LACP
2. [ ] Créer un LAG avec 2 ports
3. [ ] Modifier la config Netplan pour mode 802.3ad
4. [ ] Appliquer et vérifier l'agrégation
5. [ ] Tester les performances avec iperf3
6. [ ] Mesurer le débit (devrait être ~2 Gbps)

**Temps estimé : 30 minutes**

---

### Exercice 4 : Monitoring et alertes (Expert)

**Objectif : Mettre en place une surveillance complète**

**Étapes :**
1. [ ] Créer le script de monitoring
2. [ ] Configurer la crontab
3. [ ] Tester les alertes en simulant des pannes
4. [ ] Configurer l'envoi d'emails (avec mailutils)
5. [ ] Créer un dashboard de monitoring

**Temps estimé : 1 heure**

---

## [GUIDE] RESSOURCES SUPPLÉMENTAIRES

### Documentation officielle

- **Linux Kernel Bonding** : https://www.kernel.org/doc/Documentation/networking/bonding.txt
- **Netplan.io** : https://netplan.io/reference/
- **IEEE 802.3ad** : Standard LACP officiel

### Tutoriels vidéo recommandés

- "Linux Network Bonding Tutorial" (YouTube)
- "LACP Configuration on Cisco Switches" (YouTube)
- "High Availability Networking with Linux" (YouTube)

### Livres recommandés

- "Linux Network Administrator's Guide" (O'Reilly)
- "TCP/IP Network Administration" (O'Reilly)
- "Network Warrior" (O'Reilly)

### Forums et communautés

- **Stack Overflow** : Tag [linux-networking]
- **Reddit** : r/networking, r/linuxadmin
- **Server Fault** : Questions sur administration système
- **Linux Questions** : Forum communautaire

---

## [BRAVO] CONCLUSION

### Ce que tu as appris

Tu maîtrises maintenant :

[OK] **Les concepts** :
- Agrégation de liens (bonding/LAG)
- Les 7 modes de bonding Linux
- Redondance et haute disponibilité

[OK] **La pratique** :
- Configuration Netplan
- Commandes de gestion réseau
- Tests de failover
- Monitoring et surveillance

[OK] **La production** :
- Choix du bon mode selon le contexte
- Configuration de switches
- Bonnes pratiques de sécurité
- Documentation et maintenance

### Prochaines étapes

**Niveau 1 : Consolider les bases**
- Pratiquer sur VirtualBox/VMware
- Tester différents modes
- Créer des documentations

**Niveau 2 : Aller plus loin**
- VLAN + Bonding
- Bonding + Firewall (iptables/nftables)
- Monitoring avancé (Zabbix, Nagios)

**Niveau 3 : Expert**
- Haute disponibilité complète (Bonding + VRRP/Keepalived)
- SDN (Software-Defined Networking)
- Automatisation (Ansible)

---

## [IDEE] CONSEILS FINAUX

### Pour les débutants

1. **Commence simple** : Mode 1 (active-backup) sans switch
2. **Teste d'abord** : Utilise VirtualBox avant la production
3. **Documente tout** : Notes, screenshots, configurations
4. **Pose des questions** : Forums, communautés, collègues

### Pour la production

1. **Planifie** : Fenêtre de maintenance, plan de rollback
2. **Sauvegarde** : Configs, VMs, état actuel
3. **Teste** : Environnement de dev avant production
4. **Surveille** : Logs, monitoring, alertes
5. **Documente** : Wiki, procédures, contacts

### Erreurs à éviter

[X] **Ne pas tester** le failover avant la production
[X] **Oublier** de sauvegarder les configs
[X] **Mélanger** des câbles de catégories différentes
[X] **Négliger** le monitoring
[X] **Ignorer** les logs d'erreur

---

## [TEL] BESOIN D'AIDE ?

### Débogage rapide

**Problème réseau ? Checklist rapide :**

```bash
# 1. bond0 existe ?
ip link show bond0

# 2. IP configurée ?
ip addr show bond0

# 3. Interfaces esclaves actives ?
cat /proc/net/bonding/bond0

# 4. Ping vers passerelle ?
ping -c 4 192.168.1.1

# 5. Ping vers Internet ?
ping -c 4 8.8.8.8

# 6. Résolution DNS ?
ping -c 4 google.com

# 7. Logs d'erreurs ?
sudo journalctl -u systemd-networkd -n 50
```

### Commandes de diagnostic

```bash
# État complet du réseau
sudo ip addr
sudo ip route
sudo ip link

# Détails bonding
cat /proc/net/bonding/bond0

# Statistiques réseau
sudo ethtool eth0
sudo ethtool eth1

# Logs en temps réel
sudo tail -f /var/log/syslog
sudo journalctl -f
```

---

## [TROPHEE] CERTIFICAT DE RÉUSSITE

**Tu as terminé ce guide !**

Tu es maintenant capable de :

[OK] Comprendre et expliquer le bonding réseau
[OK] Choisir le bon mode selon tes besoins
[OK] Configurer un bonding Linux de A à Z
[OK] Tester et valider la configuration
[OK] Dépanner les problèmes courants
[OK] Mettre en production en sécurité

**Bravo ! [BRAVO]**

Continue à pratiquer et à explorer !

---

## [NOTE] NOTES PERSONNELLES

*Espace pour tes propres notes :*

```
Date de configuration : _______________

Adresse IP bond0 : _______________

Interfaces utilisées :
- eth0 (MAC : ________________)
- eth1 (MAC : ________________)

Mode choisi : _______________

Switch utilisé : _______________

Tests effectués :
[ ] Failover eth0 -> eth1
[ ] Failover eth1 -> eth0
[ ] Performance iperf3
[ ] Redémarrage système

Problèmes rencontrés :
_________________________________
_________________________________
_________________________________

Solutions appliquées :
_________________________________
_________________________________
_________________________________

Notes supplémentaires :
_________________________________
_________________________________
_________________________________
```

---

**FIN DU GUIDE**

*Créé avec [HEAVY_BLACK_HEART] pour la communauté Linux*