# [COURS] GUIDE COMPLET - CONFIGURATION IP (STATIQUE OU DYNAMIQUE) POUR DÉBUTANTS ABSOLUS

---

## * AVANT DE COMMENCER : COMPRENDRE LES BASES

### Qu'est-ce qu'une adresse IP ?

**IP = Internet Protocol = Protocole Internet**

C'est l'identifiant unique d'un appareil sur un réseau, comme l'adresse postale d'une maison.

**Format typique : `192.168.1.51`**

#### [GRAPHIQUE] Anatomie d'une adresse IP

```
192 . 168 . 1 . 51
│     │    │    │
│     │    │    └─ Numéro de l'appareil (1 à 254)
│     │    └────── Numéro du sous-réseau
│     └─────────── Réseau privé type "maison/bureau"
└───────────────── Réseau privé
```

#### [HOUSE_BUILDINGS] Visualisation du réseau

```
TON QUARTIER (= TON RÉSEAU LOCAL 192.168.1.0/24)
├─ [ACCUEIL] Maison n°1   (192.168.1.1)   <- La Poste (Box Internet/Routeur)
├─ [ACCUEIL] Maison n°2   (192.168.1.2)   <- Disponible
├─ [ACCUEIL] Maison n°10  (192.168.1.10)  <- PC Windows (IP dynamique)
├─ [ACCUEIL] Maison n°51  (192.168.1.51)  <- Serveur Web (IP statique)
├─ [ACCUEIL] Maison n°100 (192.168.1.100) <- Serveur DHCP (IP statique)
└─ [ACCUEIL] Maison n°254 (192.168.1.254) <- Dernière adresse utilisable
```

#### [ATTENTION] Règles importantes

1. **192.168.X.X = Adresses privées** (pour réseaux locaux)
   - Pas accessibles depuis Internet directement
   - Parfaites pour la maison/entreprise

2. **Chaque appareil = IP UNIQUE**
   - Si 2 appareils ont la même IP -> CONFLIT [IMPACT]
   - Les deux ne fonctionnent plus correctement

3. **Adresses réservées**
   - `.1` = Souvent la Box/Routeur
   - `.255` = Adresse de broadcast (diffusion)
   - `.0` = Identifiant du réseau lui-même

---

## [SYNC] IP STATIQUE vs IP DYNAMIQUE : QUELLE DIFFÉRENCE ?

### [IMPORTANT] IP Statique (Configuration Manuelle)

#### Définition
L'adresse IP est **configurée manuellement** et **ne change JAMAIS**.

#### Analogie
C'est comme avoir une **maison avec une adresse permanente** :
- [IMPORTANT] Ton adresse : "123 Rue de la Paix"
- [OK] Elle ne change jamais
- [OK] Les gens savent toujours où te trouver
- [OK] Le facteur livre toujours au bon endroit

#### Quand utiliser une IP statique ?

| Appareil | Pourquoi ? |
|----------|------------|
| **Serveur Web** | Les clients doivent toujours trouver le site à la même adresse |
| **Serveur DHCP** | Les clients doivent savoir où demander une IP |
| **Serveur DNS** | Les appareils doivent savoir où résoudre les noms de domaine |
| **Imprimante réseau** | Les PC doivent toujours savoir où envoyer les impressions |
| **Caméra de surveillance** | L'application doit toujours se connecter à la même IP |
| **NAS (stockage)** | Les utilisateurs doivent accéder aux fichiers à une adresse fixe |

#### [OK] Avantages
- **Fiabilité** : L'adresse ne change jamais
- **Prévisibilité** : Facile à mémoriser et configurer
- **Idéal pour services** : Les clients savent où se connecter

#### [X] Inconvénients
- **Configuration manuelle** : Plus de travail initial
- **Risque d'erreur** : Conflit possible si mal configuré
- **Gestion complexe** : Sur grands réseaux, difficile de suivre qui a quoi

---

### [SYNC] IP Dynamique (via DHCP)

#### Définition
L'adresse IP est **attribuée automatiquement** par un serveur DHCP et peut **changer** dans le temps.

#### Analogie
C'est comme **louer une chambre d'hôtel** :
- [HOTEL] Tu arrives : "J'ai besoin d'une chambre"
- [PERSONNE][PRO] Réceptionniste (DHCP) : "Voici la chambre 51"
- [CALENDRIER] Le lendemain, tu pourrais avoir la chambre 52
- [OK] Pas besoin de réserver à l'avance
- [OK] Automatique et sans effort

#### Quand utiliser une IP dynamique ?

| Appareil | Pourquoi ? |
|----------|------------|
| **PC personnel** | Pas besoin d'adresse fixe, juste d'être connecté |
| **Smartphone** | Change souvent de réseau (WiFi maison, travail, café) |
| **Tablette** | Utilisateur nomade |
| **Laptop** | Se déplace entre différents réseaux |
| **Console de jeux** | Juste besoin d'Internet, pas d'être serveur |

#### [OK] Avantages
- **Automatique** : Aucune configuration manuelle
- **Zero Touch** : Brancher et utiliser immédiatement
- **Pas de conflits** : Le serveur DHCP gère l'unicité
- **Facile à déployer** : Idéal pour grands réseaux

#### [X] Inconvénients
- **Adresse changeante** : Peut compliquer l'accès à distance
- **Dépendance DHCP** : Si le serveur tombe, plus d'IPs distribuées
- **Pas idéal pour serveurs** : Les clients ne savent pas où se connecter

---

## [GRAPHIQUE] RÉCAPITULATIF : QUEL MODE CHOISIR ?

