# [DOCS] GUIDE COMPLET : CONFIGURATION DNS AVEC /etc/hosts, Unbound et systemd-resolved

## [OBJECTIF] INTRODUCTION : TROIS APPROCHES DIFFÉRENTES

Ce guide détaille **3 méthodes alternatives** de configuration DNS pour compléter ce que tu as appris avec BIND9 et DNSmasq.

```
┌────────────────────────────────────────────────────┐
│         MÉTHODES DNS DISPONIBLES                   │
├────────────────────────────────────────────────────┤
│                                                    │
│  Déjà vues:                                        │
│  [OK] BIND9 (professionnel, complexe)                │
│  [OK] DNSmasq (simple, tout-en-un)                   │
│                                                    │
│  Nouvelles méthodes:                               │
│  🆕 /etc/hosts (ultra-simple, statique)            │
│  🆕 Unbound (moderne, sécurisé, performant)        │
│  🆕 systemd-resolved (intégré, automatique)        │
│                                                    │
└────────────────────────────────────────────────────┘
```

---

## [GRAPHIQUE] TABLEAU COMPARATIF GLOBAL

| Critère | /etc/hosts | Unbound | systemd-resolved | DNSmasq | BIND9 |
|---------|------------|---------|------------------|---------|-------|
| **Difficulté** | * Très facile | *** Moyen | ** Facile | * Facile | ***** Difficile |
| **Installation** | Aucune (intégré) | `apt install unbound` | Souvent préinstallé | `apt install dnsmasq` | `apt install bind9` |
| **Performance** | [RAPIDE] Instantané | [RAPIDE][RAPIDE][RAPIDE] Excellent | [RAPIDE][RAPIDE] Bon | [RAPIDE][RAPIDE] Bon | [RAPIDE][RAPIDE][RAPIDE] Excellent |
| **Cache DNS** | [X] Non | [OK] Oui | [OK] Oui | [OK] Oui | [OK] Oui |
| **DNSSEC** | [X] Non | [OK] Oui | [OK] Oui | [X] Non | [OK] Oui |
| **Zones DNS** | [X] Non | [ATTENTION] Limité | [X] Non | [OK] Oui | [OK] Oui (complet) |
| **DHCP** | [X] Non | [X] Non | [X] Non | [OK] Oui | [X] Non |
| **Forwarders** | [X] Non | [OK] Oui | [OK] Oui | [OK] Oui | [OK] Oui |
| **Réseau local** | [OK] Oui (limité) | [OK] Oui | [OK] Oui | [OK] Oui | [OK] Oui |
| **Meilleur pour** | 1-5 entrées | Résolveur pur | Desktop/Laptop | Petit réseau | Entreprise |

---

# - MÉTHODE 1 : /etc/hosts (LA PLUS SIMPLE)

## [BABY_BOTTLE] QU'EST-CE QUE /etc/hosts ?

### [GUIDE] Analogie du carnet d'adresses

**Imagine /etc/hosts comme un petit carnet d'adresses personnel** :

```
┌─────────────────────────────────────┐
│     [CARNET] Carnet /etc/hosts            │
├─────────────────────────────────────┤
│                                     │
│  Jean -> 06 12 34 56 78              │
│  Marie -> 06 98 76 54 32             │
│  Pierre -> 06 11 22 33 44            │
│                                     │
│  Équivalent DNS:                    │
│  server1.local -> 192.168.1.100      │
│  web.local -> 192.168.1.100          │
│  nas.local -> 192.168.1.101          │
│                                     │
└─────────────────────────────────────┘
```

**Différence avec DNS :**
- [CARNET] /etc/hosts = Carnet personnel (local uniquement)
- [WEB] Serveur DNS = Annuaire téléphonique (réseau entier)

### [OBJECTIF] Cas d'usage de /etc/hosts

**[OK] Utilise /etc/hosts quand :**
- Tu as moins de 10 entrées
- Tu ne veux pas installer de logiciel
- Tu veux une solution instantanée
- Tu configures UNE SEULE machine

**[X] N'utilise PAS /etc/hosts quand :**
- Tu as plus de 20 machines sur le réseau
- Tu veux un cache DNS
- Tu as besoin de DNSSEC
- Tu veux une gestion centralisée

---

## [CONFIG] CONFIGURATION DE /etc/hosts

### [DOSSIER] ÉTAPE 1 : Comprendre le fichier

```bash
cat /etc/hosts
```

**Contenu par défaut (Ubuntu/Debian) :**

```bash
127.0.0.1       localhost
127.0.1.1       votre-nom-machine

# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
```

**[GUIDE] Explication ligne par ligne :**

```bash
127.0.0.1       localhost
```
**Ce que ça fait :**
- Associe `localhost` à l'adresse de loopback IPv4
- Permet de faire `ping localhost` ou `ssh localhost`

**Analogie :** C'est ton numéro interne, comme un poste téléphonique interne (ex: poste 100)

```bash
127.0.1.1       votre-nom-machine
```
**Ce que ça fait :**
- Associe le hostname de ta machine à une adresse locale
- Utilisé par certains programmes pour se référer à la machine locale

**Pourquoi 127.0.1.1 et pas 127.0.0.1 ?**
- `127.0.0.1` est **strictement** réservé à `localhost`
- `127.0.1.1` permet d'avoir un hostname différent de localhost
- C'est une convention Ubuntu/Debian

```bash
::1     ip6-localhost ip6-loopback
```
**Ce que ça fait :**
- Équivalent IPv6 de `127.0.0.1`
- `::1` = Adresse de loopback IPv6

---

### [EDIT] ÉTAPE 2 : Ajouter tes propres entrées

#### Sauvegarder le fichier original

```bash
sudo cp /etc/hosts /etc/hosts.backup
```

**Pourquoi ?** Si tu fais une erreur, tu peux restaurer :
```bash
sudo cp /etc/hosts.backup /etc/hosts
```

#### Éditer le fichier

```bash
sudo nano /etc/hosts
```

#### Ajouter tes serveurs

**À la fin du fichier, ajoute :**

```bash
# Serveurs locaux
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
192.168.1.101   server2.local   server2
192.168.1.102   nas.local       nas
192.168.1.103   db.local        db
```

**Structure complète du fichier :**

```bash
127.0.0.1       localhost
127.0.1.1       ma-machine

# Serveurs locaux
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
192.168.1.101   server2.local   server2
192.168.1.102   nas.local       nas

# IPv6
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
```

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

---

### [GUIDE] COMPRENDRE LA SYNTAXE

```bash
192.168.1.100   server1.local   server1
│              │               │
│              │               └─ Alias (raccourci optionnel)
│              └─────────────────── FQDN (nom complet)
└────────────────────────────────── Adresse IP
```

**Règles importantes :**

1. **IP en premier** (obligatoire)
2. **Espaces ou tabulations** comme séparateur
3. **Au moins un nom** (requis)
4. **Plusieurs alias possibles** (optionnel)

**Exemples valides :**

```bash
# Style minimal
192.168.1.100   server1

# Style complet
192.168.1.100   server1.local   server1

# Plusieurs alias
192.168.1.100   server1.local   server1   srv1   web
```

**[ATTENTION] ATTENTION : Une IP peut avoir plusieurs noms**

```bash
# C'EST CORRECT [OK]
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
192.168.1.100   api.local       api

# Équivalent (sur une ligne) [OK]
192.168.1.100   server1.local web.local api.local server1 web api
```

---

## [TEST] ÉTAPE 3 : TESTER LA CONFIGURATION

### Test 1 : Résolution de noms (depuis la VM)

```bash
# Test avec ping
ping server1.local -c 2
ping web.local -c 2
ping server1 -c 2
```

**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 ttl=64 time=0.015 ms
64 bytes from server1.local (192.168.1.100): icmp_seq=2 ttl=64 time=0.020 ms

