---
title: "TP : suivre une résolution et faire tourner votre propre zone"
domain: networking
level: beginner
duration: "60 min"
cost: "gratuit"
environment: "votre propre ordinateur (Linux, ou WSL2 sous Windows, ou macOS) avec Podman ou Docker"
lang: fr
source_hash: 551cfe9c1290
---

# TP : suivre une résolution et faire tourner votre propre zone

## Objectif
Utilisez `dig` pour suivre une vraie résolution de nom depuis la racine, lire chaque partie d'une réponse DNS et comparer les transports DNS. Ensuite, faites tourner votre propre serveur DNS faisant autorité dans un conteneur, qui sert la zone `lab.example`, interrogez-le, modifiez un enregistrement et observez comment le serial du SOA décide du moment où le changement entre en vigueur.

## Objectifs
- Suivre une résolution de la racine jusqu'aux serveurs faisant autorité avec `dig +trace`, et voir le cache à l'œuvre pendant que le TTL décroît.
- Interroger et reconnaître les types d'enregistrements courants : A, AAAA, CNAME, MX, NS, TXT, PTR, SOA et CAA.
- Lire la sortie de `dig` : statut, indicateurs (`qr`, `aa`, `rd`, `ra`, `ad`, `tc`) et sections réponse, autorité et additionnelle.
- Envoyer la même requête en UDP, TCP, DNS sur TLS et DNS sur HTTPS, et voir la troncature déclencher une nouvelle tentative en TCP.
- Faire tourner un serveur faisant autorité pour une zone à vous, modifier un enregistrement et confirmer le changement grâce au serial du SOA.

## Prérequis
- `dig` de BIND 9.18 ou ultérieur (`dig -v`). Sous Fedora/RHEL : `bind-utils` ; sous Debian/Ubuntu : `bind9-dnsutils` ; sous macOS : `brew install bind` (le `dig` fourni avec macOS est plus ancien et n'a ni `+tls` ni `+https`). Sous Windows, utilisez une distribution Linux dans WSL2.
- Podman 4 ou ultérieur (testé avec Podman 5.8, sans privilèges root, sans `sudo`), ou Docker 20.10 ou ultérieur : remplacez `podman` par `docker` dans chaque commande.
- Accès à Internet pour la partie 1. Les étapes 3, 5 (la requête directe), 8 et 9 s'adressent à d'autres serveurs que le résolveur de votre propre réseau ; elles échouent donc sur les réseaux qui n'autorisent le DNS que vers leur propre résolveur ; voir Dépannage.
- Environ 75 Mo d'espace disque pour l'image CoreDNS.
- [La leçon sur le DNS](lesson.fr.md) de ce module.

> [!WARNING]
> La partie 1 envoie des recherches ordinaires de noms publics à des résolveurs publics ; c'est un usage normal du DNS. N'allez pas au-delà : pas de tentatives de transfert de zone (AXFR), d'avalanches, de scans ni de tests de « résolveur ouvert » contre des serveurs qui ne sont pas à vous. La partie 2 fait tourner un serveur lié uniquement à `127.0.0.1` ; rien en dehors de votre machine ne peut donc l'atteindre, et le seul transfert de zone que vous tentez vise ce serveur. Le TP est gratuit et ne modifie rien sur votre système en dehors d'un dossier et d'une image de conteneur, tous deux supprimés à la fin.

> [!NOTE]
> Les sorties ci-dessous ont été capturées en novembre 2026. Les adresses, TTL, serveurs de noms et signatures de domaines réels (comme `example.com`, que l'IANA héberge chez un fournisseur DNS commercial) changent avec le temps ; les vôtres seront donc différentes. Ce qu'il faut comparer, c'est la structure, les indicateurs et les codes de statut. Votre propre zone n'utilise que des adresses de documentation (RFC 5737 et RFC 3849).

## Architecture
![Architecture du TP. Sur votre ordinateur, dig s'exécute dans un terminal. Partie 1 : dig interroge des résolveurs publics comme 1.1.1.1, 9.9.9.9 et 8.8.8.8, ou le résolveur du système, en UDP ou TCP 53, TLS 853 ou HTTPS 443 ; les résolveurs font des requêtes itératives à la hiérarchie DNS : racine, com. et example.com. Partie 2 : dig interroge 127.0.0.1 port 5300, redirigé vers le port 53 du conteneur Podman dns-lab, où CoreDNS 1.12.0 fait autorité pour lab.example. Le dossier ~/dns-lab, avec le Corefile et le fichier de zone db.lab.example, est monté en lecture seule dans le conteneur](../../../assets/diagrams/dns-lab-architecture.fr.svg)

*Figure 1. La partie 1 s'adresse au vrai DNS via des résolveurs ; la partie 2 s'adresse à votre propre serveur faisant autorité sur `127.0.0.1:5300`.*

Le port 5300 est utilisé parce que le port 53 exige des droits d'administrateur et est généralement occupé par le résolveur de votre système, et que le port 5353 est utilisé par le DNS multicast (mDNS, par exemple Avahi ou Bonjour).

## Étapes

### Étape 1 — Vérifiez vos outils et créez un dossier de travail
Confirmez d'abord les versions : `+tls` et `+https` nécessitent BIND 9.18 ou ultérieur. Vous garderez les fichiers de zone dans un seul dossier, pour que le nettoyage soit facile.

```bash
dig -v
podman --version
mkdir -p ~/dns-lab && cd ~/dns-lab
```

> [!WARNING]
> Exécutez toutes les commandes suivantes depuis `~/dns-lab`. L'étape 11 monte le dossier courant dans le conteneur avec `:Z`, qui le réétiquette pour SELinux ; lancé depuis votre dossier personnel, cela réétiqueterait et exposerait tout son contenu.

Sortie attendue (les versions peuvent être plus récentes) :
```text
DiG 9.18.50
podman version 5.8.7
```

Vérifiez que rien n'écoute déjà sur le port 5300 (Linux) :
```bash
ss -lntu | grep ':5300 ' || echo "port 5300 is free"
```

Sortie attendue :
```text
port 5300 is free
```

Si quelque chose apparaît, choisissez un autre port élevé (par exemple 5301) et utilisez-le partout où ce TP indique `5300`. Sous macOS, utilisez plutôt `lsof -nP -i :5300` ; l'absence de sortie signifie que le port est libre.

## Partie 1 — Le vrai DNS, en lecture seule

### Étape 2 — Votre première recherche, lue en entier
Commencez par une requête simple au résolveur de votre système et lisez chaque section, comme sur la figure 2 de la leçon.

```bash
dig example.com
```

Sortie attendue :
```text
; <<>> DiG 9.18.50 <<>> example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 46107
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;example.com.			IN	A

;; ANSWER SECTION:
example.com.		176	IN	A	104.20.23.154
example.com.		176	IN	A	172.66.147.243

;; Query time: 2 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Fri Nov 06 22:12:34 CET 2026
;; MSG SIZE  rcvd: 72
```

Notez dans vos notes :
- **Statut** `NOERROR` et indicateurs `qr rd ra` : une réponse (`qr`), vous avez demandé la récursivité (`rd`) et le serveur l'offre (`ra`). Il n'y a pas de `aa` : c'est un résolveur qui a répondu, pas le serveur faisant autorité. Il n'y a pas non plus de `ad` : ce résolveur n'a pas signalé de validation DNSSEC.
- **Réponse** : deux enregistrements A (un RRset), chacun avec nom, TTL, classe `IN`, type et adresse.
- **SERVER** : quel résolveur a répondu et par quel transport. `127.0.0.53` est le stub local de systemd-resolved sur de nombreux systèmes Linux ; le vôtre peut être l'adresse de votre box ou de votre FAI. La valeur élevée `udp: 65494` vient de ce stub local ; les vrais résolveurs annoncent généralement 1232.

### Étape 3 — Suivez la délégation depuis la racine
`+trace` fait faire à `dig` lui-même ce que fait un résolveur récursif : interroger la racine, suivre chaque renvoi et finir chez les serveurs faisant autorité.

```bash
dig +trace example.com
```

Sortie attendue (les longues lignes de signature `RRSIG` abrégées en `…`) :
```text
.			22378	IN	NS	a.root-servers.net.
.			22378	IN	NS	b.root-servers.net.
...
.			22378	IN	NS	m.root-servers.net.
.			23505	IN	RRSIG	NS 8 0 518400 20261119170000 20261106160000 8763 . …
;; Received 1037 bytes from 127.0.0.53#53(127.0.0.53) in 3 ms

com.			172800	IN	NS	a.gtld-servers.net.
...
com.			172800	IN	NS	m.gtld-servers.net.
com.			86400	IN	DS	19718 13 2 8ACBB0CD28F41250A80A491389424D341522D946B0DA0C0291F2D3D7 71D7805A
com.			86400	IN	RRSIG	DS 8 1 86400 20261119170000 20261106160000 8763 . …
;; Received 1171 bytes from 2801:1b8:10::b#53(b.root-servers.net) in 77 ms

example.com.		172800	IN	NS	hera.ns.cloudflare.com.
example.com.		172800	IN	NS	elliott.ns.cloudflare.com.
example.com.		86400	IN	DS	2371 13 2 C988EC423E3880EB8DD8A46FE06CA230EE23F35B578D64E78B29C3E1 C83D245A
example.com.		86400	IN	RRSIG	DS 13 2 86400 20261113013408 20261106002408 65344 com. …
;; Received 506 bytes from 2001:503:d2d::30#53(k.gtld-servers.net) in 37 ms

example.com.		300	IN	A	172.66.147.243
example.com.		300	IN	A	104.20.23.154
example.com.		300	IN	RRSIG	A 13 2 300 20261107221240 20261105201240 34505 example.com. …
;; Received 179 bytes from 2606:4700:50::adf5:3aa2#53(hera.ns.cloudflare.com) in 3 ms
```

Associez chaque bloc à la figure 5 de la leçon :
1. Votre résolveur fournit les 13 noms de serveurs racine, de `a` à `m` (comme les root hints).
2. Un serveur racine (ici `b.root-servers.net`) vous renvoie vers les 13 serveurs de `com`. Il envoie aussi un enregistrement **DS** pour `com` : le lien DNSSEC entre la racine et `com`.
3. Un serveur de `com` vous renvoie vers les serveurs de noms d'`example.com`, avec un enregistrement DS pour `example.com`.
4. L'un de ces serveurs répond avec les enregistrements A. Son TTL est la valeur complète, 300, car il s'agit de la copie faisant autorité, pas d'une copie en cache.

Notez les serveurs de noms qu'`example.com` utilise aujourd'hui ; vous aurez besoin de l'un d'eux à l'étape 5.

### Étape 4 — Découvrez les types d'enregistrements
Demandez différents types de données. `+noall +answer` masque tout sauf la section réponse.

```bash
dig example.com AAAA +noall +answer
dig example.com NS +noall +answer
dig example.com SOA +noall +answer
dig example.com MX +noall +answer
dig example.com TXT +noall +answer
```

Sortie attendue :
```text
example.com.		70	IN	AAAA	2606:4700:10::6814:179a
example.com.		70	IN	AAAA	2606:4700:10::ac42:93f3
example.com.		25054	IN	NS	elliott.ns.cloudflare.com.
example.com.		25054	IN	NS	hera.ns.cloudflare.com.
example.com.		1800	IN	SOA	elliott.ns.cloudflare.com. dns.cloudflare.com. 2418004112 10000 2400 604800 1800
example.com.		300	IN	MX	0 .
example.com.		300	IN	TXT	"v=spf1 -all"
example.com.		300	IN	TXT	"_k2n1y4vw3qtb4skdx9e7dxt97qrmmq9"
```

Lisez-les en regard du tableau des enregistrements de la leçon :
- **AAAA** : les adresses IPv6.
- **NS** : les serveurs faisant autorité, comme à l'étape 3.
- **SOA** : serveur primaire, boîte aux lettres de contact (`dns@cloudflare.com`, avec le `@` écrit sous forme de point), serial `2418004112`, puis refresh, retry, expire et minimum (TTL du cache négatif, 1800 s).
- **MX `0 .`** est un **MX nul** (RFC 7505) : `example.com` n'accepte aucun courrier. Le TXT `v=spf1 -all` ajoute qu'aucun serveur ne peut envoyer de courrier en son nom. Ensemble, ils empêchent qu'un domaine qui ne doit jamais envoyer ni recevoir de courrier serve à du courrier usurpé.
- La seconde chaîne TXT est un jeton typique de preuve de propriété du domaine.

Voyons maintenant un enregistrement **CNAME** et un enregistrement **CAA**, sur des domaines bien connus :

```bash
dig www.wikipedia.org +noall +answer
dig wikipedia.org CAA +noall +answer
```

Sortie attendue :
```text
www.wikipedia.org.	17574	IN	CNAME	dyna.wikimedia.org.
dyna.wikimedia.org.	109	IN	A	185.15.58.224
wikipedia.org.		600	IN	CAA	0 iodef "mailto:dns-admin@wikimedia.org"
wikipedia.org.		600	IN	CAA	0 issue "pki.goog"
wikipedia.org.		600	IN	CAA	0 issue "letsencrypt.org"
```

Le résolveur a suivi le CNAME pour vous et renvoyé toute la chaîne : d'abord l'alias, puis l'enregistrement A de la cible. Chaque enregistrement a son propre TTL. Les enregistrements CAA autorisent deux AC à émettre des certificats (`issue`) et donnent un contact pour les rapports (`iodef`). L'adresse A dépend de l'endroit où vous vous trouvez : les grands sites répondent avec un centre de données proche.

### Étape 5 — Réponses du cache ou faisant autorité
Interrogez deux fois votre résolveur, à environ 10 secondes d'intervalle, et observez le TTL.

```bash
dig www.ietf.org +noall +answer; sleep 10; dig www.ietf.org +noall +answer
```

Sortie attendue :
```text
www.ietf.org.		28	IN	A	104.16.45.99
www.ietf.org.		28	IN	A	104.16.44.99
www.ietf.org.		17	IN	A	104.16.44.99
www.ietf.org.		17	IN	A	104.16.45.99
```

Le TTL a diminué d'environ le temps écoulé : les deux réponses proviennent de la même copie en cache. Quand il atteint 0, le résolveur récupère une copie fraîche et le TTL remonte à la valeur de la zone. (L'ordre des enregistrements d'un RRset peut changer d'une réponse à l'autre ; il n'a pas de signification.)

> [!TIP]
> Si vous essayez avec un grand résolveur public comme `1.1.1.1`, le TTL peut sauter au lieu de décroître régulièrement : l'anycast et la répartition de charge peuvent envoyer vos deux requêtes vers des caches différents.

Interrogez maintenant directement l'un des serveurs faisant autorité que vous avez notés à l'étape 3, avec la récursivité désactivée :

```bash
dig @<ns> example.com +norec
```

`<ns>` est l'un des serveurs de noms d'`example.com` de l'étape 3, par exemple `hera.ns.cloudflare.com`.

Sortie attendue (en-tête et réponse) :
```text
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40469
;; flags: qr aa; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
...
;; ANSWER SECTION:
example.com.		300	IN	A	172.66.147.243
example.com.		300	IN	A	104.20.23.154
```

`aa` est activé et `ra` ne l'est pas : un serveur faisant autorité, qui ne fait pas de récursivité pour vous. Relancez la commande : le TTL reste à 300, car le serveur est propriétaire des données au lieu de les mettre en cache.

### Étape 6 — Un nom qui n'existe pas
Les réponses négatives apportent aussi de l'information.

```bash
dig nonexistent.iana.org
```

Sortie attendue (de l'en-tête à la section autorité) :
```text
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 4050
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
;; QUESTION SECTION:
;nonexistent.iana.org.		IN	A

;; AUTHORITY SECTION:
iana.org.		3600	IN	SOA	sns.dns.icann.org. noc.dns.icann.org. 2026110301 7200 3600 1209600 3600
```

`NXDOMAIN` avec une réponse vide et le SOA de la zone dans la section autorité. Le résolveur met en cache ce « n'existe pas » pendant la plus petite valeur entre le TTL du SOA et son dernier champ (tous deux 3600 ici) : cache négatif, RFC 2308. Cette sortie provient d'un résolveur validant ; elle porte donc aussi `ad` : l'inexistence elle-même a été prouvée avec DNSSEC.

> [!NOTE]
> Certains fournisseurs DNS répondent aux requêtes de noms inexistants dans des zones signées par `NOERROR` et une réponse vide plutôt que par `NXDOMAIN` (une technique pour réduire la taille des réponses de déni DNSSEC). Si vous essayez d'autres domaines et constatez cela, c'est un choix du fournisseur, pas une erreur de votre part.

### Étape 7 — Recherches inverses
`-x` construit pour vous le nom inverse sous `in-addr.arpa` ou `ip6.arpa` et demande son enregistrement PTR.

```bash
dig -x 8.8.8.8 +noall +question +answer
dig -x 2001:4860:4860::8888 +short
```

Sortie attendue :
```text
;8.8.8.8.in-addr.arpa.		IN	PTR
8.8.8.8.in-addr.arpa.	17593	IN	PTR	dns.google.
dns.google.
```

La question montre l'adresse inversée. Pour l'adresse IPv6, `dig` écrit les 32 chiffres hexadécimaux à l'envers, un label chacun, sous `ip6.arpa` ; ajoutez `+noall +answer` à la place de `+short` pour voir ce nom.

### Étape 8 — Transports : UDP, TCP, TLS, HTTPS
Envoyez la même requête par chaque transport et lisez la ligne `SERVER`. `1.1.1.1` est utilisé parce qu'il prend en charge les quatre ; n'importe quel résolveur proposant DoT et DoH conviendrait.

```bash
dig @1.1.1.1 example.com +noall +answer +stats | grep SERVER
dig @1.1.1.1 example.com +tcp +noall +answer +stats | grep SERVER
dig @1.1.1.1 example.com +tls +noall +answer +stats | grep SERVER
dig @1.1.1.1 example.com +https +noall +answer +stats | grep SERVER
```

Sortie attendue :
```text
;; SERVER: 1.1.1.1#53(1.1.1.1) (UDP)
;; SERVER: 1.1.1.1#53(1.1.1.1) (TCP)
;; SERVER: 1.1.1.1#853(1.1.1.1) (TLS)
;; SERVER: 1.1.1.1#443(1.1.1.1) (HTTPS)
```

Même question, même réponse, quatre transports : port 53 en UDP et TCP (en clair), 853 pour DNS sur TLS, 443 pour DNS sur HTTPS.

Voyons maintenant la **troncature**. Le jeu de clés de la zone racine avec ses signatures fait environ 1 100 octets. Faites comme si votre client ne pouvait recevoir que 512 octets en UDP, et dites à `dig` de ne pas réessayer (`+ignore`) :

```bash
dig @1.1.1.1 . DNSKEY +dnssec +bufsize=512 +ignore | grep -E 'flags|SERVER'
```

Sortie attendue :
```text
;; flags: qr tc rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
;; SERVER: 1.1.1.1#53(1.1.1.1) (UDP)
```

`tc` est activé et la réponse est vide. Relancez sans `+ignore` :

```bash
dig @1.1.1.1 . DNSKEY +dnssec +bufsize=512 | grep -E 'Truncated|flags:|SERVER|MSG'
```

Sortie attendue :
```text
;; Truncated, retrying in TCP mode.
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1
;; SERVER: 1.1.1.1#53(1.1.1.1) (TCP)
;; MSG SIZE  rcvd: 1139
```

C'est pourquoi TCP 53 ne doit jamais être bloqué : les grosses réponses, comme les réponses signées, en dépendent.

### Étape 9 — DNSSEC : validé, puis volontairement en échec
Demandez des données signées à un résolveur validant et cherchez `ad` :

```bash
dig @1.1.1.1 example.com +dnssec +noall +comments | grep flags
```

Sortie attendue :
```text
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
```

`ad` : le résolveur a validé la chaîne de confiance. Le troisième enregistrement de la réponse est la signature RRSIG (ajoutez `+answer` pour le voir).

`dnssec-failed.org` est un domaine de test dont l'opérateur maintient volontairement le DNSSEC cassé pour que l'on puisse voir ce qui se passe. Interrogez-le normalement, puis avec la vérification désactivée (`+cd`) :

```bash
dig @1.1.1.1 dnssec-failed.org | grep status
dig @1.1.1.1 dnssec-failed.org +cd | grep -E 'status|flags:|EDE'
```

Sortie attendue :
```text
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 26914
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 18406
;; flags: qr rd ra cd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags:; udp: 1232
; EDE: 9 (DNSKEY Missing): (no SEP matching the DS found for dnssec-failed.org.)
```

Le résolveur validant refuse les données falsifiées avec `SERVFAIL`. Avec `+cd`, vous obtenez quand même les données, sans `ad`, et une erreur DNS étendue (EDE, Extended DNS Error, RFC 8914) explique pourquoi la validation a échoué : la clé de la zone ne correspond pas à l'enregistrement DS du parent. Notez que tout ce que vous avez vu à cette étape a circulé en clair : DNSSEC prouve l'authenticité, pas la confidentialité.

## Partie 2 — Votre propre serveur faisant autorité

### Étape 10 — Écrivez le fichier de zone et la configuration du serveur
Un serveur faisant autorité a besoin de deux choses : les données de la zone et une configuration qui dit quelle zone servir. Vous utiliserez **CoreDNS**, un petit serveur DNS open source, avec son plugin `file`. La zone `lab.example` est sûre à utiliser : le TLD `example` est réservé à la documentation (RFC 2606) et n'existe jamais sur Internet.

Créez le fichier de zone dans `~/dns-lab` :

```bash
cat > db.lab.example <<'EOF'
$ORIGIN lab.example.
$TTL 300
@       IN  SOA   ns1.lab.example. hostmaster.lab.example. (
                  2026110601 ; serial (YYYYMMDDnn)
                  3600       ; refresh
                  600        ; retry
                  604800     ; expire
                  60 )       ; minimum: negative-caching TTL
        IN  NS    ns1.lab.example.
        IN  MX    10 mail.lab.example.
        IN  TXT   "v=spf1 mx -all"
        IN  CAA   0 issue "ca.example.net"
ns1     IN  A     192.0.2.53
www     IN  A     192.0.2.10
www     IN  AAAA  2001:db8::10
mail    IN  A     192.0.2.25
app     IN  CNAME www.lab.example.
EOF
```

Puis la configuration de CoreDNS, le `Corefile` :

```bash
cat > Corefile <<'EOF'
lab.example {
    file /etc/coredns/db.lab.example {
        reload 10s
    }
    log
    errors
}
EOF
```

Elle dit : pour les noms de `lab.example`, répondre depuis le fichier de zone ; vérifier le fichier toutes les 10 secondes pour détecter un nouveau serial ; journaliser chaque requête. Les noms hors de `lab.example` sont refusés : c'est un serveur uniquement faisant autorité, pas un résolveur.

Aucune sortie n'est attendue. `ls` doit afficher `Corefile` et `db.lab.example`.

### Étape 11 — Démarrez le serveur dans un conteneur
Lancez CoreDNS avec votre dossier monté en lecture seule et le port 53 du conteneur publié sur `127.0.0.1:5300`, en UDP comme en TCP.

```bash
podman run -d --name dns-lab \
  -p 127.0.0.1:5300:53/udp -p 127.0.0.1:5300:53/tcp \
  -v "$PWD":/etc/coredns:ro,Z \
  docker.io/coredns/coredns:1.12.0 -conf /etc/coredns/Corefile
```

- `-p 127.0.0.1:5300:53/udp` et `/tcp` : seule votre propre machine peut atteindre le serveur ; le DNS a besoin des deux protocoles.
- `-v "$PWD":/etc/coredns:ro,Z` : monte le dossier courant en lecture seule. `Z` le réétiquette pour SELinux (Fedora, RHEL) ; sur les systèmes sans SELinux, il ne gêne pas, et vous pouvez le retirer si votre version de Docker s'en plaint. Le dossier entier est monté, et non des fichiers isolés, pour que les modifications faites par n'importe quel éditeur de texte soient visibles dans le conteneur.
- L'étiquette de l'image est figée sur `1.12.0` pour que le TP se comporte de la même façon pour tout le monde.

Vérifiez ensuite qu'il tourne :
```bash
podman ps --filter name=dns-lab
podman logs dns-lab
```

Sortie attendue (les ID diffèrent) :
```text
CONTAINER ID  IMAGE                             COMMAND               CREATED        STATUS        PORTS                                           NAMES
b0474e9d2db7  docker.io/coredns/coredns:1.12.0  -conf /etc/coredn...  2 seconds ago  Up 2 seconds  127.0.0.1:5300->53/tcp, 127.0.0.1:5300->53/udp  dns-lab
maxprocs: Leaving GOMAXPROCS=16: CPU quota undefined
lab.example.:53
CoreDNS-1.12.0
linux/amd64, go1.23.3, 51e11f1
```

`lab.example.:53` confirme que la zone est chargée et que le serveur écoute sur le port 53 à l'intérieur du conteneur.

### Étape 12 — Interrogez votre zone
Interrogez directement votre serveur. `-p 5300` fixe le port ; `+norec` car ce n'est pas un résolveur.

```bash
dig @127.0.0.1 -p 5300 www.lab.example +norec
```

Sortie attendue (de l'en-tête à la ligne du serveur) :
```text
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42732
;; flags: qr aa; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: ce837fc3bf088f64 (echoed)
;; QUESTION SECTION:
;www.lab.example.		IN	A

;; ANSWER SECTION:
www.lab.example.	300	IN	A	192.0.2.10

;; AUTHORITY SECTION:
lab.example.		300	IN	NS	ns1.lab.example.

;; Query time: 0 msec
;; SERVER: 127.0.0.1#5300(127.0.0.1) (UDP)
```

`aa` : c'est vous, maintenant, qui faites autorité. Ce serveur liste aussi l'enregistrement NS de la zone dans la section autorité. La ligne `COOKIE` est un cookie DNS (RFC 7873), une protection légère contre les requêtes usurpées.

Interrogez maintenant chaque type d'enregistrement que vous avez publié :

```bash
D="dig @127.0.0.1 -p 5300 +norec +noall +answer"
$D lab.example SOA
$D lab.example MX
$D lab.example TXT
$D lab.example CAA
$D www.lab.example AAAA
$D app.lab.example A
```

Sortie attendue :
```text
lab.example.		300	IN	SOA	ns1.lab.example. hostmaster.lab.example. 2026110601 3600 600 604800 60
lab.example.		300	IN	MX	10 mail.lab.example.
lab.example.		300	IN	TXT	"v=spf1 mx -all"
lab.example.		300	IN	CAA	0 issue "ca.example.net"
www.lab.example.	300	IN	AAAA	2001:db8::10
app.lab.example.	300	IN	CNAME	www.lab.example.
www.lab.example.	300	IN	A	192.0.2.10
```

`D` est simplement une variable shell qui évite de la saisie. Chaque enregistrement a le TTL par défaut de la zone, 300, issu de `$TTL`. Pour `app`, le serveur a suivi le CNAME dans sa propre zone et ajouté l'enregistrement A de la cible.

Ensuite, trois réponses qui ne sont pas des données :

```bash
dig @127.0.0.1 -p 5300 nope.lab.example +norec | grep -E 'status|SOA'
dig @127.0.0.1 -p 5300 www.example.com +norec | grep status
dig @127.0.0.1 -p 5300 lab.example AXFR
```

Sortie attendue :
```text
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 32533
lab.example.		300	IN	SOA	ns1.lab.example. hostmaster.lab.example. 2026110601 3600 600 604800 60
;; ->>HEADER<<- opcode: QUERY, status: REFUSED, id: 60198

; <<>> DiG 9.18.50 <<>> @127.0.0.1 -p 5300 lab.example AXFR
; (1 server found)
;; global options: +cmd
; Transfer failed.
```

- `NXDOMAIN` avec votre SOA. CoreDNS envoie le SOA avec son propre TTL (300) ; selon la RFC 2308, un résolveur met en cache la réponse négative pendant la plus petite valeur entre ce TTL et le dernier champ du SOA, soit 60 secondes.
- `REFUSED` pour `www.example.com` : votre serveur ne fait pas autorité pour ce nom et ne fait pas de récursivité.
- Le transfert de zone échoue parce que CoreDNS n'autorise pas les transferts tant que vous ne les configurez pas (avec son plugin `transfer`). C'est le réglage sûr par défaut : seuls vos propres serveurs secondaires devraient pouvoir copier une zone.

Enfin, regardez le journal des requêtes :
```bash
podman logs dns-lab 2>&1 | tail -3
```

Sortie attendue (l'adresse du client dépend de la configuration réseau de Podman sur votre machine) :
```text
[INFO] <client-ip>:59919 - 48226 "A IN app.lab.example. udp 56 false 1232" NOERROR qr,aa 148 0.000053703s
[INFO] <client-ip>:38194 - 27721 "A IN nope.lab.example. udp 57 false 1232" NXDOMAIN qr,aa 118 0.000072779s
[INFO] <client-ip>:60166 - 21479 "AXFR IN lab.example. tcp 52 false 65535" - - 0 0.000022052s
```

Chaque ligne indique l'adresse et le port du client, l'ID du message, la question, le transport (remarquez `tcp` pour l'AXFR), le code de réponse, les indicateurs, la taille de la réponse et le temps écoulé. La requête refusée pour `www.example.com` n'y figure pas : la ligne `log` du `Corefile` ne s'applique qu'au bloc `lab.example`.

### Étape 13 — Modifiez un enregistrement et observez le serial
Vous allez déplacer `www` de `192.0.2.10` vers `192.0.2.11`. D'abord, ne changez que l'adresse et **ne touchez pas** au serial. Ouvrez `db.lab.example` dans un éditeur de texte et modifiez la ligne `www IN A`, ou sous Linux :

```bash
sed -i 's/192\.0\.2\.10/192.0.2.11/' db.lab.example
grep '^www' db.lab.example
```

Sortie attendue :
```text
www     IN  A     192.0.2.11
www     IN  AAAA  2001:db8::10
```

Attendez au moins 15 secondes (l'intervalle `reload` est de 10 s), puis interrogez :

```bash
dig @127.0.0.1 -p 5300 www.lab.example +short
```

Sortie attendue :
```text
192.0.2.10
```

C'est toujours l'ancienne adresse. CoreDNS (comme les serveurs secondaires) ne recharge une zone que lorsque le **serial** augmente. Augmentez maintenant le serial de `2026110601` à `2026110602` :

```bash
sed -i 's/2026110601 ; serial/2026110602 ; serial/' db.lab.example
```

Attendez encore 15 secondes, puis répétez la requête et la vérification du journal :

```bash
dig @127.0.0.1 -p 5300 www.lab.example +short
dig @127.0.0.1 -p 5300 lab.example SOA +short
podman logs dns-lab 2>&1 | grep reloaded
```

Sortie attendue :
```text
192.0.2.11
ns1.lab.example. hostmaster.lab.example. 2026110602 3600 600 604800 60
[INFO] plugin/file: Successfully reloaded zone "lab.example." in "/etc/coredns/db.lab.example" with 2026110602 SOA serial
```

La nouvelle adresse est en service dès que le serial augmente. Sur le vrai Internet, il y aurait un délai de plus : les résolveurs qui ont mis en cache l'ancien enregistrement A continuent de le renvoyer jusqu'à l'épuisement de son TTL de 300 secondes.

> [!NOTE]
> Sous macOS, `sed -i` nécessite un argument vide : `sed -i '' 's/…/…/' db.lab.example`. Ou modifiez simplement le fichier dans n'importe quel éditeur de texte.

## Vérification
Vous avez terminé le TP si tous les points suivants sont vrais :

| Contrôle | Condition de réussite |
|---|---|
| Trace | À l'étape 3, vous pouvez nommer le serveur qui a répondu à chaque niveau (racine, `com`, `example.com`) et montrer les enregistrements DS qui les relient. |
| Cache | À l'étape 5, le TTL de votre résolveur a diminué entre deux requêtes, et le TTL du serveur faisant autorité est resté identique avec `aa` activé. |
| Enregistrements | Vous avez identifié des réponses A, AAAA, NS, SOA, MX (MX nul), TXT, CNAME, CAA (étape 4) et PTR (étape 7). |
| Transports | L'étape 8 a montré `(UDP)`, `(TCP)`, `(TLS)` sur le port 853 et `(HTTPS)` sur le port 443, et une réponse `tc` refaite en TCP. |
| DNSSEC | L'étape 9 a montré `ad` pour `example.com` et `SERVFAIL` pour `dnssec-failed.org`. |
| Votre zone | `dig @127.0.0.1 -p 5300 www.lab.example +norec` affiche `flags: qr aa` et, après l'étape 13, l'adresse `192.0.2.11` avec le serial `2026110602`. |

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `dig +trace` s'arrête avec `communications error … timed out` après la liste de la racine | Votre réseau bloque le DNS sortant vers tout autre serveur que son propre résolveur (courant en entreprise, à l'hôtel et sur certaines box). | Sautez l'étape 3 ou faites-la sur un autre réseau que vous avez le droit d'utiliser ; le reste de la partie 1 passe par des résolveurs. |
| `+tls` ou `+https` affiche `Invalid option` | `dig` antérieur à 9.18 (par exemple celui intégré à macOS) ou compilé sans prise en charge de DoH. | Installez un BIND récent (`brew install bind`, ou le paquet de votre Linux) et vérifiez `dig -v`. |
| `+tls` ou `+https` expire | Le réseau bloque le port 853, ou filtre DoH. | Notez-le comme une observation : c'est le compromis évoqué dans la leçon. Essayez un autre réseau que vous avez le droit d'utiliser. |
| `podman run` échoue avec `address already in use` | Quelque chose écoute déjà sur `127.0.0.1:5300`. | Choisissez un autre port (par exemple 5301) dans les options `-p` et dans chaque commande `dig -p`. |
| `dig @127.0.0.1 -p 5300 …` renvoie `connection refused` ou expire | Le conteneur ne tourne pas : une erreur dans le `Corefile` ou le fichier de zone arrête CoreDNS. | `podman logs dns-lab` affiche l'erreur et le numéro de ligne. Corrigez le fichier, puis `podman rm -f dns-lab` et refaites l'étape 11. |
| `permission denied` à la lecture de `/etc/coredns/Corefile` dans les journaux | SELinux a bloqué le dossier monté. | Vérifiez que l'option du volume inclut `Z` (`:ro,Z`). |
| `REFUSED` pour `www.lab.example` | La zone n'a pas été chargée (par exemple une faute de frappe dans `$ORIGIN` ou un point final manquant) ; le serveur n'a donc pas de zone `lab.example`. | Consultez `podman logs dns-lab` et comparez votre fichier de zone avec l'étape 10. |
| Un enregistrement modifié n'apparaît pas | Le serial n'a pas été augmenté, ou moins de 10 secondes se sont écoulées. | Augmentez le serial et attendez 15 secondes ; cherchez `Successfully reloaded zone` dans les journaux. |
| `podman: command not found` | Podman n'est pas installé. | Installez-le depuis les paquets de votre distribution, ou utilisez Docker et remplacez `podman` par `docker` dans chaque commande. |

## Défi (facultatif)
Ajoutez à votre serveur une zone inverse pour `192.0.2.0/24` : un second bloc `file` dans le `Corefile` pour `2.0.192.in-addr.arpa`, et un fichier de zone avec un SOA, un NS et des enregistrements PTR pour `192.0.2.10`, `192.0.2.25` et `192.0.2.53`. Vérifiez avec `dig @127.0.0.1 -p 5300 -x 192.0.2.10 +norec`. Abaissez ensuite le TTL de `www` à 60 secondes (n'oubliez pas le serial) et expliquez, en deux phrases, pourquoi vous le feriez un jour avant une vraie migration.

## Nettoyage
Arrêtez et supprimez le conteneur, supprimez l'image et effacez le dossier du TP :

```bash
podman rm -f dns-lab
podman rmi docker.io/coredns/coredns:1.12.0
cd ~ && rm -r ~/dns-lab
```

Sortie attendue (les ID diffèrent) :
```text
dns-lab
Untagged: docker.io/coredns/coredns:1.12.0
Deleted: 1cf5f116067c67da67f97bff78c4bbc76913f59057c18627b96facaced73ea0b
```

Vérifiez qu'il ne reste rien :
```bash
podman ps -a --filter name=dns-lab
podman images coredns/coredns
```

Les deux commandes ne doivent afficher que leurs lignes d'en-tête. La partie 1 n'a rien créé à nettoyer ; les enregistrements que votre résolveur a mis en cache expirent d'eux-mêmes.

## Ce que vous avez appris
- `dig +trace` montre la chaîne de délégation : renvoi de la racine vers `com`, renvoi de `com` vers les serveurs du domaine, et réponse faisant autorité, avec des enregistrements DS reliant chaque niveau pour DNSSEC.
- Le TTL d'un résolveur décroît parce que la réponse vient de son cache ; celui d'un serveur faisant autorité non, et il active `aa`.
- Comment lire chaque type d'enregistrement, y compris un MX nul, une chaîne de CNAME, CAA, les champs du SOA et les enregistrements PTR sous `in-addr.arpa` et `ip6.arpa`.
- Les codes de statut NOERROR, NXDOMAIN (avec SOA pour le cache négatif), SERVFAIL (échec de validation DNSSEC) et REFUSED.
- La même requête fonctionne en UDP 53, TCP 53, TLS 853 et HTTPS 443, et une réponse UDP tronquée (`tc`) est refaite en TCP.
- Un serveur faisant autorité ne sert que ses zones, refuse les autres et devrait refuser les transferts de zone à des inconnus ; les modifications d'une zone ne prennent effet que lorsque le serial du SOA augmente.
