Dyn-DNS mit PowerDNS

Whitepaper: Redundante PowerDNS-Infrastruktur mit MariaDB und Wildcard-SSL
Eine Schritt-für-Schritt-Anleitung für Entwickler, die dynamisches DNS, Hochverfügbarkeit und automatisierte SSL-Zertifikate vereinen wollen.

Einleitung

Tausende dezentrale cBOX@ Server bekommen dynamische IPs via DHCP – wir wollen ihre Erreichbarkeit über eine hochverfügbare DNS-Infrastruktur absichern, die auch Wildcard-SSL-Zertifikate ausspielt. Deshalb kombinieren wir PowerDNS mit MariaDB! Warum?

• Redundanz: Zwei PowerDNS-Server im Master-Slave-Setup, abgesichert durch MariaDB-Replikation.
• Automatisierung: Wildcard-SSL-Zertifikate wie *.example.com via Let’s Encrypt, integriert in die DNS-Infrastruktur.
• Skalierbarkeit: Keine manuellen Zone-Files – alles läuft über die Datenbank.

Hier kommt die Anleitung, wie du das in deinem NOC umsetzt.

Schritt 1: Basis-Installation auf beiden Servern

Wiederhole diese Schritte auf beiden PowerDNS-Servern (Master + Slave).

1.1 System updaten & MariaDB installieren

sudo apt update && sudo apt upgrade -y  
sudo apt install mariadb-server -y  
sudo mysql_secure_installation  # Setze ein starkes Root-Passwort!  

1.2 Datenbank und Benutzer anlegen

sudo mysql -u root -p  

-- Führe dies auf beiden Servern aus (Passwort anpassen!)  
CREATE DATABASE pdns;  
CREATE USER 'pdns'@'localhost' IDENTIFIED BY 'S3cr3tP@ssw0rd!';  
GRANT ALL PRIVILEGES ON pdns.* TO 'pdns'@'localhost';  
FLUSH PRIVILEGES;  
EXIT;  

1.3 PowerDNS-Repository hinzufügen

sudo add-apt-repository ppa:powerdns/authoritative-server -y  
sudo apt update  

1.4 PowerDNS mit MariaDB-Backend installieren

sudo apt install pdns-server pdns-backend-mysql -y  

1.5 PowerDNS konfigurieren

Öffne /etc/powerdns/pdns.conf und ergänze:

launch=gmysql  
gmysql-host=127.0.0.1  
gmysql-user=pdns  
gmysql-password=S3cr3tP@ssw0rd!  
gmysql-dbname=pdns  
api=yes  
api-key=DeinGlobalerAPIKey123!  # Muss auf Master und Slave gleich sein!  

Starte PowerDNS neu:

sudo systemctl restart pdns  

Schritt 2: MariaDB-Replikation einrichten

Damit beide Server dieselben DNS-Daten haben.

2.1 Master-Server vorbereiten

Aktuelle Position notieren:

SHOW MASTER STATUS;  # Merke 'File' und 'Position'  

Replikations-Benutzer anlegen:

CREATE USER 'repl'@'slave-ip' IDENTIFIED BY 'ReplPasswort!';  
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'slave-ip';  
FLUSH PRIVILEGES;  

Datenbank neustarten:

sudo systemctl restart mariadb  

Bearbeite /etc/mysql/mariadb.conf.d/50-server.cnf:

[mysqld]  
server-id = 1  
log_bin = /var/log/mysql/mysql-bin.log  
binlog_do_db = pdns  

2.2 Slave-Server konfigurieren

Status prüfen:

SHOW SLAVE STATUS\G  # Suche nach 'Seconds_Behind_Master: 0'  

Replikation starten:

CHANGE MASTER TO  
MASTER_HOST='master-ip',  
MASTER_USER='repl',  
MASTER_PASSWORD='ReplPasswort!',  
MASTER_LOG_FILE='Datei-vom-Master',  
MASTER_LOG_POS=Position-vom-Master;  
START SLAVE;  

Bearbeite /etc/mysql/mariadb.conf.d/50-server.cnf:

[mysqld]  
server-id = 2  
relay-log = /var/log/mysql/mysql-relay-bin  

Schritt 3: PowerDNS Master-Slave-Zonen

Synchronisiere DNS-Zonen zwischen den Servern.