--- server1.local ping statistics ---
2 packets transmitted, 2 received, 0% packet loss
```

[OK] **Le nom est résolu !**

### Test 2 : Avec getent (méthode plus propre)

```bash
getent hosts server1.local
```

**Résultat attendu :**

```
192.168.1.100   server1.local
```

**Explication :**
- `getent` = **Get entries** (récupérer les entrées)
- `hosts` = Base de données des hôtes
- Plus fiable que ping pour tester la résolution

### Test 3 : Avec nslookup (ne fonctionne PAS avec /etc/hosts)

```bash
nslookup server1.local
```

**Résultat :**

```
** server: can't find server1.local: NXDOMAIN
```

**[X] C'EST NORMAL !**

**Pourquoi ?**
- `nslookup` interroge UNIQUEMENT les serveurs DNS
- `/etc/hosts` n'est PAS un serveur DNS
- C'est un fichier local lu par le système

**Analogie :** C'est comme chercher un numéro dans l'annuaire téléphonique alors qu'il est dans ton carnet personnel.

### Test 4 : Ordre de résolution (comprendre la priorité)

```bash
cat /etc/nsswitch.conf | grep hosts
```

**Résultat typique :**

```
hosts:          files mdns4_minimal [NOTFOUND=return] dns
                ^^^^^
            /etc/hosts consulté EN PREMIER [OK]
```

**Explication :**

1. `files` = Consulte `/etc/hosts` **EN PREMIER**
2. `mdns4_minimal` = Multicast DNS (pour les noms `.local` via Avahi)
3. `dns` = Consulte les serveurs DNS **EN DERNIER**

**Ordre de priorité :**

```
┌─────────────────────────────────────┐
│  Question: "Où est server1.local ?" │
└──────────────┬──────────────────────┘
               │
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │  1. /etc/hosts│
       │  Trouvé? [OK]   │
       │  -> FIN        │
       └───────────────┘
               │
               │ Si non trouvé
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │  2. mDNS      │
       │  (.local)     │
       └───────────────┘
               │
               │ Si non trouvé
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │  3. DNS Server│
       │  (8.8.8.8)    │
       └───────────────┘
```

---

## [WEB] ÉTAPE 4 : TESTER DEPUIS LA MACHINE PHYSIQUE

### [ATTENTION] IMPORTANT : Configuration nécessaire

Pour que ta machine physique utilise les noms dans `/etc/hosts` de ta VM, **tu dois aussi modifier /etc/hosts sur ta machine physique**.

**Pourquoi ?**
- `/etc/hosts` est un fichier **LOCAL**
- Chaque machine a son propre fichier
- Il n'y a **AUCUNE synchronisation automatique**

### Sur Windows (machine physique)

#### Localiser le fichier hosts

```
C:\Windows\System32\drivers\etc\hosts
```

#### Ouvrir avec droits administrateur

1. **Ouvre le Bloc-notes en tant qu'administrateur** :
   - Cherche "Notepad" dans le menu Démarrer
   - Clique droit -> "Exécuter en tant qu'administrateur"

2. **Fichier -> Ouvrir**

3. **Va dans** : `C:\Windows\System32\drivers\etc\`

4. **Change le filtre** : "Tous les fichiers (*.*)"

5. **Ouvre** : `hosts`

#### Contenu par défaut (Windows)

```
# Copyright (c) 1993-2009 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#	127.0.0.1       localhost
#	::1             localhost
```

#### Ajouter tes entrées

**À la fin du fichier, ajoute :**

```
# Serveurs sur VM Linux
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
192.168.1.101   server2.local   server2
192.168.1.102   nas.local       nas
```

**Sauvegarder :** `Fichier -> Enregistrer`

#### Vider le cache DNS Windows

```cmd
ipconfig /flushdns
```

**Résultat :**

```
Configuration IP de Windows

Cache de résolution DNS vidé.
```

---

### Sur Mac (machine physique)

#### Éditer /etc/hosts

```bash
sudo nano /etc/hosts
```

**Mot de passe requis**

#### Ajouter tes entrées

```bash
# Serveurs sur VM Linux
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
192.168.1.101   server2.local   server2
```

#### Vider le cache DNS

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

---

### Sur Linux (autre machine physique)

```bash
sudo nano /etc/hosts
```

**Ajouter les mêmes entrées**

```bash
# Serveurs sur VM Linux
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
```

**Pas besoin de vider le cache** (lecture directe du fichier)

---

## [TEST] TESTS FINAUX DEPUIS LA MACHINE PHYSIQUE

### Test 1 : Ping

**Windows :**
```cmd
ping server1.local
ping web.local
```

**Mac/Linux :**
```bash
ping server1.local -c 4
```

**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
64 bytes from 192.168.1.100: icmp_seq=1 ttl=64 time=0.4 ms
```

[OK] **Ça fonctionne !**

### Test 2 : Navigateur web

**Ouvre un navigateur et tape :**

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

[OK] **Si Apache est installé sur la VM, la page s'affiche !**

### Test 3 : SSH

```bash
ssh user@server1.local
```

[OK] **Connexion SSH avec le nom au lieu de l'IP !**

---

## [SCALES] AVANTAGES ET INCONVÉNIENTS DE /etc/hosts

### [OK] AVANTAGES

1. **Ultra-simple** : Un seul fichier texte
2. **Aucune installation** : Déjà présent sur toutes les machines
3. **Instantané** : Pas de cache, pas de délai
4. **Pas de service** : Ne consomme aucune ressource
5. **Prioritaire** : Consulté avant les serveurs DNS
6. **Hors-ligne** : Fonctionne sans réseau

### [X] INCONVÉNIENTS

1. **Non centralisé** : Chaque machine doit être configurée individuellement
2. **Pas de cache** : Pas d'optimisation des requêtes DNS Internet
3. **Maintenance** : Ajouter 1 serveur = Modifier N machines
4. **Pas de wildcard** : Impossible de faire `*.local`
5. **Statique** : Pas de mise à jour automatique
6. **Pas de zones** : Pas de gestion de domaines complets
7. **Limité** : Devient ingérable au-delà de 10-20 entrées

---

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

### Cas 1 : Développeur avec 1-2 VMs

**Configuration :**
- 1 machine physique (développement)
- 2 VMs (staging + database)

**Solution : /etc/hosts** [OK]

```bash
# /etc/hosts
192.168.1.100   staging.local   staging
192.168.1.101   db.local        db
```

**Avantages :**
- Configuration en 30 secondes
- Pas besoin de serveur DNS
- Parfait pour ce cas

### Cas 2 : Home Lab avec 5 serveurs

**Configuration :**
- 1 machine physique
- 5 serveurs (web, db, nas, media, backup)

**Solution : /etc/hosts** [ATTENTION] (limite)

**Mieux : DNSmasq ou Unbound** [OK]

**Pourquoi ?**
- 5 serveurs = encore gérable avec /etc/hosts
- Mais si tu ajoutes des machines, ça devient pénible
- Un serveur DNS centralisé est préférable

### Cas 3 : Réseau d'entreprise avec 20+ serveurs

**Solution : BIND9 ou Unbound** [OK]

**Pourquoi /etc/hosts ne convient PAS :**
- 20 serveurs × 10 machines clientes = 200 entrées à maintenir
- Ajout d'un serveur = Modifier 10 fichiers
- Ingérable !

---

## [OUTIL] DÉPANNAGE /etc/hosts

### [X] "Nom ou service inconnu"

**Cause :** Erreur de syntaxe dans /etc/hosts

**Vérifier :**

```bash
# Afficher le fichier
cat /etc/hosts

# Vérifier les permissions
ls -l /etc/hosts
```

**Permissions correctes :**

```
-rw-r--r-- 1 root root 221 /etc/hosts
```

**Si permissions incorrectes :**

```bash
sudo chmod 644 /etc/hosts
sudo chown root:root /etc/hosts
```

