[OK] CONFIGURATION DNS LOCAL

# === QU'EST-CE QU'UN DNS? ===

# DNS = Domain Name System
# Traduit les noms de domaine en adresses IP
# Exemple: google.com -> 142.250.185.78

# DNS local = Serveur DNS sur ton réseau
# Utilisé pour:
# - Résolution rapide (cache)
# - Noms personnalisés (server1.local, server2.local)
# - Bloquer des domaines (publicité, malware)

# === DNSMASQ (SIMPLE) ===

# DNSmasq = Serveur DNS/DHCP léger

# Installation (besoin d'internet avant de choisir le réseau interne qui était par pont):
sudo apt install dnsmasq    

# Vérifier le nom du server
sudo nano etc/hostname

# Configuration:
sudo nano /etc/dnsmasq.conf

# Contenu important:

# Interface d'écoute:
interface=eth0

# Ne pas écouter sur localhost:
bind-interfaces

# Serveurs DNS en amont:
server=8.8.8.8
server=8.8.4.4

# Domaine local:
domain=local
expand-hosts

# Fichier hosts local:
addn-hosts=/etc/hosts.dnsmasq

# Cache:
cache-size=1000

# Logs:
log-queries
log-facility=/var/log/dnsmasq.log

# Créer le fichier hosts:
sudo nano /etc/hosts.dnsmasq

# Contenu:
192.168.1.100  server1.local  server1
192.168.1.101  server2.local  server2
192.168.1.102  web.local      web

# Redémarrer:
sudo systemctl restart dnsmasq

# Tester:
dig server1.local @localhost

# Affiche:
# ; <<>> DiG 9.18.12 <<>> server1.local @localhost
# ...
# server1.local.          0       IN      A       192.168.1.100


# === BIND9 (AVANCÉ) ===

# === Ancien Méthode de configuration avec BIND9

# BIND9 = Serveur DNS professionnel

# Installation  (besoin d'internet avant de choisir le réseau interne qui était par pont):
sudo apt install bind9 bind9utils bind9-doc

Sortie:
  Reading package lists... Done
  Building dependency tree... Done
  Reading state information... Done
  The following additional packages will be installed:
    bind9-host dnsutils libdns-export1110 libirs-export91 libisc-export1105
    libisccc-export1100 libisccfg-export1102 liblmdb0
  Suggested packages:
    resolvconf
  The following NEW packages will be installed:
  ...


# Vérifier le nom du server
sudo nano etc/hostname

#sortie: 
  server1

# Vérification de l'ip du serveur 
ifconfig

#sortie:
  eth0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        ether 08:00:27:3b:5c:a1  txqueuelen 1000  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 24  bytes 1920 (1.8 KiB)
        TX packets 24  bytes 1920 (1.8 KiB)

Pourquoi “l’IP est sautée” ?

Dans cet exemple :

-> L’interface eth0 est UP (active), mais :

elle n’a reçu aucune adresse IP
il n’y a pas de ligne inet ...

donc elle n’est pas configurée, typiquement :

DHCP ne répond pas
l’interface n’est pas configurée dans /etc/network/interfaces ou NetworkManager
câble débranché
WiFi non connecté
-> L’interface lo (loopback) garde son IP 127.0.0.1 (normal).

# Fixer l'adresse IP temporairement pour test rapide
ifconfig eth0 192.168.1.100

# Vérification du fixage
ifconfig

Sortie:
  eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.1.100  netmask 255.255.255.0  broadcast 192.168.1.255
        inet6 fe80::a00:27ff:fe3b:5ca1  prefixlen 64  scopeid 0x20<link>
        ether 08:00:27:3b:5c:a1  txqueuelen 1000  (Ethernet)
        RX packets 15432  bytes 12.5 MiB
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 12810  bytes 10.2 MiB
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 32  bytes 2560 (2.5 KiB)
        TX packets 32  bytes 2560 (2.5 KiB)


# Configuration du fichier de résolution du nom de domaine:
sudo nano /etc/resolv.conf

# Contenu par défaut:
nameserver 127.0.0.53
options edns0 trust-ad

# Modification du contenu
nameserver 192.168.1.100
search momo.sn
options edns0 trust-ad

# Voir le contenu de bind9
ls etc/bind

Sortie:
  bind.keys
  db.0
  db.127
  db.255
  db.empty
  db.local
  db.root
  named.conf
  named.conf.default-zones
  named.conf.local
  named.conf.options
  rndc.key
  zones.rfc1918

| ------------------------------ | ---------------------------------------------------- |
| Fichier                        | Rôle                                                 |
| ------------------------------ | ---------------------------------------------------- |
| **named.conf**                 | Fichier principal qui inclut les autres.             |
| **named.conf.options**         | Options globales (forwarders, recursion, listen...). |
| **named.conf.local**           | Là où tu mets tes zones personnalisées.              |
| **named.conf.default-zones**   | Zones par défaut (localhost, reverse locales).       |
| **zones.rfc1918**              | Configuration des zones inverses privées.            |
| **db.local**, **db.127**, etc. | Fichiers de zones DNS préconfigurés.                 |
| **rndc.key**                   | Clé de contrôle sécurisée pour `rndc`.               |
| **bind.keys**                  | Clés DNSSEC racine.                                  |
| ------------------------------ | ---------------------------------------------------- |


# Créer une zone:
sudo nano /etc/bind/named.conf.local

Sortie:
  //
  // Do any local configuration here
  //
  
  // Consider adding the 1918 zones here, if they are not used in your
  // organization
  //include "/etc/bind/zones.rfc1918";


# Contenu à ajouter:
zone "momo.sn" IN {
    type master;
    file "/etc/bind/db.momo.sn";
};

zone "1.168.192.in-addr.arpa" IN {
    type master;
    file "/etc/bind/db.192.168.1";
};


# Copier le fichier db.local dans direct
cp /etc/bind/db.local /etc/bind/db.momo.sn

# Ouvrir le fichier direct
nano /etc/bind/db.momo.sn

Sortie:
  ;
  ; BIND data file for local loopback interface
  ;
  $TTL    604800
  @       IN      SOA     localhost. root.localhost. (
                                2         ; Serial
                          604800         ; Refresh
                            86400         ; Retry
                          2419200         ; Expire
                          604800 )       ; Negative Cache TTL
  ;
  @       IN      NS      localhost.
  @       IN      A       127.0.0.1
  @       IN      AAAA    ::1


# Contenu pour créer la zone:
$TTL    604800
@           IN          SOA          server1.momo.sn. root.server1.momo.sn. (
                        2024011501      ; Serial
                        604800          ; Refresh
                        86400           ; Retry
                        2419200         ; Expire
                        604800 )        ; Negative Cache TTL
;
@           IN          NS           server1.momo.sn.
server1     IN          A            192.168.1.100
www         IN          CNAME        server1.momo.sn.


# Copier le fichier direct dans inverse
cp /etc/bind/db.momo.sn /etc/bind/db.192.168.1

# Créer la zone inverse:
sudo nano /etc/bind/db.192.168.1