3.1 Auf dem Master: Zone als MASTER markieren

sudo pdnsutil create-zone example.com  
sudo pdnsutil set-zone-kind example.com MASTER  

3.2 Auf dem Slave: Zone als SLAVE hinzufügen

sudo pdnsutil create-zone example.com  
sudo pdnsutil set-zone-kind example.com SLAVE  
sudo pdnsutil set-zone-masters example.com master-ip  

3.3 Teste die Replikation

Prüfe auf dem Slave nach:

dig @localhost www.example.com  # Sollte 192.0.2.1 zurückgeben  

Füge auf dem Master einen DNS-Eintrag hinzu:

sudo pdnsutil add-record example.com www A 192.0.2.1  

Schritt 4: Wildcard-SSL mit Let’s Encrypt

Zertifikate für *.example.com automatisch ausstellen und erneuern.

4.1 Certbot mit PowerDNS-Plugin installieren

sudo apt install certbot python3-certbot-dns-powerdns -y  

4.2 Certbot konfigurieren

Erstelle /etc/letsencrypt/pdns-config.ini:

dns_powerdns_api_url = http://localhost:8081/api/v1  
dns_powerdns_api_key = DeinGlobalerAPIKey123!  

Setze Berechtigungen:

sudo chmod 600 /etc/letsencrypt/pdns-config.ini  

4.3 Wildcard-Zertifikat anfordern

sudo certbot certonly \  
  --dns-powerdns \  
  --dns-powerdns-credentials /etc/letsencrypt/pdns-config.ini \  
  -d *.example.com -d example.com  

Das Zertifikat landet in /etc/letsencrypt/live/example.com/.

4.4 Automatische Erneuerung einrichten

sudo crontab -e  

Füge hinzu:

0 3 * * * certbot renew --quiet --post-hook "systemctl reload nginx"  

Schritt 5: Redundanz absichern – Best Practices

• Firewall-Regeln: Erlaube MariaDB-Replikation (Port 3306) nur zwischen Master/Slave.
• Health-Checks: Nutze keepalived oder HAProxy für automatisches Failover.

Backups: Automatisiere tägliche MariaDB-Dumps:

mysqldump -u root -p pdns > /backups/pdns-$(date +%F).sql  

Monitoring:

pdns_control ping  # Prüft, ob PowerDNS läuft  
mysql -e "SHOW SLAVE STATUS\G"  # Überwacht Replikations-Lag  

Warum PowerDNS + MariaDB besser ist als BIND

• Keine Zone-Files: Alles in der DB → einfachere Skalierung.
• API-getrieben: Automatisiere DNS-Updates via REST (z. B. für Kundenserver-Skripte).
• Echte Redundanz: MariaDB-Replikation + PowerDNS Master-Slave = Kein Single Point of Failure.

Fazit

Mit dieser Anleitung hast du eine bankfeste DNS-Infrastruktur im NOC:

• 🔄 Redundante PowerDNS-Server mit MariaDB-Replikation.
• 🔒 Wildcard-SSL-Zertifikate, die sich automatisch erneuern.
• 🚀 Skalierbar für tausende dynamische Kundenserver.

Pro-Tipp: Nutze Infrastructure-as-Code (z. B. Ansible), um die Setup-Schritte zu automatisieren – so spielst du neue Server in Minuten aus.

Weiterführend:

• Offizielle PowerDNS-Dokumentation
• MariaDB Replication Guide
• Let’s Encrypt DNS-01 Challenge

Ergänzung: DynDNS-Funktionalität für Kundenserver
Damit deine Kunden-Server ihre IPs automatisch aktualisieren können – ohne manuellen Aufwand.

Schritt 6: DynDNS für Client-Updates einrichten

PowerDNS ermöglicht dynamische DNS-Updates via API. So richtest du es sicher ein.

6.1 Zone für DynDNS vorbereiten

Aktiviere DNS-Updates für eine Zone (z. B. clients.example.com):

# Auf dem Master-Server:  
sudo pdnsutil create-zone clients.example.com  
sudo pdnsutil set-meta clients.example.com ALLOW-DNSUPDATE-FROM 0.0.0.0/0  # Nur für Test! Später einschränken.  

Hinweis: Ersetze 0.0.0.0/0 später durch die IP-Bereiche deiner Kunden-Server (z. B. 192.0.2.0/24).