### [X] Résolution DNS ne fonctionne plus

**Cause :** Erreur dans /etc/hosts qui casse la résolution

**Restaurer la sauvegarde :**

```bash
sudo cp /etc/hosts.backup /etc/hosts
```

### [X] Certains noms marchent, d'autres non

**Cause :** Espaces vs tabulations

**Vérifier :**

```bash
cat -A /etc/hosts
```

**Résultat :**

```
192.168.1.100^Iserver1.local^Iserver1$
              ^             ^
          Tabulations
```

**Solution :** Utiliser des espaces ou des tabulations, mais pas mélanger

---

# - MÉTHODE 2 : UNBOUND (RÉSOLVEUR DNS MODERNE)

## [BABY_BOTTLE] QU'EST-CE QU'UNBOUND ?

### [GUIDE] Définition

**Unbound est un résolveur DNS récursif et validateur** :
- **Récursif** : Il fait le travail de recherche DNS pour toi
- **Validateur** : Il vérifie la sécurité (DNSSEC)
- **Cache** : Il mémorise les réponses pour accélérer

### [OBJECTIF] Analogie

**Unbound = Un assistant de recherche intelligent** :

```
┌─────────────────────────────────────┐
│  Toi: "Où est google.com ?"         │
└──────────────┬──────────────────────┘
               │
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │   UNBOUND     │
       │  (Assistant)  │
       └───────┬───────┘
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 1. Je regarde dans ma mémoire (cache)
               │   "J'ai déjà cherché google.com il y a 2 min"
               │   -> Réponse instantanée [OK]
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 2. Si pas en mémoire, je cherche
               │   "Je demande aux serveurs racine"
               │   -> "google.com est chez 8.8.8.8"
               │
               └─[BLACK_RIGHT-POINTING_POINTER] 3. Je vérifie la sécurité (DNSSEC)
                   "La signature est valide [OK]"
                   -> Je te donne la réponse
```

---

## 🆚 UNBOUND VS AUTRES SOLUTIONS

| Caractéristique | Unbound | BIND9 | DNSmasq |
|-----------------|---------|-------|---------|
| **Rôle** | Résolveur pur | Serveur autoritaire + résolveur | Résolveur + DHCP |
| **Zones DNS** | [ATTENTION] Limitées (local-data) | [OK] Complet | [OK] Bon (via hosts) |
| **Performance** | ***** Excellent | **** Très bon | *** Bon |
| **Sécurité** | ***** DNSSEC natif | **** DNSSEC possible | ** Basique |
| **Mémoire** | [BAISSE] Léger | [GRAPHIQUE] Moyen | [BAISSE] Très léger |
| **Configuration** | *** Moyenne | ***** Complexe | * Facile |
| **Meilleur pour** | Résolveur réseau local | Serveur DNS entreprise | Petit réseau domestique |

---

## [PACKAGE] ÉTAPE 1 : INSTALLATION

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

**Durée :** ~30 secondes

**Vérifier l'installation :**

```bash
unbound -V
```

**Résultat :**

```
Version 1.17.1
Linked libs: libevent 2.1.12-stable (it uses epoll), OpenSSL 3.0.2
Linked modules: dns64 respip validator iterator
```

---

## [CONFIG] ÉTAPE 2 : CONFIGURATION DE BASE

### [DOSSIER] Structure des fichiers Unbound

```
/etc/unbound/
├── unbound.conf                 # Configuration principale (NE PAS MODIFIER)
├── unbound.conf.d/              # [OK] TES CONFIGS ICI
│   └── custom.conf              # [OK] Ton fichier personnalisé
└── root.hints                   # Serveurs racine DNS
```

**[ATTENTION] IMPORTANT :** Ne modifie JAMAIS `unbound.conf` directement !

**Pourquoi ?**
- Ce fichier peut être écrasé lors des mises à jour
- Utilise plutôt le répertoire `unbound.conf.d/`

### [EDIT] Créer ta configuration personnalisée

```bash
sudo nano /etc/unbound/unbound.conf.d/custom.conf
```

**Contenu complet (copie/colle) :**

```yaml
server:
    # Interface d'écoute
    interface: 0.0.0.0
    interface: ::0
    
    # Port
    port: 53
    
    # Qui peut faire des requêtes ?
    access-control: 192.168.1.0/24 allow
    access-control: 127.0.0.0/8 allow
    access-control: ::1 allow
    
    # Ne pas écouter sur ces interfaces
    do-not-query-localhost: no
    
    # Activer le cache
    cache-max-ttl: 86400
    cache-min-ttl: 300
    
    # Taille du cache
    msg-cache-size: 50m
    rrset-cache-size: 100m
    
    # Performances
    num-threads: 2
    
    # Logs (pour debug, désactiver en production)
    verbosity: 1
    log-queries: yes
    log-replies: yes
    logfile: "/var/log/unbound.log"
    
    # Désactiver DNSSEC pour simplifier au début
    # (À réactiver plus tard)
    val-permissive-mode: yes
    
    # Domaine local
    local-zone: "local." static
    
    # Entrées DNS personnalisées
    local-data: "server1.local. IN A 192.168.1.100"
    local-data: "web.local. IN A 192.168.1.100"
    local-data: "server2.local. IN A 192.168.1.101"
    local-data: "nas.local. IN A 192.168.1.102"
    
    # DNS inverse (reverse)
    local-data-ptr: "192.168.1.100 server1.local"
    local-data-ptr: "192.168.1.100 web.local"
    local-data-ptr: "192.168.1.101 server2.local"
    local-data-ptr: "192.168.1.102 nas.local"

# Serveurs DNS en amont (forwarders)
forward-zone:
    name: "."
    forward-addr: 8.8.8.8
    forward-addr: 8.8.4.4
    forward-addr: 1.1.1.1
```

---

## [GUIDE] EXPLICATION DÉTAILLÉE LIGNE PAR LIGNE

### Section server:

```yaml
server:
```
**Ce que ça fait :** Début de la section de configuration du serveur

---

```yaml
    interface: 0.0.0.0
    interface: ::0
```
**Ce que ça fait :**
- `0.0.0.0` = Écoute sur toutes les interfaces IPv4
- `::0` = Écoute sur toutes les interfaces IPv6

**Analogie :** Comme Apache, Unbound accepte les connexions de partout

**Alternatives :**
```yaml
# Écouter uniquement sur une IP spécifique
interface: 192.168.1.100

# Écouter uniquement localhost
interface: 127.0.0.1
```

---

```yaml
    port: 53
```
**Ce que ça fait :** Définit le port d'écoute

**Pourquoi 53 ?** C'est le port standard DNS (comme 80 pour HTTP)

---

```yaml
    access-control: 192.168.1.0/24 allow
    access-control: 127.0.0.0/8 allow
    access-control: ::1 allow
```
**Ce que ça fait :** Définit qui peut faire des requêtes DNS

**Décomposition :**
- `192.168.1.0/24` = Tout ton réseau local (192.168.1.1 à 192.168.1.254)
- `127.0.0.0/8` = Localhost IPv4
- `::1` = Localhost IPv6
- `allow` = Autorisé

**Syntaxe des ACL (Access Control List) :**
```yaml
access-control: RÉSEAU ACTION
```

**Actions possibles :**
- `allow` = Autorisé [OK]
- `deny` = Refusé [X]
- `refuse` = Refusé silencieusement (pas de réponse)
- `allow_snoop` = Autorisé + logs détaillés

**Exemples d'ACL :**
```yaml
# Autoriser tout le monde (DANGER en production!)
access-control: 0.0.0.0/0 allow

# Autoriser uniquement localhost
access-control: 127.0.0.0/8 allow
access-control: 0.0.0.0/0 refuse

# Autoriser plusieurs réseaux
access-control: 192.168.1.0/24 allow
access-control: 10.0.0.0/8 allow
```

