# Guide simple : configurer AdGuard Home (DNS + blocage pubs) 

+ Config  Docker + DoH

Ce guide explique comment installer et configurer **AdGuard Home** pour un réseau domestique ou un petit serveur, avec une configuration **solide, rapide et fiable**.  
Objectifs :
- Bloquer pubs/trackers via DNS
- Utiliser des DNS amont modernes (**DoH** = DNS over HTTPS)
- Garder une config simple à maintenir
- (Optionnel) Split-DNS pour accéder à des services locaux avec le même domaine
- Check Command
---

## 1) Concepts rapides

### AdGuard Home, c’est quoi ?
- Un serveur DNS local : tes appareils l’utilisent comme DNS.
- AdGuard filtre les domaines (listes, règles) et met en cache les réponses.
- Si un domaine n’est pas bloqué, AdGuard le résout via des **DNS amont** (“upstream”).

### DoH (DNS over HTTPS), c’est quoi ?
- DNS classique : requêtes en clair sur UDP/TCP 53.
- **DoH** : requêtes DNS envoyées **dans HTTPS** (port 443), chiffré.
- Avantages : confidentialité sur le réseau, moins de blocages sur certains réseaux, config cohérente.

---

## 2) Installation Docker (recommandé)

Crée un dossier de travail :
```bash
mkdir -p /opt/adguardhome/{work,conf}
cd /opt/adguardhome
```

### Option A — Mode `host` (souvent le plus simple pour un DNS)
`docker-compose.yml` :
```yaml
services:
  adguardhome:
    image: adguard/adguardhome:latest
    container_name: adguardhome
    network_mode: host
    volumes:
      - ./work:/opt/adguardhome/work
      - ./conf:/opt/adguardhome/conf
    restart: unless-stopped
```

Démarrer :
```bash
docker compose up -d
```

Accès à l’assistant (setup) :
- `http://IP_DU_SERVEUR:3000`

> En mode `host`, AdGuard écoute directement sur la machine (DNS sur 53, etc.).

### Option B — Mode “bridge” (si tu préfères mapper les ports)
`docker-compose.yml` :
```yaml
services:
  adguardhome:
    image: adguard/adguardhome:latest
    container_name: adguardhome
    ports:
      - "3000:3000/tcp"   # setup
      - "53:53/tcp"
      - "53:53/udp"
      - "80:80/tcp"
      - "443:443/tcp"
    volumes:
      - ./work:/opt/adguardhome/work
      - ./conf:/opt/adguardhome/conf
    restart: unless-stopped
```

---

## 3) Vérifier que le port DNS 53 est libre

Sur Linux, le port 53 peut déjà être pris (ex: systemd-resolved, dnsmasq).

```bash
sudo ss -lntup | grep -E ':(53)\b'
sudo ss -lnup  | grep -E ':(53)\b'
```

S’il y a un service sur `:53`, il faut le désactiver ou changer sa config, sinon AdGuard ne pourra pas écouter.

---

## 4) Configuration dans l’assistant (premier lancement)

Dans l’UI de setup :
- **Interface web admin** : IP du serveur + port (souvent `3000` au début)
- **Serveur DNS** :
  - Interface : “toutes les interfaces” (ou l’IP LAN si tu veux limiter)
  - Port : `53`

Une fois terminé, l’UI peut passer sur `http://IP:80` ou `https://IP:443` selon ton choix.

---

## 5) Config DNS “solide et rapide” (tout-DoH)

Dans l’UI :
**Paramètres → Paramètres DNS → Serveurs DNS amont**

### Upstream DoH recommandés (simples et efficaces)
Utilise 2 upstream max (plus que 2 = moins prévisible) : 
exemple avec ces bon dns
 - Cloudflare DoH : `https://cloudflare-dns.com/dns-query`
 - Quad9 DoH :  `https://dns.quad9.net/dns-query`

#### Upstream 
  ```
 https://cloudflare-dns.com/dns-query
 https://dns.quad9.net/dns-query
  ```
 

### Bootstrap DNS
Le bootstrap sert à résoudre les noms des endpoints DoH au démarrage :
```
1.1.1.1
9.9.9.9
```

### Fallback DNS
Secours si les upstream ne répondent pas :
```
1.1.1.1
9.9.9.9
```

### Mode upstream (important)
Selon ta version, tu peux voir plusieurs modes :
- **parallel** : interroge plusieurs upstream en même temps, garde le premier → très réactif
- **fastest_addr** : choisit souvent la route la plus rapide
- **load_balance** : répartit les requêtes entre les upstream