6.2 API-Key für Clients erstellen

Für sichere Updates nutzt du einen separaten API-Key:

Restarte PowerDNS:

sudo systemctl restart pdns  

Bearbeite /etc/powerdns/pdns.conf auf dem Master:

api=yes  
api-key=DeinGlobalerAPIKey123!  
webserver-allow-from=0.0.0.0/0  # Nur für Test! Später auf interne IPs beschränken.  

6.3 Client-Skript bereitstellen

Beispiel-Skript (/usr/local/bin/update-dns.sh):

#!/bin/bash  
DOMAIN="client123.clients.example.com"  # Eindeutige Subdomain pro Kunde  
API_KEY="DeinGlobalerAPIKey123!"  
API_URL="http://dns-master.example.com:8081/api/v1/servers/localhost/zones/$DOMAIN"  

# Aktuelle öffentliche IP ermitteln  
NEW_IP=$(curl -s https://api.ipify.org)  

# DNS-Update via PowerDNS-API  
curl -X PATCH -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" -d "{  
  \"rrsets\": [{  
    \"name\": \"$DOMAIN.\",  
    \"type\": \"A\",  
    \"ttl\": 60,  
    \"changetype\": \"REPLACE\",  
    \"records\": [{ \"content\": \"$NEW_IP\", \"disabled\": false }]  
  }]  
}" "$API_URL"  

Anpassungen:

• Jeder Kunde erhält eine eindeutige DOMAIN (z. B. kundenname.clients.example.com).
• Für Produktivbetrieb: Nutze individuelle API-Keys pro Kunde (siehe Sicherheitstipps).

6.4 Skript auf den Kunden-Servern ausrollen

Füge einen Cron-Job hinzu (prüft alle 5 Minuten):

crontab -e  

Füge hinzu:

*/5 * * * * /usr/local/bin/update-dns.sh >/dev/null 2>&1  

Mach das Skript ausführbar:

chmod +x /usr/local/bin/update-dns.sh  

Sicherheitstipps für DynDNS

• IP-Whitelisting: Beschränke ALLOW-DNSUPDATE-FROM auf die IPs der Kunden-Server.
• HTTPS für die API: Setze einen Reverse-Proxy (Nginx/Apache) mit Let’s Encrypt-Zertifikat vor die PowerDNS-API.

Individuelle API-Keys: Nutze Tools wie pwgen, um pro Kunde einen Key zu generieren:

pwgen 32 1  # Generiert einen 32-stelligen Key  

Trage diese Keys in die update-dns.sh-Skripte der Kunden ein.

Troubleshooting: Wenn Updates nicht klappen

Replikation prüfen:

mysql -u root -p -e "SHOW SLAVE STATUS\G"  # Ist der Slave synchron?  

Test-Curl-Befehl:

curl -v -X PATCH -H "X-API-Key: DEIN_KEY" [...]  # Zeigt detaillierte Fehler  

Logs prüfen:

journalctl -u pdns -f  # Zeigt PowerDNS-Logs in Echtzeit  

Warum DynDNS mit PowerDNS besser skaliert

• Automatisierung: Kein manuelles Bearbeiten von Zone-Files – alles läuft über API und Datenbank.
• Echtzeit-Updates: Änderungen sind sofort nach API-Call verfügbar.
• Audit-Fähigkeit: Jeder Update-Request landet in der MariaDB – perfekt für Nachverfolgung.

Fazit mit DynDNS
Jetzt hast du eine komplette Lösung:

• 🌐 Redundante PowerDNS-Server mit MariaDB.
• 🔄 Automatische DynDNS-Updates für tausende Clients.
• 🔒 Wildcard-SSL und API-Sicherheit.

Mit dieser Basis kannst du Cloud-ähnliche DNS-Services anbieten – ohne Abhängigkeit von externen Anbietern.

Nächste Schritte:

• Teste das Setup mit einem Demo-Client.
• Ersetze die Platzhalter-API-Keys durch individuelle Secrets.
• Setze Monitoring-Alarme für fehlgeschlagene DNS-Updates.

Du willst mehr Infos zum Thema bekommen? Log dich einfach kostenlos ein und genieße weiter Infos. So kannst du auch Fragen im Kommentar unten an unsere Community stellen. 👌

Log dich kostenlos ein und lies den Artikel weiter im Memberbereich: