Comment déployer un serveur DNS dynamique avec Docker sur Debian 10

Le DNS dynamique est un service réseau permettant de mapper des noms de domaine à des adresses IP dynamiques (temporaires, changeant fréquemment). Il est utilisé pour accéder à des ordinateurs qui n’ont pas d’adresse IP statique, comme ceux dans des réseaux SOHO (petits bureaux/bureaux à domicile), et est souvent utilisé en combinaison avec le transfert de port pour accéder à des systèmes qui se trouvent derrière des pare-feu NAT. Cet article vous guidera à travers la configuration complète d’un serveur DNS dynamique dans un conteneur Docker sur un système Debian 10, y compris la configuration des enregistrements DNS requis, le placement de l’API de gestion derrière un proxy inverse Nginx HTTPS, et l’automatisation des mises à jour des enregistrements DNS côté client.

Exigences

Un seul serveur Debian 10, éventuellement avec connectivité IPv6. (192.0.2.2 et 2001:0db8::0db9 seront utilisés comme espaces réservés pour l’IPv4 et l’IPv6 du serveur respectivement.)
Accès à l’utilisateur root, ou un utilisateur avec des privilèges sudo.
Les ports tcp/53 et udp/53 doivent être disponibles sur l’hôte.
Un nom de domaine enregistré et accès à ses serveurs de noms/fichier de zone. Créez des enregistrements DNS pour ce domaine comme indiqué dans la section suivante.
La variable d’environnement $EDITOR doit être définie.
En option, tout système client Linux/Unix pour configurer des mises à jour automatiques des enregistrements DNS.

Création des enregistrements DNS.

Vous devrez créer au moins 2 enregistrements DNS pour que votre serveur DNS dynamique fonctionne. Tout d’abord, choisissez un sous-domaine tel que ns1.your_domain qui pointera vers l’adresse IPv4 de votre serveur. Deuxièmement, choisissez un sous-domaine tel que ddns.your_domain qui sera délégué à ns1.your_domain.

Votre serveur DNS dynamique gérera tous les enregistrements sous ddns.your_domain. Le troisième enregistrement, de type AAAA, est optionnel. Les enregistrements correspondants ressemblent à ceci :

ns1.your_domain A 192.0.2.2

ddns.your_domain NS ns1.your_domain

ns1.your_domain AAAA 2001:0db8::0db9 (optionnel)

Exemple d'enregistrements DNS

Vous devez créer ces enregistrements dans le panneau de contrôle de votre registraire de domaine. Veuillez noter qu’il peut falloir jusqu’à 24 heures pour que ces enregistrements se propagent correctement, mais cela prend généralement quelques minutes.

Installation

Si vous n’utilisez pas l’utilisateur root, nous vous recommandons de démarrer un shell root temporaire, car la plupart des commandes présentées dans ce guide nécessitent des privilèges élevés. Pour lancer un shell root, utilisez l’une des commandes suivantes :

sudo su - root

sudo -s

Étape 1 : Mise à jour et installation des dépendances.

Il est toujours bon de commencer par mettre à jour votre système :

apt update

apt upgrade -y

reboot

Après le redémarrage, installez les paquets logiciels requis pour cette configuration :

certbot sera utilisé pour obtenir des certificats SSL/TLS.
make est requis pour construire l’image docker dans laquelle le serveur DDNS fonctionnera.
apt-transport-https, ca-certificates, curl, gnupg2 et software-properties-common sont nécessaires pour installer le dépôt Docker et sa clé GPG correspondante.
dnsutils fournit dig, qui sera utilisé pour les tests.

apt install -y certbot make apt-transport-https curl ca-certificates software-properties-common gnupg2 dnsutils

Étape 2 : Installer Docker CE.

Ajoutez la clé GPG de Docker :

curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -

Installez le dépôt docker :

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian buster stable"

Mettez à jour le cache du dépôt de Debian puis installez docker et ses dépendances :

apt update

apt install -y docker-ce docker-ce-cli containerd.io

Une fois l’installation terminée, assurez-vous que le service docker est activé et en cours d’exécution comme suit :

systemctl enable --now docker.service

Étape 3 : Télécharger et construire docker-ddns

Notre serveur DNS dynamique sera alimenté par un conteneur docker qui utilise Bind comme serveur DNS et une API de gestion écrite en Go. Tout d’abord, clonez le dépôt Github et construisez l’image du conteneur avec les commandes suivantes :

git clone https://github.com/dprandzioch/docker-ddns.git

cd docker-ddns

make image

Attendez que le processus se termine, ce qui peut prendre un certain temps, puis ouvrez le fichier envfile avec un éditeur de texte :

$EDITOR envfile

Et saisissez ce qui suit :

SHARED_SECRET=your_secret   
ZONE=ddns.your_domain   
RECORD_TTL=60