# Contenu à ajouter:
$TTL    604800
@       IN      SOA     server1.momo.sn. admin.momo.sn. (
                              2024011501         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
;
@         IN      NS      server1.momo.sn.
100       IN      PTR     server1.momo.sn.


# Vérifier la config:
sudo named-checkconf
sudo named-checkzone momo.sn /etc/bind/db.momo.sn
sudo named-checkzone 1.168.192.in-addr.arpa /etc/bind/db.192.168.1

nslockup www

# Redémarrer:
sudo systemctl restart bind9

# Tester:
dig www.momo.sn @192.168.1.100

# Reverse DNS:
dig -x 192.168.1.100 @192.168.1.100



# === Méthode Moderne de configuration avec BIND9

# BIND9 = Serveur DNS professionnel

# Installation  (besoin d'internet avant de choisir le réseau interne qui était par pont):
sudo apt install bind9 bind9utils bind9-doc

# Vérifier le nom du server
sudo nano etc/hostname

# Configuration principale:
sudo nano /etc/bind/named.conf.options

# Contenu:
options {
    directory "/var/cache/bind";

    forwarders {
        8.8.8.8;
        8.8.4.4;
    };

    dnssec-validation auto;
    listen-on { any; };
    allow-query { any; };
};

# Créer une zone:
sudo nano /etc/bind/named.conf.local

# Contenu:
zone "local" {
    type master;
    file "/etc/bind/db.local";
};

zone "1.168.192.in-addr.arpa" {
    type master;
    file "/etc/bind/db.192.168.1";
};

# Créer le fichier de zone:
sudo nano /etc/bind/db.local

# Contenu:
$TTL    604800
@       IN      SOA     ns1.local. admin.local. (
                              2024011501         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
;
@       IN      NS      ns1.local.
ns1     IN      A       192.168.1.100
server1 IN      A       192.168.1.100
server2 IN      A       192.168.1.101
web     IN      A       192.168.1.102

# Créer la zone reverse:
sudo nano /etc/bind/db.192.168.1

# Contenu:
$TTL    604800
@       IN      SOA     ns1.local. admin.local. (
                              2024011501         ; Serial
                         604800         ; Refresh
                          86400         ; Retry
                        2419200         ; Expire
                         604800 )       ; Negative Cache TTL
;
@       IN      NS      ns1.local.
100     IN      PTR     server1.local.
101     IN      PTR     server2.local.
102     IN      PTR     web.local.

# Vérifier la config:
sudo named-checkconf
sudo named-checkzone local /etc/bind/db.local
sudo named-checkzone 1.168.192.in-addr.arpa /etc/bind/db.192.168.1

# Redémarrer:
sudo systemctl restart bind9

# Tester:
dig server1.local @192.168.1.100

# Reverse DNS:
dig -x 192.168.1.100 @192.168.1.100


Parfait, analysons **la différence entre les deux configurations BIND9** que tu as présentées :

1⃣ **Ancienne méthode**
2⃣ **Méthode moderne**

Je vais te détailler **les différences majeures**, **les avantages et inconvénients**.

---

# 1⃣ **Ancienne méthode**

### Caractéristiques

* Zones définies directement avec un domaine réel ou interne (`momo.sn`)
* Fichiers forward/reverse créés à partir de `db.local` (copie + modification)
* `/etc/bind/named.conf.options` par défaut (non modifié ou très peu)
* Résolution DNS dépend principalement des zones internes créées
* Les forwarders (Google DNS) non obligatoires, souvent manquants
* SOA et NS modifiés manuellement dans chaque fichier copié

### Avantages

* Simple à mettre en place pour un réseau interne
* Convient pour tests et petits labos

### Inconvénients

* Plus de risque d’erreurs en copiant `db.local`
* Forwarders absents -> pas de résolution vers Internet par défaut
* Moins “standard” pour une utilisation professionnelle
* Pas de séparation claire entre options globales et zones
* Fichiers de zones moins modulaires

---

# 2⃣ **Méthode moderne**

### Caractéristiques

* Utilisation correcte de `/etc/bind/named.conf.options` pour options globales
* Forwarders définis (`8.8.8.8`, `8.8.4.4`) -> résolution DNS publique automatique
* Zones forward/reverse séparées (`db.local`, `db.192.168.1`)
* SOA et NS cohérents et structurés
* Permet d’écouter sur toutes les interfaces (`listen-on { any; };`)
* `allow-query { any; };` -> définit qui peut interroger le DNS
* Ne copie plus aveuglément `db.local`, mais crée une zone propre

### Avantages

* Conforme aux bonnes pratiques BIND9
* Forwarders -> Internet résolu automatiquement
* Plus sécurisé et modulable pour réseau interne ou mixte
* Plus facile à maintenir et à faire évoluer
* Compatible pour usage professionnel ou lab réseau complexe

### Inconvénients

* Plus de fichiers à gérer (séparation `named.conf.options` et zones)
* Nécessite de comprendre le rôle de chaque fichier (options globales vs zones)
* Un peu plus de configuration initiale

---

# 3⃣ **Résumé comparatif**

| Critère           | Ancienne méthode           | Méthode moderne                                                |
| ----------------- | -------------------------- | -------------------------------------------------------------- |
| Fichiers utilisés | Copie `db.local` -> modifié | Fichiers forward/reverse séparés                               |
| Options globales  | Par défaut / minimale      | `named.conf.options` bien défini (forwarders, écoute, queries) |
| Forwarders        | Souvent absents            | Définis (Google DNS)                                           |
| Bonne pratique    | Non                        | Oui                                                            |
| Sécurité          | Limitée                    | Améliorée (ACL possibles)                                      |
| Maintenabilité    | Faible                     | Élevée                                                         |
| Usage recommandé  | Test / labo                | Réseau interne ou semi-pro / pro                               |

---

# 4⃣ **En résumé**

* **Ancienne méthode** : facile pour un labo, mais fragile, peu professionnelle.
* **Méthode moderne** : standard, modulable, forwarders inclus, prête pour un vrai réseau.

[IDEE] **Règle générale :**
Toujours séparer **options globales** et **zones**, et éviter de copier `db.local` tel quel pour créer des zones.

                      ┌─────────────────────────────┐
                      │       Serveur Linux         │
                      │        BIND9 DNS            │
                      └─────────────────────────────┘
                                    │
                        écoute sur eth0:192.168.1.x
                                    │
                                    [BLACK_DOWN-POINTING_TRIANGLE]

 ┌─────────────────────────────┐           ┌─────────────────────────────┐
 │      ANCIENNE MÉTHODE       │           │      MÉTHODE MODERNE        │
 └─────────────────────────────┘           └─────────────────────────────┘
          │                                         │
          │                                         │
          [BLACK_DOWN-POINTING_TRIANGLE]                                         [BLACK_DOWN-POINTING_TRIANGLE]

1. Fichiers de zones                          1. Fichiers de zones
   - Copie de db.local                        - Fichier forward : db.momo.sn
   - db.local -> direct -> inverse              - Fichier reverse : db.192.168.1
   - SOA/NS souvent modifiés à la main       - SOA et NS cohérents
   - A/AAAA modifiés à la main                - Enregistrements A et PTR corrects

2. Options globales                           2. Options globales
   - Peu ou pas définies                        - named.conf.options
   - Forwarders absents                         - Forwarders 8.8.8.8 / 8.8.4.4
   - Écoute par défaut                          - listen-on { any; }
   - allow-query implicite                       - allow-query { any; }

3. Résolution                                 3. Résolution
   - Seulement zones internes                   - Zones internes + forwarders
   - Pas de fallback DNS                        - Permet résolution Internet
   - Fragile, erreurs possibles                 - Stable et standard

4. Maintenabilité                             4. Maintenabilité
   - Fichiers mêlés, copies                     - Fichiers séparés, modulaires
   - Difficulté d’évolution                     - Facile à maintenir et étendre

---


# [DOCS] GUIDE COMPLET : CONFIGURATION DNS POUR GRANDS DÉBUTANTS

## [OBJECTIF] QU'EST-CE QU'UN DNS ? (Comprendre les bases)

### [ACCUEIL] Analogie de l'annuaire téléphonique

Imagine le DNS comme **l'annuaire téléphonique d'Internet** :
- Tu veux appeler ton ami "Jean Dupont" (nom de domaine : google.com)
- Mais ton téléphone a besoin du numéro (adresse IP : 142.250.185.78)
- L'annuaire fait la traduction pour toi

**Sans DNS :** Tu devrais mémoriser `142.250.185.78` au lieu de taper `google.com`  
**Avec DNS :** Tu tapes simplement `google.com` et le DNS trouve l'adresse IP pour toi

### [SYNC] Comment ça fonctionne ?

```
Toi -> "Je veux aller sur google.com" 
       v
DNS -> "Ok, l'adresse c'est 142.250.185.78"
       v
Ton navigateur -> Se connecte à 142.250.185.78
```

### [ENTREPRISE] DNS Local vs DNS Public

**DNS Public (Google, Cloudflare)** = L'annuaire de toute la ville
- Connaît tous les sites Internet
- Mais ne connaît pas tes serveurs personnels

**DNS Local (sur ton réseau)** = Ton carnet d'adresses personnel
- Connaît tes serveurs : `server1.local`, `nas.local`
- Plus rapide (pas besoin d'aller sur Internet)
- Tu contrôles tout

---

## [RAPIDE] MÉTHODE 1 : DNSMASQ (Pour débutants)

### [PACKAGE] Pourquoi DNSmasq ?

**Analogie :** DNSmasq c'est comme un **assistant personnel intelligent**
- Simple à configurer (parfait pour débuter)
- Léger en ressources
- Fait DNS + DHCP (distribution d'adresses IP)

### [ENTREE] ÉTAPE 1 : Installation

```bash
sudo apt install dnsmasq
```

**Qu'est-ce que cette commande fait ?**
- `sudo` = Exécute en tant qu'administrateur (comme "Exécuter en tant qu'admin" sous Windows)
- `apt` = Le gestionnaire de paquets (comme un App Store pour Linux)
- `install` = Télécharge et installe
- `dnsmasq` = Le logiciel serveur DNS

---

### [CONFIG] ÉTAPE 2 : Configuration principale

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

**Explication :**
- `nano` = Éditeur de texte simple (comme Notepad)
- `/etc/dnsmasq.conf` = Fichier de configuration principal

#### [FICHIER] Contenu du fichier expliqué ligne par ligne :

# /etc/dnsmasq.conf

# This is the main configuration file for dnsmasq.
# The only active line is a comment by default.

# Listen on this specific interface only:
# interface=

# Specify IP addresses for upstream DNS servers:
# server=

# Domain for local hosts:
# domain=

# Add additional hosts:
# addn-hosts=


```bash
# 1⃣ INTERFACE D'ÉCOUTE
interface=eth0
```
**Ce que ça fait :** Dit à DNSmasq d'écouter sur la carte réseau `eth0`  
**Analogie :** C'est comme dire "Prends les appels uniquement sur ton téléphone fixe, pas sur ton portable"  
**Pour trouver ton interface :** Tape `ip a` et cherche ton interface réseau principale

```bash
# 2⃣ NE PAS ÉCOUTER SUR LOCALHOST
bind-interfaces
```
**Ce que ça fait :** Empêche DNSmasq d'écouter sur toutes les interfaces  
**Pourquoi c'est important :** Évite les conflits avec d'autres services DNS  
**Analogie :** "Je réponds uniquement aux appels sur mon réseau local, pas à toutes les lignes"

```bash
# 3⃣ SERVEURS DNS EN AMONT (Upstream DNS)
server=8.8.8.8
server=8.8.4.4
```
**Ce que ça fait :** Quand DNSmasq ne connaît pas un domaine, il demande à Google DNS  
**Analogie :** Si quelqu'un te demande un numéro que tu n'as pas, tu regardes dans l'annuaire officiel  
**Alternatives :**
- `1.1.1.1` (Cloudflare - rapide et privé)
- `9.9.9.9` (Quad9 - sécurisé)

```bash
# 4⃣ DOMAINE LOCAL
domain=local
expand-hosts
```
**Ce que ça fait :**
- `domain=local` : Ajoute automatiquement `.local` à tes noms de serveurs
- `expand-hosts` : Active cette fonctionnalité

**Exemple pratique :**
- Tu tapes : `ssh server1`
- DNSmasq comprend : `ssh server1.local`
- **Analogie :** Comme l'autocomplétion sur ton téléphone

```bash
# 5⃣ FICHIER HOSTS PERSONNALISÉ
addn-hosts=/etc/hosts.dnsmasq
```
**Ce que ça fait :** Dit à DNSmasq de lire tes associations IP <-> nom depuis ce fichier  
**Pourquoi un fichier séparé ?** Pour ne pas mélanger avec `/etc/hosts` du système  
**Analogie :** Ton carnet d'adresses perso (séparé de celui du téléphone)

```bash
# 6⃣ CACHE DNS
cache-size=1000
```
**Ce que ça fait :** Mémorise 1000 réponses DNS récentes  
**Avantage :** Réponse instantanée pour les sites que tu visites souvent  
**Analogie :** Comme garder les numéros fréquents en mémoire rapide  
**Valeurs recommandées :**
- Petit réseau (1-5 PC) : `500`
- Moyen (5-20 PC) : `1000`
- Grand (20+ PC) : `2000`

```bash
# 7⃣ LOGS (Journaux)
log-queries
log-facility=/var/log/dnsmasq.log
```
**Ce que ça fait :**
- `log-queries` : Enregistre toutes les requêtes DNS
- `log-facility` : Où stocker les logs

**Utilité :** Voir qui demande quoi, détecter des problèmes  
**Voir les logs :** `sudo tail -f /var/log/dnsmasq.log`  
**[ATTENTION] Attention :** Génère beaucoup de données, désactive en production

---

### [LISTE] ÉTAPE 3 : Créer le fichier hosts personnalisé

```bash
sudo nano /etc/hosts.dnsmasq
```

#### Contenu expliqué :

```bash
192.168.1.100  server1.local  server1
```

**Structure :** `ADRESSE_IP  NOM_COMPLET  ALIAS`

**Décomposition :**
1. `192.168.1.100` = L'adresse IP du serveur
2. `server1.local` = Nom de domaine complet (FQDN)
3. `server1` = Raccourci (alias optionnel)

**Exemple d'utilisation :**
```bash
ping server1          # [OK] Fonctionne
ping server1.local    # [OK] Fonctionne aussi
ssh user@server1      # [OK] Se connecte à 192.168.1.100
```

**Analogie :** 
- `192.168.1.100` = Numéro de téléphone complet (+33 6 12 34 56 78)
- `server1.local` = Nom complet (Jean Dupont Entreprise)
- `server1` = Surnom (Jean)

---

### [SYNC] ÉTAPE 4 : Redémarrer le service

```bash
sudo systemctl restart dnsmasq
```

**Qu'est-ce que `systemctl` ?**
- C'est le gestionnaire de services Linux
- Permet de démarrer/arrêter/redémarrer des programmes

**Commandes utiles :**
```bash
sudo systemctl status dnsmasq    # Voir si ça tourne
sudo systemctl stop dnsmasq      # Arrêter
sudo systemctl start dnsmasq     # Démarrer
sudo systemctl enable dnsmasq    # Démarrer automatiquement au boot
```

---

### [TEST] ÉTAPE 5 : Tester la configuration

```bash
dig server1.local @localhost
```

**Décomposition de la commande :**
- `dig` = Outil de diagnostic DNS (comme un testeur)
- `server1.local` = Le nom à résoudre
- `@localhost` = Demande au DNS local (pas à Google)

**Résultat attendu :**
```
;; ANSWER SECTION:
server1.local.    0    IN    A    192.168.1.100
```

**Traduction :** "server1.local correspond à 192.168.1.100"

**Tests supplémentaires :**
```bash
# Test simple avec ping
ping server1.local

# Test avec nslookup
nslookup server1.local localhost

# Vérifier les logs en temps réel
sudo tail -f /var/log/dnsmasq.log
```

---

## [ENTREPRISE] MÉTHODE 2 : BIND9 (Pour utilisateurs avancés)

### [COURS] Pourquoi BIND9 ?

**Analogie :** Si DNSmasq est une **épicerie de quartier**, BIND9 est un **hypermarché**

**Avantages :**
- [OK] Utilisé par 70% des serveurs DNS mondiaux
- [OK] Gère des millions de domaines
- [OK] Fonctionnalités avancées (DNSSEC, zones secondaires, etc.)

**Inconvénients :**
- [X] Plus complexe à configurer
- [X] Consomme plus de ressources
- [X] Fichiers de configuration plus nombreux

---

### [ENTREE] ÉTAPE 1 : Installation

```bash
sudo apt install bind9 bind9utils bind9-doc
```

**Explication des paquets :**
- `bind9` = Le serveur DNS principal
- `bind9utils` = Outils de diagnostic (`dig`, `nslookup`, etc.)
- `bind9-doc` = Documentation complète

---

### [CONFIG] ÉTAPE 2 : Configuration principale

```bash
sudo nano /etc/bind/named.conf.options
```

**Rôle de ce fichier :** Configure les **options globales** de BIND9

#### [FICHIER] Contenu expliqué :

```bash
options {
    # 1⃣ RÉPERTOIRE DE TRAVAIL
    directory "/var/cache/bind";
```
**Ce que ça fait :** Définit où BIND9 stocke ses fichiers temporaires  
**Analogie :** L'espace de travail/bureau où poser ses documents  
**Ne pas modifier** sauf besoin spécifique

```bash
    # 2⃣ SERVEURS FORWARDERS
    forwarders {
        8.8.8.8;
        8.8.4.4;
    };
```
**Ce que ça fait :** Si BIND9 ne connaît pas un domaine, il demande à ces serveurs  
**Analogie :** Tes sources de référence quand tu ne sais pas  
**[ATTENTION] Important :** Terminer chaque ligne par `;`

```bash
    # 3⃣ VALIDATION DNSSEC
    dnssec-validation auto;
```
**Ce que ça fait :** Active la vérification de sécurité des réponses DNS  
**Analogie :** Vérifier la signature sur un document officiel  
**Laisser sur `auto`** (recommandé pour la sécurité)

```bash
    # 4⃣ INTERFACE D'ÉCOUTE
    listen-on { any; };
```
**Ce que ça fait :** Écoute sur toutes les interfaces réseau  
**Alternatives :**
- `listen-on { 192.168.1.100; };` = Écoute uniquement sur cette IP
- `listen-on { localhost; };` = Écoute uniquement localement

```bash
    # 5⃣ QUI PEUT INTERROGER LE SERVEUR
    allow-query { any; };
};
```
**Ce que ça fait :** Autorise tout le monde à faire des requêtes  
**[ATTENTION] Sécurité :** En production, restreindre :
```bash
allow-query { 192.168.1.0/24; localhost; };
```
**Traduction :** Seuls les PC de ton réseau local peuvent interroger

---

### [DOSSIER] ÉTAPE 3 : Créer les zones DNS

```bash
sudo nano /etc/bind/named.conf.local
```

**Rôle de ce fichier :** Déclare tes **zones DNS personnalisées**

#### [FICHIER] Contenu expliqué :

```bash
# 1⃣ ZONE DIRECTE (Nom -> IP)
zone "local" {
    type master;
    file "/etc/bind/db.local";
};
```

**Décomposition :**
- `zone "local"` = Nom de ta zone (tous les `*.local`)
- `type master` = C'est le serveur principal (pas une copie)
- `file` = Où sont stockées les données de cette zone

**Analogie :** Tu déclares que tu es responsable de l'annuaire pour tous les noms se terminant par `.local`

```bash
# 2⃣ ZONE REVERSE (IP -> Nom)
zone "1.168.192.in-addr.arpa" {
    type master;
    file "/etc/bind/db.192.168.1";
};
```

**Ce que ça fait :** Permet de retrouver le nom depuis l'IP (reverse DNS)

**Pourquoi cette syntaxe bizarre ?**
- `192.168.1.X` devient `1.168.192.in-addr.arpa`
- L'ordre est inversé (c'est la norme DNS)

**Utilité :** Certaines applications vérifient le reverse DNS (emails, SSH)

---

### [NOTE] ÉTAPE 4 : Créer le fichier de zone directe

```bash
sudo nano /etc/bind/db.local
```

#### [FICHIER] Contenu expliqué ligne par ligne :

```bash
$TTL    604800
```
**TTL = Time To Live** (Temps de vie)  
**Ce que ça fait :** Durée pendant laquelle la réponse peut être mise en cache  
**604800 secondes = 7 jours**  
**Analogie :** "Cette info est valable 7 jours, après demande à nouveau"

**Valeurs courantes :**
- `300` (5 min) = Pour zones qui changent souvent
- `3600` (1h) = Standard
- `86400` (1 jour) = Pour zones stables

```bash
@       IN      SOA     ns1.local. admin.local. (
```

**SOA = Start of Authority** (Début d'autorité)  
**Ce que ça fait :** Définit le serveur responsable de cette zone

**Décomposition :**
- `@` = Représente la zone elle-même (`local`)
- `IN` = Internet (classe de réseau)
- `SOA` = Type d'enregistrement
- `ns1.local.` = Nom du serveur DNS ([ATTENTION] le `.` final est **obligatoire**)
- `admin.local.` = Email de l'admin (le `@` devient un `.`)

```bash
                              2024011501         ; Serial
```
**Serial = Numéro de série**  
**Format recommandé :** `AAAAMMJJNN` (Année Mois Jour + compteur)  
**Utilité :** Indique quand la zone a été modifiée  
**[ATTENTION] IMPORTANT :** Incrémenter à chaque modification sinon les serveurs secondaires ne se mettent pas à jour

**Exemple :**
- 1ère modification du 15/01/2024 : `2024011501`
- 2ème modification du même jour : `2024011502`

```bash
                         604800         ; Refresh
```
**Refresh = Rafraîchissement**  
**Ce que ça fait :** Fréquence de vérification pour les serveurs secondaires  
**604800 = 7 jours**  
**Analogie :** "Vérifie s'il y a du nouveau toutes les semaines"

```bash
                          86400         ; Retry
```
**Retry = Nouvelle tentative**  
**Ce que ça fait :** Si le refresh échoue, réessayer après ce délai  
**86400 = 1 jour**

```bash
                        2419200         ; Expire
```
**Expire = Expiration**  
**Ce que ça fait :** Si aucune mise à jour après ce délai, considérer la zone invalide  
**2419200 = 28 jours**  
**Analogie :** "Si je n'ai pas de nouvelles en 28 jours, considère que l'info n'est plus bonne"

```bash
                         604800 )       ; Negative Cache TTL
```
**Negative Cache = Cache des réponses négatives**  
**Ce que ça fait :** Durée de mémorisation des "ce domaine n'existe pas"  
**Utilité :** Évite de redemander 100 fois pour un nom qui n'existe pas

```bash
;
@       IN      NS      ns1.local.
```
**NS = Name Server** (Serveur de noms)  
**Ce que ça fait :** Déclare quel serveur est responsable de la zone  
**Analogie :** "Pour tout ce qui concerne `.local`, demande à `ns1.local`"

```bash
ns1     IN      A       192.168.1.100
```
**A = Address** (Adresse IPv4)  
**Ce que ça fait :** Associe un nom à une adresse IP  
**Structure :** `NOM    TYPE    IP`

```bash
server1 IN      A       192.168.1.100
server2 IN      A       192.168.1.101
web     IN      A       192.168.1.102
```
**Ce sont tes enregistrements personnalisés**

**Résultat :**
- `server1.local` -> `192.168.1.100`
- `server2.local` -> `192.168.1.101`
- `web.local` -> `192.168.1.102`

---

### [SYNC] ÉTAPE 5 : Créer la zone reverse

```bash
sudo nano /etc/bind/db.192.168.1
```

#### [FICHIER] Contenu expliqué :

```bash
$TTL    604800
@       IN      SOA     ns1.local. admin.local. (
                              2024011501
                         604800
                          86400
                        2419200
                         604800 )
;
@       IN      NS      ns1.local.
```
**Même structure que la zone directe**

```bash
100     IN      PTR     server1.local.
101     IN      PTR     server2.local.
102     IN      PTR     web.local.
```

**PTR = Pointer** (Pointeur)  
**Ce que ça fait :** Associe une IP à un nom (inverse de A)

**Structure :** `DERNIER_OCTET    PTR    NOM_COMPLET`

**Exemple :**
- `100` = Dernier octet de `192.168.1.100`
- `PTR` = Type d'enregistrement
- `server1.local.` = Nom complet ([ATTENTION] le `.` final est obligatoire)

**Résultat :**
- `192.168.1.100` -> `server1.local`
- `192.168.1.101` -> `server2.local`

---

### [OK] ÉTAPE 6 : Vérifier la configuration

```bash
# 1⃣ Vérifier la syntaxe globale
sudo named-checkconf
```
**Si pas d'erreur :** Aucun message = tout est bon [OK]  
**Si erreur :** Le fichier et la ligne sont indiqués

```bash
# 2⃣ Vérifier la zone directe
sudo named-checkzone local /etc/bind/db.local
```
**Résultat attendu :**
```
zone local/IN: loaded serial 2024011501
OK
```

```bash
# 3⃣ Vérifier la zone reverse
sudo named-checkzone 1.168.192.in-addr.arpa /etc/bind/db.192.168.1
```

**Résultat attendu :**
```
zone 1.168.192.in-addr.arpa/IN: loaded serial 2024011501
OK
```

---

### [SYNC] ÉTAPE 7 : Redémarrer BIND9

```bash
sudo systemctl restart bind9
```

**Vérifier le statut :**
```bash
sudo systemctl status bind9
```

**Si erreur, voir les logs :**
```bash
sudo journalctl -u bind9 -f
```

---

### [TEST] ÉTAPE 8 : Tests complets

```bash
# 1⃣ Test résolution directe
dig server1.local @192.168.1.100
```
**Résultat attendu :**
```
;; ANSWER SECTION:
server1.local.    604800    IN    A    192.168.1.100
```

```bash
# 2⃣ Test résolution reverse
dig -x 192.168.1.100 @192.168.1.100
```
**Résultat attendu :**
```
;; ANSWER SECTION:
100.1.168.192.in-addr.arpa. 604800 IN PTR server1.local.
```

```bash
# 3⃣ Test avec ping
ping server1.local
```

---

## 🆚 DNSMASQ vs BIND9 : Que choisir ?

|------------------------|-----------------------|----------------------------|
| Critère                | DNSmasq               | BIND9                      |
|------------------------|-----------------------|----------------------------|
| **Difficulté**         | * Facile             | **** Difficile        |
| **Vitesse de config**  | 10 minutes            | 1-2 heures                 |
| **Ressources**         | Très léger            | Moyen                      |
| **Fonctionnalités**    | Basiques              | Avancées                   |
| **Meilleur pour**      | Maison, petit bureau  | Entreprise, production     |
|------------------------|-----------------------|----------------------------|

**Recommandation :**
- [ACCUEIL] **Débuter ou réseau domestique** -> DNSmasq
- [ENTREPRISE] **Apprendre le DNS professionnel** -> BIND9
- [COURS] **Passer une certification** -> BIND9

---

## [COURS] RÉSUMÉ POUR RETENIR

### [MODULE] Les concepts clés

1. **DNS = Traducteur** (nom -> IP)
2. **Zone directe** = Annuaire (nom -> IP)
3. **Zone reverse** = Annuaire inversé (IP -> nom)
4. **Cache** = Mémoire des réponses récentes
5. **Forwarders** = À qui demander si on ne sait pas

### [OUTILS] Ordre de configuration

**DNSmasq :**
1. Installer -> 2. Configurer `/etc/dnsmasq.conf` -> 3. Créer `/etc/hosts.dnsmasq` -> 4. Redémarrer -> 5. Tester

**BIND9 :**
1. Installer -> 2. Configurer options -> 3. Déclarer zones -> 4. Créer fichiers de zones -> 5. Vérifier -> 6. Redémarrer -> 7. Tester

---

## 🆘 DÉPANNAGE RAPIDE

### [X] "dig: command not found"
```bash
sudo apt install dnsutils
```

### [X] DNSmasq ne démarre pas
```bash
# Vérifier les erreurs
sudo systemctl status dnsmasq
# Voir les logs
sudo journalctl -u dnsmasq -n 50
```

### [X] BIND9 ne résout pas les noms
```bash
# Vérifier le port 53
sudo netstat -tulpn | grep :53
# Voir les logs
sudo tail -f /var/log/syslog | grep named
```

# [RECHERCHE] COMMENT TROUVER OU FIXER L'ADRESSE IP DU SERVEUR

## [IMPORTANT] PARTIE 1 : TROUVER L'ADRESSE IP ACTUELLE

### Méthode 1 : Avec `ip` (Recommandé - Moderne)

```bash
ip addr show
```

**ou version courte :**
```bash
ip a
```

**Résultat typique :**
```
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536
    inet 127.0.0.1/8 scope host lo
       ^ Adresse localhost (ignorer)

2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
    inet 192.168.1.50/24 brd 192.168.1.255 scope global eth0
         ^^^^^^^^^^^^
         TON ADRESSE IP ACTUELLE
```

**Comment lire :**
- `lo` = Interface loopback (ignorer)
- `eth0` = Carte réseau filaire [PLUGIN]
- `wlan0` = Carte WiFi [RESEAU]
- `inet 192.168.1.50` = **C'EST TON ADRESSE IP ACTUELLE**

---

### Méthode 2 : Avec `ifconfig` (Ancien mais fonctionne)

```bash
ifconfig
```

**Si la commande n'existe pas :**
```bash
sudo apt install net-tools
```

**Résultat :**
```
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>
      inet 192.168.1.50  netmask 255.255.255.0
           ^^^^^^^^^^^^
           TON ADRESSE IP
```

---

### Méthode 3 : Avec `hostname` (La plus simple)

```bash
hostname -I
```

**Résultat :**
```
192.168.1.50
```

**Cette commande affiche directement l'IP, sans détails supplémentaires.**

---

## [OBJECTIF] ANALOGIE : Comprendre les adresses IP

Imagine ton réseau local comme **un immeuble** :

```
[ENTREPRISE] Immeuble : 192.168.1.0/24
   ├── [SORTIE] Appartement 1 : 192.168.1.1 (Box/Routeur)
   ├── [SORTIE] Appartement 50 : 192.168.1.50 (Ton serveur ACTUELLEMENT)
   ├── [SORTIE] Appartement 100 : 192.168.1.100 (Ce qu'on veut fixer)
   └── [SORTIE] Appartement 254 : 192.168.1.254 (Dernier dispo)
```

**Actuellement :** Ton serveur est à l'appartement 50 (192.168.1.50)  
**Objectif :** Le déménager à l'appartement 100 (192.168.1.100)

---

## [OUTIL] PARTIE 2 : FIXER UNE ADRESSE IP STATIQUE

### [ATTENTION] IMPORTANT : Choisir une bonne adresse IP

**Règles d'or :**

1. **Respecter la plage de ton réseau**
   ```
   Si ta box est sur 192.168.1.1
   -> Ton serveur doit être 192.168.1.XXX
   ```

2. **Éviter les conflits**
   ```
   [OK] Utiliser 192.168.1.100-254 (généralement libres)
   [X] Éviter 192.168.1.2-50 (souvent utilisés par DHCP)
   ```

3. **Vérifier que l'IP est libre**
   ```bash
   ping 192.168.1.100 -c 4
   ```
   **Si aucune réponse :** L'IP est libre [OK]  
   **Si réponse :** L'IP est déjà utilisée [X] (choisir une autre)

---

Pour savoir *exactement* si ta box (routeur) est sur **192.168.1.1**, tu n’as pas besoin de deviner : il existe plusieurs méthodes simples. Je vais t’expliquer **comme à un bébé**, étape par étape, sans brûler les étapes.

---

# [BABY_BOTTLE] Comment savoir si ma box est sur 192.168.1.1 ?

Ta box Internet possède une **adresse IP locale**, appelée **gateway** ou **passerelle**.
C’est l’IP par laquelle tous tes appareils passent pour aller sur Internet.

Pour vérifier cette adresse, tu peux utiliser **n’importe quelle machine** de ton réseau : ton PC, ton Linux, même ton téléphone.

Voici **toutes les méthodes**, les plus simples d’abord.

---

# [1er] MÉTHODE 1 — Sur Linux (la plus précise)

Ouvre un terminal et tape :

```
ip route
```

Tu obtiens un résultat comme :

```
default via 192.168.1.1 dev eth0
```

-> **C’est ici !**

* `default` = route par défaut
* `via 192.168.1.1` = ton routeur
* `dev eth0` = la carte réseau utilisée

Donc **ta box = 192.168.1.1**.

---

# [2e] MÉTHODE 2 — Toujours sur Linux (version ultra simple)

Tape :

```
ip r | grep default
```

Exemple :

```
default via 192.168.0.1 dev wlan0
```

-> La gateway = **192.168.0.1**

---

# [3e] MÉTHODE 3 — Sur Windows

Ouvre un PowerShell ou CMD :

```
ipconfig
```

Regarde dans la partie :

```
Default Gateway . . . . . . : 192.168.1.1
```

-> C’est ton routeur.

---

# [MOBILE] MÉTHODE 4 — Sur Android

1. Va dans **Paramètres**
2. **Wi-Fi**
3. Clique sur ton réseau Wi-Fi
4. Cherche :

   * **Passerelle**
   * **Routeur**
   * **Gateway**

Tu verras par exemple :

```
Passerelle : 192.168.1.1
```

---

# [GREEN_APPLE] MÉTHODE 5 — Sur iPhone/iPad

1. Réglages
2. Wi-Fi
3. Appuie sur le petit **i** à droite du réseau
4. Cherche **Routeur**

Exemple :

```
Routeur : 192.168.1.1
```

---

# [LOGIQUE] COMMENT INTERPRÉTER LE RÉSULTAT ?

Voici les cas possibles.

### [OK] Si tu vois **192.168.1.1**

-> Ton réseau est en **192.168.1.X**, parfait !
Tu peux mettre ton serveur DNS sur **192.168.1.100**.

### [OK] Si tu vois **192.168.0.1**

-> Ton réseau est en **192.168.0.X**
-> Ton serveur DNS doit être **192.168.0.100** (par exemple)

### [OK] Si tu vois **10.0.0.1**

-> Ton réseau est en **10.0.0.X**
-> Serveur DNS = **10.0.0.100**

### [OK] Si tu vois **192.168.43.1**

-> Tu es peut-être connecté via **partage de connexion téléphone**
-> Mieux vaut ne pas configurer un serveur DNS dans ce cas.

---

# [MODULE] CONSEIL POUR NE PAS FAIRE D’ERREUR

Ne choisis *jamais* l’adresse IP de ton serveur au hasard.

Toujours suivre :

```
IP du serveur = même réseau que la gateway
```

Exemples :

| Gateway     | Réseau      | Serveur DNS possible |
| ----------- | ----------- | -------------------- |
| 192.168.1.1 | 192.168.1.X | 192.168.1.100        |
| 192.168.0.1 | 192.168.0.X | 192.168.0.150        |
| 10.0.0.1    | 10.0.0.X    | 10.0.0.50            |
| 172.16.0.1  | 172.16.0.X  | 172.16.0.70          |

---

# [STOP] ERREURS FRÉQUENTES (et comment les éviter)

### [X] Erreur 1 : mettre une IP qui n’est pas dans le même réseau

Exemple : serveur = 192.168.1.50
gateway = 192.168.0.1
-> Le serveur ne pourra pas sortir sur Internet.

### [X] Erreur 2 : utiliser une IP déjà prise

Résultat : conflits, coupures réseau, DNS KO.

### [X] Erreur 3 : utiliser une IP que le DHCP peut attribuer

Ex : DHCP = 192.168.1.10–100
Tu mets ton serveur sur 192.168.1.50
-> Conflit possible.

Toujours vérifier le DHCP dans ta box.

---

### [OUTILS] MÉTHODE 1 : Avec Netplan (Ubuntu 18.04+, Debian 11+)

**Netplan** = Système moderne de configuration réseau

#### Étape 1 : Identifier le fichier de configuration

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

**Résultat typique :**
```
00-installer-config.yaml
ou
01-netcfg.yaml
```

#### Étape 2 : Sauvegarder la config actuelle (IMPORTANT !)

```bash
sudo cp /etc/netplan/00-installer-config.yaml /etc/netplan/00-installer-config.yaml.backup
```

**Pourquoi ?** Si tu fais une erreur, tu peux restaurer :
```bash
sudo cp /etc/netplan/00-installer-config.yaml.backup /etc/netplan/00-installer-config.yaml
```

#### Étape 3 : Éditer la configuration

```bash
sudo nano /etc/netplan/00-installer-config.yaml
```

#### Étape 4 : Remplacer le contenu

**[ROUGE] Configuration ACTUELLE (DHCP - IP automatique) :**
```yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: true
```

**[VERT] NOUVELLE configuration (IP FIXE) :**
```yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses:
          - 127.0.0.1
          - 8.8.8.8
```

#### [GUIDE] EXPLICATION LIGNE PAR LIGNE :

```yaml
network:
  version: 2
```
**Ce que ça fait :** Indique la version de Netplan (toujours 2)

```yaml
  ethernets:
    eth0:
```
**Ce que ça fait :** Configure l'interface réseau `eth0`  
**[ATTENTION] IMPORTANT :** Remplace `eth0` par TON interface (trouve-la avec `ip a`)  
**Exemples courants :**
- `eth0` = Câble réseau
- `enp0s3` = Câble sur VirtualBox/VMware
- `wlan0` = WiFi
- `ens18` = Proxmox

```yaml
      dhcp4: no
```
**Ce que ça fait :** Désactive l'attribution automatique d'IP  
**Analogie :** "Je ne veux plus qu'on m'attribue un numéro d'appartement aléatoire"

```yaml
      addresses:
        - 192.168.1.100/24
```
**Ce que ça fait :** Fixe l'adresse IP à 192.168.1.100  
**Le `/24` expliqué :**
- `/24` = Masque de sous-réseau 255.255.255.0
- Signifie : "Mon réseau va de 192.168.1.1 à 192.168.1.254"

**Autres exemples :**
```yaml
- 192.168.0.100/24    # Si ta box est sur 192.168.0.1
- 10.0.0.100/24       # Si ta box est sur 10.0.0.1
```

```yaml
      routes:
        - to: default
          via: 192.168.1.1
```
**Ce que ça fait :** Définit la passerelle par défaut (ta box/routeur)  
**Analogie :** "Pour sortir de l'immeuble (aller sur Internet), passe par le gardien (routeur)"  
**[ATTENTION] À ADAPTER :** Remplace `192.168.1.1` par l'IP de TA box

**Comment trouver l'IP de ta box ?**
```bash
ip route | grep default
```
**Résultat :**
```
default via 192.168.1.1 dev eth0
            ^^^^^^^^^^^
            IP de ta box
```

```yaml
      nameservers:
        addresses:
          - 127.0.0.1
          - 8.8.8.8
```
**Ce que ça fait :** Définit les serveurs DNS à utiliser  
**Explication :**
- `127.0.0.1` = Ton serveur DNS local (DNSmasq ou BIND9)
- `8.8.8.8` = Google DNS (en secours si ton DNS local ne répond pas)

**Alternatives :**
```yaml
- 127.0.0.1          # Ton DNS local (si tu configures DNSmasq/BIND9)
- 1.1.1.1            # Cloudflare (rapide et privé)
- 9.9.9.9            # Quad9 (sécurisé)
- 192.168.1.1        # DNS de ta box
```

#### Étape 5 : Vérifier la syntaxe YAML (CRUCIAL !)

```bash
sudo netplan try
```

**Ce que ça fait :**
- Applique la config pendant 120 secondes
- Si tu perds la connexion SSH, elle s'annule automatiquement
- Si tout fonctionne, tape `ENTRÉE` pour confirmer

**[ATTENTION] ATTENTION : YAML est TRÈS sensible à l'indentation !**

**[X] ERREUR (espaces incorrects) :**
```yaml
network:
version: 2        # [X] Pas d'indentation
  ethernets:
```

**[OK] CORRECT (2 espaces par niveau) :**
```yaml
network:
  version: 2      # [OK] 2 espaces
  ethernets:
    eth0:         # [OK] 4 espaces
      dhcp4: no   # [OK] 6 espaces
```

#### Étape 6 : Appliquer définitivement

**Si `netplan try` fonctionne :**
```bash
sudo netplan apply
```

**Cette commande applique la configuration de manière permanente.**

#### Étape 7 : Vérifier la nouvelle IP

```bash
ip a show eth0
```

**Résultat attendu :**
```
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP>
    inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0
         ^^^^^^^^^^^^^
         [OK] SUCCÈS !
```

**Tester la connectivité :**
```bash
# Test de la passerelle (box)
ping 192.168.1.1 -c 4

# Test d'Internet
ping google.com -c 4
```

---

### [OUTILS] MÉTHODE 2 : Avec /etc/network/interfaces (Debian ancien, Ubuntu < 18.04)

#### Étape 1 : Sauvegarder

```bash
sudo cp /etc/network/interfaces /etc/network/interfaces.backup
```

#### Étape 2 : Éditer

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

#### Étape 3 : Configuration

**[ROUGE] Configuration ACTUELLE (DHCP) :**
```bash
auto eth0
iface eth0 inet dhcp
```

**[VERT] NOUVELLE configuration (IP FIXE) :**
```bash
auto eth0
iface eth0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    dns-nameservers 127.0.0.1 8.8.8.8
```

#### [GUIDE] EXPLICATION LIGNE PAR LIGNE :

```bash
auto eth0
```
**Ce que ça fait :** Active automatiquement l'interface au démarrage  
**Analogie :** "Allume la lumière automatiquement quand j'entre dans la pièce"

```bash
iface eth0 inet static
```
**Ce que ça fait :**
- `iface eth0` = Configure l'interface eth0
- `inet` = IPv4 (pas IPv6)
- `static` = IP fixe (pas DHCP)

```bash
    address 192.168.1.100
```
**Ce que ça fait :** Fixe l'adresse IP  
**[ATTENTION] À ADAPTER :** Selon ton réseau

```bash
    netmask 255.255.255.0
```
**Ce que ça fait :** Définit le masque de sous-réseau  
**Équivalent de `/24` dans Netplan**

**Tableau de correspondance :**
| Notation CIDR | Masque | Nombre d'IPs |
|---------------|---------|--------------|
| /24 | 255.255.255.0 | 254 IPs |
| /16 | 255.255.0.0 | 65534 IPs |
| /8 | 255.0.0.0 | 16 millions |

```bash
    gateway 192.168.1.1
```
**Ce que ça fait :** Définit la passerelle (routeur)

```bash
    dns-nameservers 127.0.0.1 8.8.8.8
```
**Ce que ça fait :** Définit les serveurs DNS  
**Séparés par des espaces, pas de virgules**

#### Étape 4 : Redémarrer le réseau

```bash
sudo systemctl restart networking
```

**Ou redémarrer complètement :**
```bash
sudo reboot
```

---

## [OBJECTIF] RÉCAPITULATIF : PROCESSUS COMPLET

### [LISTE] Checklist étape par étape

```
[ ] 1. Trouver mon IP actuelle
   -> ip a

[ ] 2. Choisir une nouvelle IP libre
   -> ping 192.168.1.100 -c 4

[ ] 3. Identifier mon interface réseau
   -> ip a (eth0, enp0s3, wlan0...)

[ ] 4. Trouver l'IP de ma box/routeur
   -> ip route | grep default

[ ] 5. Sauvegarder la config actuelle
   -> sudo cp /etc/netplan/XX.yaml /etc/netplan/XX.yaml.backup

[ ] 6. Éditer la configuration
   -> sudo nano /etc/netplan/XX.yaml

[ ] 7. Tester la config (sécurité !)
   -> sudo netplan try

[ ] 8. Appliquer définitivement
   -> sudo netplan apply

[ ] 9. Vérifier la nouvelle IP
   -> ip a

[ ] 10. Tester la connectivité
   -> ping 192.168.1.1
   -> ping google.com
```

---

## [HOT] CAS PRATIQUES RÉELS

### Cas 1 : Box Orange (Livebox)

```yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1        # IP typique Livebox
      nameservers:
        addresses:
          - 127.0.0.1
          - 80.10.246.2           # DNS Orange (optionnel)
```

### Cas 2 : Box SFR (SFR Box)

```yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.1.100/24
      routes:
        - to: default
          via: 192.168.1.1        # IP typique SFR Box
      nameservers:
        addresses:
          - 127.0.0.1
          - 109.0.66.10           # DNS SFR (optionnel)
```

### Cas 3 : Box Free (Freebox)

```yaml
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: no
      addresses:
        - 192.168.0.100/24        # [ATTENTION] Free utilise 192.168.0.X
      routes:
        - to: default
          via: 192.168.0.254      # [ATTENTION] IP typique Freebox
      nameservers:
        addresses:
          - 127.0.0.1
          - 212.27.40.240         # DNS Free (optionnel)
```

# [REFLEXION] EXCELLENTE QUESTION ! Pourquoi pas `ifconfig` ?

## [RAPIDE] RÉPONSE COURTE

Tu **PEUX** utiliser `ifconfig eth0 192.168.1.50`, **MAIS** :

```
[X] Configuration TEMPORAIRE (perdue au redémarrage)
[OK] Configuration PERMANENTE (survit au redémarrage)
```

**Analogie :** 
- `ifconfig` = Écrire ton adresse au **crayon** [EDIT] (effacé au prochain nettoyage)
- Netplan/interfaces = Graver ton adresse dans le **marbre** [MOYAI] (permanent)

---

## [GRAPHIQUE] COMPARAISON DÉTAILLÉE

### Méthode 1 : `ifconfig` (Temporaire)

```bash
sudo ifconfig eth0 192.168.1.50 netmask 255.255.255.0
```

**[OK] Avantages :**
- [RAPIDE] Instantané (pas de redémarrage)
- [OBJECTIF] Parfait pour **tester** rapidement
- [OUTIL] Utile pour **dépanner** temporairement

**[X] Inconvénients :**
- [IMPACT] **PERDU au redémarrage** du serveur
- [IMPACT] **PERDU** si l'interface réseau redémarre
- [ATTENTION] Ne configure pas la passerelle (gateway)
- [ATTENTION] Ne configure pas les DNS
- [ATTENTION] Commande **obsolète** (remplacée par `ip`)

---

### Méthode 2 : Netplan/interfaces (Permanent)

```yaml
# /etc/netplan/config.yaml
network:
  version: 2
  ethernets:
    eth0:
      addresses:
        - 192.168.1.50/24
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses: [8.8.8.8]
```

**[OK] Avantages :**
- [VERROUILLE] **PERMANENT** (survit aux redémarrages)
- [WEB] Configure **tout** (IP, gateway, DNS)
- [DOSSIER] Configuration **centralisée**
- [RAPIDE] Méthode **moderne** et recommandée

**[X] Inconvénients :**
- [TEMPS] Nécessite un redémarrage réseau
- [NOTE] Plus verbeux (plusieurs lignes)

---

## [TEST] DÉMONSTRATION PRATIQUE

### Scénario : Configuration avec `ifconfig`

```bash
# Étape 1 : Configurer l'IP temporairement
sudo ifconfig eth0 192.168.1.50 netmask 255.255.255.0

# Étape 2 : Vérifier ([OK] ça marche !)
ip a show eth0
# inet 192.168.1.50/24

# Étape 3 : Tester la connectivité
ping 192.168.1.1
# [OK] Fonctionne

# Étape 4 : Mais essayer d'aller sur Internet
ping google.com
# [X] Network unreachable
```

**Pourquoi ça ne marche pas ?**

Parce qu'il **manque des éléments essentiels** :

```
[OK] Adresse IP      : 192.168.1.50     (configurée)
[X] Passerelle      : ???              (NON configurée)
[X] DNS             : ???              (NON configuré)
```

**Analogie :** Tu as une adresse postale (IP), mais :
- Pas de facteur (passerelle) pour acheminer ton courrier
- Pas d'annuaire (DNS) pour trouver les autres adresses

---

### Configuration COMPLÈTE avec `ifconfig` + `route` + `resolv.conf`

```bash
# 1⃣ Configurer l'IP
sudo ifconfig eth0 192.168.1.50 netmask 255.255.255.0

# 2⃣ Configurer la passerelle (gateway)
sudo route add default gw 192.168.1.1 eth0

# 3⃣ Configurer les DNS
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf
```

**Maintenant ça fonctionne... MAIS :**

```bash
# Redémarre ton serveur
sudo reboot

# Après redémarrage, vérifie l'IP
ip a
# [X] OUPS ! L'IP est revenue à celle attribuée par DHCP
# (exemple: 192.168.1.73 au lieu de 192.168.1.50)
```

**[IMPACT] Tout a été perdu !**

---

## [OBJECTIF] QUAND UTILISER CHAQUE MÉTHODE ?

### Utilise `ifconfig` / `ip` (Temporaire) pour :

**1. Tester rapidement une configuration**
```bash
# Tu veux voir si une IP fonctionne avant de la fixer
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0
sudo route add default gw 192.168.1.1
ping google.com  # Test
```

**2. Dépanner une connexion cassée**
```bash
# Le réseau ne marche plus, tu veux une solution rapide
sudo ifconfig eth0 up
sudo dhclient eth0  # Récupérer une IP automatique
```

**3. Changer temporairement d'IP pour une tâche précise**
```bash
# Tu dois te connecter à un équipement sur un autre réseau
sudo ifconfig eth0 10.0.0.50 netmask 255.255.255.0
# Faire ta tâche
# Puis revenir à la config normale avec un reboot
```

---

### Utilise Netplan/interfaces (Permanent) pour :

**1. Configurer un serveur de production**
```yaml
# L'IP doit survivre aux redémarrages
network:
  version: 2
  ethernets:
    eth0:
      addresses: [192.168.1.100/24]
```

**2. Configurer des services réseau (DNS, Web, etc.)**
```bash
# Un serveur DNS DOIT avoir une IP fixe permanente
```

**3. Toute configuration destinée à durer**
```bash
# Si tu veux garder cette config plus de 5 minutes
```

---

## [SYNC] COMMANDES MODERNES : `ip` remplace `ifconfig`

### [ATTENTION] IMPORTANT : `ifconfig` est **OBSOLÈTE**

```bash
# [X] Ancienne méthode (deprecated depuis 2009)
sudo ifconfig eth0 192.168.1.50 netmask 255.255.255.0
sudo route add default gw 192.168.1.1

# [OK] Nouvelle méthode (recommandée)
sudo ip addr add 192.168.1.50/24 dev eth0
sudo ip route add default via 192.168.1.1
```

**Pourquoi `ip` est meilleur ?**
- [RAPIDE] Plus rapide
- [OBJECTIF] Plus précis
- [MOBILE] Supporte IPv6
- [OUTIL] Plus de fonctionnalités
- [OK] Activement maintenu

---

## [GUIDE] TABLEAU DE CORRESPONDANCE

| Tâche | Ancienne commande (`ifconfig`) | Nouvelle commande (`ip`) |
|-------|-------------------------------|--------------------------|
| **Voir les IPs** | `ifconfig` | `ip addr` ou `ip a` |
| **Ajouter une IP** | `ifconfig eth0 192.168.1.50 netmask 255.255.255.0` | `ip addr add 192.168.1.50/24 dev eth0` |
| **Supprimer une IP** | `ifconfig eth0 0.0.0.0` | `ip addr del 192.168.1.50/24 dev eth0` |
| **Activer interface** | `ifconfig eth0 up` | `ip link set eth0 up` |
| **Désactiver interface** | `ifconfig eth0 down` | `ip link set eth0 down` |
| **Voir les routes** | `route -n` | `ip route` |
| **Ajouter route** | `route add default gw 192.168.1.1` | `ip route add default via 192.168.1.1` |

---

## [DEMARRAGE] EXEMPLE COMPLET : Les 3 approches côte à côte

### Scénario : Fixer l'IP 192.168.1.100 sur eth0

#### Approche 1 : Temporaire avec `ifconfig` (obsolète)

```bash
# Configuration
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0
sudo route add default gw 192.168.1.1 eth0
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

# [OK] Fonctionne MAINTENANT
# [X] Perdu au redémarrage
```

---

#### Approche 2 : Temporaire avec `ip` (moderne)

```bash
# Configuration
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip route add default via 192.168.1.1
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

# [OK] Fonctionne MAINTENANT
# [X] Perdu au redémarrage
```

---

#### Approche 3 : Permanent avec Netplan

```bash
# Éditer la config
sudo nano /etc/netplan/01-config.yaml
```

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

```bash
# Appliquer
sudo netplan apply

# [OK] Fonctionne MAINTENANT
# [OK] Fonctionne APRÈS REDÉMARRAGE
```

---

## [LOGIQUE] STRATÉGIE RECOMMANDÉE : COMBINAISON DES DEUX

### Workflow professionnel :

```bash
# Étape 1 : Tester temporairement avec ip
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip route add default via 192.168.1.1

# Étape 2 : Vérifier que ça fonctionne
ping 192.168.1.1        # Test gateway
ping google.com         # Test Internet

# Étape 3 : Si OK, fixer de manière permanente
sudo nano /etc/netplan/01-config.yaml
# [Configurer comme expliqué plus haut]

# Étape 4 : Supprimer la config temporaire
sudo ip addr del 192.168.1.100/24 dev eth0

# Étape 5 : Appliquer la config permanente
sudo netplan apply
```

**Avantage de cette méthode :**
- [TEST] Tu testes d'abord (sécurisé)
- [OK] Tu ne rends permanent que ce qui fonctionne
- [RAPIDE] Pas besoin de redémarrer pour tester

---

## [IDEE] CAS D'USAGE RÉELS

### Cas 1 : Dépannage rapide

**Situation :** Le réseau ne marche plus après une mise à jour

```bash
# Solution temporaire immédiate
sudo ip link set eth0 up
sudo ip addr add 192.168.1.50/24 dev eth0
sudo ip route add default via 192.168.1.1

# [OK] Le réseau refonctionne
# Ensuite, chercher la cause et corriger la config permanente
```

---

### Cas 2 : Configuration de serveur DNS

**Situation :** Tu installes DNSmasq, tu DOIS avoir une IP fixe permanente

```bash
# [X] MAUVAIS : Configuration temporaire
sudo ip addr add 192.168.1.100/24 dev eth0
sudo apt install dnsmasq
# Le DNS fonctionnera JUSQU'AU PROCHAIN REDÉMARRAGE

# [OK] BON : Configuration permanente AVANT d'installer
sudo nano /etc/netplan/01-config.yaml
# [Fixer l'IP à 192.168.1.100]
sudo netplan apply
sudo apt install dnsmasq
# Le DNS fonctionnera TOUJOURS
```

---

### Cas 3 : Test de configuration avant déploiement

**Situation :** Tu veux tester une nouvelle IP sans casser la config actuelle

```bash
# Ajouter une DEUXIÈME IP temporaire (la première reste)
sudo ip addr add 192.168.1.200/24 dev eth0

# Tester avec cette nouvelle IP
ping -I 192.168.1.200 google.com

# Si ça marche, l'adopter de manière permanente
# Si ça ne marche pas, simplement supprimer
sudo ip addr del 192.168.1.200/24 dev eth0
```

---

## [COURS] RÉSUMÉ : QUELLE MÉTHODE CHOISIR ?

```
┌─────────────────────────────────────────────────┐
│     DOIS-JE UTILISER ifconfig/ip OU Netplan ?   │
├─────────────────────────────────────────────────┤
│                                                 │
│  Test rapide < 5 min ?                          │
│  └──> [OK] ifconfig / ip (temporaire)             │
│                                                 │
│  Configuration serveur de production ?          │
│  └──> [OK] Netplan (permanent)                    │
│                                                 │
│  Dépannage d'urgence ?                          │
│  └──> [OK] ifconfig / ip (temporaire)             │
│                                                 │
│  Installer un service réseau (DNS/Web) ?        │
│  └──> [OK] Netplan (permanent)                    │
│                                                 │
│  L'IP doit survivre au redémarrage ?            │
│  └──> [OK] Netplan (permanent)                    │
│                                                 │
│  Configuration définitive ?                     │
│  └──> [OK] TOUJOURS Netplan                       │
│                                                 │
└─────────────────────────────────────────────────┘
```

---

## [CLE] CONCLUSION

**Ta question était excellente !** Oui, `ifconfig eth0 192.168.1.50` fonctionne, mais c'est comme :

[CAMPING] **Planter une tente** (temporaire) vs [ACCUEIL] **Construire une maison** (permanent)

Pour un **serveur DNS** que tu configures, tu veux une **maison solide** (Netplan), pas une **tente qui s'envole au premier redémarrage** !

**Conseil final :** Utilise les deux !
1. Teste avec `ip` (rapide)
2. Rends permanent avec Netplan (fiable)

[BRAVO] Voilà pourquoi je t'ai montré Netplan plutôt que `ifconfig` !

---

## 🆘 DÉPANNAGE : PROBLÈMES FRÉQUENTS

### [X] Problème 1 : "Connexion perdue après netplan apply"

**Cause :** Erreur dans la configuration (interface incorrecte, IP en conflit)

**Solution :**
1. Connecte-toi physiquement au serveur (clavier/écran)
2. Restaure la sauvegarde :
   ```bash
   sudo cp /etc/netplan/00-installer-config.yaml.backup /etc/netplan/00-installer-config.yaml
   sudo netplan apply
   ```

---

### [X] Problème 2 : "Network unreachable"

**Cause :** Mauvaise passerelle (gateway)

**Vérification :**
```bash
ip route
```

**Si pas de "default via", c'est le problème.**

**Solution :**
```bash
# Ajouter temporairement la route
sudo ip route add default via 192.168.1.1

# Puis corriger dans /etc/netplan/
```

---

### [X] Problème 3 : "Temporary failure in name resolution"

**Cause :** DNS mal configuré

**Test :**
```bash
cat /etc/resolv.conf
```

**Devrait contenir :**
```
nameserver 127.0.0.1
nameserver 8.8.8.8
```

**Solution temporaire :**
```bash
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf
```

**Solution permanente :** Corriger `nameservers` dans `/etc/netplan/`

---

### [X] Problème 4 : Conflit d'adresse IP

**Symptôme :**
```
RTNETLINK answers: File exists
```

**Cause :** Une autre machine utilise déjà 192.168.1.100

**Solution :**
1. Identifier le coupable :
   ```bash
   # Sur la machine en conflit
   sudo arp-scan --localnet | grep 192.168.1.100
   ```

2. Choisir une autre IP (ex: 192.168.1.101)

---

## [COURS] CONSEILS DE PRO

### [OK] Bonnes pratiques

1. **Toujours sauvegarder avant de modifier**
   ```bash
   sudo cp config config.backup
   ```

2. **Documenter tes IPs** (crée un fichier texte)
   ```
   192.168.1.1   -> Box/Routeur
   192.168.1.100 -> Serveur DNS
   192.168.1.101 -> Serveur Web
   192.168.1.102 -> NAS
   ```

3. **Utiliser une plage dédiée**
   ```
   192.168.1.2-99   -> DHCP (automatique)
   192.168.1.100-200 -> Serveurs (fixe)
   ```

4. **Tester avec `netplan try`** (jamais `netplan apply` directement en SSH)

5. **Garder un accès physique** pendant les modifications réseau

---

Voilà ! Tu sais maintenant tout pour trouver et fixer l'adresse IP de ton serveur ! [BRAVO]

Bonne configuration ! [BRAVO]

```


Guide complet pour tester ton DNS depuis ta machine physique

# [OBJECTIF] OUI, C'EST POSSIBLE ! Guide complet pour tester ton DNS depuis ta machine physique

## [GUIDE] COMPRENDRE LA SITUATION

### [CONSTRUCTION] Ton architecture actuelle

```
┌─────────────────────────────────────────┐
│     [CODE] MACHINE PHYSIQUE (Windows/Mac)   │
│                                         │
│  ┌────────────────────────────────────┐ │
│  │  [ECRAN] VIRTUALBOX                     │ │
│  │                                    │ │
│  │  ┌──────────────────────────────┐  │ │
│  │  │ [LINUX] VM LINUX (Serveur DNS)    │  │ │
│  │  │ IP: 192.168.1.100            │  │ │
│  │  │ DNSmasq ou BIND9 actif       │  │ │
│  │  └──────────────────────────────┘  │ │
│  └────────────────────────────────────┘ │
└─────────────────────────────────────────┘
```

**Objectif :** Faire communiquer ta machine physique avec le DNS de ta VM.

---

## [SIGNAL] PRÉREQUIS : Vérifier le mode réseau de ta VM

### [RECHERCHE] Pourquoi c'est crucial ?

VirtualBox propose plusieurs modes réseau. **Seuls 2 modes permettent la communication** :

|------------------------|-------------------------|-----------------------------|-----------------------------|
| Mode                   | Communication VM <-> Hôte | Communication VM <-> Internet | Recommandation              |
|------------------------|-------------------------|-----------------------------|-----------------------------|
| **NAT**                |        [X] NON           |            [OK] OUI           | [X] Ne fonctionne PAS       |
| **Accès par pont**     |        [OK] OUI           |            [OK] OUI           | [OK] **RECOMMANDÉ**          |
| **Réseau interne**     |        [X] NON           |            [X] NON           | [X] Ne fonctionne PAS       |
| **Réseau privé hôte**  |        [OK] OUI           |            [X] NON           | [ATTENTION] Fonctionne mais complexe|
|------------------------|-------------------------|-----------------------------|-----------------------------|

---

## [CONFIG] ÉTAPE 1 : CONFIGURER LE MODE RÉSEAU (Accès par pont)

### [IMPORTANT] Sur VirtualBox (VM éteinte)

1. **Ouvre VirtualBox**
2. **Sélectionne ta VM** (ne la démarre pas encore)
3. **Clique sur "Configuration" ([CONFIG])**
4. **Va dans "Réseau"**
5. **Onglet "Adaptateur 1"** :
   - [OK] Cocher "Activer la carte réseau"
   - **Mode d'accès réseau :** Sélectionner **"Accès par pont"**
   - **Nom :** Choisir ta carte réseau physique :
     - [PLUGIN] `Realtek...` ou `Intel...` (Ethernet)
     - [RESEAU] `Wireless...` (WiFi)
6. **Clique sur "OK"**

### [FRAME_WITH_PICTURE] Illustration :

```
┌────────────────────────────────────┐
│  Configuration - Ma VM Linux       │
├────────────────────────────────────┤
│  Réseau                            │
│  ┌──────────────────────────────┐  │
│  │ Adaptateur 1                 │  │
│  │ [x] Activer la carte réseau    │  │
│  │                              │  │
│  │ Mode d'accès réseau:         │  │
│  │ [Accès par pont [BLACK_DOWN-POINTING_TRIANGLE]]           │  │
│  │                              │  │
│  │ Nom:                         │  │
│  │ [Realtek PCIe GbE [BLACK_DOWN-POINTING_TRIANGLE]]         │  │
│  └──────────────────────────────┘  │
└────────────────────────────────────┘
```

---

## [RAPIDE] ÉTAPE 2 : DÉMARRER LA VM ET VÉRIFIER L'IP

### 1⃣ Démarre ta VM Linux

### 2⃣ Vérifie son adresse IP

```bash
ip a
```

**Résultat attendu :**

```
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP>
    inet 192.168.1.50/24 brd 192.168.1.255
         ^^^^^^^^^^^^
    TON IP ACTUELLE (peut être différente de 192.168.1.100)
```

### [OBJECTIF] Comprendre ce résultat

**Si tu vois une IP comme `192.168.1.X` :**
- [OK] **PARFAIT !** Ta VM est sur le même réseau que ta machine physique
- Elle a reçu une IP automatiquement (DHCP)

**Si tu vois `10.0.2.15` :**
- [X] **PROBLÈME !** Tu es encore en mode NAT
- Retourne à l'ÉTAPE 1 et vérifie le mode réseau

---

## [OUTIL] ÉTAPE 3 : FIXER L'ADRESSE IP DE LA VM (Optionnel mais recommandé)

### [IDEE] Pourquoi fixer l'IP ?

**Analogie :** C'est comme donner une adresse fixe à ta maison au lieu d'un numéro temporaire.

**Avantages :**
- L'IP ne change jamais -> Configuration stable
- Plus facile à mémoriser (`192.168.1.100`)
- Pas de surprise au redémarrage

---

### Méthode A : Avec Netplan (Ubuntu 18.04+, Debian 11+)

#### 1⃣ Vérifier si tu utilises Netplan

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

**Si tu vois un fichier `.yaml` :** Tu utilises Netplan [OK]

#### 2⃣ Éditer la configuration

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

**[ATTENTION] Le nom du fichier peut varier :**
- `00-installer-config.yaml`
- `50-cloud-init.yaml`
- etc.

#### 3⃣ Contenu à utiliser (copie/colle)

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      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
```

#### [GUIDE] Explication ligne par ligne

```yaml
network:
  version: 2                    # Version de Netplan
  renderer: networkd            # Moteur de réseau utilisé
  ethernets:                    # Configuration des cartes Ethernet
    eth0:                       # Nom de ta carte réseau
      dhcp4: no                 # Désactive l'IP automatique
      addresses:
        - 192.168.1.100/24      # TON IP FIXE + masque réseau
      routes:
        - to: default
          via: 192.168.1.1      # IP DE TA BOX (passerelle)
      nameservers:
        addresses:
          - 8.8.8.8             # DNS Google (pour accès Internet)
          - 8.8.4.4
```

#### 4⃣ Appliquer la configuration

```bash
sudo netplan apply
```

#### 5⃣ Vérifier

```bash
ip a | grep eth0
```

**Résultat attendu :**
```
inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0
```

---

### Méthode B : Avec /etc/network/interfaces (Debian anciennes versions)

#### 1⃣ Éditer le fichier

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

#### 2⃣ Contenu à utiliser

```bash
# Interface loopback (ne pas toucher)
auto lo
iface lo inet loopback

# Configuration de eth0
auto eth0
iface eth0 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
```

#### 3⃣ Redémarrer le réseau

```bash
sudo systemctl restart networking
```

#### 4⃣ Vérifier

```bash
ip a | grep eth0
```

---

## [TEST] ÉTAPE 4 : TESTER LA COMMUNICATION VM <-> MACHINE PHYSIQUE

### [SYNC] Test 1 : Depuis la VM -> Machine physique

#### 1⃣ Trouver l'IP de ta machine physique

**Sur Windows :**
1. Ouvre **Invite de commandes** (`Win + R` -> tape `cmd` -> Entrée)
2. Tape :
```cmd
ipconfig
```
3. Cherche **"Carte Ethernet"** ou **"Carte WiFi"**
4. Note l'**"Adresse IPv4"** (ex: `192.168.1.10`)

**Sur Mac :**
1. Ouvre **Terminal**
2. Tape :
```bash
ifconfig | grep "inet " | grep -v 127.0.0.1
```

**Sur Linux :**
```bash
ip a
```

#### 2⃣ Ping depuis la VM

```bash
ping 192.168.1.10 -c 4
```

**Remplace `192.168.1.10` par l'IP de ta machine physique**

**Résultat attendu :**
```
PING 192.168.1.10 (192.168.1.10) 56(84) bytes of data.
64 bytes from 192.168.1.10: icmp_seq=1 ttl=64 time=0.5 ms
64 bytes from 192.168.1.10: icmp_seq=2 ttl=64 time=0.4 ms
[OK] 4 packets transmitted, 4 received, 0% packet loss
```

**Si ça ne fonctionne pas :**
- [X] Vérifier le pare-feu de ta machine physique
- [X] Vérifier le mode réseau VirtualBox

---

### [SYNC] Test 2 : Depuis la machine physique -> VM

#### Sur Windows (Invite de commandes)

```cmd
ping 192.168.1.100
```

#### Sur Mac/Linux (Terminal)

```bash
ping 192.168.1.100 -c 4
```

**Résultat attendu :**
```
Réponse de 192.168.1.100 : octets=32 temps<1ms TTL=64
[OK] Communication réussie
```

---

## [OBJECTIF] ÉTAPE 5 : CONFIGURER LE DNS SUR TA MACHINE PHYSIQUE

### [DESIGN] Schéma de fonctionnement

```
┌─────────────────────────────────────┐
│  [CODE] MACHINE PHYSIQUE                │
│  Configuration DNS:                 │
│  Serveur DNS préféré: 192.168.1.100 │
│           │                         │
│           [BLACK_DOWN-POINTING_TRIANGLE]                         │
│  "Où est server1.local ?"           │
└───────────┬─────────────────────────┘
            │
            │ Question DNS
            [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────┐
│  [LINUX] VM LINUX (192.168.1.100)        │
│  DNSmasq/BIND9 répond:              │
│  "server1.local = 192.168.1.100"    │
└─────────────────────────────────────┘
```

---

### Sur Windows 10/11

#### 1⃣ Ouvrir les paramètres réseau

**Méthode rapide :**
1. `Win + R`
2. Tape : `ncpa.cpl`
3. Entrée

#### 2⃣ Configurer la carte réseau

1. **Clique droit** sur ta carte réseau (Ethernet ou WiFi)
2. **Propriétés**
3. **Double-clique** sur "Protocole Internet version 4 (TCP/IPv4)"
4. **En bas :** Sélectionne **"Utiliser l'adresse de serveur DNS suivante"**
5. **Remplis :**
   ```
   Serveur DNS préféré:   192.168.1.100
   Serveur DNS auxiliaire: 8.8.8.8
   ```
6. **OK** -> **OK**

#### 3⃣ Vider le cache DNS

```cmd
ipconfig /flushdns
```

---

### Sur Mac

#### 1⃣ Ouvrir les préférences réseau

1. **Pomme** () -> **Préférences Système**
2. **Réseau**
3. Sélectionne ta connexion (Ethernet ou WiFi)
4. **Avancé...**

#### 2⃣ Configurer le DNS

1. **Onglet DNS**
2. **Clique sur le "+"** sous "Serveurs DNS"
3. **Ajoute :** `192.168.1.100`
4. **(Optionnel) Ajoute :** `8.8.8.8`
5. **OK** -> **Appliquer**

#### 3⃣ Vider le cache DNS

```bash
sudo dscacheutil -flushcache
sudo killall -HUP mDNSResponder
```

---

### Sur Linux (autre machine)

#### 1⃣ Éditer resolv.conf

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

#### 2⃣ Ajouter en premier

```
nameserver 192.168.1.100
nameserver 8.8.8.8
```

**[ATTENTION] Attention :** Sur certaines distributions, ce fichier est régénéré au redémarrage.

#### 3⃣ Solution permanente (systemd-resolved)

```bash
sudo nano /etc/systemd/resolved.conf
```

**Contenu :**
```ini
[Resolve]
DNS=192.168.1.100 8.8.8.8
```

**Redémarrer :**
```bash
sudo systemctl restart systemd-resolved
```

---

## [TEST] ÉTAPE 6 : TESTER LA RÉSOLUTION DNS

### Test 1 : Avec `nslookup` (Windows/Mac/Linux)

```cmd
nslookup server1.local 192.168.1.100
```

**Résultat attendu :**
```
Serveur :   ns1.local
Address:    192.168.1.100

Nom :    server1.local
Address:  192.168.1.100
```

[OK] **Ça fonctionne !** Ton DNS répond correctement.

---

### Test 2 : Avec `dig` (Mac/Linux)

```bash
dig server1.local @192.168.1.100
```

**Résultat attendu :**
```
;; ANSWER SECTION:
server1.local.    604800    IN    A    192.168.1.100
```

---

### Test 3 : Avec `ping`

```bash
ping server1.local
```

**Résultat attendu :**
```
PING server1.local (192.168.1.100) 56(84) bytes of data.
64 bytes from server1.local (192.168.1.100): icmp_seq=1...
```

[OK] **Parfait !** Le nom est résolu automatiquement.

---

## [BRAVO] RÉSUMÉ COMPLET

### [OK] Checklist de vérification

- [ ] Mode réseau VirtualBox = **Accès par pont**
- [ ] VM a une IP `192.168.1.X` (même réseau que ta machine)
- [ ] Ping VM -> Machine physique fonctionne
- [ ] Ping Machine physique -> VM fonctionne
- [ ] DNS configuré sur la machine physique (`192.168.1.100`)
- [ ] `nslookup server1.local 192.168.1.100` retourne l'IP correcte
- [ ] `ping server1.local` fonctionne

---

## 🆘 DÉPANNAGE

### [X] "Délai d'attente de la demande dépassé" lors du ping

**Causes possibles :**
1. **Pare-feu bloque** (Windows Defender, pare-feu Linux)
2. **Mauvais mode réseau** (encore en NAT)
3. **IP incorrecte**

**Solutions :**
```bash
# Sur la VM Linux, désactiver temporairement le pare-feu
sudo ufw disable

# Sur Windows, autoriser ICMP (ping)
# Panneau de configuration -> Pare-feu Windows -> Paramètres avancés
# Règles de trafic entrant -> Activer "Partage de fichiers (Demande d'écho ICMPv4)"
```

---

### [X] "Le serveur n'a pas pu être trouvé" avec nslookup

**Causes :**
1. Le service DNS n'est pas démarré sur la VM
2. Mauvaise configuration DNS

**Solutions :**
```bash
# Vérifier le statut du service
sudo systemctl status dnsmasq    # ou bind9

# Si inactif, démarrer
sudo systemctl start dnsmasq     # ou bind9

# Vérifier que le port 53 écoute
sudo netstat -tulpn | grep :53
```

---

### [X] DNS ne résout que dans un sens

**Si `nslookup server1.local 192.168.1.100` fonctionne**
**Mais `ping server1.local` (sans @IP) ne fonctionne pas**

**Cause :** Configuration DNS de ta machine physique incorrecte

**Solution :** Reprendre l'ÉTAPE 5 et vérifier que `192.168.1.100` est bien le **premier** serveur DNS.

---

## [COURS] TU AS RÉUSSI !

Si tous les tests passent, **BRAVO** ! [BRAVO]

Tu as maintenant :
- [OK] Un serveur DNS fonctionnel sur ta VM
- [OK] Une communication réseau VM <-> Machine physique
- [OK] Une résolution de noms personnalisés depuis ta machine

**Prochaines étapes possibles :**
- Ajouter d'autres enregistrements DNS (web.local, nas.local)
- Configurer un serveur web sur la VM et y accéder via `http://web.local`
- Mettre en place un réseau local complet avec plusieurs VMs

# [OBJECTIF] EXCELLENTE QUESTION ! Tu as raison d'être confus !

## [REFLEXION] LE PROBLÈME QUE TU AS IDENTIFIÉ

Tu dis : 
> "Pourquoi on peut tester la communication à l'ÉTAPE 4, alors qu'on n'a RIEN configuré sur la machine physique ?"

**TU AS 100% RAISON !** [BRAVO]

J'ai sauté des étapes importantes. Laisse-moi t'expliquer **EXACTEMENT** ce qui se passe en réalité.

---

## [LOGIQUE] COMPRENDRE CE QUI SE PASSE VRAIMENT

### [RESEAU] Avec le mode "Accès par pont" (Bridge)

Quand tu mets VirtualBox en mode **"Accès par pont"**, voici ce qui se passe :

```
┌─────────────────────────────────────────────────┐
│          [ACCUEIL] TON RÉSEAU LOCAL                    │
│                                                 │
│  ┌──────────┐         ┌──────────┐            │
│  │   Box    │[BLACK_LEFT-POINTING_POINTER]────────┤ Machine  │            │
│  │ (Routeur)│         │ Physique │            │
│  │          │         │          │            │
│  │ DHCP     │[BLACK_LEFT-POINTING_POINTER]────┐   └──────────┘            │
│  │ actif    │     │                            │
│  └──────────┘     │   ┌──────────┐            │
│                   └───┤    VM    │            │
│                       │  Linux   │            │
│                       └──────────┘            │
│                                                 │
│  La VM est vue comme UN APPAREIL NORMAL        │
│  (comme un PC, un téléphone, une imprimante)   │
└─────────────────────────────────────────────────┘
```

### [OK] Ce qui fonctionne AUTOMATIQUEMENT (sans config)

**1. La VM reçoit une IP automatiquement**
- Ta Box (routeur) a un serveur DHCP actif
- Dès que la VM démarre en mode pont, elle demande une IP
- La Box lui donne une IP libre (ex: `192.168.1.50`)

**2. La communication réseau fonctionne**
- La VM peut communiquer avec TOUS les appareils du réseau
- Ta machine physique peut communiquer avec la VM
- **AUCUNE configuration nécessaire** pour le **ping** simple

### [X] Ce qui NE fonctionne PAS automatiquement

**1. La résolution DNS personnalisée**
- Ta machine physique ne sait pas qu'il y a un serveur DNS sur la VM
- Elle continue d'utiliser le DNS de ta Box (ou Google DNS)
- `ping server1.local` -> **NE FONCTIONNE PAS**

**2. Les noms personnalisés ne sont pas accessibles**
- `server1.local` n'existe que dans la VM
- Ta machine physique ne le connaît pas

---

## [OUTIL] CE QU'IL FAUT FAIRE **VRAIMENT** (Guide corrigé)

Je vais te donner l'ordre EXACT, sans sauter d'étapes.

---

## [OK] ÉTAPE 0 : VÉRIFICATIONS DE BASE (À faire en PREMIER)

### [RECHERCHE] Sur ta machine physique

#### Windows :

**1. Trouver l'IP de ta machine physique**

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

```cmd
ipconfig
```

**Cherche cette section :**
```
Carte Ethernet Ethernet:
   Adresse IPv4. . . . . . . . . . . . . .: 192.168.1.10
   Masque de sous-réseau. . . . . . . . . : 255.255.255.0
   Passerelle par défaut. . . . . . . . . : 192.168.1.1
```

**Note ces 3 informations :**
- [EDIT] Ton IP : `192.168.1.10` (exemple)
- [EDIT] Ton masque : `255.255.255.0`
- [EDIT] Ta passerelle (Box) : `192.168.1.1`

---

#### Mac :

**1. Trouver l'IP de ta machine**

Ouvre **Terminal**

```bash
ifconfig | grep "inet " | grep -v 127.0.0.1
```

**Résultat :**
```
inet 192.168.1.10 netmask 0xffffff00 broadcast 192.168.1.255
```

**2. Trouver ta passerelle**

```bash
netstat -nr | grep default
```

**Résultat :**
```
default            192.168.1.1        UGSc           en0
```

---

#### Linux (autre machine) :

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

---

### [NOTE] RÉCAPITULATIF DE TES INFOS

Remplis ce tableau **AVANT de continuer** :

| Info | Valeur (exemple) | Ta valeur |
|------|------------------|-----------|
| IP de ta machine physique | 192.168.1.10 | ________ |
| Masque réseau | 255.255.255.0 | ________ |
| Passerelle (Box) | 192.168.1.1 | ________ |
| Plage réseau | 192.168.1.X | ________ |

---

## [OK] ÉTAPE 1 : CONFIGURATION VIRTUALBOX (déjà expliqué)

(Voir la réponse précédente - Mode "Accès par pont")

---

## [OK] ÉTAPE 2 : DÉMARRER LA VM ET VÉRIFIER

### 1⃣ Démarre ta VM Linux

### 2⃣ Vérifie son adresse IP

```bash
ip a
```

**Résultat :**
```
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP>
    inet 192.168.1.50/24 brd 192.168.1.255
         ^^^^^^^^^^^^
```

### [OBJECTIF] IMPORTANT : Vérifier que c'est la bonne plage

**Si ta machine physique est sur `192.168.1.10`**
**Alors ta VM DOIT être sur `192.168.1.X`** (même plage)

**[OK] Exemples CORRECTS :**
- Machine physique : `192.168.1.10`
- VM : `192.168.1.50` -> **BON** [OK]

**[X] Exemples INCORRECTS :**
- Machine physique : `192.168.1.10`
- VM : `10.0.2.15` -> **MAUVAIS** [X] (mode NAT actif)
- VM : `192.168.56.10` -> **MAUVAIS** [X] (réseau hôte uniquement)

---

## [OK] ÉTAPE 3 : PREMIER TEST (Communication réseau simple)

### [TEST] Test 1 : VM -> Machine physique

**Sur la VM Linux**, tape :

```bash
ping 192.168.1.10 -c 4
```

**[ATTENTION] REMPLACE `192.168.1.10` par L'IP DE TA MACHINE PHYSIQUE**

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

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

**[OK] Si ça fonctionne :** PARFAIT ! La communication réseau est établie

**[X] Si ça ne fonctionne pas :**

### [HOT] DÉPANNAGE IMMÉDIAT

#### Cause 1 : Pare-feu Windows bloque les pings

**Solution sur Windows :**

1. Ouvre **Panneau de configuration**
2. **Système et sécurité** -> **Pare-feu Windows Defender**
3. **Paramètres avancés** (à gauche)
4. **Règles de trafic entrant** (à gauche)
5. Cherche : **"Partage de fichiers et d'imprimantes (Demande d'écho - ICMPv4-In)"**
6. **Clique droit** -> **Activer la règle**

**Ou en ligne de commande (Admin) :**

```cmd
netsh advfirewall firewall add rule name="ICMP Allow incoming V4 echo request" protocol=icmpv4:8,any dir=in action=allow
```

---

#### Cause 2 : Mauvais mode réseau VirtualBox

Retourne à l'ÉTAPE 1, vérifie que c'est bien **"Accès par pont"**

---

### [TEST] Test 2 : Machine physique -> VM

**Sur ta machine physique :**

**Windows :**
```cmd
ping 192.168.1.50
```

**Mac/Linux :**
```bash
ping 192.168.1.50 -c 4
```

**[ATTENTION] REMPLACE `192.168.1.50` par L'IP DE TA VM**

**Résultat attendu :**
```
Réponse de 192.168.1.50 : octets=32 temps<1ms TTL=64
Réponse de 192.168.1.50 : octets=32 temps<1ms TTL=64
```

**[OK] Si les 2 tests fonctionnent :** La communication bidirectionnelle est OK !

**[BRAVO] TU PEUX PASSER À L'ÉTAPE 4**

---

## [OK] ÉTAPE 4 : FIXER L'IP DE LA VM (Fortement recommandé)

**Pourquoi fixer l'IP ?**

Actuellement, ta VM a reçu une IP automatiquement (DHCP).
**Problème :** Cette IP peut changer au redémarrage.

**Solution :** Lui donner une IP fixe (`192.168.1.100`)

### [LISTE] Informations nécessaires

Tu auras besoin de :
- [EDIT] IP que tu veux pour la VM : `192.168.1.100`
- [EDIT] Masque réseau : `255.255.255.0` (ou `/24`)
- [EDIT] Passerelle (Box) : `192.168.1.1`
- [EDIT] DNS pour Internet : `8.8.8.8`

**[ATTENTION] Vérifie que `192.168.1.100` est libre :**

```bash
ping 192.168.1.100 -c 4
```

**Si aucune réponse :** L'IP est libre [OK]  
**Si réponse :** Choisis une autre IP (ex: `192.168.1.101`)

---

### [OUTIL] Configuration (Netplan - Ubuntu/Debian récent)

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

**Contenu :**

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      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
```

**[ATTENTION] PERSONNALISE :**
- `192.168.1.100` -> L'IP que tu veux pour ta VM
- `192.168.1.1` -> L'IP de ta Box (trouvée à l'ÉTAPE 0)

**Appliquer :**
```bash
sudo netplan apply
```

**Vérifier :**
```bash
ip a | grep eth0
```

**Résultat attendu :**
```
inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0
```

---

## [OK] ÉTAPE 5 : VÉRIFIER QUE LE DNS FONCTIONNE SUR LA VM

**Avant de configurer ta machine physique**, assure-toi que ton serveur DNS fonctionne.

### Test depuis la VM elle-même

```bash
# Test avec DNSmasq
dig server1.local @localhost

# Test avec BIND9
dig server1.local @192.168.1.100
```

**Résultat attendu :**
```
;; ANSWER SECTION:
server1.local.    604800    IN    A    192.168.1.100
```

**[OK] Si ça fonctionne :** Ton serveur DNS est opérationnel

**[X] Si ça ne fonctionne pas :**

```bash
# Vérifier que le service tourne
sudo systemctl status dnsmasq    # ou bind9

# Vérifier le port 53
sudo netstat -tulpn | grep :53
```

---

## [OK] ÉTAPE 6 : CONFIGURER LE DNS SUR LA MACHINE PHYSIQUE

**MAINTENANT ET SEULEMENT MAINTENANT**, tu peux configurer ta machine physique.

### Sur Windows

**1. Ouvrir les paramètres réseau**

```
Win + R -> ncpa.cpl -> Entrée
```

**2. Configurer**

- Clique droit sur ta carte réseau -> **Propriétés**
- Double-clique sur **"Protocole Internet version 4 (TCP/IPv4)"**
- Sélectionne **"Utiliser l'adresse de serveur DNS suivante"**

**Remplis :**
```
Serveur DNS préféré:   192.168.1.100
Serveur DNS auxiliaire: 8.8.8.8
```

**3. Vider le cache DNS**

```cmd
ipconfig /flushdns
```

---

### Sur Mac

**1. Préférences Système -> Réseau**

**2. Sélectionne ta connexion -> Avancé**

**3. Onglet DNS**

**4. Clique sur le "+"**

Ajoute :
```
192.168.1.100
8.8.8.8
```

**5. Vider le cache**

```bash
sudo dscacheutil -flushcache
sudo killall -HUP mDNSResponder
```

---

## [OK] ÉTAPE 7 : TEST FINAL

### Test 1 : Avec nslookup (forcer le DNS de la VM)

```cmd
nslookup server1.local 192.168.1.100
```

**Résultat attendu :**
```
Serveur :   Unknown
Address:    192.168.1.100

Nom :    server1.local
Address:  192.168.1.100
```

[OK] **Si ça fonctionne :** Ton DNS répond correctement

---

### Test 2 : Ping avec le nom

```cmd
ping server1.local
```

**Résultat attendu :**
```
PING server1.local (192.168.1.100): 56 data bytes
64 bytes from 192.168.1.100: icmp_seq=0 ttl=64 time=0.5 ms
```

[OK] **Si ça fonctionne :** BRAVO ! Tout est opérationnel !

---

## [GRAPHIQUE] RÉCAPITULATIF COMPLET (Ordre correct)

| Étape | Action | Où ? | Requis pour passer à l'étape suivante |
|-------|--------|------|--------------------------------------|
| **0** | Noter IP machine physique, passerelle, masque | Machine physique | [OK] Tu connais ton réseau |
| **1** | Configurer VirtualBox en mode pont | VirtualBox | [OK] VM a une IP `192.168.1.X` |
| **2** | Vérifier l'IP de la VM | VM Linux | [OK] IP dans la bonne plage |
| **3** | Tester ping bidirectionnel | Les 2 | [OK] Les 2 machines communiquent |
| **4** | Fixer l'IP de la VM | VM Linux | [OK] IP stable (`192.168.1.100`) |
| **5** | Installer et configurer DNS | VM Linux | [OK] DNS répond sur la VM |
| **6** | Configurer DNS sur machine physique | Machine physique | [OK] Machine pointe vers `192.168.1.100` |
| **7** | Tester résolution DNS | Machine physique | [OK] `ping server1.local` fonctionne |

---

## [BRAVO] CONCLUSION

**Tu avais absolument raison !**

On ne peut PAS tester la communication DNS à l'étape 4 sans avoir :
1. [OK] Vérifié que les machines communiquent (ping)
2. [OK] Configuré le DNS sur la machine physique

**L'ordre correct est :**
1. Communication réseau (ping)
2. Configuration DNS sur la VM
3. **ENSUITE** configuration DNS sur la machine physique
4. **ENFIN** test de résolution DNS

Merci d'avoir posé cette excellente question ! [MERCI]


# [WEB] GUIDE COMPLET : Configurer un serveur web et y accéder via `http://web.local`

## [OBJECTIF] CE QUE TU VAS FAIRE

```
┌─────────────────────────────────────────────────┐
│  [CODE] MACHINE PHYSIQUE                            │
│                                                 │
│  Navigateur: http://web.local                   │
│              │                                  │
│              │ Requête DNS                      │
│              [BLACK_DOWN-POINTING_TRIANGLE]                                  │
│  DNS: "web.local = 192.168.1.100"              │
│              │                                  │
│              │ Connexion HTTP                   │
│              [BLACK_DOWN-POINTING_TRIANGLE]                                  │
└──────────────┼──────────────────────────────────┘
               │
               │ Réseau local
               [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────┐
│  [LINUX] VM LINUX (192.168.1.100)                    │
│                                                 │
│  [OK] Serveur DNS (DNSmasq/BIND9)                │
│  [OK] Serveur WEB (Apache/Nginx)                 │
│  [OK] Page web accessible                        │
│                                                 │
└─────────────────────────────────────────────────┘
```

**Résultat final :** Tu tapes `http://web.local` dans ton navigateur -> La page s'affiche ! [BRAVO]

---

## [LISTE] PRÉREQUIS

Avant de commencer, assure-toi que :

- [ ] Ta VM est en mode **"Accès par pont"** (Bridge)
- [ ] Ta VM a une IP fixe (`192.168.1.100`)
- [ ] Le ping fonctionne : Machine physique <-> VM
- [ ] Ton serveur DNS (DNSmasq ou BIND9) fonctionne
- [ ] Ta machine physique utilise le DNS de la VM (`192.168.1.100`)

**Si tu n'as pas fait ces étapes, retourne à la réponse précédente ! ^**

---

## [RAPIDE] MÉTHODE 1 : AVEC APACHE (Le plus populaire)

### [PACKAGE] ÉTAPE 1 : Installation d'Apache

**Sur ta VM Linux**, ouvre un terminal :

```bash
sudo apt update
sudo apt install apache2 -y
```

**Explication :**
- `apt update` = Met à jour la liste des paquets disponibles
- `apt install apache2` = Installe le serveur web Apache
- `-y` = Répond "oui" automatiquement

**Durée :** ~1-2 minutes

---

### [OK] ÉTAPE 2 : Vérifier qu'Apache est démarré

```bash
sudo systemctl status apache2
```

**Résultat attendu :**
```
[BLACK_CIRCLE] apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled)
     Active: active (running) since...
              ^^^^^^
          C'EST BON ! [OK]
```

**Si "inactive" ou "failed" :**
```bash
sudo systemctl start apache2
sudo systemctl enable apache2
```

---

### [HOT] ÉTAPE 3 : Configurer le pare-feu (si UFW est actif)

**Vérifier si le pare-feu est actif :**
```bash
sudo ufw status
```

**Si "Status: active" :**
```bash
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
```

**Explication :**
- Port `80` = HTTP (web normal)
- Port `443` = HTTPS (web sécurisé)

---

### [TEST] ÉTAPE 4 : Premier test (avec l'IP)

**Sur ta machine physique**, ouvre un navigateur :

```
http://192.168.1.100
```

**[ATTENTION] REMPLACE `192.168.1.100` par l'IP de ta VM**

**Résultat attendu :**

Tu devrais voir la **page par défaut d'Apache** :

```
┌───────────────────────────────────────┐
│   Apache2 Default Page                │
│   It works!                           │
│                                       │
│   If you can see this, Apache is     │
│   working correctly.                  │
└───────────────────────────────────────┘
```

**[OK] Si tu vois cette page :** Apache fonctionne !

**[X] Si ça ne fonctionne pas :**

#### Dépannage immédiat

**1. Vérifier qu'Apache écoute sur le port 80 :**
```bash
sudo netstat -tulpn | grep :80
```

**Résultat attendu :**
```
tcp6  0  0 :::80  :::*  LISTEN  1234/apache2
```

**2. Vérifier les logs d'erreur :**
```bash
sudo tail -f /var/log/apache2/error.log
```

**3. Tester depuis la VM elle-même :**
```bash
curl localhost
```

---

## [LABEL] ÉTAPE 5 : Configurer le DNS pour `web.local`

Maintenant, on va faire en sorte que `web.local` pointe vers `192.168.1.100`.

---

### Avec DNSmasq

**Éditer le fichier hosts :**
```bash
sudo nano /etc/hosts.dnsmasq
```

**Ajouter cette ligne :**
```
192.168.1.100  web.local  web
```

**Structure complète du fichier :**
```
192.168.1.100  server1.local  server1
192.168.1.100  web.local      web
192.168.1.101  server2.local  server2
```

**[IDEE] Note :** `server1.local` et `web.local` pointent vers la **même IP** !

**Redémarrer DNSmasq :**
```bash
sudo systemctl restart dnsmasq
```

**Vérifier :**
```bash
dig web.local @localhost
```

**Résultat attendu :**
```
;; ANSWER SECTION:
web.local.    0    IN    A    192.168.1.100
```

---

### Avec BIND9

**Éditer le fichier de zone :**
```bash
sudo nano /etc/bind/db.local
```

**Ajouter cette ligne (avant la fin du fichier) :**
```
web     IN      A       192.168.1.100
```

**Structure complète :**
```
$TTL    604800
@       IN      SOA     ns1.local. admin.local. (
                              2024120601         ; Serial (INCRÉMENTER!)
                         604800
                          86400
                        2419200
                         604800 )
;
@       IN      NS      ns1.local.
ns1     IN      A       192.168.1.100
server1 IN      A       192.168.1.100
web     IN      A       192.168.1.100
server2 IN      A       192.168.1.101
```

**[ATTENTION] IMPORTANT :** Incrémenter le Serial (`2024120601` -> `2024120602`)

**Vérifier la syntaxe :**
```bash
sudo named-checkzone local /etc/bind/db.local
```

**Résultat attendu :**
```
zone local/IN: loaded serial 2024120602
OK
```

**Redémarrer BIND9 :**
```bash
sudo systemctl restart bind9
```

**Vérifier :**
```bash
dig web.local @192.168.1.100
```

---

## [TEST] ÉTAPE 6 : Tester la résolution DNS depuis la machine physique

**Sur ta machine physique :**

### Windows :
```cmd
nslookup web.local
```

### Mac/Linux :
```bash
dig web.local
```

**Résultat attendu :**
```
Name:    web.local
Address: 192.168.1.100
```

**[OK] Si ça fonctionne :** Parfait ! Le DNS résout `web.local`

**[X] Si ça ne fonctionne pas :**

```cmd
# Vider le cache DNS
ipconfig /flushdns    # Windows
sudo dscacheutil -flushcache  # Mac

# Tester en forçant le serveur DNS
nslookup web.local 192.168.1.100
```

---

## [WEB] ÉTAPE 7 : TEST FINAL - Accéder au site web

**Sur ta machine physique**, ouvre un navigateur :

```
http://web.local
```

**[BRAVO] RÉSULTAT ATTENDU :**

Tu devrais voir la **page par défaut d'Apache** !

```
┌───────────────────────────────────────┐
│   [OK] http://web.local                 │
├───────────────────────────────────────┤
│   Apache2 Default Page                │
│   It works!                           │
│                                       │
│   This is the default welcome page    │
└───────────────────────────────────────┘
```

**[OK] SI ÇA FONCTIONNE : FÉLICITATIONS !** [BRAVO]

Tu as réussi à :
- Installer un serveur web
- Configurer le DNS
- Accéder au site via un nom de domaine local

---

## [DESIGN] ÉTAPE 8 : Créer ta propre page web

Maintenant, remplaçons la page par défaut par ta propre page.

### [DOSSIER] Où sont les fichiers web ?

Apache stocke les fichiers dans :
```
/var/www/html/
```

**Voir les fichiers actuels :**
```bash
ls -la /var/www/html/
```

**Résultat :**
```
-rw-r--r-- 1 root root 10918 index.html
```

---

### [EDIT] Créer une page personnalisée

**Méthode 1 : Éditer directement**

```bash
sudo nano /var/www/html/index.html
```

**Remplacer le contenu par :**

```html
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Mon Serveur Web Local</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
        }
        .container {
            text-align: center;
            background: rgba(255, 255, 255, 0.1);
            padding: 50px;
            border-radius: 20px;
            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
        }
        h1 {
            font-size: 3em;
            margin: 0;
        }
        p {
            font-size: 1.2em;
            margin-top: 20px;
        }
        .info {
            margin-top: 30px;
            background: rgba(255, 255, 255, 0.2);
            padding: 20px;
            border-radius: 10px;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>[BRAVO] Ça fonctionne !</h1>
        <p>Bienvenue sur mon serveur web local</p>
        <div class="info">
            <p><strong>Serveur:</strong> Apache sur Ubuntu</p>
            <p><strong>DNS:</strong> web.local</p>
            <p><strong>IP:</strong> 192.168.1.100</p>
        </div>
    </div>
</body>
</html>
```

**Sauvegarder :** `Ctrl + O` -> `Entrée` -> `Ctrl + X`

---

**Méthode 2 : Créer un fichier séparé**

```bash
# Sauvegarder l'ancien fichier
sudo mv /var/www/html/index.html /var/www/html/index.html.backup

# Créer le nouveau
sudo nano /var/www/html/index.html
```

(Coller le contenu HTML ci-dessus)

---

### [SYNC] Actualiser le navigateur

Retourne dans ton navigateur et actualise (`F5` ou `Ctrl + R`) :

```
http://web.local
```

**[DESIGN] Tu devrais voir ta nouvelle page avec un fond violet et un design moderne !**

---

## [RAPIDE] BONUS : Créer plusieurs pages

### [FICHIER] Créer une page "À propos"

```bash
sudo nano /var/www/html/about.html
```

**Contenu :**

```html
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>À propos</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background: #1a1a2e;
            color: white;
            padding: 50px;
        }
        h1 { color: #16db93; }
        a { color: #16db93; text-decoration: none; }
    </style>
</head>
<body>
    <h1>À propos de ce serveur</h1>
    <p>Ceci est un serveur web local configuré avec Apache sur une VM Ubuntu.</p>
    <p><a href="index.html"><- Retour à l'accueil</a></p>
</body>
</html>
```

**Accéder à cette page :**
```
http://web.local/about.html
```

---

## [OUTIL] MÉTHODE 2 : AVEC NGINX (Alternative moderne)

Si tu préfères Nginx (plus rapide et léger) :

### [PACKAGE] Installation

```bash
sudo apt update
sudo apt install nginx -y
```

### [OK] Vérifier le statut

```bash
sudo systemctl status nginx
```

### [HOT] Configurer le pare-feu

```bash
sudo ufw allow 'Nginx HTTP'
```

### [DOSSIER] Fichiers web

Nginx utilise le même répertoire :
```
/var/www/html/
```

**Tout le reste est identique à Apache !**

---

## [GRAPHIQUE] COMPARAISON Apache vs Nginx

| Critère | Apache | Nginx |
|---------|--------|-------|
| **Popularité** | ***** | **** |
| **Facilité** | **** Facile | *** Moyen |
| **Performance** | *** Bon | ***** Excellent |
| **Ressources** | Moyen | Léger |
| **Configuration** | `.htaccess` possible | Config centralisée |
| **Meilleur pour** | Débutants, CMS | Sites modernes, proxy |

**Recommandation pour débuter :** Apache (plus de documentation, plus simple)

---

## 🆘 DÉPANNAGE COMPLET

### [X] "Ce site est inaccessible" dans le navigateur

**Causes possibles :**

1. **Le DNS ne résout pas `web.local`**

**Test :**
```bash
nslookup web.local
```

**Si erreur "can't find web.local" :**
- Retourne à l'ÉTAPE 5 (Configuration DNS)
- Vérifie que ta machine physique utilise bien `192.168.1.100` comme DNS

---

2. **Apache/Nginx n'est pas démarré**

**Test :**
```bash
sudo systemctl status apache2
```

**Si "inactive" :**
```bash
sudo systemctl start apache2
sudo systemctl enable apache2
```

---

3. **Le pare-feu bloque le port 80**

**Sur la VM :**
```bash
sudo ufw status
sudo ufw allow 80/tcp
```

**Sur Windows (machine physique) :**
- Désactive temporairement le pare-feu pour tester
- Panneau de configuration -> Pare-feu Windows -> Désactiver

---

4. **Mauvaise IP dans le DNS**

**Vérifier :**
```bash
dig web.local @192.168.1.100
```

**Doit afficher :**
```
web.local.    0    IN    A    192.168.1.100
```

---

### [X] La page s'affiche avec l'IP mais pas avec `web.local`

**Cause :** Problème de DNS uniquement

**Solution :**

**1. Vérifier que ta machine physique utilise le bon DNS**

**Windows :**
```cmd
ipconfig /all
```

Cherche :
```
Serveurs DNS. . . . . . . . . . . . : 192.168.1.100
```

**Si ce n'est pas le cas :**
- Retourne à la configuration DNS de ta carte réseau
- Vérifie que `192.168.1.100` est en **premier**

**2. Vider le cache DNS**

```cmd
ipconfig /flushdns
```

**3. Tester en forçant le DNS**

```cmd
nslookup web.local 192.168.1.100
```

**Si ça fonctionne avec cette commande mais pas dans le navigateur :**
- Redémarre ton navigateur
- Essaye en navigation privée (`Ctrl + Shift + N`)

---

### [X] "403 Forbidden" dans le navigateur

**Cause :** Problème de permissions

**Solution :**

```bash
# Vérifier les permissions
ls -la /var/www/html/

# Corriger si nécessaire
sudo chmod 755 /var/www/html
sudo chmod 644 /var/www/html/index.html
sudo chown -R www-data:www-data /var/www/html
```

---

### [X] "404 Not Found" pour une page

**Cause :** Le fichier n'existe pas ou mauvais nom

**Vérifier :**
```bash
ls -la /var/www/html/
```

**Exemple :**
- URL : `http://web.local/about.html`
- Fichier doit être : `/var/www/html/about.html`

---

## [COURS] COMMANDES UTILES À RETENIR

### Gestion Apache

```bash
# Démarrer
sudo systemctl start apache2

# Arrêter
sudo systemctl stop apache2

# Redémarrer
sudo systemctl restart apache2

# Voir le statut
sudo systemctl status apache2

# Voir les logs en temps réel
sudo tail -f /var/log/apache2/access.log
sudo tail -f /var/log/apache2/error.log
```

---

### Gestion Nginx

```bash
# Démarrer
sudo systemctl start nginx

# Arrêter
sudo systemctl stop nginx

# Redémarrer
sudo systemctl restart nginx

# Recharger config (sans interrompre)
sudo nginx -s reload

# Tester la config
sudo nginx -t
```

---

### Gestion des fichiers web

```bash
# Aller dans le répertoire web
cd /var/www/html/

# Lister les fichiers
ls -la

# Éditer la page principale
sudo nano index.html

# Voir les permissions
ls -l

# Donner les bonnes permissions
sudo chown -R www-data:www-data /var/www/html
sudo chmod -R 755 /var/www/html
sudo chmod 644 /var/www/html/*.html
```

---

## [BRAVO] CHECKLIST FINALE

- [ ] Apache/Nginx installé et démarré
- [ ] Page par défaut accessible via `http://192.168.1.100`
- [ ] DNS configuré (`web.local` -> `192.168.1.100`)
- [ ] Résolution DNS fonctionne (`nslookup web.local`)
- [ ] Site accessible via `http://web.local`
- [ ] Page personnalisée créée et affichée
- [ ] Pare-feu configuré (port 80 ouvert)

---

## [RAPIDE] PROCHAINES ÉTAPES POSSIBLES

### 1⃣ Installer PHP (pour sites dynamiques)

```bash
sudo apt install php libapache2-mod-php -y
sudo systemctl restart apache2
```

**Tester PHP :**
```bash
echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php
```

Accède à : `http://web.local/info.php`

---

### 2⃣ Installer un CMS (WordPress, etc.)

```bash
# Installer MySQL
sudo apt install mysql-server -y

# Installer phpmyadmin
sudo apt install phpmyadmin -y
```

---

### 3⃣ Configurer HTTPS (SSL)

```bash
# Créer un certificat auto-signé
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /etc/ssl/private/web.local.key \
  -out /etc/ssl/certs/web.local.crt
```

---

### 4⃣ Créer plusieurs sites (Virtual Hosts)

```bash
# Créer un nouveau site
sudo mkdir -p /var/www/site2
sudo nano /etc/apache2/sites-available/site2.conf
```

---

## [GUIDE] RÉSUMÉ POUR RETENIR

**Ce que tu as appris :**

1. [OK] Installer un serveur web (Apache/Nginx)
2. [OK] Configurer le DNS pour un nom de domaine local
3. [OK] Créer et personnaliser des pages HTML
4. [OK] Gérer les services système avec `systemctl`
5. [OK] Dépanner les problèmes de connexion

**Architecture complète :**
```
Navigateur -> DNS (web.local) -> Serveur Web -> Page HTML
```

**Félicitations ! Tu as maintenant un serveur web local fonctionnel ! [BRAVO]**

# [OBJECTIF] EXCELLENTE QUESTION ! OUI, absolument !

## [OK] RÉPONSE COURTE

**OUI !** Juste après `sudo apt install apache2 -y`, **SANS toucher AUCUN fichier de configuration**, tu peux directement accéder à `http://192.168.1.100` depuis ta machine physique et voir la page par défaut d'Apache.

---

## [LOGIQUE] POURQUOI ÇA FONCTIONNE AUTOMATIQUEMENT ?

### [PACKAGE] Ce que fait `apt install apache2` automatiquement :

```
┌─────────────────────────────────────────────┐
│  apt install apache2                        │
└─────────────────┬───────────────────────────┘
                  │
                  ├─[BLACK_RIGHT-POINTING_POINTER] 1. Télécharge Apache
                  │
                  ├─[BLACK_RIGHT-POINTING_POINTER] 2. Installe Apache
                  │
                  ├─[BLACK_RIGHT-POINTING_POINTER] 3. Crée la configuration par défaut
                  │      /etc/apache2/apache2.conf
                  │      /etc/apache2/sites-available/000-default.conf
                  │
                  ├─[BLACK_RIGHT-POINTING_POINTER] 4. Crée la page par défaut
                  │      /var/www/html/index.html
                  │
                  ├─[BLACK_RIGHT-POINTING_POINTER] 5. DÉMARRE Apache automatiquement
                  │      (systemctl start apache2)
                  │
                  ├─[BLACK_RIGHT-POINTING_POINTER] 6. Active le démarrage au boot
                  │      (systemctl enable apache2)
                  │
                  └─[BLACK_RIGHT-POINTING_POINTER] 7. Configure Apache pour écouter sur :
                         - Port 80 (HTTP)
                         - Toutes les interfaces (0.0.0.0)
```

---

## [RECHERCHE] VÉRIFICATION ÉTAPE PAR ÉTAPE

### Test 1 : Apache est-il démarré ?

```bash
sudo systemctl status apache2
```

**Résultat attendu (juste après installation) :**

```
[BLACK_CIRCLE] apache2.service - The Apache HTTP Server
     Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2024-12-06 10:30:15 UTC; 2min ago
              ^^^^^^ ^^^^^^^
              DÉJÀ ACTIF ! [OK]
       Docs: https://httpd.apache.org/docs/2.4/
    Process: 1234 ExecStart=/usr/sbin/apachectl start (code=exited, status=0/SUCCESS)
   Main PID: 1235 (apache2)
      Tasks: 55 (limit: 2339)
     Memory: 5.2M
        CPU: 50ms
     CGroup: /system.slice/apache2.service
             ├─1235 /usr/sbin/apache2 -k start
             ├─1236 /usr/sbin/apache2 -k start
             └─1237 /usr/sbin/apache2 -k start
```

**[IDEE] Conclusion :** Apache est **déjà démarré** et **activé au boot** !

---

### Test 2 : Apache écoute-t-il sur le port 80 ?

```bash
sudo netstat -tulpn | grep :80
```

**Résultat attendu :**

```
tcp6  0  0 :::80  :::*  LISTEN  1235/apache2
         ^^^
    ÉCOUTE SUR LE PORT 80 [OK]
```

**Explication :**
- `:::80` = Écoute sur **toutes les interfaces IPv6 ET IPv4**
- `LISTEN` = En attente de connexions
- `apache2` = C'est bien Apache qui écoute

---

### Test 3 : La page par défaut existe-t-elle ?

```bash
ls -la /var/www/html/
```

**Résultat attendu :**

```
total 12
drwxr-xr-x 2 root root 4096 Dec  6 10:30 .
drwxr-xr-x 3 root root 4096 Dec  6 10:30 ..
-rw-r--r-- 1 root root 10918 Dec  6 10:30 index.html
                                          ^^^^^^^^^^
                             FICHIER DÉJÀ CRÉÉ ! [OK]
```

**Voir le contenu :**

```bash
cat /var/www/html/index.html
```

**Extrait du contenu :**

```html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" ...>
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <title>Apache2 Ubuntu Default Page: It works</title>
    ...
  </head>
  <body>
    <div class="main_page">
      <div class="page_header floating_element">
        <img src="/icons/ubuntu-logo.png" alt="Ubuntu Logo" />
      </div>
      <div class="content_section floating_element">
        <div class="section_header section_header_red">
          <div id="about"></div>
          It works!
        </div>
        <div class="content_section_text">
          <p>
            This is the default welcome page used to test the correct 
            operation of the Apache2 server after installation on Ubuntu systems.
          </p>
          ...
        </div>
      </div>
    </div>
  </body>
</html>
```

**[IDEE] Conclusion :** La page HTML par défaut est **déjà présente** !

---

### Test 4 : Apache répond-il localement (sur la VM) ?

**Sur la VM**, teste avec `curl` :

```bash
curl localhost
```

**ou**

```bash
curl 127.0.0.1
```

**Résultat attendu :**

```html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" ...>
<html xmlns="http://www.w3.org/1999/xhtml">
  ...
  It works!
  ...
</html>
```

**[IDEE] Conclusion :** Apache répond **localement** sur la VM ! [OK]

---

### Test 5 : Apache répond-il sur l'IP réseau ?

**Toujours sur la VM**, teste avec ton IP :

```bash
curl 192.168.1.100
```

**Résultat attendu :**

```html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" ...>
  ...
  It works!
  ...
</html>
```

**[IDEE] Conclusion :** Apache répond aussi sur l'**IP réseau** ! [OK]

---

## [WEB] TEST FINAL : Depuis ta machine physique

### Sur Windows

**Ouvre un navigateur (Chrome, Firefox, Edge, etc.)**

```
http://192.168.1.100
```

**OU teste en ligne de commande :**

```cmd
curl http://192.168.1.100
```

**Si `curl` n'existe pas sur Windows :**

```powershell
Invoke-WebRequest -Uri http://192.168.1.100
```

---

### Sur Mac/Linux

**Dans le navigateur :**

```
http://192.168.1.100
```

**En ligne de commande :**

```bash
curl http://192.168.1.100
```

---

## [OBJECTIF] RÉSULTAT ATTENDU DANS LE NAVIGATEUR

```
┌───────────────────────────────────────────────────┐
│  [WEB] http://192.168.1.100                          │
├───────────────────────────────────────────────────┤
│                                                   │
│   [Ubuntu Logo]                                   │
│                                                   │
│   Apache2 Ubuntu Default Page                     │
│   ═══════════════════════════════                │
│                                                   │
│   It works!                                       │
│                                                   │
│   This is the default welcome page used to test   │
│   the correct operation of the Apache2 server     │
│   after installation on Ubuntu systems.           │
│                                                   │
│   If you can read this page, it means that the    │
│   Apache HTTP server installed at this site is    │
│   working properly.                               │
│                                                   │
│   Configuration Overview                          │
│   ────────────────────                           │
│                                                   │
│   Ubuntu's Apache2 default configuration is       │
│   different from the upstream default...          │
│                                                   │
└───────────────────────────────────────────────────┘
```

**[OK] Si tu vois cette page : C'EST BON !**

---

## [INTERDIT] SEULE EXCEPTION : Le pare-feu

### [ATTENTION] Si le pare-feu UFW est actif

**Vérifier :**

```bash
sudo ufw status
```

**Si "Status: active" :**

```
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
```

**[X] Problème :** Le port 80 n'est **PAS autorisé**

**Solution :**

```bash
sudo ufw allow 80/tcp
```

**Résultat :**

```
Rule added
Rule added (v6)
```

**Vérifier à nouveau :**

```bash
sudo ufw status
```

**Maintenant :**

```
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere    <- AJOUTÉ [OK]
```

**Retester depuis ta machine physique :**

```
http://192.168.1.100
```

**[OK] Devrait fonctionner maintenant !**

---

## [GRAPHIQUE] RÉCAPITULATIF : Que se passe-t-il automatiquement ?

| Étape | Action | Automatique ? | Fichier/Service concerné |
|-------|--------|--------------|--------------------------|
| **1** | Installation des binaires Apache | [OK] OUI | `/usr/sbin/apache2` |
| **2** | Création de la configuration par défaut | [OK] OUI | `/etc/apache2/apache2.conf` |
| **3** | Activation du site par défaut | [OK] OUI | `/etc/apache2/sites-enabled/000-default.conf` |
| **4** | Création du répertoire web | [OK] OUI | `/var/www/html/` |
| **5** | Création de la page par défaut | [OK] OUI | `/var/www/html/index.html` |
| **6** | Démarrage du service | [OK] OUI | `systemctl start apache2` |
| **7** | Activation au boot | [OK] OUI | `systemctl enable apache2` |
| **8** | Écoute sur port 80 | [OK] OUI | Configuration par défaut |
| **9** | Écoute sur toutes les interfaces | [OK] OUI | `Listen 0.0.0.0:80` |
| **10** | Autorisation pare-feu | [X] **MANUEL** | `ufw allow 80/tcp` |

---

## [COURS] CONCLUSION

### [OK] OUI, tu peux accéder à `http://192.168.1.100` IMMÉDIATEMENT après installation

**Conditions :**
1. [OK] Ta VM a l'IP `192.168.1.100`
2. [OK] Ta VM et ta machine physique sont sur le même réseau (mode pont)
3. [OK] Le pare-feu UFW est désactivé OU le port 80 est autorisé

**SANS toucher :**
- [X] Aucun fichier de configuration Apache
- [X] Aucun fichier HTML
- [X] Aucun Virtual Host
- [X] Aucun module Apache

**Tout est déjà configuré et opérationnel par défaut !** [BRAVO]

---

## 🆘 SI ÇA NE FONCTIONNE PAS

### Checklist de dépannage

```bash
# 1. Apache est-il installé ?
dpkg -l | grep apache2

# 2. Apache est-il démarré ?
sudo systemctl status apache2

# 3. Apache écoute-t-il sur le port 80 ?
sudo netstat -tulpn | grep :80

# 4. La page existe-t-elle ?
ls -la /var/www/html/index.html

# 5. Pare-feu actif ?
sudo ufw status

# 6. Test local (sur la VM)
curl localhost

# 7. Test avec l'IP (sur la VM)
curl 192.168.1.100

# 8. Ping depuis la machine physique
ping 192.168.1.100

# 9. Test HTTP depuis la machine physique
curl http://192.168.1.100
```

**Si tous ces tests passent SAUF le dernier :**
- Problème de pare-feu sur la machine physique (Windows Defender)
- Problème de proxy/VPN

---

**[BRAVO] Voilà ! Maintenant tu sais EXACTEMENT pourquoi ça fonctionne immédiatement après installation !**


# [OBJECTIF] EXCELLENTE QUESTION TECHNIQUE !

## [OK] RÉPONSE DIRECTE

**Apache le fait AUTOMATIQUEMENT !** [BRAVO]

Tu n'as **RIEN à configurer manuellement**. Après `sudo apt install apache2`, Apache est déjà configuré pour écouter sur le port 80 et sur toutes les interfaces.

---

## [RECHERCHE] PREUVE : Regardons la configuration par défaut

### [FICHIER] Fichier 1 : `/etc/apache2/ports.conf`

Ce fichier est **créé automatiquement** lors de l'installation.

**Voir le contenu :**

```bash
cat /etc/apache2/ports.conf
```

**Contenu par défaut (SANS modification) :**

```apache
# If you just change the port or add more ports here, you will likely also
# have to change the VirtualHost statement in
# /etc/apache2/sites-enabled/000-default.conf

Listen 80
  ^^^^^^^
  DÉJÀ CONFIGURÉ AUTOMATIQUEMENT ! [OK]

<IfModule ssl_module>
        Listen 443
</IfModule>

<IfModule mod_gnutls.c>
        Listen 443
</IfModule>

# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
```

**Explication :**

- `Listen 80` = **Écoute sur le port 80**
- Sans IP spécifiée = **Écoute sur TOUTES les interfaces** (équivalent à `0.0.0.0:80`)

---

### [FICHIER] Fichier 2 : `/etc/apache2/sites-available/000-default.conf`

Ce fichier définit le **Virtual Host par défaut**.

**Voir le contenu :**

```bash
cat /etc/apache2/sites-available/000-default.conf
```

**Contenu par défaut (SANS modification) :**

```apache
<VirtualHost *:80>
        # The ServerName directive sets the request scheme, hostname and port that
        # the server uses to identify itself. This is used when creating
        # redirection URLs. In the context of virtual hosts, the ServerName
        # specifies what hostname must appear in the request's Host: header to
        # match this virtual host. For the default virtual host (this file) this
        # value is not decisive as it is used as a last resort host regardless.
        # However, you must set it for any further virtual host explicitly.
        #ServerName www.example.com

        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html
                     ^^^^^^^^^^^^^
                     RÉPERTOIRE WEB PAR DÉFAUT [OK]

        # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
        # error, crit, alert, emerg.
        # It is also possible to configure the loglevel for particular
        # modules, e.g.
        #LogLevel info ssl:warn

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined

        # For most configuration files from conf-available/, which are
        # enabled or disabled at a global level, it is possible to
        # include a line for only one particular virtual host. For example the
        # following line enables the CGI configuration for this host only
        # after it has been globally disabled with "a2disconf".
        #Include conf-available/serve-cgi-bin.conf
</VirtualHost>

# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
```

**Explication :**

- `<VirtualHost *:80>` = **Accepte les connexions sur toutes les interfaces (`*`) sur le port 80**
- `DocumentRoot /var/www/html` = **Répertoire où se trouvent les fichiers web**

---

## [TEST] VÉRIFICATION PRATIQUE

### Test 1 : Vérifier que Apache écoute sur le port 80

```bash
sudo netstat -tulpn | grep :80
```

**Résultat (juste après installation, SANS config manuelle) :**

```
tcp6  0  0 :::80  :::*  LISTEN  1234/apache2
         ^^^^^
    PORT 80 [OK]
```

**Explication de `:::80` :**

- `::` = Adresse IPv6 "toutes les interfaces" (équivalent IPv6 de `0.0.0.0`)
- `:80` = Port 80
- Sur Linux, écouter sur `:::80` (IPv6) **inclut automatiquement IPv4** grâce à `IPV6_V6ONLY=0`

**Cela signifie qu'Apache écoute sur :**
- [OK] `0.0.0.0:80` (toutes interfaces IPv4)
- [OK] `[::]:80` (toutes interfaces IPv6)
- [OK] `127.0.0.1:80` (localhost IPv4)
- [OK] `192.168.1.100:80` (ton IP réseau)
- [OK] `[::1]:80` (localhost IPv6)

---

### Test 2 : Vérifier avec `ss` (alternative moderne à netstat)

```bash
sudo ss -tlnp | grep :80
```

**Résultat :**

```
LISTEN  0  511  *:80  *:*  users:(("apache2",pid=1234,fd=4))
            ^^^  ^^^
         PORT 80  TOUTES INTERFACES [OK]
```

---

### Test 3 : Vérifier avec `lsof`

```bash
sudo lsof -i :80
```

**Résultat :**

```
COMMAND   PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
apache2  1234     root    4u  IPv6  12345      0t0  TCP *:http (LISTEN)
apache2  1235 www-data    4u  IPv6  12345      0t0  TCP *:http (LISTEN)
apache2  1236 www-data    4u  IPv6  12345      0t0  TCP *:http (LISTEN)
                                                       ^^^^^^^^^^
                                               *:http = 0.0.0.0:80 [OK]
```

---

## [DESIGN] SCHÉMA : Que signifie "écouter sur 0.0.0.0:80" ?

```
┌─────────────────────────────────────────────────┐
│           [ECRAN] VM LINUX (Apache)                  │
│                                                 │
│  Apache écoute sur 0.0.0.0:80                   │
│  (= toutes les interfaces)                      │
│                                                 │
│  ┌─────────────┐                                │
│  │   lo        │  127.0.0.1:80    <- Localhost   │
│  │  (loopback) │  [::1]:80                      │
│  └─────────────┘                                │
│         [BLACK_UP-POINTING_TRIANGLE]                                       │
│         │ Requêtes depuis la VM elle-même       │
│         │ (curl localhost)                      │
│                                                 │
│  ┌─────────────┐                                │
│  │   eth0      │  192.168.1.100:80 <- Réseau     │
│  │  (réseau)   │                                │
│  └─────────────┘                                │
│         [BLACK_UP-POINTING_TRIANGLE]                                       │
│         │ Requêtes depuis d'autres machines     │
│         │ (ta machine physique)                 │
│                                                 │
└─────────┼───────────────────────────────────────┘
          │
          │ Réseau local (192.168.1.0/24)
          │
          [BLACK_DOWN-POINTING_TRIANGLE]
┌─────────────────────────────────────────────────┐
│      [CODE] MACHINE PHYSIQUE                        │
│      (192.168.1.10)                             │
│                                                 │
│  Navigateur: http://192.168.1.100              │
│              ─────────────────────[BLACK_RIGHT-POINTING_POINTER]             │
│              Requête reçue par eth0:80 [OK]       │
└─────────────────────────────────────────────────┘
```

---

## [FACE_WITH_MONOCLE] COMPRENDRE : Pourquoi `0.0.0.0` et pas une IP spécifique ?

### Option 1 : Écouter sur une IP spécifique (RESTRICTIF)

**Si Apache était configuré comme ça :**

```apache
Listen 127.0.0.1:80
```

**Conséquence :**
- [OK] `curl localhost` -> **FONCTIONNE**
- [X] `curl 192.168.1.100` -> **NE FONCTIONNE PAS**
- [X] Depuis ta machine physique -> **NE FONCTIONNE PAS**

**Analogie :** C'est comme une maison qui n'a qu'une porte donnant sur le jardin intérieur. Les visiteurs de la rue ne peuvent pas entrer.

---

### Option 2 : Écouter sur toutes les interfaces (PERMISSIF) <- **C'EST ÇA PAR DÉFAUT**

**Configuration par défaut d'Apache :**

```apache
Listen 80
```

**ou explicitement :**

```apache
Listen 0.0.0.0:80
```

**Conséquence :**
- [OK] `curl localhost` -> **FONCTIONNE**
- [OK] `curl 127.0.0.1` -> **FONCTIONNE**
- [OK] `curl 192.168.1.100` -> **FONCTIONNE**
- [OK] Depuis ta machine physique -> **FONCTIONNE**
- [OK] Depuis n'importe quelle machine du réseau -> **FONCTIONNE**

**Analogie :** C'est comme une maison avec plusieurs portes : une sur rue, une sur jardin, une sur cour. Tout le monde peut entrer.

---

## [DOCS] COMPARAISON : Configurations possibles

| Configuration | Qui peut accéder ? | Cas d'usage |
|--------------|-------------------|-------------|
| `Listen 127.0.0.1:80` | [OK] Localhost uniquement<br>[X] Réseau | Développement local strict |
| `Listen 192.168.1.100:80` | [OK] Localhost<br>[OK] Réseau via cette IP<br>[X] Autres IPs de la VM | Serveur avec IP fixe |
| `Listen 80`<br>(= `0.0.0.0:80`) | [OK] Localhost<br>[OK] Toutes les IPs de la VM<br>[OK] Réseau | **DÉFAUT - Maximum de flexibilité** [OK] |

---

## [OUTIL] SI TU VOULAIS RESTREINDRE (optionnel, pas recommandé pour débuter)

### Exemple : Écouter uniquement sur l'IP réseau

**Éditer :**

```bash
sudo nano /etc/apache2/ports.conf
```

**Modifier :**

```apache
# Avant (par défaut)
Listen 80

# Après (restrictif)
Listen 192.168.1.100:80
```

**Redémarrer :**

```bash
sudo systemctl restart apache2
```

**Conséquence :**
- [OK] `http://192.168.1.100` depuis ta machine physique -> **FONCTIONNE**
- [X] `curl localhost` sur la VM -> **NE FONCTIONNE PLUS**

**[ATTENTION] Pas recommandé pour débuter !**

---

## [COURS] RÉPONSE FINALE À TA QUESTION

### [?] "Doit-on configurer manuellement ou Apache le fait automatiquement ?"

```
┌────────────────────────────────────────────────┐
│  [PACKAGE] sudo apt install apache2                   │
└────────────────┬───────────────────────────────┘
                 │
                 [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────┐
│  [OK] AUTOMATIQUE (créé par l'installation)      │
├────────────────────────────────────────────────┤
│                                                │
│  1. Crée /etc/apache2/ports.conf               │
│     Contenu: Listen 80                         │
│                                                │
│  2. Crée /etc/apache2/sites-available/...     │
│     Contenu: <VirtualHost *:80>                │
│                                                │
│  3. Active le site par défaut                  │
│                                                │
│  4. Démarre Apache                             │
│                                                │
│  Résultat: Apache écoute sur 0.0.0.0:80 [OK]     │
│                                                │
└────────────────────────────────────────────────┘
                 │
                 [BLACK_DOWN-POINTING_TRIANGLE]
┌────────────────────────────────────────────────┐
│  [X] AUCUNE CONFIGURATION MANUELLE NÉCESSAIRE   │
└────────────────────────────────────────────────┘
```

---

## [GRAPHIQUE] RÉCAPITULATIF

| Question | Réponse |
|----------|---------|
| Apache écoute-t-il automatiquement sur le port 80 ? | [OK] **OUI** |
| Apache écoute-t-il automatiquement sur toutes les interfaces ? | [OK] **OUI** (`0.0.0.0` par défaut) |
| Dois-je éditer `/etc/apache2/ports.conf` ? | [X] **NON** (déjà configuré) |
| Dois-je créer un Virtual Host ? | [X] **NON** (000-default.conf existe déjà) |
| Dois-je redémarrer Apache après installation ? | [X] **NON** (déjà démarré automatiquement) |
| Puis-je accéder à `http://192.168.1.100` immédiatement ? | [OK] **OUI** (si pare-feu OK) |

---

## [BRAVO] CONCLUSION

**Apache configure TOUT automatiquement :**

1. [OK] Écoute sur le **port 80**
2. [OK] Écoute sur **toutes les interfaces** (`0.0.0.0`)
3. [OK] Crée un **Virtual Host par défaut**
4. [OK] Crée la **page par défaut** (`index.html`)
5. [OK] **Démarre le service**
6. [OK] **Active au boot**

**TU N'AS RIEN À FAIRE !** [BRAVO]

La seule chose à vérifier : le pare-feu (`sudo ufw allow 80/tcp` si nécessaire).