---

```yaml
    do-not-query-localhost: no
```
**Ce que ça fait :** Permet à Unbound d'interroger localhost

**Pourquoi c'est important ?**
- Par défaut, Unbound ne s'interroge pas lui-même
- `no` = On désactive cette protection
- Utile si tu as plusieurs serveurs DNS locaux

---

```yaml
    cache-max-ttl: 86400
    cache-min-ttl: 300
```
**Ce que ça fait :** Configure la durée du cache

**TTL = Time To Live** (Durée de vie)

- `cache-max-ttl: 86400` = Maximum 24 heures (86400 secondes)
- `cache-min-ttl: 300` = Minimum 5 minutes (300 secondes)

**Analogie :** C'est comme la date de péremption d'un produit alimentaire

**Pourquoi un minimum et un maximum ?**
```
┌────────────────────────────────────────┐
│  Requête: "Où est google.com ?"        │
│  Réponse DNS: TTL=3600 (1 heure)       │
└────────────┬───────────────────────────┘
             │
             [BLACK_DOWN-POINTING_TRIANGLE]
    ┌────────────────┐
    │  UNBOUND       │
    │  Cache         │
    └────────────────┘
             │
             ├─[BLACK_RIGHT-POINTING_POINTER] Garde google.com en cache
             │   Durée: 3600s (respecte le TTL original)
             │
             ├─[BLACK_RIGHT-POINTING_POINTER] Sauf si TTL < 300s
             │   Alors garde quand même 300s (min-ttl)
             │
             └─[BLACK_RIGHT-POINTING_POINTER] Sauf si TTL > 86400s
                 Alors garde seulement 86400s (max-ttl)
```

**Valeurs recommandées :**
```yaml
# Réseau domestique (cache long)
cache-max-ttl: 86400       # 1 jour
cache-min-ttl: 600         # 10 minutes

# Réseau d'entreprise (cache court pour changements fréquents)
cache-max-ttl: 3600        # 1 heure
cache-min-ttl: 60          # 1 minute

# Développement (cache très court)
cache-max-ttl: 300         # 5 minutes
cache-min-ttl: 30          # 30 secondes
```

---

```yaml
    msg-cache-size: 50m
    rrset-cache-size: 100m
```
**Ce que ça fait :** Définit la taille des caches en mémoire

**Deux types de cache :**

1. **msg-cache** (Message cache) :
   - Stocke les **requêtes complètes**
   - "Où est google.com ?" -> "142.250.185.78"

2. **rrset-cache** (Resource Record Set cache) :
   - Stocke les **enregistrements DNS individuels**
   - Plus granulaire

**Notation :**
- `m` = Mégaoctets
- `k` = Kilooctets
- `g` = Gigaoctets

**Exemples :**
```yaml
# Petit serveur (faible mémoire)
msg-cache-size: 10m
rrset-cache-size: 20m

# Serveur moyen (configuration par défaut)
msg-cache-size: 50m
rrset-cache-size: 100m

# Gros serveur (beaucoup de requêtes)
msg-cache-size: 256m
rrset-cache-size: 512m
```

**Comment choisir la taille ?**
```bash
# Voir l'utilisation actuelle
sudo unbound-control stats | grep cache
```

---

```yaml
    num-threads: 2
```
**Ce que ça fait :** Nombre de threads (processus parallèles)

**Comment choisir ?**
```yaml
# Serveur avec 1-2 cœurs CPU
num-threads: 1

# Serveur avec 4 cœurs CPU
num-threads: 2

# Serveur puissant (8+ cœurs)
num-threads: 4
```

**[ATTENTION] Plus != Mieux**
- Trop de threads = Ralentit le système
- Règle : `num-threads` = Nombre de cœurs CPU ÷ 2

**Voir le nombre de cœurs :**
```bash
nproc
```

---

```yaml
    verbosity: 1
    log-queries: yes
    log-replies: yes
    logfile: "/var/log/unbound.log"
```
**Ce que ça fait :** Configure les logs (journaux)

**Niveaux de verbosity :**
| Niveau | Description | Utilisation |
|--------|-------------|-------------|
| 0 | Aucun log (sauf erreurs) | Production |
| 1 | Logs opérationnels | **Recommandé pour débuter** |
| 2 | Logs détaillés | Debug |
| 3-5 | Logs très verbeux | Développement Unbound |

**Options de log :**
```yaml
# Logs complets (debug)
verbosity: 2
log-queries: yes        # Enregistre chaque requête
log-replies: yes        # Enregistre chaque réponse
log-local-actions: yes  # Enregistre les actions locales

# Production (minimal)
verbosity: 0
log-queries: no
log-replies: no

# Fichier de log
logfile: "/var/log/unbound.log"

# Log vers syslog (au lieu d'un fichier)
use-syslog: yes
```

**Créer le fichier de log :**
```bash
sudo touch /var/log/unbound.log
sudo chown unbound:unbound /var/log/unbound.log
```

---

```yaml
    val-permissive-mode: yes
```
**Ce que ça fait :** Mode permissif pour DNSSEC

**DNSSEC = DNS Security Extensions** (Sécurité DNS)

**En mode permissif :**
- [OK] Validation DNSSEC activée
- [ATTENTION] Les erreurs sont logées mais ne bloquent pas
- Utile pour débuter et diagnostiquer

**Modes disponibles :**
```yaml
# Mode strict (recommandé en production)
val-permissive-mode: no
# -> Bloque les réponses invalides

# Mode permissif (recommandé pour débuter)
val-permissive-mode: yes
# -> Logue les erreurs mais ne bloque pas

# Désactiver DNSSEC complètement (non recommandé)
module-config: "iterator"
# -> Pas de validation du tout
```

---

```yaml
    local-zone: "local." static
```
**Ce que ça fait :** Définit une zone DNS locale

**Types de zones :**
| Type | Description | Exemple d'utilisation |
|------|-------------|----------------------|
| `static` | Zone locale avec données statiques | **Recommandé** |
| `transparent` | Délègue aux forwarders si pas trouvé | Zones partielles |
| `refuse` | Refuse toutes les requêtes | Bloquer des domaines |
| `deny` | Nie l'existence du domaine | Bloquer + cacher |
| `redirect` | Redirige vers une IP fixe | Page de blocage |

**Exemples :**
```yaml
# Zone locale standard
local-zone: "local." static

# Bloquer un domaine publicitaire
local-zone: "doubleclick.net." refuse

# Rediriger vers une page de blocage
local-zone: "ads.example.com." redirect
local-data: "ads.example.com. A 192.168.1.254"
```

---

```yaml
    local-data: "server1.local. IN A 192.168.1.100"
    local-data: "web.local. IN A 192.168.1.100"
```
**Ce que ça fait :** Ajoute des enregistrements DNS

**Structure :**
```yaml
local-data: "NOM. CLASSE TYPE VALEUR"
```

**Décomposition :**
- `server1.local.` = Nom ([ATTENTION] point final obligatoire!)
- `IN` = Internet (classe)
- `A` = Adresse IPv4 (type)
- `192.168.1.100` = Valeur

**Types d'enregistrements DNS :**
```yaml
# A = IPv4
local-data: "server1.local. IN A 192.168.1.100"

# AAAA = IPv6
local-data: "server1.local. IN AAAA 2001:db8::1"

# CNAME = Alias
local-data: "www.local. IN CNAME server1.local."

# MX = Serveur mail
local-data: "local. IN MX 10 mail.local."

# TXT = Texte libre
local-data: "local. IN TXT 'Mon réseau local'"

# PTR = Reverse DNS (voir ci-dessous)
```

---

```yaml
    local-data-ptr: "192.168.1.100 server1.local"
```
**Ce que ça fait :** Configure le DNS inverse (PTR)

**DNS inverse = IP -> Nom**

