# 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 🙂