Tuto: Installer Pi-hole et Unbound avec Docker, gérer les publicités et les requêtes DNS (DOT) de manière efficace.

[nam1962]

Introduction

Ce tutoriel met en place Pi-hole et Unbound avec Docker.

Pi-hole bloque les publicités, les traqueurs et les domaines indésirables selon vos listes locales. Unbound reçoit les requêtes de Pi-hole, met les réponses en cache, valide DNSSEC et transmet les requêtes vers des résolveurs DNS-over-TLS choisis.

DNS-over-TLS chiffre les requêtes DNS entre Unbound et les résolveurs amont sur le port 853. Le fournisseur d’accès ne reçoit plus vos requêtes DNS via son propre résolveur.

Cette configuration apporte trois fonctions :

• blocage local des publicités et traqueurs ;
• résolution DNS chiffrée vers des résolveurs sélectionnés ;
• validation DNSSEC par Unbound.

Mise à jour : la liste des résolveurs DNS-over-TLS a été actualisée avec des serveurs testés et non filtrants.

Prérequis

• un système Linux à jour ;
• Docker et Docker Compose installés ;
• un accès terminal avec privilèges sudo ;
• le port local 53 disponible sur la machine.

Étape 1 : installer Docker et Docker Compose

Arch Linux et dérivés

sudo pacman -S docker docker-compose
sudo systemctl enable --now docker
sudo usermod -aG docker "$USER"

Debian et Linux Mint

sudo apt update
sudo apt install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/debian/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

sudo systemctl enable --now docker
sudo usermod -aG docker "$USER"

Déconnectez-vous puis reconnectez-vous pour que l’ajout au groupe Docker soit pris en compte.

Étape 2 : créer la structure de répertoires

mkdir -p ~/docker/dns-dot/unbound
mkdir -p ~/docker/dns-dot/etc-dnsmasq.d
cd ~/docker/dns-dot

Étape 3 : créer docker-compose.yml

nano docker-compose.yml

services:
  unbound:
    container_name: unbound
    image: mvance/unbound:latest
    restart: unless-stopped
    hostname: unbound
    volumes:
      - ./unbound:/opt/unbound/etc/unbound/custom.conf.d:ro
    networks:
      pihole_net:
        ipv4_address: 172.22.0.2
    ports:
      - "127.0.0.1:5335:53/tcp"
      - "127.0.0.1:5335:53/udp"
    mem_limit: 512m
    mem_reservation: 256m
    cpus: "1.0"

  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    restart: unless-stopped
    hostname: pihole
    depends_on:
      - unbound
    env_file:
      - .env
    environment:
      TZ: ${TZ}
      FTLCONF_webserver_api_password: ${PIHOLE_WEBPASSWORD}
      FTLCONF_dns_upstreams: 172.22.0.2#53
      FTLCONF_dns_listeningMode: all
      FTLCONF_misc_etc_dnsmasq_d: "true"
    volumes:
      - ./etc-pihole:/etc/pihole
      - ./etc-dnsmasq.d:/etc/dnsmasq.d
    ports:
      - "127.0.0.1:53:53/tcp"
      - "127.0.0.1:53:53/udp"
      - "127.0.0.1:8080:80/tcp"
    networks:
      pihole_net:
        ipv4_address: 172.22.0.3
    mem_limit: 512m
    mem_reservation: 256m
    cpus: "1.0"

networks:
  pihole_net:
    ipam:
      config:
        - subnet: 172.22.0.0/24

Étape 4 : créer le fichier .env

nano .env

TZ=Europe/Paris
PIHOLE_WEBPASSWORD=remplacez_moi

Étape 5 : configurer Unbound avec DNS-over-TLS

nano ~/docker/dns-dot/unbound/custom.conf