| Critère | IP Statique | IP Dynamique |
|---------|-------------|--------------|
| **Configuration** | Manuelle | Automatique |
| **Changement d'IP** | Jamais | Possible |
| **Pour serveurs** | [OK] Recommandé | [X] Déconseillé |
| **Pour clients** | [X] Trop complexe | [OK] Parfait |
| **Risque de conflit** | [ATTENTION] Moyen (si mal géré) | [OK] Aucun (géré par DHCP) |
| **Facilité déploiement** | [X] Chronophage | [OK] Rapide |
| **Idéal pour...** | Serveurs, imprimantes, NAS | PC, téléphones, tablettes |

---

## [OBJECTIF] STRATÉGIE DE PLANIFICATION RÉSEAU

### [WORLD_MAP] Organisation recommandée d'un réseau 192.168.1.0/24

```
RÉSEAU : 192.168.1.0/24
│
├─ 192.168.1.1          <- RÉSERVÉ : Box/Routeur (passerelle)
│
├─ 192.168.1.2-49       <- ZONE IPS STATIQUES (48 adresses)
│  ├─ .2-10  : Serveurs critiques (Web, DNS, Base de données)
│  ├─ .11-20 : Équipements réseau (Switchs, Points d'accès WiFi)
│  ├─ .21-30 : Imprimantes et périphériques
│  └─ .31-49 : Réserve pour futurs services
│
├─ 192.168.1.50-150     <- PLAGE DHCP (101 adresses)
│  └─ IPs attribuées automatiquement aux clients
│
├─ 192.168.1.151-200    <- ZONE RÉSERVÉE FUTURE (50 adresses)
│  └─ Extension DHCP ou nouveaux serveurs
│
└─ 192.168.1.201-254    <- ZONE LIBRE (54 adresses)
   └─ Appareils temporaires, tests, invités
```

### [IDEE] Bonnes pratiques

1. **Documente ton réseau** : Tiens un tableau des IPs statiques
2. **Sépare les zones** : Statiques en bas, DHCP au milieu
3. **Laisse de la marge** : Prévois l'expansion future
4. **Évite .1 et .255** : Réservés (routeur et broadcast)

---

## [CONFIG] PARTIE 1 : CONFIGURATION IP STATIQUE SUR LINUX (VM)

### [LISTE] Prérequis

[OK] Une VM Linux (Ubuntu/Debian) dans VirtualBox  
[OK] Mode réseau : **Accès par pont** (Bridged Adapter)  
[OK] Connexion réseau active  

### [OBJECTIF] Objectif
Donner à ta VM l'adresse IP fixe : **192.168.1.100**

---

### [OUTILS] Étape 1 : Identifier ton interface réseau

Ouvre un terminal dans ta VM et tape :

```bash
ip a
```

#### Explication de la commande
- `ip` = Programme pour gérer le réseau
- `a` = Raccourci pour "address" (adresse)

#### Résultat attendu

```
1: lo: <LOOPBACK,UP,LOWER_UP>
   inet 127.0.0.1/8 scope host lo
   ^^^^^^^^^^
   Interface "loopback" (interne, ignore-la)

2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP>
   ^^^^^^
   NOM DE TON INTERFACE [OK] (note-le !)
   
   inet 192.168.1.15/24 brd 192.168.1.255 scope global dynamic enp0s3
   ^^^^^^^^^^^^
   IP ACTUELLE (probablement via DHCP)
```

#### [NOTE] Noms d'interfaces courants

| Nom | Signification |
|-----|---------------|
| `enp0s3` | Ethernet, carte 0, slot 3 (VirtualBox) |
| `eth0` | Ethernet 0 (ancien système de nommage) |
| `ens33` | Ethernet, slot 33 (VMware) |
| `wlan0` | WiFi (Wireless LAN) |

[ATTENTION] **IMPORTANT** : Note le nom de ton interface ! Tu en auras besoin.

---

### [OUTILS] Étape 2 : Trouver ton fichier de configuration Netplan

Ubuntu/Debian moderne utilise **Netplan** pour configurer le réseau.

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

#### Résultat attendu

Tu verras un fichier comme :
- `00-installer-config.yaml`
- `01-netcfg.yaml`
- `50-cloud-init.yaml`

[NOTE] **Note le nom exact de ton fichier !**

---

### [OUTILS] Étape 3 : 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
```

#### Explication
- `sudo` = Super User DO (droits administrateur)
- `cp` = Copy (copier)
- On crée une copie `.backup` au cas où

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

---

### [OUTILS] Étape 4 : Éditer le fichier de configuration

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

#### Explication
- `nano` = Éditeur de texte simple en ligne de commande
- Tu modifieras le fichier de configuration réseau

---

### [NOTE] Étape 5 : Écrire la configuration IP statique

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

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

---

### [RECHERCHE] EXPLICATION LIGNE PAR LIGNE (ULTRA DÉTAILLÉE)

#### Ligne 1 : `network:`
```yaml
network:
```
- **Signification** : Début de la section réseau
- **Indentation** : Niveau 0 (pas d'espaces)
- **Rôle** : Conteneur pour toute la configuration réseau

---

#### Ligne 2 : `version: 2`
```yaml
  version: 2
```
- **Signification** : Version du format Netplan (toujours 2)
- **Indentation** : 2 espaces (niveau 1)
- **Pourquoi** : Netplan a deux versions, la v2 est la moderne

---

#### Ligne 3 : `renderer: networkd`
```yaml
  renderer: networkd
```
- **Signification** : Programme qui appliquera la configuration
- **Indentation** : 2 espaces (niveau 1)
- **Options possibles** :
  - `networkd` = systemd-networkd (simple, recommandé pour serveurs)
  - `NetworkManager` = Pour desktop avec GUI

**Analogie** : C'est comme choisir entre deux outils pour peindre un mur :
- `networkd` = Rouleau professionnel (efficace, direct)
- `NetworkManager` = Pistolet à peinture avec interface (plus d'options visuelles)

---

#### Ligne 4 : `ethernets:`
```yaml
  ethernets:
```
- **Signification** : Section pour les cartes réseau Ethernet
- **Indentation** : 2 espaces (niveau 1)
- **Rôle** : Contient la configuration des interfaces câblées ou virtuelles

**Note** : Pour WiFi, on utiliserait `wifis:` à la place

---

#### Ligne 5 : `enp0s3:`
```yaml
    enp0s3:
```
- **Signification** : Nom de l'interface réseau à configurer
- **Indentation** : 4 espaces (niveau 2)
- [ATTENTION] **CRITIQUE** : Remplace `enp0s3` par le nom de TON interface !

**Comment trouver ton interface ?**
```bash
ip a | grep -E '^[0-9]+: [^lo]'
```
Tu verras quelque chose comme :
```
2: enp0s3: <BROADCAST,MULTICAST,UP>
```

---

#### Ligne 6 : `dhcp4: no`
```yaml
      dhcp4: no
```
- **Signification** : Désactive le client DHCP pour IPv4
- **Indentation** : 6 espaces (niveau 3)
- **Explication détaillée** :
  - `dhcp4` = DHCP pour IPv4 (les adresses IP normales)
  - `no` = Désactivé
  - **Pourquoi ?** On veut une IP statique, pas automatique

**Analogie** :
- `dhcp4: yes` = "Laisse l'hôtel choisir ma chambre"
- `dhcp4: no` = "Je réserve la chambre 100, toujours la même"

**Alternatives possibles** :
```yaml
dhcp4: yes   # Utiliser DHCP (IP dynamique)
dhcp4: no    # IP statique (ce qu'on veut)
```

---

#### Lignes 7-8 : `addresses:`
```yaml
      addresses:
        - 192.168.1.100/24
```
- **Signification** : Liste des adresses IP à attribuer
- **Indentation** : 
  - `addresses:` = 6 espaces (niveau 3)
  - `- 192.168.1.100/24` = 8 espaces (niveau 4)

**Décryptage de `192.168.1.100/24`** :

| Partie | Signification |
|--------|---------------|
| `192.168.1.100` | L'adresse IP fixe de la VM |
| `/24` | Masque de sous-réseau (= 255.255.255.0) |

**Qu'est-ce que `/24` ?**

Le `/24` signifie : "Les 24 premiers bits identifient le réseau"

En clair :
- Réseau : `192.168.1.X`
- Les appareils de `.1` à `.254` peuvent communiquer directement
- `.0` = Identifiant du réseau
- `.255` = Broadcast (diffusion)

**Visualisation** :
```
192.168.1.100/24
│   │   │  │  └─ Masque (/24 = les 24 premiers bits = réseau)
│   │   │  └──── Numéro de l'appareil (100)
│   │   └─────── Sous-réseau (1)
│   └─────────── Réseau privé (168)
└─────────────── Classe réseau privé (192)
```

**Table des masques courants** :

| CIDR | Masque | Nombre d'hôtes | Usage |
|------|--------|----------------|-------|
| `/24` | 255.255.255.0 | 254 | Petit réseau (maison, PME) |
| `/16` | 255.255.0.0 | 65,534 | Grand réseau d'entreprise |
| `/8` | 255.0.0.0 | 16,777,214 | Très grand réseau |

**Tu peux avoir plusieurs IPs** :
```yaml
addresses:
  - 192.168.1.100/24
  - 192.168.1.101/24  # IP secondaire
  - 10.0.0.50/8       # IP sur un autre réseau
```

---

#### Lignes 9-11 : `routes:`
```yaml
      routes:
        - to: default
          via: 192.168.1.1
```
- **Signification** : Configuration du routage (chemin vers Internet)
- **Indentation** :
  - `routes:` = 6 espaces
  - `- to: default` = 8 espaces
  - `via: 192.168.1.1` = 10 espaces

**Décryptage ligne par ligne** :

##### `to: default`
- **Signification** : Pour toutes les destinations (tout Internet)
- "default" = Route par défaut = "Si tu ne sais pas où aller, passe par là"

##### `via: 192.168.1.1`
- **Signification** : Passe par cette adresse IP (ta Box/Routeur)
- C'est la **passerelle** (gateway)

**Analogie complète** :
```
Tu veux aller à Paris depuis ton quartier :
- "to: Paris" = Destination
- "via: Gare" = Passe par la gare
```

Pour le réseau :
```
Tu veux aller sur google.com (Internet) :
- "to: default" = Toute destination hors réseau local
- "via: 192.168.1.1" = Passe par la Box (qui a accès Internet)
```

**Fonctionnement détaillé** :

1. La VM veut accéder à `google.com` (142.250.185.78)
2. Elle regarde : "Cette IP est-elle dans mon réseau local (192.168.1.X) ?"
3. Non -> Elle consulte la route `default`
4. "Ah ! Pour aller ailleurs, je dois passer par 192.168.1.1"
5. Elle envoie le paquet à la Box
6. La Box le transmet vers Internet

[ATTENTION] **VÉRIFIE que 192.168.1.1 est bien l'IP de ta Box !**

**Comment vérifier l'IP de ta Box ?**

Sur Windows :
```cmd
ipconfig
```
Cherche "Passerelle par défaut" -> c'est l'IP de ta Box

Sur Linux/Mac :
```bash
ip route | grep default
```
Tu verras : `default via 192.168.1.1 dev eth0`

**Routes supplémentaires (exemple avancé)** :
```yaml
routes:
  - to: default
    via: 192.168.1.1
  - to: 10.0.0.0/8          # Réseau spécifique
    via: 192.168.1.254      # Passe par un autre routeur
  - to: 172.16.0.0/16
    via: 192.168.1.200
