Accueil > Linux > Installation de Pihole en contenaire

Installation de Pihole en contenaire

mercredi 15 mai 2024, par Rémi

Descriptif
Pour créer un nouveau point d’accès wifi, et un médiacenter, j’ai acquis une mini-machine à base d’AMD Ryzen 7 / 32Go de mémoire.
J’ai galéré pour le partage de connexion entre hostapd et pihole, alors ci-dessous, la description de l’installation de pihole, hostapd et ufw, sous Debian/Linux.

Configuration du réseau de la maison
Le réseau se présente (en partie) de cette façon

Le serveur est le point central (oui j’ai un très gros serveur), en adresse 192.168.3.0/24
le wifi actuel est délivré par un Cubieboard en adresse 10.20.30.0/24
la nouvelle machine délivrera en wifi les adresses en 192.168.4.0/24

Installation

  1. Configuration réseau de la nouvelle machine
    J’ai supprimé NetworkManager, qui a tendance à m’agacer. Debian à deux paquets : ifupdown et ifupdown-extra (si besoin). Avec ifdown, on configure les interfaces réseaux. J’ai donc fait le fichier qui va bien :
    $ sudo vi /etc/network/interfaces
    # This file describes the network interfaces available on your system
    # and how to activate them. For more information, see interfaces(5).
    
    source /etc/network/interfaces.d/*
    
    # The loopback network interface
    auto lo enp2s0 wlp3s0
    
    iface lo inet loopback
    
    iface enp2s0 inet dhcp
    
    iface wlp3s0 inet static
          address 192.168.4.254/24
          address 192.168.103.1
          network 192.168.4.0
          broadcast 192.168.4.255
          dns-search unimatrice0
          dns-nameservers 127.0.0.1

    En même temps, cela ’désactive’ la modification de /etc/resolv.conf. Toute la gestion du dns passera donc par l’adresse loopback donc par pihole !

  2. Hostapd
    pour l’installation, rien de plus simple :
    $ sudo apt update
    $ sudo apt install hostapd
    $ sudo vi /etc/hostapd/hostapd.conf
    Le contenu du fichier est au minimum :
    interface=wlp3s0
    driver=nl80211
    ssid=unimatrice0
    hw_mode=g
    channel=6
    wmm_enabled=0
    macaddr_acl=0
    auth_algs=1
    ignore_broadcast_ssid=0
    country_code=FR
    ctrl_interface=/var/run/wpa_supplicant
    beacon_int=500
    ieee80211d=1
    ieee80211n=1
    max_num_sta=100
    utf8_ssid=1
    wpa_passphrase=lemotdepasseduwifiquituelavie
    wpa=3
    wpa_disable_eapol_key_retries=0
    wpa_key_mgmt=WPA-PSK
    wpa_pairwise=TKIP
    rsn_pairwise=CCMP
  3. Pihole
    Pour pihole, le plus simple, et surtout afin d’éviter les interférences dans les paquets installés sur la distribution (vécu !), c’est de passer par docker. Je vous laisse chercher comment installer docker et docker-compose si ce n’est pas déjà fait. Ensuite, faire un répertoire dédié (ici, je pars de ma configuration pour plus de simplicité) :
    $ mkdir -p $HOME/Container/pihole
    $ cd $HOME/Container/pihole
    puis, on cré un docker-compose, avec les variables d’environnements qui vont bien. Attention au mot de passe de connexion de l’interface web, qui est dedans (je pense qu’on peut faire mieux, avec un dotfile mais j’ai fait au plus vite, d’ailleurs, on peut s’en passer, voir plus bas) .
    → Les adresses sont adaptées à mon propre réseau bien sûr.
    → Pour que le dhcp fourni par pihole (en fait par dnsmasq) fonctionne, il faut supprimer les références au partage de ports, sinon, il y aura des warnings.
    → Et le mode réseau dans le fichier docker-compose doit être en "network_mode : host" (justement pour le dhcp)
    $ vi docker-compose.yml
    (attention à l’indentation dans le docker-compose.yml)
    # More info at https://github.com/pi-hole/docker-pi-hole/ 
    # and
    # https://docs.pi-hole.net/
    services:
      pihole:
        container_name: pihole
        image: pihole/pihole:latest
        hostname: lou-le-borg
        #   ports:
        #  - "53:53/tcp" # dns
        #  - "53:53/udp" # dns
        #  - "67:67/udp" # pour dhcp
        #  - "80:80/tcp" # pour l'interface graphique
        #  - "443:443/tcp" # l'interface graphique si configuré en sécurisé
        environment:
          TZ: 'France/Paris'
          WEBPASSWORD: 'Lemotdepassedelamortquituelavie'
          PIHOLE_DNS_: '192.168.3.1'
          DNS_BOGUS_PRIV: true
          DNS_FQDN_REQUIRED: true
          DHCP_ACTIVE: true
          DHCP_START: '192.168.4.30'
          DHCP_END: '192.168.4.100'
          DHCP_ROUTER: '192.168.3.26'
          DHCP_LEASETIME: '24'
          PIHOLE_DOMAIN: 'unimatrice0'
          DHCP_IPV6: false
          DHCP_rapid_commit: true
    
        # Volumes pour conserver les paramétrages lors des mises à jours
        volumes:
          - './etc-pihole/:/etc/pihole/'
          - './etc-dnsmasq.d/:/etc/dnsmasq.d/'
          # pour avoir le container à la bonne heure, mais cela n'a pas l'air de fonctionner:
          - "/etc/timezone:/etc/timezone:ro"
          - "/etc/localtime:/etc/localtime:ro"
    
        cap_add:
          # recommandé mais non obligatoire (DHCP a besoin de NET_ADMIN)
          #  https://github.com/pi-hole/docker-pi-hole#note-on-capabilities
          - NET_ADMIN
        # mode de redémarrage
        restart: unless-stopped
        # mode réseau du container
        network_mode: host

    Une fois enregistré, démarrer pihole :
    $ docker compose up -d
    $ docker compose logs <— pour voir les logs du lancement de pihole
    $ docker ps -a <— pour vérifier de le container fonctionne, exemple :

    docker ps -a
    CONTAINER ID   IMAGE                  COMMAND      CREATED      STATUS                   PORTS     NAMES
    6a446a823992   pihole/pihole:latest   "/s6-init"   9 days ago   Up 2 minutes (healthy)             pihole

    $ docker exec pihole -a -p <— si dans le docker-compose.yml vous n’avez pas mis de mot de passe, utiliser cette commande pour le modifier/changer/créer

  4. UFW
    le pare-feu le plus simple, mais c’est celui qui m’a servi.
    $ sudo apt install ufw
    $ sudo ufw enable
    $ sudo systemctl disable nftable <- ça, c’est pour éviter tout conflit entre iptables et nftable !!
    Modifier le fichier /etc/ufw/before.rules pour y ajouter les règles de nat : le premier COMMIT est déjà présent, ne pas l’enlever. Écrire après celui-ci.
    COMMIT
    # Modification le 05 mai 2024 pour le routage wifi
    # NAT
    *nat
    :POSTROUTING ACCEPT [0:0]
    -A POSTROUTING -s 192.168.4.0/24 -o enp2s0 -j MASQUERADE
    # don't delete the 'COMMIT' line or these rules won't be processed
    COMMIT

    Ensuite, recharger ufw :
    $ sudo ufw reload
    et ouvrir les ports necessaires si besoin :
    $ sudo ufw allow bootps
    $ sudo ufw allow bootpc
    $ sudo ufw allow 53/udp
    $ sudo ufw allow 53/tcp

Systemd
On peut faire démarer pihole par systemd. Créer le fichier suivant dans /etc/systemd/system/docker-compose chez pihole.service
Toutes les référence à %i dans le fichier font référence au nom après l’@ du nom du fichier

# container-pihole.service
# mer 08 mai 2024 / 19:05 (FR)
[Unit]

Description=%i service with docker compose
PartOf=docker.service
After=docker.service

Wants=network-online.target
After=network-online.target
RequiresMountsFor=%t/containers

[Service]
Type=oneshot
RemainAfterExit=True
WorkingDirectory=/home/remi/Container/%i
ExecStart=/usr/bin/docker-compose up -d --remove-orphans
ExecStop=/usr/bin/docker-compose stop

[Install]

WantedBy=multi-user.target

Mettre en place avec systemd :
$ sudo systemctl enable docker-compose@pihole <— activation du nouveau service
$ sudo systemctl daemon-reload <— peut être pas nécessaire, mais j’ai eu quelques problèmes concomitants, réglés avec cette commande.
$ sudo systemctl start docker-compose@pihole <— démarrage du service
$ sudo systemctl status docker-compose@pihole <— vérifier l’état du service

Mise à jour de l’image
A faire dans l’ordre :
docker pull pihole/pihole:latest <— mise à jour de l’image de base de pihole
docker exec pihole apt update <— mise à jour de la base des paquets debian
docker exec pihole apt upgrade -y <— mise à jours des paquets sans interaction

Avec ça, chez moi, ça a fonctionné ©® .
Je peux avoir accès à l’interface graphique de pihole sur http://192.168.4.254/admin
Qui est l’adresse de la carte wifi. Mais j’ai accès aussi, si besoin, par l’autre côté de mon réseau, sur l’adresse 192.168.3.26.
Le seul problème qu’il me reste à corriger, c’est l’arrêt de la machine qui me prend 10 secondes sans pihole et 1 minute 30 quand le container fonctionne.
A priori, c’est le service s6-svscan dans le container qui prend du temps à rendre gorge.
Je ne sais pas (encore) pourquoi ...

Je crois ne rien avoir oublié. Si besoin, me contacter (ou pour m’envoyer un mot d’encouragement) !