Le secret partagé est un mot de passe qui sera utilisé pour s’authentifier auprès de l’API de gestion. ZONE indique quelle zone DNS votre serveur sera responsable, et le TTL de l’enregistrement spécifie combien de temps les enregistrements DNS peuvent être mis en cache. Un TTL de 60 secondes est recommandé pour les IP dynamiques changeant fréquemment.

Si nécessaire, vous pouvez générer une chaîne aléatoire de 40 caractères pour le secret en utilisant la commande suivante :

cat /dev/urandom | tr -dc "a-zA-Z0-9" | fold -w 40 | head -1

Nous pouvons maintenant créer le conteneur :

docker create -it -p 127.0.0.1:8080:8080 -p 53:53 -p 53:53/udp --env-file envfile -v /mnt/ddns-data:/var/cache/bind --name ddns-server davd/docker-ddns

Cette commande créera un conteneur nommé ddns-server à partir de l’image que nous avons construite précédemment, et mappera les ports 8080/tcp, 53/tcp et 53/udp de l’hôte au conteneur. Il montera également le répertoire /mnt/ddns-data de l’hôte, sur /var/cache/bind dans le système de fichiers du conteneur. Ceci est utilisé pour persister les données DNS à travers la recréation du conteneur.

Vérifiez que le conteneur a été créé avec la commande :

docker container ls -a

Une seule entrée devrait être affichée avec le nom ddns-server.

Étape 4 : Service systemd (optionnel)

Cette étape est pour une gestion plus simple mais n’est pas strictement requise. Si vous choisissez de ne pas utiliser un service systemd, vous devrez gérer le conteneur manuellement ou utiliser une autre solution de gestion. Veuillez noter que pour des déploiements de conteneurs plus grands et plus complexes, une solution d’orchestration telle que Kubernetes ou Docker Swarm est recommandée. Dans ce cas, un service systemd est parfaitement adapté, car nous ne faisons fonctionner qu’un seul conteneur.

Pour pouvoir gérer ce conteneur comme un service système, nous allons l’encapsuler dans une unité systemd. Créez le fichier /etc/systemd/system/ddns-server-ct.service avec votre éditeur de texte :

$EDITOR /etc/systemd/system/ddns-server-ct.service

Et ajoutez ce qui suit :

[Unit]  
Description=Serveur DDNS Conteneur Docker  
After=docker.service  
Requires=docker.service  
Requires=network.target  
[Service]  
Type=oneshot  
TimeoutStartSec=240  
Restart=no  
RemainAfterExit=yes  
ExecStart=/usr/bin/docker start ddns-server  
ExecStop=/usr/bin/docker stop ddns-server  
[Install]  
WantedBy=multi-user.target

Enregistrez et quittez, puis définissez les bonnes permissions sur ce fichier d’unité :

chmod 664 /etc/systemd/system/ddns-server-ct.service

Chargez le nouveau fichier de service avec la commande suivante :

systemctl daemon-reload

Vous devriez maintenant pouvoir démarrer et arrêter ce conteneur en utilisant systemctl comme tout autre service système.

Si vous souhaitez que le serveur DDNS démarre automatiquement au démarrage du système, exécutez ce qui suit :

systemctl enable ddns-server-ct.service

Étape 5 : Tester votre serveur

Avant de procéder à la configuration, nous allons tester l’API de gestion localement. Démarrez le conteneur :

systemctl start ddns-server-ct.service

Envoyez une requête GET à l’API pour créer un nouvel enregistrement :

REMARQUE : L’API est actuellement uniquement accessible localement (c’est-à-dire depuis localhost).

curl "http://127.0.0.1:8080/update?secret=your_secret&domain=test1&addr=1.1.1.1"

Curl devrait retourner la réponse suivante :

{"Success":true,"Message":"Enregistrement A mis à jour pour test1 à l'adresse IP 1.1.1.1","Domain":"test1","Domains":["test1"],"Address":"1.1.1.1","AddrType":"A"}

REMARQUE : Le domaine test1 fait référence à test1.ddns.your_domain. puisque le serveur gère la zone ddns.your_domain.

Effectuez une recherche DNS pour vérifier que l’enregistrement a bien été créé et pour tester la résolution DNS :

dig +short -t A test1.ddns.your_domain @127.0.0.1

La sortie devrait être 1.1.1.1.

Étape 6 : Proxy inverse

Puisque l’API fonctionne sur HTTP, votre secret d’authentification peut potentiellement être sniffé chaque fois que vous envoyez une requête sur le réseau. Un attaquant pourrait alors manipuler vos enregistrements DNS en utilisant votre secret. Nous allons configurer un proxy inverse en utilisant Nginx et le sécuriser en utilisant HTTPS. Tout d’abord, obtenez un certificat SSL de Let’s Encrypt en utilisant certbot :