server:
  interface: 0.0.0.0
  port: 53

  do-ip4: yes
  do-ip6: yes
  do-udp: yes
  do-tcp: yes

  access-control: 127.0.0.0/8 allow
  access-control: ::1/128 allow
  access-control: 172.22.0.0/24 allow

  verbosity: 1
  num-threads: 2

  outgoing-range: 8192
  so-rcvbuf: 4m
  so-sndbuf: 4m
  edns-buffer-size: 1232

  msg-cache-size: 128m
  rrset-cache-size: 256m
  cache-min-ttl: 60
  cache-max-ttl: 86400
  cache-max-negative-ttl: 60

  hide-identity: yes
  hide-version: yes
  harden-glue: yes
  harden-dnssec-stripped: yes
  harden-algo-downgrade: yes
  harden-short-bufsize: yes
  qname-minimisation: yes
  qname-minimisation-strict: yes
  minimal-responses: yes

  auto-trust-anchor-file: "root.key"
  tls-cert-bundle: "/etc/ssl/certs/ca-certificates.crt"
  tls-ciphersuites: "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"
  tls-ciphers: "HIGH:!aNULL:!MD5:!3DES"

  prefetch: yes
  prefetch-key: yes
  serve-expired: yes
  aggressive-nsec: yes
  ratelimit: 1000

  module-config: "validator iterator"

forward-zone:
  name: "pi.hole"
  forward-addr: 172.22.0.3@53

forward-zone:
  name: "."
  forward-tls-upstream: yes
  forward-addr: 116.202.176.26@853#dot.libredns.gr
  forward-addr: 5.9.164.112@853#dns3.digitalcourage.de
  forward-addr: 5.1.66.255@853#dot.ffmuc.net
  forward-addr: 185.150.99.255@853#dot.ffmuc.net
  forward-addr: 89.233.43.71@853#unicast.uncensoreddns.org
  forward-addr: 91.239.100.100@853#anycast.uncensoreddns.org
  forward-addr: 146.255.56.98@853#dot1.applied-privacy.net

Étape 6 : configurer dnsmasq pour Pi-hole

cat > ~/docker/dns-dot/etc-dnsmasq.d/99-custom.conf <<'EOF'
dns-forward-max=300
EOF

Étape 7 : vérifier la configuration Docker Compose

cd ~/docker/dns-dot
docker compose config

La commande doit afficher la configuration complète sans erreur.

Étape 8 : démarrer les conteneurs

cd ~/docker/dns-dot
docker compose up -d

Étape 9 : vérifier les conteneurs

docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}' | grep -E 'NAMES|pihole|unbound'

Résultat attendu :

pihole    Up ... (healthy)   127.0.0.1:53->53/tcp, 127.0.0.1:53->53/udp, 127.0.0.1:8080->80/tcp
unbound   Up ... (healthy)   127.0.0.1:5335->53/tcp, 127.0.0.1:5335->53/udp

Étape 10 : tester la résolution DNS

dig @127.0.0.1 kernel.org A +short
dig @127.0.0.1 pi.hole A +short

Résultat attendu :

kernel.org renvoie une adresse IP
pi.hole renvoie 172.22.0.3

Étape 11 : tester DNSSEC

dig @127.0.0.1 sigok.verteiltesysteme.net A +dnssec +short
dig @127.0.0.1 sigfail.verteiltesysteme.net A +dnssec

Résultat attendu :

sigok renvoie une réponse valide
sigfail renvoie SERVFAIL avec DNSSEC Bogus

Étape 12 : utiliser Pi-hole comme DNS local

Configurez le gestionnaire réseau de votre système pour utiliser :

127.0.0.1

Avec NetworkManager, identifiez la connexion active :

nmcli connection show --active

Appliquez le DNS local à la connexion choisie :

sudo nmcli connection modify "NOM_DE_LA_CONNEXION" ipv4.ignore-auto-dns yes ipv4.dns "127.0.0.1" ipv6.ignore-auto-dns yes
sudo nmcli connection down "NOM_DE_LA_CONNEXION"
sudo nmcli connection up "NOM_DE_LA_CONNEXION"

Vérifiez le serveur DNS utilisé :

dig kernel.org A

La sortie doit indiquer :

SERVER: 127.0.0.1#53

Étape 13 : accéder à l’interface Pi-hole

Ouvrez :

http://localhost:8080/admin

Connectez-vous avec le mot de passe défini dans le fichier .env.

Étape 14 : ajouter des listes de blocage

Dans l’interface Pi-hole :

1. ouvrez http://localhost:8080/admin ;
2. allez dans Group Management, puis Adlists ;
3. ajoutez vos listes ;
4. allez dans Tools, puis Update Gravity.

Listes utiles :