**Structure simplifiée :**
```yaml
local-data-ptr: "IP NOM"
```

**Équivalent en format complet :**
```yaml
local-data: "100.1.168.192.in-addr.arpa. IN PTR server1.local."
```

**Pourquoi c'est important ?**
- Certains services vérifient le reverse DNS (mail, SSH)
- Logs plus lisibles (noms au lieu d'IPs)

**Exemples :**
```yaml
# IPv4 reverse
local-data-ptr: "192.168.1.100 server1.local"
local-data-ptr: "192.168.1.101 server2.local"

# Équivalent format long
local-data: "100.1.168.192.in-addr.arpa. PTR server1.local."
local-data: "101.1.168.192.in-addr.arpa. PTR server2.local."
```

---

### Section forward-zone:

```yaml
forward-zone:
    name: "."
    forward-addr: 8.8.8.8
    forward-addr: 8.8.4.4
    forward-addr: 1.1.1.1
```

**Ce que ça fait :** Définit les serveurs DNS en amont (forwarders)

**Décomposition :**

```yaml
forward-zone:
    name: "."                  # Point = toutes les zones non locales
    forward-addr: 8.8.8.8      # Google DNS primaire
    forward-addr: 8.8.4.4      # Google DNS secondaire
    forward-addr: 1.1.1.1      # Cloudflare DNS
```

**Comment ça marche ?**
```
┌───────────────────────────────────────┐
│  Requête: "Où est google.com ?"       │
└──────────────┬────────────────────────┘
               │
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │   UNBOUND     │
       └───────┬───────┘
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 1. C'est dans local-zone "local." ?
               │   -> Non
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 2. C'est dans le cache ?
               │   -> Non
               │
               └─[BLACK_RIGHT-POINTING_POINTER] 3. Demander aux forwarders
                   ├─[BLACK_RIGHT-POINTING_POINTER] Essaye 8.8.8.8
                   │   -> Réponse OK [OK]
                   │
                   ├─[BLACK_RIGHT-POINTING_POINTER] (Si 8.8.8.8 échoue)
                   │   Essaye 8.8.4.4
                   │
                   └─[BLACK_RIGHT-POINTING_POINTER] (Si les 2 échouent)
                       Essaye 1.1.1.1
```

**Choix des forwarders :**

| Fournisseur | IPv4 | IPv6 | Avantages |
|-------------|------|------|-----------|
| **Google DNS** | 8.8.8.8<br>8.8.4.4 | 2001:4860:4860::8888<br>2001:4860:4860::8844 | Rapide, fiable |
| **Cloudflare DNS** | 1.1.1.1<br>1.0.0.1 | 2606:4700:4700::1111<br>2606:4700:4700::1001 | Très rapide, respecte la vie privée |
| **Quad9** | 9.9.9.9<br>149.112.112.112 | 2620:fe::fe<br>2620:fe::9 | Sécurisé, bloque malware |
| **OpenDNS** | 208.67.222.222<br>208.67.220.220 | 2620:119:35::35<br>2620:119:53::53 | Filtrage parental |

**Configuration multi-forwarders :**
```yaml
# Configuration simple (Google)
forward-zone:
    name: "."
    forward-addr: 8.8.8.8
    forward-addr: 8.8.4.4

# Configuration mixte (plusieurs fournisseurs)
forward-zone:
    name: "."
    forward-addr: 1.1.1.1       # Cloudflare (priorité 1)
    forward-addr: 8.8.8.8       # Google (priorité 2)
    forward-addr: 9.9.9.9       # Quad9 (priorité 3)

# Avec IPv6
forward-zone:
    name: "."
    forward-addr: 1.1.1.1
    forward-addr: 2606:4700:4700::1111
```

---

## [OK] ÉTAPE 3 : VÉRIFIER LA CONFIGURATION

### Vérifier la syntaxe

```bash
sudo unbound-checkconf
```

**Résultat attendu (si tout est bon) :**
```
unbound-checkconf: no errors in /etc/unbound/unbound.conf
```

**Si erreur :**
```
unbound-checkconf: /etc/unbound/unbound.conf.d/custom.conf:5: syntax error
```

**Causes fréquentes d'erreurs :**
1. Oubli du point final dans les noms : `server1.local` au lieu de `server1.local.`
2. Mauvaise indentation (YAML est sensible aux espaces)
3. Guillemets manquants

---

## [RAPIDE] ÉTAPE 4 : DÉMARRER UNBOUND

### Redémarrer le service

```bash
sudo systemctl restart unbound
```

### Vérifier le statut

```bash
sudo systemctl status unbound
```

**Résultat attendu :**
```
[BLACK_CIRCLE] unbound.service - Unbound DNS server
     Loaded: loaded (/lib/systemd/system/unbound.service; enabled)
     Active: active (running) since Wed 2024-12-06 14:30:00 UTC; 5s ago
              ^^^^^^ ^^^^^^^
              ACTIF [OK]
       Docs: man:unbound(8)
    Process: 1234 ExecStartPre=/usr/lib/unbound/package-helper chroot_setup
    Process: 1235 ExecStartPre=/usr/lib/unbound/package-helper root_trust_anchor_update
   Main PID: 1236 (unbound)
      Tasks: 3 (limit: 2339)
     Memory: 15.2M
        CPU: 123ms
     CGroup: /system.slice/unbound.service
             └─1236 /usr/sbin/unbound -d -p

Dec 06 14:30:00 server1 unbound[1236]: [1236:0] info: start of service (unbound 1.17.1).
```

### Activer au démarrage

```bash
sudo systemctl enable unbound
```

---

## [TEST] ÉTAPE 5 : TESTER UNBOUND

### Test 1 : Depuis la VM (localhost)

```bash
dig server1.local @127.0.0.1
```

**Résultat attendu :**
```
; <<>> DiG 9.18.12 <<>> server1.local @127.0.0.1
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 12345
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; QUESTION SECTION:
;server1.local.                 IN      A

;; ANSWER SECTION:
server1.local.          3600    IN      A       192.168.1.100
                                                ^^^^^^^^^^^^^
                                                [OK] RÉSOLU !

;; Query time: 0 msec
;; SERVER: 127.0.0.1#53(127.0.0.1) (UDP)
;; WHEN: Wed Dec 06 14:35:00 UTC 2024
;; MSG SIZE  rcvd: 58
```

### Test 2 : Test des forwarders (Internet)

```bash
dig google.com @127.0.0.1
```

**Résultat attendu :**
```
;; ANSWER SECTION:
google.com.             300     IN      A       142.250.185.78
```

[OK] **Unbound résout aussi les domaines Internet !**

### Test 3 : Test du cache

```bash
# Première requête (va chercher sur Internet)
time dig google.com @127.0.0.1 +noall +answer

# Deuxième requête (depuis le cache)
time dig google.com @127.0.0.1 +noall +answer
```

**Résultat :**
```
# Première fois (10-50 ms)
google.com.             300     IN      A       142.250.185.78
real    0m0.042s

# Deuxième fois (< 1 ms) <- BEAUCOUP PLUS RAPIDE!
google.com.             300     IN      A       142.250.185.78
real    0m0.001s
```

[OK] **Le cache fonctionne !**

### Test 4 : Test du reverse DNS

```bash
dig -x 192.168.1.100 @127.0.0.1
```

**Résultat attendu :**
```
;; ANSWER SECTION:
100.1.168.192.in-addr.arpa. 3600 IN PTR server1.local.
```

### Test 5 : Voir les statistiques

```bash
sudo unbound-control stats
```

**Résultat (extrait) :**
```
total.num.queries=1523
total.num.cachehits=982
total.num.cachemiss=541
total.num.recursivereplies=541
```

**Traduction :**
- Requêtes totales : 1523
- Réponses depuis le cache : 982 ([OK] efficace!)
- Cache miss : 541
- Requêtes récursives : 541

---

## [WEB] ÉTAPE 6 : CONFIGURER LES CLIENTS

### Sur la VM Linux (utiliser Unbound local)

#### Méthode 1 : Modifier /etc/resolv.conf directement

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

**Contenu :**
```
nameserver 127.0.0.1
nameserver 8.8.8.8
```

**[ATTENTION] Problème :** Sur certains systèmes, ce fichier est régénéré au redémarrage

#### Méthode 2 : Via systemd-resolved (voir section 3)

#### Méthode 3 : Via Netplan

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

**Modifier la section nameservers :**
```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        # <- Unbound local
          - 8.8.8.8          # <- Backup
```

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

---

### Sur la machine physique Windows

**Configuration réseau :**
1. `Win + R` -> `ncpa.cpl`
2. Clique droit sur ta carte -> **Propriétés**
3. **Protocole Internet version 4**
4. **Serveur DNS préféré :** `192.168.1.100`
5. **Serveur DNS auxiliaire :** `8.8.8.8`

**Vider le cache :**
```cmd
ipconfig /flushdns
```

**Tester :**
```cmd
nslookup server1.local
```

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

Nom :    server1.local
Address:  192.168.1.100
```

---

### Sur Mac

**Préférences Système -> Réseau -> Avancé -> DNS**

**Serveurs DNS :**
```
192.168.1.100
8.8.8.8
```

**Vider le cache :**
```bash
sudo dscacheutil -flushcache
sudo killall -HUP mDNSResponder
```

**Tester :**
```bash
dig server1.local @192.168.1.100
```

---

## [GRAPHIQUE] VOIR LES LOGS

```bash
sudo tail -f /var/log/unbound.log
```

**Exemple de sortie :**
```
[1701878400] unbound[1236:0] info: server1.local. A IN
[1701878400] unbound[1236:0] info: reply server1.local. A IN 192.168.1.100
[1701878401] unbound[1236:0] info: google.com. A IN
[1701878401] unbound[1236:0] info: resolving google.com. A IN
[1701878401] unbound[1236:0] info: response for google.com. A IN
```

---

## [OUTIL] CONFIGURATION AVANCÉE UNBOUND

### Bloquer des domaines (publicité, malware)

```yaml
server:
    # Bloquer un domaine
    local-zone: "ads.example.com." refuse
    local-zone: "tracker.example.com." refuse
    
    # Rediriger vers une page de blocage
    local-zone: "malware.example.com." redirect
    local-data: "malware.example.com. A 192.168.1.254"
```

### Créer des vues DNS (split-horizon)

```yaml
# Vue interne (réseau local)
server:
    access-control-view: 192.168.1.0/24 internal
    
view:
    name: "internal"
    local-zone: "internal.local." static
    local-data: "admin.internal.local. A 192.168.1.10"

# Vue externe (Internet)
view:
    name: "external"
    local-zone: "internal.local." refuse
```

### Activer DNSSEC strict

```yaml
server:
    # Désactiver le mode permissif
    val-permissive-mode: no
    
    # Activer la validation stricte
    module-config: "validator iterator"
    
    # Fichier des clés racine
    auto-trust-anchor-file: "/var/lib/unbound/root.key"
```

---

## 🆘 DÉPANNAGE UNBOUND

### [X] "unbound.service: Failed with result 'exit-code'"

**Cause :** Erreur de configuration

**Solution :**
```bash
# Vérifier la configuration
sudo unbound-checkconf

# Voir les logs détaillés
sudo journalctl -u unbound -n 50

# Tester en mode debug
sudo unbound -d -vvv
```

### [X] "can't bind socket: Address already in use"

**Cause :** Le port 53 est déjà utilisé

**Trouver le coupable :**
```bash
sudo netstat -tulpn | grep :53
```

**Si c'est systemd-resolved :**
```bash
# Désactiver systemd-resolved
sudo systemctl stop systemd-resolved
sudo systemctl disable systemd-resolved

# Supprimer le lien symbolique
sudo rm /etc/resolv.conf

# Créer un nouveau resolv.conf
echo "nameserver 127.0.0.1" | sudo tee /etc/resolv.conf
```

### [X] "validation failure server1.local"

**Cause :** DNSSEC activé pour une zone locale

**Solution :**
```yaml
server:
    # Désactiver DNSSEC pour les zones locales
    domain-insecure: "local."
    
    # Ou mode permissif
    val-permissive-mode: yes
```

---

# - MÉTHODE 3 : systemd-resolved (MODERNE ET INTÉGRÉ)

## [BABY_BOTTLE] QU'EST-CE QUE systemd-resolved ?

### [GUIDE] Définition

**systemd-resolved est le gestionnaire DNS intégré à systemd** :
- Préinstallé sur Ubuntu 18.04+ et Debian 11+
- Cache DNS local automatique
- Intégration parfaite avec le système
- Configuration déclarative (via fichiers)

### [OBJECTIF] Analogie

**systemd-resolved = GPS intégré à ta voiture** :

```
┌────────────────────────────────────┐
│  Voiture classique (sans GPS)     │
│  -> Acheter GPS séparé (Unbound)   │
│  -> Installer, configurer           │
└────────────────────────────────────┘

┌────────────────────────────────────┐
│  Voiture moderne (GPS intégré)    │
│  -> Déjà présent (systemd-resolved)│
│  -> Juste activer                   │
└────────────────────────────────────┘
```

---

## 🆚 systemd-resolved VS AUTRES

| Caractéristique | systemd-resolved | Unbound | DNSmasq |
|-----------------|------------------|---------|---------|
| **Installation** | [OK] Préinstallé | [X] À installer | [X] À installer |
| **Configuration** | ** Facile | *** Moyenne | * Très facile |
| **Cache** | [OK] Oui | [OK] Oui | [OK] Oui |
| **DNSSEC** | [OK] Oui | [OK] Oui | [X] Non |
| **LLMNR/mDNS** | [OK] Oui | [X] Non | [X] Non |
| **Zones DNS** | [X] Non | [ATTENTION] Limité | [OK] Oui |
| **Intégration système** | ***** Parfaite | *** Bonne | ** Moyenne |
| **Meilleur pour** | Desktop/Laptop | Serveur réseau | Petit réseau |

---

## [CONFIG] ÉTAPE 1 : VÉRIFIER systemd-resolved

### Vérifier s'il est installé

```bash
systemctl status systemd-resolved
```

**Résultat possible 1 (actif) :**
```
[BLACK_CIRCLE] systemd-resolved.service - Network Name Resolution
     Loaded: loaded
     Active: active (running)
```

[OK] **Déjà actif !**

**Résultat possible 2 (inactif) :**
```
[BLACK_CIRCLE] systemd-resolved.service - Network Name Resolution
     Loaded: loaded
     Active: inactive (dead)
```

**L'activer :**
```bash
sudo systemctl start systemd-resolved
sudo systemctl enable systemd-resolved
```

---

## [GUIDE] COMPRENDRE L'ARCHITECTURE

```
┌────────────────────────────────────────────┐
│          APPLICATIONS                      │
│  (Firefox, curl, ping, etc.)               │
└──────────────┬─────────────────────────────┘
               │
               │ Demandent une résolution DNS
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │  /etc/resolv.conf (lien symbolique)
       │  -> /run/systemd/resolve/stub-resolv.conf
       └───────┬───────┘
               │
               [BLACK_DOWN-POINTING_TRIANGLE]
       ┌───────────────┐
       │  systemd-resolved
       │  (127.0.0.53:53)
       └───────┬───────┘
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 1. Cache local
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 2. Fichiers locaux (/etc/hosts)
               │
               ├─[BLACK_RIGHT-POINTING_POINTER] 3. LLMNR (réseau local)
               │
               └─[BLACK_RIGHT-POINTING_POINTER] 4. Serveurs DNS configurés
                   (8.8.8.8, etc.)
```

---

## [CONFIG] ÉTAPE 2 : CONFIGURATION

### [DOSSIER] Fichiers de configuration

```
/etc/systemd/resolved.conf           # Configuration principale
/etc/systemd/resolved.conf.d/        # Configurations personnalisées
/run/systemd/resolve/resolv.conf     # resolv.conf géré par systemd
/etc/resolv.conf                     # Lien symbolique (normalement)
```

### [EDIT] Configuration principale

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

**Contenu par défaut :**
```ini
#  This file is part of systemd.
#
#  systemd is free software; you can redistribute it and/or modify it
#  under the terms of the GNU Lesser General Public License as published by
#  the Free Software Foundation; either version 2.1 of the License, or
#  (at your option) any later version.
#
# Entries in this file show the compile time defaults.
# You can change settings by editing this file.
# Defaults can be restored by simply deleting this file.
#
# See resolved.conf(5) for details

[Resolve]
#DNS=
#FallbackDNS=
#Domains=
#LLMNR=yes
#MulticastDNS=yes
#DNSSEC=allow-downgrade
#DNSOverTLS=no
#Cache=yes
#DNSStubListener=yes
#ReadEtcHosts=yes
```

**Configuration personnalisée :**

```ini
[Resolve]
# Serveurs DNS
DNS=8.8.8.8 8.8.4.4 1.1.1.1

# DNS de secours (si DNS principal ne répond pas)
FallbackDNS=9.9.9.9

# Domaines de recherche
Domains=local

# LLMNR (Link-Local Multicast Name Resolution)
LLMNR=yes

# Multicast DNS (Bonjour, Avahi)
MulticastDNS=yes

# DNSSEC
DNSSEC=allow-downgrade

# DNS over TLS (chiffré)
DNSOverTLS=opportunistic

# Cache
Cache=yes

# Écouter sur 127.0.0.53
DNSStubListener=yes

# Lire /etc/hosts
ReadEtcHosts=yes
```

---

## [GUIDE] EXPLICATION DÉTAILLÉE

### DNS=

```ini
DNS=8.8.8.8 8.8.4.4 1.1.1.1
```

**Ce que ça fait :** Définit les serveurs DNS

**Syntaxe :**
```ini
# Un seul serveur
DNS=8.8.8.8

# Plusieurs serveurs (séparés par espaces)
DNS=8.8.8.8 8.8.4.4

# IPv4 et IPv6
DNS=8.8.8.8 2001:4860:4860::8888
```

---

### FallbackDNS=

```ini
FallbackDNS=9.9.9.9
```

**Ce que ça fait :** DNS de secours si tous les DNS principaux échouent

**Différence avec DNS= :**
- `DNS=` : Utilisés en priorité
- `FallbackDNS=` : Utilisés en dernier recours

---

### Domains=

```ini
Domains=local example.com
```

**Ce que ça fait :** Domaines de recherche DNS

**Exemple pratique :**
```bash
# Sans Domains=
ping server1            # [X] Échec
ping server1.local      # [OK] Fonctionne

# Avec Domains=local
ping server1            # [OK] Fonctionne (ajoute automatiquement .local)
ping server1.local      # [OK] Fonctionne aussi
```

---

### LLMNR=

```ini
LLMNR=yes
```

**LLMNR = Link-Local Multicast Name Resolution**

**Ce que ça fait :** Permet de résoudre les noms sur le réseau local sans DNS

**Exemple :**
```bash
# Ordinateur "laptop" sur le réseau
ping laptop            # [OK] Fonctionne grâce à LLMNR
```

**Valeurs :**
- `yes` = Activé
- `no` = Désactivé
- `resolve` = Uniquement pour résoudre, pas répondre

---

### MulticastDNS=

```ini
MulticastDNS=yes
```

**MulticastDNS = mDNS** (protocole Bonjour/Avahi)

**Ce que ça fait :** Résolution de noms `.local` sans serveur DNS

**Compatible avec :**
- macOS (Bonjour)
- Linux (Avahi)
- Imprimantes réseau
- Apple TV, Chromecast

**Exemple :**
```bash
# Imprimante sur le réseau
ping printer.local     # [OK] Trouvée via mDNS
```

---

### DNSSEC=

```ini
DNSSEC=allow-downgrade
```

**DNSSEC = DNS Security Extensions**

**Valeurs :**
| Valeur | Description | Sécurité |
|--------|-------------|----------|
| `no` | Désactivé | [X] Aucune |
| `allow-downgrade` | Activé mais tolère l'absence | [ATTENTION] Moyenne |
| `yes` | Activé strict | [OK] Maximale |

**Recommandation :**
```ini
# Pour débuter
DNSSEC=allow-downgrade

# En production
DNSSEC=yes
```

---

### DNSOverTLS=

```ini
DNSOverTLS=opportunistic
```

**DNS over TLS = DNS chiffré** (comme HTTPS pour le web)

**Valeurs :**
| Valeur | Description |
|--------|-------------|
| `no` | Désactivé (DNS en clair) |
| `opportunistic` | Utilise TLS si disponible |
| `yes` | TLS obligatoire (strict) |

**Analogie :** C'est comme chiffrer tes appels téléphoniques

---

### Cache=

```ini
Cache=yes
```

**Ce que ça fait :** Active le cache DNS local

**Voir les statistiques du cache :**
```bash
resolvectl statistics
```

**Résultat :**
```
DNSSEC supported: yes
Current Cache Size: 42
Cache Hits: 156
Cache Misses: 89
```

---

## [OUTIL] ÉTAPE 3 : CONFIGURATION POUR RÉSEAU LOCAL

### Créer une configuration personnalisée

```bash
sudo mkdir -p /etc/systemd/resolved.conf.d
sudo nano /etc/systemd/resolved.conf.d/local.conf
```

**Contenu :**

```ini
[Resolve]
DNS=8.8.8.8 8.8.4.4
Domains=local
LLMNR=yes
MulticastDNS=yes
DNSSEC=allow-downgrade
Cache=yes
ReadEtcHosts=yes
```

---

### Ajouter des entrées dans /etc/hosts

**systemd-resolved lit automatiquement /etc/hosts !**

```bash
sudo nano /etc/hosts
```

**Ajouter :**
```
192.168.1.100   server1.local   server1
192.168.1.100   web.local       web
192.168.1.101   server2.local   server2
```

**systemd-resolved utilisera ces entrées en priorité !**

---

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

```bash
# Redémarrer le service
sudo systemctl restart systemd-resolved

# Vérifier le statut
sudo systemctl status systemd-resolved
```

---

## [TEST] ÉTAPE 5 : TESTER systemd-resolved

### Test 1 : Résolution de base

```bash
resolvectl query server1.local
```

**Résultat attendu :**
```
server1.local: 192.168.1.100

-- Information acquired via 'hosts' file.
```

[OK] **Résolu via /etc/hosts !**

### Test 2 : Résolution Internet

```bash
resolvectl query google.com
```

**Résultat :**
```
google.com: 142.250.185.78
            2a00:1450:4007:818::200e

-- Information acquired via DNS in 15ms.
-- Data is authenticated: no
```

### Test 3 : Voir les statistiques

```bash
resolvectl statistics
```

**Résultat :**
```
DNSSEC supported: yes
DNSSEC NTA: 10.in-addr.arpa
           16.172.in-addr.arpa
           168.192.in-addr.arpa
           ...

Current Cache Size: 127
Cache Hits: 423
Cache Misses: 234
DNSSEC Verdicts
  Secure: 156
  Insecure: 267
  Bogus: 0
  Indeterminate: 0
```

### Test 4 : Voir la configuration actuelle

```bash
resolvectl status
```

**Résultat (extrait) :**
```
Global
       Protocols: +LLMNR +mDNS +DNSOverTLS DNSSEC=allow-downgrade/supported
resolv.conf mode: stub
     DNS Servers: 8.8.8.8
                  8.8.4.4

Link 2 (eth0)
    Current Scopes: DNS LLMNR/IPv4 LLMNR/IPv6 mDNS/IPv4 mDNS/IPv6
         Protocols: +DefaultRoute +LLMNR +mDNS +DNSOverTLS DNSSEC=allow-downgrade/supported
       DNS Servers: 192.168.1.1
```

### Test 5 : Vider le cache

```bash
sudo resolvectl flush-caches
```

---

## [WEB] UTILISER systemd-resolved COMME SERVEUR DNS

### Configuration pour écouter sur le réseau

**Par défaut, systemd-resolved écoute uniquement sur 127.0.0.53**

**Pour qu'il soit accessible depuis d'autres machines :**

**[ATTENTION] Ce n'est PAS recommandé !**
- systemd-resolved n'est pas conçu pour être un serveur DNS réseau
- Utilise plutôt Unbound ou BIND9 pour ça

**Mais si tu insistes :**

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

```ini
[Resolve]
DNSStubListener=0.0.0.0
```

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

**Vérifier :**
```bash
sudo netstat -tulpn | grep systemd-resolve
```

---

## [LIEN] INTÉGRATION AVEC UNBOUND

**Tu peux combiner systemd-resolved (cache local) + Unbound (serveur réseau) !**

### Architecture combinée

```
┌────────────────────────────────────────┐
│      MACHINE LOCALE                    │
│                                        │
│  Applications                          │
│      v                                 │
│  systemd-resolved (127.0.0.53)         │
│      v                                 │
│  Unbound (127.0.0.1:5353)              │
│      v                                 │
│  Internet (8.8.8.8)                    │
└────────────────────────────────────────┘
```

### Configuration

**1. Configurer Unbound sur un port différent :**

```yaml
# /etc/unbound/unbound.conf.d/custom.conf
server:
    interface: 127.0.0.1
    port: 5353          # <- Port non standard
```

**2. Configurer systemd-resolved pour utiliser Unbound :**

```ini
# /etc/systemd/resolved.conf
[Resolve]
DNS=127.0.0.1:5353
FallbackDNS=8.8.8.8
```

**3. Redémarrer les services :**

```bash
sudo systemctl restart unbound
sudo systemctl restart systemd-resolved
```

---

## 🆘 DÉPANNAGE systemd-resolved

### [X] "Temporary failure in name resolution"

**Cause :** systemd-resolved ne fonctionne pas correctement

**Vérifier :**
```bash
sudo systemctl status systemd-resolved
resolvectl status
```

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

### [X] /etc/resolv.conf ne pointe pas vers systemd-resolved

**Vérifier le lien symbolique :**
```bash
ls -la /etc/resolv.conf
```

**Devrait afficher :**
```
lrwxrwxrwx 1 root root 39 /etc/resolv.conf -> /run/systemd/resolve/stub-resolv.conf
```

**Si c'est un fichier normal :**
```bash
sudo rm /etc/resolv.conf
sudo ln -s /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf
sudo systemctl restart systemd-resolved
```

### [X] "DNSSEC validation failed"

**Désactiver temporairement DNSSEC :**

```ini
[Resolve]
DNSSEC=no
```

```bash
sudo systemctl restart systemd-resolved
```

---

# [GRAPHIQUE] COMPARAISON FINALE : QUELLE MÉTHODE CHOISIR ?

## [OBJECTIF] TABLEAU DE DÉCISION

| Situation | Méthode recommandée | Pourquoi |
|-----------|---------------------|----------|
| **1-5 machines, pas de serveur** | **/etc/hosts** | Ultra-simple, aucune installation |
| **Desktop/Laptop personnel** | **systemd-resolved** | Déjà intégré, fonctionne out-of-the-box |
| **Serveur réseau local (5-20 machines)** | **Unbound** | Performant, cache efficace, DNSSEC |
| **Petit réseau avec DHCP** | **DNSmasq** | Fait DNS + DHCP |
| **Entreprise, datacenter** | **BIND9** | Standard professionnel, fonctionnalités complètes |

---

## [SYNC] COMBINAISONS POSSIBLES

### Combo 1 : systemd-resolved + /etc/hosts

**Utilisation :**
- Desktop Linux
- 1-5 serveurs locaux

**Configuration :**
```bash
# /etc/hosts
192.168.1.100   server1.local

# systemd-resolved lit automatiquement /etc/hosts
# Rien d'autre à faire !
```

[OK] **Le meilleur des deux mondes**

---

### Combo 2 : Unbound (serveur) + systemd-resolved (clients)

**Utilisation :**
- Réseau local de 5-20 machines
- 1 serveur Linux avec Unbound
- Clients avec systemd-resolved

**Configuration serveur (Unbound) :**
```yaml
# /etc/unbound/unbound.conf.d/custom.conf
server:
    interface: 0.0.0.0
    access-control: 192.168.1.0/24 allow
    local-data: "server1.local. A 192.168.1.100"
```

**Configuration clients (systemd-resolved) :**
```ini
# /etc/systemd/resolved.conf
[Resolve]
DNS=192.168.1.100
FallbackDNS=8.8.8.8
Domains=local
```

[OK] **Architecture professionnelle**

---

### Combo 3 : /etc/hosts (local) + forwarder vers serveur DNS

**Utilisation :**
- Quelques serveurs locaux sur UNE machine
- Reste du réseau géré par serveur DNS central

**Configuration :**
```bash
# /etc/hosts (pour localhost uniquement)
127.0.0.1   db.local
127.0.0.1   cache.local

# /etc/resolv.conf (pour le reste)
nameserver 192.168.1.1    # Serveur DNS du réseau
```

[OK] **Bon compromis**

---

## [DOCS] RÉCAPITULATIF DES COMMANDES ESSENTIELLES

### /etc/hosts
```bash
# Éditer
sudo nano /etc/hosts

# Tester
ping server1.local
getent hosts server1.local

# Voir l'ordre de résolution
cat /etc/nsswitch.conf | grep hosts
```

### Unbound
```bash
# Installer
sudo apt install unbound

# Configurer
sudo nano /etc/unbound/unbound.conf.d/custom.conf

# Vérifier config
sudo unbound-checkconf

# Redémarrer
sudo systemctl restart unbound

# Tester
dig server1.local @127.0.0.1

# Statistiques
sudo unbound-control stats

# Vider le cache
sudo unbound-control flush server1.local

# Voir les logs
sudo tail -f /var/log/unbound.log
```

### systemd-resolved
```bash
# Statut
resolvectl status

# Tester
resolvectl query server1.local

# Statistiques
resolvectl statistics

# Vider le cache
sudo resolvectl flush-caches

# Éditer config
sudo nano /etc/systemd/resolved.conf

# Redémarrer
sudo systemctl restart systemd-resolved

# Voir les logs
sudo journalctl -u systemd-resolved -f
```

---

## [BRAVO] CONCLUSION

Tu connais maintenant **5 méthodes** de configuration DNS :

1. [OK] **/etc/hosts** - Ultra-simple, limité mais efficace
2. [OK] **DNSmasq** - Simple, tout-en-un (DNS + DHCP)
3. [OK] **BIND9** - Professionnel, complet, complexe
4. [OK] **Unbound** - Moderne, performant, sécurisé
5. [OK] **systemd-resolved** - Intégré, automatique

**Règle d'or :** Commence simple, complexifie uniquement si nécessaire !

```
┌────────────────────────────────────────┐
│  Débutant -> /etc/hosts                 │
│  Intermédiaire -> DNSmasq ou Unbound    │
│  Avancé -> BIND9                        │
│  Desktop -> systemd-resolved            │
└────────────────────────────────────────┘
```

**[BRAVO] Félicitations ! Tu maîtrises maintenant la configuration DNS sur Linux !**