certbot certonly --standalone --agree-tos -m [email protected] -d ns1.your_domain

La propriété de votre domaine sera vérifiée et un certificat sera émis. Ensuite, installez Nginx et assurez-vous qu’il est activé et en cours d’exécution :

apt install -y nginx systemctl enable --now nginx.service

Ensuite, désactivez le fichier de bloc de serveur par défaut, car il n’est pas nécessaire :

unlink /etc/nginx/sites-enabled/default

Nous allons maintenant créer un nouveau fichier de configuration pour le proxy inverse, par exemple :

$EDITOR /etc/nginx/sites-available/ddns-api-proxy.conf

Et collez ce qui suit, en vous assurant de remplacer les adresses IP et les noms de domaine par les vôtres :

server {  
listen 192.0.2.2:8080;  
server_name ns1.your_domain;  
ssl on;  
ssl_certificate /etc/letsencrypt/live/ns1.your_domain/fullchain.pem;  
ssl_certificate_key /etc/letsencrypt/live/ns1.your_domain/privkey.pem;  
  
location /update {  
proxy_pass http://127.0.0.1:8080;  
}  
location / {  
return 404;  
}  
access_log /var/log/nginx/ddns-api-access.log;  
error_log /var/log/nginx/ddns-api-error.log;  
}

Optionnel : Si vous souhaitez que l’API soit accessible via IPv6, ajoutez la ligne suivante après la directive listen existante :

listen [2001:0db8::0db9]:8080;

Activez cette configuration et appliquez les modifications en rechargeant Nginx :

ln -s /etc/nginx/sites-available/ddns-api-proxy.conf /etc/nginx/sites-enabled/

systemctl reload nginx.service

L’API devrait maintenant être accessible sur Internet et n’acceptera que les connexions HTTPS. Pour le tester, exécutez la commande :

curl "https://ns1.your_domain:8080/update?secret=your_secret&domain=test2&addr=1.1.1.2"

Il devrait retourner ce qui suit :

{"Success":true,"Message":"Enregistrement A mis à jour pour test2 à l'adresse IP 1.1.1.2","Domain":"test2","Domains":["test2"],"Address":"1.1.1.2","AddrType":"A"}

Étape 7 : Configuration du client

Vous pouvez configurer des mises à jour automatiques des enregistrements sur tout routeur qui prend en charge des fournisseurs de DNS dynamiques personnalisés, tels que Pfsense. Vous pouvez également les configurer sur la plupart des autres appareils de votre bureau ou de votre réseau domestique. Pour mettre à jour ou créer un enregistrement, une requête GET doit être envoyée à l’endpoint suivant :

https://ns1.your_domain:8080/update?secret=your_secret&domain=your_subdomain&addr=your_ip_address

Vous pouvez également mettre à jour les enregistrements de plusieurs sous-domaines avec une seule requête. Par exemple, pour créer/metttre à jour des enregistrements pour sub1.ddns.your_domain et sub2.ddns.your_domain avec l’adresse IP 198.51.100.100, vous enverriez une requête GET à cette URL :

https://ns1.your_domain:8080/update?secret=your_secret&domain=sub1,sub2&addr=198.51.100.100

Le paramètre addr peut également contenir une adresse IPv6 pour créer/metttre à jour des enregistrements DNS AAAA, par exemple :

https://ns1.your_domain:8080/update?secret=your_secret&domain=cheese&addr=2001:0db8:aaaa::

Pour automatiser ces mises à jour sur un client Linux, enregistrez le script bash suivant sous /opt/ddns-update.sh :

#!/bin/bash  
  
while [ -z $CURRENTIP ]
do  
CURRENTIP=`dig -r +short myip.opendns.com @resolver1.opendns.com 2>/dev/null`  
sleep 1  
done  
curl -s "https://ns1.your_domain:8080/update?secret=your_secret&domain=your_subdomain&addr=${CURRENTIP}"

Ce script utilise une boucle while entourée d’une commande dig qui obtient l’adresse IP publique du client et la stocke dans une variable. La boucle assure que l’IP publique est correctement récupérée. Ensuite, cURL est utilisé pour envoyer une requête API pour mettre à jour l’enregistrement DNS avec cette IP nouvellement récupérée. Assurez-vous de remplacer les valeurs pour your_secret et your_subdomain.

Ensuite, rendez ce script exécutable :

chmod +x /opt/ddns-update.sh

Puis lancez l’éditeur crontab :

crontab -e

Ajoutez la ligne suivante à la fin de votre crontab :

*/2 * * * * /opt/ddns-update.sh

Enregistrez et quittez. Le script s’exécutera maintenant toutes les deux minutes, maintenant votre enregistrement DNS dynamique à jour avec la dernière adresse IP publique du client.

Lectures complémentaires

Article Wikipédia sur le DNS dynamique
docker-ddns sur Github