Recommandation :
- **parallel** (si dispo) sinon **load_balance**.

---

## 6) Mettre le DNS du réseau sur AdGuard

Le plus propre : configurer le **DHCP du routeur** (ou contrôleur Unifi) pour annoncer :
- DNS primaire : IP d’AdGuard (ex: `192.168.1.2`)
- DNS secondaire : optionnel (un public), mais idéalement garder AdGuard seul si tu veux un filtrage garanti.

Ensuite, renouvelle DHCP sur les clients (ou redémarre).

Vérifier côté client :
- Windows :
  ```bat
  ipconfig /all
  ```
- Linux :
  ```bash
  cat /etc/resolv.conf
  ```

---

## 7) Split-DNS (optionnel) : même domaine dedans/dehors

Utile si tu as :
- un reverse proxy (Nginx Proxy Manager, Traefik…)
- des domaines publics via Cloudflare/Internet
- et tu veux qu’en LAN le domaine pointe sur une IP locale

Dans AdGuard :
**Filtres → Réécritures DNS (DNS rewrites)**

Exemples :
- `prox.exemple.com` → `192.168.1.10` (ton proxy local)
- `app.exemple.com` → `192.168.1.10`

Avantage : en LAN, tu évites le “hairpin NAT” et tu obtiens souvent plus de stabilité.

---

## 8) Dépannage rapide

### “No such host” / Docker ne peut pas pull
Si la machine ne résout plus :
```bash
getent hosts registry-1.docker.io
cat /etc/resolv.conf
```

### Tester AdGuard
Depuis un client :
```bash
dig @IP_ADGUARD google.com +short
```

### Voir qui répond sur 53
```bash
sudo ss -lntup | grep -E ':(53)\b'
sudo ss -lnup  | grep -E ':(53)\b'
```

### Vider le cache DNS
- Windows :
  ```bat
  ipconfig /flushdns
  ```
- Linux (varie selon le système) :
  - parfois rien à faire si pas de cache local
  - ou redémarrer le service DNS local si présent

---

## 9) Exemple de bloc YAML (si tu configures via fichier)

Dans `AdGuardHome.yaml`, sections typiques :

```yaml
upstream_dns:
  - https://cloudflare-dns.com/dns-query
  - https://dns.quad9.net/dns-query

bootstrap_dns:
  - 1.1.1.1
  - 9.9.9.9

fallback_dns:
  - 1.1.1.1
  - 9.9.9.9

upstream_mode: parallel
fastest_timeout: 1s
```

Après modification :
```bash
docker restart adguardhome
```


## Checks commande shell
 
### Santé du conteneur
```
docker ps --filter name=adguardhome
docker logs --tail=200 adguardhome
```
### Vérifier que le DNS écoute bien (53 TCP/UDP)
```
ss -lntup | grep -E ':(53)\b'
ss -lnup  | grep -E ':(53)\b'
```

### Vérifier la config (YAML) : upstream / mode / rewrites
```
grep -nE 'upstream_dns:|bootstrap_dns:|fallback_dns:|upstream_mode:|rewrites:|rewrites_enabled:' /home/docker/adguard/conf/AdGuardHome.yaml
nl -ba /home/docker/adguard/conf/AdGuardHome.yaml | sed -n '15,80p'
```

### Tester la résolution DNS via AdGuard
```
dig @192.168.32.150 google.fr +short
dig @192.168.32.150 registry-1.docker.io +short
```
### Tester le DoH (indirectement)

Check si upstream sont bien des URLs DoH dans le YAML :
```
grep -n "https://.*dns-query" /home/docker/adguard/conf/AdGuardHome.yaml
```
###  Voir les rewrites actifs (split-DNS)
```
grep -n "domain:" /home/docker/adguard/conf/AdGuardHome.yaml
```
### Vérifier que la machine utilise bien AdGuard (optionnel)
```
cat /etc/resolv.conf
getent hosts google.fr
```

---

## 10) Checklist “config propre”
- [ ] AdGuard écoute sur `:53` (UDP+TCP) et personne d’autre ne l’ocupe
- [ ] Les clients utilisent AdGuard en DNS (DHCP routeur)
- [ ] Upstreams en DoH (2 max) + bootstrap + fallback
- [ ] Mode upstream = parallel/fastest_addr/load_balance selon version
- [ ] (Optionnel) Split-DNS pour domaines internes
- [ ] Tests `dig` OK

---

Bon DNS 🙂