Dynamisches DNS ist ein Netzwerkdienst zum Zuordnen von Domänennamen zu dynamischen (temporären, sich häufig ändernden) IP-Adressen. Es wird verwendet, um auf Computer zuzugreifen, die keine statische IP-Adresse haben, wie z. B. in SOHO-Netzwerken (Small Office/Home Office), und wird häufig in Kombination mit Portweiterleitung verwendet, um auf Systeme zuzugreifen, die sich hinter NAT-Firewalls befinden. Dieser Artikel führt Sie durch die vollständige Einrichtung eines dynamischen DNS-Servers in einem Docker-Container auf einem Debian 10-System, einschließlich der Einrichtung der erforderlichen DNS-Einträge, der Platzierung der Verwaltungs-API hinter einem Nginx-HTTPS-Reverse-Proxy und der Automatisierung des clientseitigen DNS Aktualisierungen aufzeichnen.
Anforderungen
- Ein einzelner Debian 10-Server, optional mit IPv6-Konnektivität. (192.0.2.2 und 2001:0db8::0db9 werden als Platzhalter für die IPv4- bzw. IPv6-Adresse des Servers verwendet.)
- Zugriff für den Root-Benutzer oder einen Benutzer mit sudo-Berechtigungen.
- Die Ports tcp/53 und udp/53 müssen auf dem Host verfügbar sein.
- Ein registrierter Domainname und Zugriff auf seine Nameserver/Zonefile. Erstellen Sie DNS-Einträge für diese Domain, wie im nächsten Abschnitt gezeigt.
- Der $EDITOR Umgebungsvariable muss gesetzt werden.
- Optional jedes Linux/Unix-Client-System zum Einrichten automatischer Aktualisierungen von DNS-Einträgen.
DNS-Einträge erstellen.
Sie müssen mindestens 2 DNS-Einträge erstellen, damit Ihr dynamischer DNS-Server funktioniert. Wählen Sie zunächst eine Subdomain wie ns1.your_domain aus, die auf die IPv4-Adresse Ihres Servers verweist. Zweitens wählen Sie eine Subdomain wie ddns.ihre_domain, die an ns1.ihre_domain delegiert wird.
Ihr dynamischer DNS-Server verarbeitet alle Einträge unter ddns.your_domain. Der dritte Datensatz vom Typ AAAA ist optional. Die entsprechenden Datensätze sehen wie folgt aus:
ns1.your_domain A 192.0.2.2
ddns.your_domain NS ns1.your_domain
ns1.your_domain AAAA 2001:0db8::0db9 (optional)
Sie sollten diese Einträge im Steuerungsfeld Ihres Domain-Registrars erstellen. Bitte beachten Sie, dass es bis zu 24 Stunden dauern kann, bis sich diese Datensätze gut verbreiten, normalerweise dauert es jedoch nur wenige Minuten.
Installation
Wenn Sie nicht den Root-Benutzer verwenden, empfehlen wir Ihnen, eine temporäre Root-Shell zu starten, da die meisten in diesem Handbuch gezeigten Befehle erhöhte Berechtigungen erfordern. Um eine Root-Shell zu starten, verwenden Sie einen der folgenden Befehle:
sudo su - root
sudo -s
Schritt 1:Aktualisieren und Installieren von Abhängigkeiten.
Es empfiehlt sich immer, zuerst Ihr System zu aktualisieren:
apt update
apt upgrade -y
reboot
Installieren Sie nach dem Neustart die für dieses Setup erforderlichen Softwarepakete:
- certbot wird verwendet, um SSL/TLS-Zertifikate zu erhalten.
- machen wird benötigt, um das Docker-Image zu erstellen, in dem der DDNS-Server ausgeführt wird.
- apt-transport-https , ca-Zertifikate , locken , gnupg2 und software-properties-common werden benötigt, um das Docker-Repository und den entsprechenden GPG-Schlüssel zu installieren.
- dnsutils bietet dig , die zum Testen verwendet wird.
apt install -y certbot make apt-transport-https curl ca-certificates software-properties-common gnupg2 dnsutils
Schritt 2:Installieren Sie Docker CE.
GPG-Schlüssel von Docker hinzufügen:
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
Installieren Sie das Docker-Repository:
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian buster stable"
Aktualisieren Sie den Repository-Cache von Debian und installieren Sie dann Docker und seine Abhängigkeiten:
apt update
apt install -y docker-ce docker-ce-cli containerd.io
Stellen Sie nach Abschluss der Installation sicher, dass der Docker-Dienst aktiviert ist und wie folgt ausgeführt wird:
systemctl enable --now docker.service
Schritt 3:Docker-ddns herunterladen und erstellen
Unser dynamischer DNS-Server wird von einem Docker-Container betrieben, der Bind als DNS-Server und eine in Go geschriebene Verwaltungs-API verwendet. Klonen Sie zunächst das Github-Repository und erstellen Sie das Container-Image mit den folgenden Befehlen:
git clone https://github.com/dprandzioch/docker-ddns.git
cd docker-ddns
make image
Warten Sie, bis der Vorgang abgeschlossen ist, was eine Weile dauern kann, und öffnen Sie dann die Datei envfile mit einem Texteditor:
$EDITOR envfile
Und geben Sie Folgendes ein:
SHARED_SECRET=your_secret
ZONE=ddns.your_domain
RECORD_TTL=60
Das gemeinsame Geheimnis ist ein Kennwort, das zur Authentifizierung bei der Verwaltungs-API verwendet wird. ZONE gibt an, für welche DNS-Zone Ihr Server verantwortlich sein wird, und die Datensatz-TTL gibt an, wie lange DNS-Einträge zwischengespeichert werden können. Für häufig wechselnde dynamische IPs wird eine TTL von 60 Sekunden empfohlen.
Bei Bedarf können Sie mit dem folgenden Befehl eine zufällige 40-stellige Zeichenfolge für das Geheimnis generieren:
cat /dev/urandom | tr -dc "a-zA-Z0-9" | fold -w 40 | head -1
Wir können jetzt den Container erstellen:
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
Dieser Befehl erstellt einen Container namens ddns-server aus dem zuvor erstellten Image und ordnet die Ports 8080/tcp, 53/tcp und 53/udp vom Host dem Container zu. Es wird auch das Verzeichnis /mnt/ddns-data vom Host in /var/cache/bind im Dateisystem des Containers einhängen. Dies wird verwendet, um DNS-Daten über die Containererneuerung hinweg beizubehalten.
Überprüfen Sie mit dem folgenden Befehl, ob der Container erstellt wurde:
docker container ls -a
Es sollte ein einzelner Eintrag mit dem Namen ddns-server.
ausgegeben werdenSchritt 4:Systemd-Dienst (optional)
Dieser Schritt dient der einfacheren Verwaltung, ist aber nicht unbedingt erforderlich. Wenn Sie sich gegen die Verwendung eines systemd-Dienstes entscheiden, müssen Sie den Container manuell verwalten oder eine andere Verwaltungslösung verwenden. Bitte beachten Sie, dass für größere, komplexere Containerbereitstellungen eine Orchestrierungslösung wie Kubernetes oder Docker Swarm empfohlen wird. In diesem Fall ist ein systemd-Dienst perfekt geeignet, da wir nur einen einzigen Container ausführen.
Um diesen Container als Systemdienst verwalten zu können, packen wir ihn in eine systemd-Unit. Erstellen Sie die Datei /etc/systemd/system/ddns-server-ct.service mit Ihrem Texteditor:
$EDITOR /etc/systemd/system/ddns-server-ct.service
Und fügen Sie Folgendes hinzu:
[Unit]
Description=DDNS Server Docker Container
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
Speichern und beenden Sie, und legen Sie dann die richtigen Berechtigungen für diese Unit-Datei fest:
chmod 664 /etc/systemd/system/ddns-server-ct.service
Laden Sie die neue Servicedatei mit dem folgenden Befehl:
systemctl daemon-reload
Sie sollten diesen Container jetzt wie jeden anderen Systemdienst mit systemctl starten und stoppen können.
Wenn Sie möchten, dass der DDNS-Server automatisch beim Systemstart gestartet wird, führen Sie Folgendes aus:
systemctl enable ddns-server-ct.service
Schritt 5:Testen Sie Ihren Server
Bevor wir mit der Einrichtung fortfahren, testen wir die Verwaltungs-API lokal. Container starten:
systemctl start ddns-server-ct.service
Senden Sie eine GET-Anforderung an die API, um einen neuen Datensatz zu erstellen:
HINWEIS: Die API ist derzeit nur lokal zugänglich (d. h. von localhost).
curl "http://127.0.0.1:8080/update?secret=your_secret&domain=test1&addr=1.1.1.1"
Curl sollte die folgende Antwort zurückgeben:
{"Success":true,"Message":"Updated A record for test1 to IP address 1.1.1.1","Domain":"test1","Domains":["test1"],"Address":"1.1.1.1","AddrType":"A"} HINWEIS: Die Domäne test1 verweist auf test1.ddns.ihre_domäne. da der Server die ddns.your_domain behandelt. Zone.
Führen Sie eine DNS-Suche durch, um zu überprüfen, ob der Eintrag tatsächlich erstellt wurde, und um die DNS-Auflösung zu testen:
dig +short -t A test1.ddns.your_domain @127.0.0.1
Die Ausgabe sollte 1.1.1.1 sein.
Schritt 6:Reverse-Proxy
Da die API über HTTP funktioniert, kann Ihr Authentifizierungsgeheimnis potenziell ausgespäht werden, wenn Sie eine Anfrage über das Netzwerk senden. Ein Angreifer könnte dann Ihre DNS-Einträge mit Ihrem Geheimnis manipulieren. Wir richten einen Reverse-Proxy mit Nginx ein und sichern ihn mit HTTPS. Besorgen Sie sich zunächst ein SSL-Zertifikat von Let’s Encrypt mit certbot:
certbot certonly --standalone --agree-tos -m [email protected] -d ns1.your_domain
Der Besitz Ihrer Domain wird überprüft und ein Zertifikat ausgestellt. Installieren Sie als Nächstes Nginx und stellen Sie sicher, dass es aktiviert ist und ausgeführt wird:
apt install -y nginx systemctl enable --now nginx.service
Deaktivieren Sie dann die Standardserverblockdatei, da sie nicht benötigt wird:
unlink /etc/nginx/sites-enabled/default
Wir werden nun eine neue Konfigurationsdatei für den Reverse-Proxy erstellen, zum Beispiel:
$EDITOR /etc/nginx/sites-available/ddns-api-proxy.conf
Fügen Sie Folgendes ein und stellen Sie sicher, dass Sie die IP-Adressen und Domänennamen durch Ihre eigenen ersetzen:
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;
} Optional: Wenn Sie möchten, dass die API über IPv6 zugänglich ist, fügen Sie die folgende Zeile nach der vorhandenen Listen-Direktive hinzu:
listen [2001:0db8::0db9]:8080;
Aktivieren Sie diese Konfiguration und wenden Sie die Änderungen an, indem Sie Nginx neu laden:
ln -s /etc/nginx/sites-available/ddns-api-proxy.conf /etc/nginx/sites-enabled/
systemctl reload nginx.service
Die API sollte jetzt über das Internet zugänglich sein und akzeptiert nur HTTPS-Verbindungen. Führen Sie zum Testen den folgenden Befehl aus:
curl "https://ns1.your_domain:8080/update?secret=your_secret&domain=test2&addr=1.1.1.2"
Es sollte Folgendes zurückgeben:
{"Success":true,"Message":"Updated A record for test2 to IP address 1.1.1.2","Domain":"test2","Domains":["test2"],"Address":"1.1.1.2","AddrType":"A"} Schritt 7:Client-Konfiguration
Sie können automatische Datensatzaktualisierungen auf jedem Router einrichten, der benutzerdefinierte dynamische DNS-Anbieter wie Pfsense unterstützt. Sie können sie auch auf den meisten anderen Geräten in Ihrem Büro- oder Heimnetzwerk einrichten. Um einen Datensatz zu aktualisieren oder zu erstellen, sollte eine GET-Anforderung an den folgenden Endpunkt gesendet werden:
https://ns1.your_domain:8080/update?secret=your_secret&domain=your_subdomain&addr=your_ip_address
Sie können auch die Datensätze mehrerer Subdomains mit einer einzigen Anfrage aktualisieren. Um beispielsweise Datensätze für sub1.ddns.your_domain und sub2.ddns.your_domain mit der IP-Adresse 198.51.100.100 zu erstellen/aktualisieren, würden Sie eine GET-Anforderung an diese URL senden:
https://ns1.ihre_domain:8080/update?secret=ihr_geheimnis&domain=sub1,sub2&addr=198.51.100.100
Der addr-Parameter kann auch eine IPv6-Adresse enthalten, um AAAA-DNS-Einträge zu erstellen/aktualisieren, zum Beispiel:
https://ns1.your_domain:8080/update?secret=your_secret&domain=cheese&addr=2001:0db8:aaaa::
Um diese Updates auf einem Linux-Client zu automatisieren, speichern Sie das folgende Bash-Skript als /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}"
Dieses Skript verwendet eine while-Schleife, die um einen dig-Befehl gewickelt ist, der die öffentliche IP-Adresse des Clients erhält und in einer Variablen speichert. Die Schleife stellt sicher, dass die öffentliche IP korrekt abgerufen wird. Dann wird cURL verwendet, um eine API-Anfrage zu senden, um den DNS-Eintrag mit dieser neu abgerufenen IP zu aktualisieren. Stellen Sie sicher, dass Sie die Werte für your_secret und your_subdomain ersetzen.
Als nächstes machen Sie dieses Skript ausführbar:
chmod +x /opt/ddns-update.sh
Starten Sie dann den Crontab-Editor:
crontab -e
Fügen Sie am Ende Ihrer Crontab die folgende Zeile hinzu:
*/2 * * * * /opt/ddns-update.sh
Speichern und schließen. Das Skript wird jetzt alle zwei Minuten ausgeführt und hält Ihren dynamischen DNS-Eintrag mit der neuesten öffentlichen IP-Adresse des Clients auf dem neuesten Stand.
Weiterführende Literatur
- Dynamischer DNS-Wikipedia-Artikel
- docker-ddns auf Github