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 sur des adresses IP dynamiques (temporaires, changeant fréquemment). Il est utilisé pour accéder aux ordinateurs qui n'ont pas d'adresse IP statique, comme ceux des réseaux SOHO (Small Office/Home Office), et est souvent utilisé en combinaison avec la redirection de port pour accéder aux 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 du DNS côté client. enregistrer les mises à jour.

Exigences

Un seul serveur Debian 10, éventuellement avec une 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 un accès à ses serveurs de noms/fichier de zone. Créez des enregistrements DNS pour ce domaine comme indiqué dans la section suivante.
Le $EDITOR la variable d'environnement doit être définie.
Facultativement, n'importe quel système client Linux/Unix pour configurer les mises à jour automatiques des enregistrements DNS.

Création d'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.votre_domaine qui pointera vers l'adresse IPv4 de votre serveur. Deuxièmement, choisissez un sous-domaine tel que ddns.votre_domaine qui sera délégué à ns1.votre_domaine.

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

ns1.votre_domaine A 192.0.2.2

ddns.votre_domaine NS ns1.votre_domaine

ns1.votre_domaine AAAA 2001:0db8::0db9 (facultatif)

Vous devez créer ces enregistrements dans le panneau de configuration de votre bureau d'enregistrement de domaine. Veuillez noter que la propagation de ces enregistrements peut prendre jusqu'à 24 heures, 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 - racine

sudo -s

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

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

mise à jour apt

apt upgrade -y

redémarrer

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

certbot seront utilisés pour obtenir des certificats SSL/TLS.
faire est nécessaire pour créer l'image docker dans laquelle le serveur DDNS s'exécutera.
apt-transport-https , ca-certificats , boucle , gnupg2 et software-properties-common sont nécessaires pour installer le référentiel Docker et sa clé GPG correspondante.
dnsutils fournit creuser , qui sera utilisé pour les tests.

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

Étape 2 :Installez Docker CE.

Ajoutez la clé GPG de Docker :

curl -fsSL https://download.docker.com/linux/debian/gpg | apt-clé ajouter -

Installez le référentiel docker :

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

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

mise à jour apt

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 fonctionne comme suit :

systemctl enable --now docker.service

Étape 3 :Téléchargez et créez 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 référentiel Github et créez l'image du conteneur avec les commandes suivantes :

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

cd docker-ddns

créer une 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=votre_secret 
ZONE=ddns.votre_domaine 
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 la zone DNS dont votre serveur sera responsable et l'enregistrement TTL spécifie la durée pendant laquelle les enregistrements DNS peuvent être mis en cache. Un TTL de 60 secondes est recommandé pour les adresses IP dynamiques qui changent fréquemment.

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

chat /dev/urandom | tr -dc "a-zA-Z0-9" | plier -w 40 | tête -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 depuis l'hôte, sur /var/cache/bind dans le système de fichiers du conteneur. Ceci est utilisé pour la persistance des données DNS dans la recréation du conteneur.

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

conteneur docker ls -a

Une seule entrée doit être générée avec le nom ddns-server.

Étape 4 :Service Systemd (facultatif)

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

Pour pouvoir gérer ce conteneur en tant que 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=Conteneur Docker du serveur DDNS
Après=docker.service
Requiert=docker.service
Requiert=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
[Installer]
WantedBy=multi-user.target

Enregistrez et quittez, puis définissez les autorisations appropriées sur ce fichier d'unité :

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

Chargez le nouveau fichier de service avec la commande suivante :

rechargement du démon systemctl

Vous devriez maintenant pouvoir démarrer et arrêter ce conteneur en utilisant systemctl comme n'importe quel 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 n'est actuellement accessible que 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 doit renvoyer la réponse suivante :

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

REMARQUE : Le domaine test1 fait référence à test1.ddns.votre_domaine. puisque le serveur gère le ddns.votre_domaine. secteur.

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 doit être 1.1.1.1.

Étape 6 :Proxy inverse

Étant donné que l'API fonctionne sur HTTP, votre secret d'authentification peut potentiellement être reniflé chaque fois que vous envoyez une demande sur le réseau. Un attaquant pourrait alors manipuler vos enregistrements DNS en utilisant votre secret. Nous allons configurer un proxy inverse à l'aide de Nginx et le sécuriser à l'aide de HTTPS. Tout d'abord, obtenez un certificat SSL auprès de Let's Encrypt à l'aide de 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 délivré. 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

Désactivez ensuite le fichier de blocage du serveur par défaut, car il n'est pas nécessaire :

dissocier /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 :

serveur {
écoute 192.0.2.2:8080 ;
nom_serveur ns1.votre_domaine ;
ssl activé ;
certificat_ssl /etc/letsencrypt/live/ns1.votre_domaine/fullchain. pem;
ssl_certificate_key /etc/letsencrypt/live/ns1.your_domain/privkey.pem;

location /update {
proxy_pass http://127.0.0.1:8080;
}
emplacement / {
return 404 ;
}
access_log /var/log/nginx/ddns-api-access.log ;
error_log /var /log/nginx/ddns-api-error.log;
}

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

écoutez [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 recharge nginx.service

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

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

Il doit renvoyer ce qui suit :

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

Étape 7 :Configuration du client

Vous pouvez configurer des mises à jour automatiques des enregistrements sur n'importe quel routeur prenant en charge les fournisseurs 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 au point de terminaison 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 demande. Par exemple, pour créer/mettre à jour des enregistrements pour sub1.ddns.your_domain et sub2.ddns.your_domain avec l'adresse IP 198.51.100.100, vous devez envoyer une requête GET à cette URL :

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

Le paramètre addr peut également contenir une adresse IPv6 pour créer/mettre à 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 enroulée autour d'une commande dig qui obtient l'adresse IP publique du client et la stocke dans une variable. La boucle garantit que l'adresse 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 adresse IP nouvellement récupérée. Assurez-vous de remplacer les valeurs de votre_secret et de votre_sous-domaine.

Ensuite, rendez ce script exécutable :

chmod +x /opt/ddns-update.sh

Lancez ensuite l'éditeur crontab :

crontab -e

Ajoutez la ligne suivante à la fin de votre crontab :

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

Sauvegarder et quitter. Le script s'exécutera désormais toutes les deux minutes, en gardant 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