https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts
https://adaway.org/hosts.txt
https://raw.githubusercontent.com/hagezi/dns-blocklists/main/domains/light.txt
https://small.oisd.nl/

Résolveurs DoT de secours

Ces résolveurs peuvent servir de secours explicite. Ils ne sont pas activés dans la configuration principale.

194.242.2.2@853#dns.mullvad.net
78.47.71.194@853#blank.dnsforge.de
138.199.149.249@853#blank.dnsforge.de
9.9.9.10@853#dns10.quad9.net
149.112.112.10@853#dns10.quad9.net
185.222.222.222@853#dot.sb
45.11.45.11@853#dot.sb

Vérifier un résolveur DoT avant usage

openssl s_client -connect 116.202.176.26:853 -servername dot.libredns.gr -brief </dev/null

Résultat attendu :

CONNECTION ESTABLISHED
Protocol version: TLSv1.3
Verification: OK

Test complet par lot :

bash <<'BASH'
set -o pipefail

while read -r ip name tag; do
  [ -z "$ip" ] && continue
  printf '\n=== %-34s %-15s %s ===\n' "$name" "$ip" "$tag"

  printf 'PING: '
  ping_out="$(timeout 5 ping -c 3 -q "$ip" 2>/dev/null || true)"
  if printf '%s\n' "$ping_out" | grep -q 'rtt min/avg/max'; then
    printf '%s\n' "$ping_out" | sed -n 's/^rtt min\/avg\/max\/mdev = /avg /p'
  else
    echo "NO_ICMP_OR_TIMEOUT"
  fi

  printf 'TCP 853: '
  if timeout 5 bash -c "cat </dev/null >/dev/tcp/$ip/853" 2>/dev/null; then
    echo "OPEN"
  else
    echo "CLOSED/TIMEOUT"
  fi

  printf 'TLS: '
  start="$(date +%s%3N)"
  out="$(timeout 8 openssl s_client -connect "${ip}:853" -servername "$name" -brief </dev/null 2>&1)"
  rc=$?
  end="$(date +%s%3N)"
  elapsed="$((end - start))ms"

  if printf '%s\n' "$out" | grep -q 'CONNECTION ESTABLISHED'; then
    echo "OK ${elapsed}"
    printf '%s\n' "$out" | sed -n '1,10p'
  else
    echo "KO rc=$rc ${elapsed}"
    printf '%s\n' "$out" | sed -n '1,8p'
  fi
done <<'EOF'
116.202.176.26 dot.libredns.gr primary-libredns
5.9.164.112 dns3.digitalcourage.de primary-digitalcourage
5.1.66.255 dot.ffmuc.net primary-ffmuc-1
185.150.99.255 dot.ffmuc.net primary-ffmuc-2
89.233.43.71 unicast.uncensoreddns.org primary-uncensored-unicast
91.239.100.100 anycast.uncensoreddns.org primary-uncensored-anycast
146.255.56.98 dot1.applied-privacy.net primary-applied-privacy
EOF
BASH

Vérifier le chemin DNS

La commande suivante doit afficher 127.0.0.1#53 :

dig kernel.org A | grep SERVER

La commande suivante teste directement Pi-hole :

dig @127.0.0.1 kernel.org A +short

La commande suivante teste directement Unbound depuis l’hôte :

dig @127.0.0.1 -p 5335 kernel.org A +short

Arrêter la stack

cd ~/docker/dns-dot
docker compose down

Redémarrer la stack

cd ~/docker/dns-dot
docker compose up -d

Mettre à jour les images

cd ~/docker/dns-dot
docker compose pull
docker compose up -d

Documentation

• Documentation Pi-hole
• Documentation Docker Pi-hole
• Documentation Unbound

Conclusion

Cette configuration fournit un DNS local filtrant avec Pi-hole, une résolution chiffrée en DNS-over-TLS avec Unbound, et une validation DNSSEC active.

Le chemin de résolution est :

applications -> 127.0.0.1 -> Pi-hole -> Unbound -> DNS-over-TLS

Les listes de blocage restent locales. Les résolveurs amont reçoivent les requêtes transmises après traitement par Pi-hole.

Un jeune site que j'aime bien, la ferrari du T-shirt ...bio en plus : GoudronBlanc

[Auteur]

Articles