```

---

#### Lignes 12-15 : `nameservers:`
```yaml
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
```
- **Signification** : Serveurs DNS (Domain Name System)
- **Indentation** :
  - `nameservers:` = 6 espaces
  - `addresses:` = 8 espaces
  - `- 8.8.8.8` et `- 8.8.4.4` = 10 espaces

**Qu'est-ce que DNS ?**

Le DNS traduit les noms de domaine en adresses IP.

**Analogie** : C'est comme un annuaire téléphonique
- Tu cherches "Pizza Napoli" -> L'annuaire te donne le numéro : 06 12 34 56 78
- Tu tapes "google.com" -> Le DNS te donne l'IP : 142.250.185.78

**Fonctionnement en détail** :

```
┌─────────────────────────────────────────────────────┐
│ 1. TU TAPES : "Je veux aller sur google.com"       │
└────────────────────┬────────────────────────────────┘
                     │
                     [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────────┐
│ 2. TON PC : "Je ne connais pas d'IP google.com"    │
│    -> Je demande au DNS : 8.8.8.8                    │
└────────────────────┬────────────────────────────────┘
                     │
                     [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────────┐
│ 3. DNS GOOGLE (8.8.8.8) : "google.com = 142.250... │
└────────────────────┬────────────────────────────────┘
                     │
                     [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────────┐
│ 4. TON PC : "Merci ! Je me connecte à 142.250...   │
└─────────────────────────────────────────────────────┘
```

**Pourquoi `8.8.8.8` et `8.8.4.4` ?**

Ce sont les serveurs DNS publics de **Google** :
- [OK] Gratuits
- [OK] Rapides
- [OK] Fiables (uptime 99.99%)
- [OK] Disponibles partout dans le monde

**Alternatives populaires** :

| Fournisseur | DNS Primaire | DNS Secondaire | Caractéristiques |
|-------------|--------------|----------------|-------------------|
| **Google** | 8.8.8.8 | 8.8.4.4 | Rapide, fiable |
| **Cloudflare** | 1.1.1.1 | 1.0.0.1 | Focus vie privée, très rapide |
| **Quad9** | 9.9.9.9 | 149.112.112.112 | Bloque malware/phishing |
| **OpenDNS** | 208.67.222.222 | 208.67.220.220 | Filtrage parental optionnel |

**Pour changer de DNS, remplace les IPs** :

```yaml
# Exemple : Utiliser Cloudflare DNS
nameservers:
  addresses:
    - 1.1.1.1
    - 1.0.0.1
```

```yaml
# Exemple : Utiliser Quad9 (sécurité)
nameservers:
  addresses:
    - 9.9.9.9
    - 149.112.112.112
```

**Pourquoi deux serveurs DNS ?**

Le deuxième est un **backup** (sauvegarde) :
- Si le premier ne répond pas -> Essaye le deuxième
- Augmente la fiabilité
- Pas d'interruption de service

---

### [ATTENTION] ATTENTION CRITIQUE : L'INDENTATION YAML

**YAML est HYPER SENSIBLE aux espaces !**

#### Règles ABSOLUES

1. **Utilise 2 ESPACES pour chaque niveau d'indentation**
2. **JAMAIS de tabulation** (appuyer sur Tab)
3. **Chaque niveau = +2 espaces**

#### Visualisation de l'indentation correcte

```yaml
network:                    <- Niveau 0 (0 espaces)
··version: 2                <- Niveau 1 (2 espaces)
··renderer: networkd
··ethernets:
····enp0s3:                 <- Niveau 2 (4 espaces)
······dhcp4: no             <- Niveau 3 (6 espaces)
······addresses:
········- 192.168.1.100/24  <- Niveau 4 (8 espaces)
······routes:
········- to: default       <- Niveau 4 (8 espaces)
··········via: 192.168.1.1  <- Niveau 5 (10 espaces)
```

Où `··` = 2 espaces

#### [X] Erreurs courantes

**Erreur 1 : Utiliser des tabulations**
```yaml
network:
->version: 2  # [X] FAUX (tabulation)
```

**Erreur 2 : Mauvais nombre d'espaces**
```yaml
network:
 version: 2  # [X] FAUX (1 seul espace au lieu de 2)
```

**Erreur 3 : Indentation incohérente**
```yaml
network:
  version: 2
    renderer: networkd  # [X] FAUX (4 espaces au lieu de 2)
```

#### [OK] Comment vérifier ton indentation dans nano

Dans l'éditeur nano :
1. Place ton curseur au début de la ligne
2. Compte les espaces avant le texte
3. Vérifie que c'est un multiple de 2

**Astuce** : Dans nano, configure l'affichage des espaces :
```bash
# Avant d'éditer, configure nano
export EDITOR="nano -c"  # Affiche numéros de ligne
```

---

### [SAUVEGARDE] Étape 6 : Sauvegarder le fichier

Dans nano :

1. **Sauvegarde** : `Ctrl + O` (lettre O, pas zéro)
2. **Confirme** : Appuie sur `Entrée`
3. **Quitte** : `Ctrl + X`

Tu verras en bas de l'écran :
```
File Name to Write: /etc/netplan/01-netcfg.yaml
```

Appuie sur `Entrée` pour confirmer.

---

### [OK] Étape 7 : Tester la syntaxe (IMPORTANT !)

Avant d'appliquer, vérifie qu'il n'y a pas d'erreurs :

```bash
sudo netplan try
```

#### Explication
- `netplan try` = Teste la configuration
- Si ça marche -> Demande confirmation
- Si ça ne marche pas -> Annule automatiquement après 120 secondes

#### Résultat attendu

[OK] **Si tout est OK** :
```
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
```

**Appuie sur `Entrée` pour accepter !**

[X] **Si erreur de syntaxe** :
```
Error in network definition: invalid YAML syntax at line 8 column 6
```

**Solution** :
1. Note le numéro de ligne (ici : ligne 8)
2. Réédite le fichier :
   ```bash
   sudo nano /etc/netplan/01-netcfg.yaml
   ```
3. Va à la ligne 8 (dans nano : `Ctrl + _` puis tape `8`)
4. Vérifie l'indentation (compte les espaces)
5. Corrige l'erreur
6. Sauvegarde et reteste

#### Erreurs YAML courantes

| Erreur | Cause | Solution |
|--------|-------|----------|
| `invalid YAML syntax` | Mauvaise indentation | Compte les espaces (multiples de 2) |
| `mapping values are not allowed` | Oubli de `:` après une clé | Ajoute `:` après `addresses`, `routes`, etc. |
| `could not find expected ':'` | Espace manquant après `:` | `dhcp4:no` -> `dhcp4: no` |

---

### [RAPIDE] Étape 8 : Appliquer la configuration

Si le test est OK, applique définitivement :

```bash
sudo netplan apply
```

#### Explication
- `netplan apply` = Applique immédiatement la nouvelle configuration
- Le réseau sera reconfiguré en quelques secondes

[ATTENTION] **ATTENTION** : Si tu es connecté en SSH, tu pourrais perdre la connexion !

#### Résultat attendu

Pas de message = Tout s'est bien passé [OK]

Si tu vois un message d'erreur, regarde les logs :
```bash
sudo journalctl -u systemd-networkd -n 50
```

---

### [RECHERCHE] Étape 9 : Vérifier la nouvelle IP

```bash
ip a
```

#### Résultat attendu

```
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_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 enp0s3
        ^^^^^^^^^^^^^
        TON IP STATIQUE ! [OK]
   valid_lft forever preferred_lft forever
        ^^^^^^^^^^^^
        Valide pour toujours (statique)
```

**Points à vérifier** :

[OK] IP = `192.168.1.100` (celle configurée)  
[OK] Masque = `/24` (255.255.255.0)  
[OK] `scope global` (adresse publique sur le réseau)  
[OK] Pas de mot "dynamic" (ce serait DHCP)  

---

### [WEB] Étape 10 : Tester la connectivité

#### Test 1 : Ping vers la passerelle (Box)

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

**Explication** :
- `ping` = Envoie des "paquets" pour tester la connexion
- `-c 4` = Envoie 4 paquets puis s'arrête
- `192.168.1.1` = IP de ta Box (passerelle)

**Résultat attendu** :
```
PING 192.168.1.1 (192.168.1.1) 56(84) bytes of data.
64 bytes from 192.168.1.1: icmp_seq=1 ttl=64 time=0.5 ms
64 bytes from 192.168.1.1: icmp_seq=2 ttl=64 time=0.6 ms
64 bytes from 192.168.1.1: icmp_seq=3 ttl=64 time=0.5 ms
64 bytes from 192.168.1.1: icmp_seq=4 ttl=64 time=0.6 ms

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

[X] **Si échec** :
```
From 192.168.1.100 icmp_seq=1 Destination Host Unreachable
```

**Causes possibles** :
1. Mauvaise IP de passerelle dans la config
2. Câble réseau débranché
3. Mauvais mode réseau VirtualBox (pas en "Accès par pont")

**Solutions** :
```bash
# Vérifier la route
ip route show

# Tu devrais voir :
# default via 192.168.1.1 dev enp0s3
```

---

#### Test 2 : Ping vers Google DNS

```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=15 time=14.8 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=115 time=15.1 ms
64 bytes 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
                                  ^^^^^^^^^^^^^
                                  INTERNET OK ! [OK]
```

[OK] **Si ça marche** : Tu as accès à Internet !

[X] **Si échec** : Problème de routage (passerelle incorrecte)

---

#### Test 3 : Résolution DNS

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

**Résultat attendu** :
```
PING google.com (142.250.185.78) 56(84) bytes of data.
              ^^^^^^^^^^^^^^^
              DNS a résolu le nom ! [OK]
64 bytes from par21s12-in-f14.1e100.net (142.250.185.78): icmp_seq=1 ttl=115 time=15.2 ms
...
```

[OK] **Si ça marche** : DNS fonctionne parfaitement !

[X] **Si tu vois** :
```
ping: google.com: Temporary failure in name resolution
```

**Cause** : Problème DNS

**Solution** :
```bash
# Vérifier les serveurs DNS configurés
cat /etc/resolv.conf

# Tu devrais voir :
# nameserver 8.8.8.8
# nameserver 8.8.4.4
```

Si les DNS ne sont pas là, réédite `/etc/netplan/01-netcfg.yaml` et vérifie la section `nameservers`.

---

### [BRAVO] Récapitulatif Partie 1

**Ce qu'on a fait** :

[OK] Identifié l'interface réseau (`enp0s3`)  
[OK] Configuré une IP statique (`192.168.1.100`)  
[OK] Configuré le masque de sous-réseau (`/24` = 255.255.255.0)  
[OK] Configuré la passerelle (`192.168.1.1`)  
[OK] Configuré les serveurs DNS (`8.8.8.8`, `8.8.4.4`)  
[OK] Testé la connectivité (passerelle, Internet, DNS)  

**Résultat final** :
La VM a maintenant une **adresse IP fixe permanente** : `192.168.1.100`

---

## [CONFIG] PARTIE 2 : CONFIGURATION IP DYNAMIQUE (DHCP) SUR LINUX

### [OBJECTIF] Objectif
Configurer la VM pour qu'elle **reçoive automatiquement** une IP via DHCP.

### [REFLEXION] Quand utiliser DHCP ?

- Pour un **client** (PC, laptop qui se déplace)
- Quand tu veux **zéro configuration manuelle**
- Pour tester un serveur DHCP sur le réseau

---

### [OUTILS] Étape 1 : Éditer le fichier Netplan

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

---

### [NOTE] Étape 2 : Configuration DHCP simple

**SUPPRIME tout** et remplace par :

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

---

### [RECHERCHE] EXPLICATION LIGNE PAR LIGNE

#### Ligne 1-4 : Identique à la config statique
```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
```

---

#### Ligne 5 : `dhcp4: yes`
```yaml
      dhcp4: yes
```

**Signification** : Active le client DHCP pour IPv4

**Ce qui se passe** :

```
┌─────────────────────────────────────────────┐
│ 1. DISCOVER                                 │
│ VM -> Réseau : "Y a-t-il un serveur DHCP ?" │
└────────────────┬────────────────────────────┘
                 │
                 [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────┐
│ 2. OFFER                                    │
│ Serveur DHCP -> VM : "Oui ! Prends 192.168.1.51" │
└────────────────┬────────────────────────────┘
                 │
                 [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────┐
│ 3. REQUEST                                  │
│ VM -> Serveur : "OK, j'accepte cette IP"    │
└────────────────┬────────────────────────────┘
                 │
                 [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────┐
│ 4. ACK                                      │
│ Serveur -> VM : "Confirmé, elle est à toi!" │
└─────────────────────────────────────────────┘
```

**Ce que le serveur DHCP fournit automatiquement** :
- [OK] Adresse IP
- [OK] Masque de sous-réseau
- [OK] Passerelle par défaut
- [OK] Serveurs DNS
- [OK] Nom de domaine (optionnel)
- [OK] Durée du bail (lease time)

**Analogie** : C'est comme aller à l'hôtel
- Tu arrives : "J'ai besoin d'une chambre"
- Réceptionniste (DHCP) : "Voici la 51, avec WiFi, petit-déj et checkout à 10h"
- Tout est fourni automatiquement !

---

### [SAUVEGARDE] Étape 3 : Sauvegarder et appliquer

```bash
# Sauvegarde dans nano
Ctrl + O -> Entrée -> Ctrl + X

# Teste la config
sudo netplan try

# Si OK, appuie sur Entrée

# Applique
sudo netplan apply
```

---

### [RECHERCHE] Étape 4 : Vérifier l'IP reçue

```bash
ip a
```

**Résultat attendu** :
```
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP>
   inet 192.168.1.51/24 brd 192.168.1.255 scope global dynamic enp0s3
        ^^^^^^^^^^^^                              ^^^^^^^
        IP automatique                             Attribuée par DHCP [OK]
```

**Points à vérifier** :

[OK] IP dans la plage DHCP (ex: `192.168.1.51`)  
[OK] Mot clé **"dynamic"** présent  
[OK] Pas "forever" mais une durée de bail  

---

### [GRAPHIQUE] Étape 5 : Voir les détails DHCP

```bash
cat /var/lib/dhcp/dhclient.leases
```

**Résultat** :
```
lease {
  interface "enp0s3";
  fixed-address 192.168.1.51;
  option subnet-mask 255.255.255.0;
  option routers 192.168.1.1;
  option dhcp-lease-time 86400;         # 24 heures
  option dhcp-message-type 5;           # ACK
  option domain-name-servers 8.8.8.8;
  option dhcp-server-identifier 192.168.1.1;
  renew 2 2024/12/07 05:30:00;         # Renouvellement dans 12h
  rebind 2 2024/12/07 17:30:00;        # Tentative secondaire dans 23h
  expire 2 2024/12/07 23:30:00;        # Expiration dans 24h
}
```

**Explication des champs clés** :

| Champ | Signification |
|-------|---------------|
| `fixed-address` | L'IP reçue |
| `routers` | Passerelle (Box) |
| `dhcp-server-identifier` | Qui a fourni l'IP |
| `dhcp-lease-time` | Durée du bail (en secondes) |
| `renew` | Quand renouveler (à 50% du bail) |
| `expire` | Quand l'IP expire si non renouvelée |

---

### [SYNC] Étape 6 : Renouveler manuellement l'IP

```bash
# Libérer l'IP actuelle
sudo dhclient -r

# Demander une nouvelle IP
sudo dhclient enp0s3
```

**Quand utiliser ?**
- Pour forcer un renouvellement
- Pour tester le serveur DHCP
- Après une modification réseau

---

## [CODE] PARTIE 3 : TESTS DEPUIS TON PC PHYSIQUE WINDOWS

### [OBJECTIF] Objectif
- Tester la **configuration IP statique** de la VM
- Tester la **connectivité réseau**
- Vérifier que le PC peut communiquer avec la VM

---

### [TEST] TEST 1 : PING VERS LA VM (IP STATIQUE)

#### Sur ton PC Windows

Ouvre **Invite de commandes** (`Windows + R` -> tape `cmd` -> `Entrée`)

```cmd
ping 192.168.1.100
```

**Résultat attendu** :
```
Envoi d'une requête 'Ping' sur 192.168.1.100 avec 32 octets de données :
Réponse de 192.168.1.100 : octets=32 temps<1ms TTL=64
Réponse de 192.168.1.100 : octets=32 temps<1ms TTL=64
Réponse de 192.168.1.100 : octets=32 temps<1ms TTL=64
Réponse de 192.168.1.100 : octets=32 temps<1ms TTL=64

Statistiques Ping pour 192.168.1.100:
    Paquets : envoyés = 4, reçus = 4, perdus = 0 (perte 0%),
                                              ^^^^^^^^^^^
                                              PARFAIT ! [OK]
```

**Interprétation** :

| Élément | Signification |
|---------|---------------|
| `temps<1ms` | Latence quasi nulle (réseau local) |
| `TTL=64` | Time To Live (compteur de sauts réseau) |
| `perdus = 0` | Aucun paquet perdu |

[OK] **Si ça marche** : Le PC et la VM communiquent parfaitement !

---

[X] **Si tu vois** :
```
Délai d'attente de la demande dépassé.
```

**Causes possibles** :

1. **VM éteinte ou suspendue**
   - Solution : Démarre la VM

2. **Pare-feu de la VM bloque ICMP (ping)**
   - Solution : Autoriser ICMP dans le pare-feu

3. **Mauvaise configuration réseau VirtualBox**
   - Solution : Vérifie que le mode est "Accès par pont"

4. **VM et PC ne sont pas sur le même réseau**
   - Solution : Vérifie les IPs (doivent commencer par `192.168.1.X`)

---

### [OUTILS] DÉPANNAGE : Autoriser PING dans le pare-feu Linux

#### Dans la VM Linux

```bash
# Vérifier l'état du pare-feu
sudo ufw status

# S'il est actif, autoriser ICMP (ping)
sudo ufw allow from any to any proto icmp

# Ou désactiver temporairement le pare-feu (pour tester)
sudo ufw disable
```

#### Pour iptables (ancien pare-feu)

```bash
# Vérifier les règles
sudo iptables -L

# Autoriser ICMP
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT
```

---

### [TEST] TEST 2 : VÉRIFIER L'IP DU PC WINDOWS

#### Sur Windows

```cmd
ipconfig /all
```

**Ce qu'on cherche** :

```
Carte Ethernet Ethernet:

   Description. . . . . . . . . . . . . . : Realtek PCIe GbE Family Controller
   Adresse physique . . . . . . . . . . . : AA-BB-CC-DD-EE-FF
   DHCP activé. . . . . . . . . . . . . . : Oui
   Adresse IPv4. . . . . . . . . . . . . .: 192.168.1.25(préféré)
   Masque de sous-réseau. . . . . . . . . : 255.255.255.0
   Passerelle par défaut. . . . . . . . . : 192.168.1.1
   Serveur DHCP . . . . . . . . . . . . . : 192.168.1.1
```

**Points à vérifier** :

[OK] **Adresse IPv4 : `192.168.1.X`** (même réseau que la VM)  
[OK] **Passerelle : `192.168.1.1`** (même que configuré dans la VM)  
[OK] **Masque : `255.255.255.0`** (équivalent de `/24`)  

---

### [TEST] TEST 3 : PING DE LA VM VERS LE PC

#### Sur la VM Linux

D'abord, trouve l'IP du PC Windows (depuis le résultat de `ipconfig` ci-dessus).

Exemple : `192.168.1.25`

```bash
ping -c 4 192.168.1.25
```

**Résultat attendu** :
```
PING 192.168.1.25 (192.168.1.25) 56(84) bytes of data.
64 bytes from 192.168.1.25: icmp_seq=1 ttl=128 time=0.8 ms
64 bytes from 192.168.1.25: icmp_seq=2 ttl=128 time=0.7 ms
64 bytes from 192.168.1.25: icmp_seq=3 ttl=128 time=0.9 ms
64 bytes from 192.168.1.25: icmp_seq=4 ttl=128 time=0.7 ms

--- 192.168.1.25 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss
```

[OK] **Communication bidirectionnelle établie !**

---

[X] **Si échec** :

**Cause** : Pare-feu Windows bloque ICMP

**Solution** : Autoriser ping dans le pare-feu Windows

#### Sur Windows

1. Ouvre **Pare-feu Windows avec fonctions avancées de sécurité**
   - `Windows + R` -> tape `wf.msc` -> `Entrée`

2. Clique sur **Règles de trafic entrant** (à gauche)

3. Cherche les règles :
   - `Partage de fichiers et d'imprimantes (Demande d'écho - ICMPv4-In)`

4. Clic droit -> **Activer la règle**

5. Reteste le ping depuis la VM

---

### [TEST] TEST 4 : TRACEROUTE (CHEMIN RÉSEAU)

#### Sur Windows

```cmd
tracert 192.168.1.100
```

**Résultat attendu** :
```
Détermination de l'itinéraire vers 192.168.1.100 avec un maximum de 30 sauts.

  1    <1 ms    <1 ms    <1 ms  192.168.1.100

Itinéraire déterminé.
```

**Interprétation** :
- **1 saut** : Communication directe (même réseau local)
- **Temps <1ms** : Latence quasi nulle

---

#### Sur Linux (VM)

```bash
traceroute 192.168.1.25
```

**Résultat** :
```
traceroute to 192.168.1.25 (192.168.1.25), 30 hops max, 60 byte packets
 1  192.168.1.25 (192.168.1.25)  0.523 ms  0.498 ms  0.476 ms
```

---

### [TEST] TEST 5 : ARP (TABLE D'ADRESSES MAC)

#### Sur Windows

```cmd
arp -a
```

**Ce que ça affiche** : La table ARP (correspondance IP <-> MAC)

**Résultat** :
```
Interface : 192.168.1.25 --- 0x12
  Adresse Internet      Adresse physique      Type
  192.168.1.1           00-11-22-33-44-55     dynamique
  192.168.1.100         08-00-27-3b-5c-a1     dynamique
                        ^^^^^^^^^^^^^^^^^
                        Adresse MAC de la VM [OK]
  192.168.1.255         ff-ff-ff-ff-ff-ff     statique
```

**Vérifications** :

[OK] `192.168.1.100` apparaît dans la table  
[OK] Une adresse MAC lui est associée  
[OK] Type = "dynamique" (appris automatiquement)  

---

### [TEST] TEST 6 : NETSTAT (CONNEXIONS ACTIVES)

#### Sur Windows

```cmd
netstat -an | findstr 192.168.1.100
```

**Résultat** : Affiche les connexions actives vers la VM

**Exemple** :
```
  TCP    192.168.1.25:50234     192.168.1.100:22       ESTABLISHED
         ^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^
         TON PC                  LA VM (port SSH)
```

**Interprétation** :
- Port `22` = SSH (connexion à distance)
- État `ESTABLISHED` = Connexion active

---

### [TEST] TEST 7 : TESTER UN SERVICE SUR LA VM

#### Exemple : Installer un serveur Web sur la VM

##### Sur la VM Linux

```bash
# Installer Apache (serveur web)
sudo apt update
sudo apt install apache2 -y

# Démarrer le service
sudo systemctl start apache2

# Vérifier qu'il tourne
sudo systemctl status apache2
```

##### Sur Windows

Ouvre un **navigateur web** et va sur :

```
http://192.168.1.100
```

**Résultat attendu** :

Tu verras la page par défaut d'Apache :

```
Apache2 Ubuntu Default Page
It works!
```

[OK] **Si tu vois ça, la VM est accessible depuis le réseau !**

---

### [TEST] TEST 8 : CONNEXION SSH À LA VM

#### Sur la VM Linux (installer SSH)

```bash
sudo apt install openssh-server -y
sudo systemctl start ssh
sudo systemctl enable ssh
```

#### Sur Windows

**Option 1 : Utiliser PowerShell (Windows 10+)**

```powershell
ssh utilisateur@192.168.1.100
```

Remplace `utilisateur` par ton nom d'utilisateur Linux.

**Option 2 : Utiliser PuTTY**

1. Télécharge PuTTY : https://www.putty.org/
2. Ouvre PuTTY
3. Host Name : `192.168.1.100`
4. Port : `22`
5. Clique sur **Open**

**Résultat attendu** :
```
login as: utilisateur
utilisateur@192.168.1.100's password: 
Welcome to Ubuntu 22.04.3 LTS

utilisateur@ubuntu:~$ _
```

[OK] **Tu es connecté à distance à la VM !**

---

### [TEST] TEST 9 : TRANSFERT DE FICHIERS (SCP)

#### Transférer un fichier du PC vers la VM

Sur Windows (PowerShell) :

```powershell
scp C:\Users\TonNom\test.txt utilisateur@192.168.1.100:/home/utilisateur/
```

#### Transférer un fichier de la VM vers le PC

Sur Windows (PowerShell) :

```powershell
scp utilisateur@192.168.1.100:/home/utilisateur/test.txt C:\Users\TonNom\
```

---

### [TEST] TEST 10 : PARTAGE DE DOSSIER SAMBA

#### Sur la VM Linux

```bash
# Installer Samba
sudo apt install samba -y

# Créer un dossier partagé
mkdir ~/partage
sudo chmod 777 ~/partage

# Configurer Samba
sudo nano /etc/samba/smb.conf
```

Ajoute à la fin :
```
[Partage]
   path = /home/utilisateur/partage
   browseable = yes
   writable = yes
   guest ok = yes
```

```bash
# Redémarrer Samba
sudo systemctl restart smbd
```

#### Sur Windows

1. Ouvre **Explorateur de fichiers**
2. Dans la barre d'adresse, tape :
   ```
   \\192.168.1.100\Partage
   ```
3. Appuie sur `Entrée`

[OK] **Tu verras le dossier partagé !**

---

## [GRAPHIQUE] TABLEAU RÉCAPITULATIF DES TESTS

| Test | Commande Windows | Commande Linux | Objectif |
|------|------------------|----------------|----------|
| **Ping PC -> VM** | `ping 192.168.1.100` | - | Tester connectivité |
| **Ping VM -> PC** | - | `ping 192.168.1.25` | Tester bidirectionnel |
| **Voir IP PC** | `ipconfig /all` | - | Vérifier config réseau |
| **Voir IP VM** | - | `ip a` | Vérifier IP statique/dynamique |
| **Traceroute** | `tracert 192.168.1.100` | `traceroute 192.168.1.25` | Voir chemin réseau |
| **Table ARP** | `arp -a` | `ip neighbor` | Correspondance IP-MAC |
| **Connexions actives** | `netstat -an` | `ss -tan` | Voir connexions TCP/UDP |
| **Test serveur Web** | Navigateur -> `http://192.168.1.100` | - | Tester service HTTP |
| **SSH** | `ssh user@192.168.1.100` | - | Connexion à distance |
| **Transfert fichier** | `scp file user@IP:/path` | `scp user@IP:/path file` | Test SCP |
| **Partage Samba** | `\\192.168.1.100\Partage` | - | Partage de fichiers |

---

## [BRAVO] CONCLUSION

### Ce qu'on a appris

[OK] **Différence IP statique vs dynamique**  
[OK] **Configuration IP statique avec Netplan**  
[OK] **Configuration IP dynamique (DHCP)**  
[OK] **Tests de connectivité complets**  
[OK] **Dépannage des problèmes réseau**  
[OK] **Installation et test de services (Web, SSH, Samba)**  

### Compétences acquises

[COURS] **Administration réseau Linux**  
[COURS] **Configuration Netplan (YAML)**  
[COURS] **Tests réseau (ping, traceroute, ARP)**  
[COURS] **Connexion à distance (SSH)**  
[COURS] **Partage de fichiers (Samba)**  

---

## [DOCS] RESSOURCES SUPPLÉMENTAIRES

### Documentation officielle

- **Netplan** : https://netplan.io/
- **systemd-networkd** : https://www.freedesktop.org/software/systemd/man/systemd.network.html
- **Ubuntu Networking** : https://ubuntu.com/server/docs/network-configuration

### Commandes de dépannage

```bash
# Voir toutes les interfaces réseau
ip link show

# Voir les routes
ip route show

# Voir les serveurs DNS
cat /etc/resolv.conf

# Redémarrer le réseau
sudo systemctl restart systemd-networkd

# Voir les logs réseau
sudo journalctl -u systemd-networkd -f

# Tester la connectivité DNS
nslookup google.com

# Voir les connexions actives
ss -tuln

# Renouveler DHCP
sudo dhclient -r && sudo dhclient enp0s3
```

---

**Félicitations ! Tu maîtrises maintenant la configuration IP sur Linux ! [COURS][OK]**