DynDNS mit Hetzner DNS API und Node-RED selbst bauen

Inhaltsverzeichnis

Dynamic DNS (DynDNS) ist ein essentieller Service für alle, die von zu Hause aus Server betreiben oder remote auf ihre Systeme zugreifen müssen. Anstatt auf externe DynDNS-Anbieter zu setzen, zeige ich euch heute, wie ihr euren eigenen DynDNS-Service mit der Hetzner DNS API und Node-RED aufbaut.

Warum eigenes DynDNS?
#

Die meisten Internetanbieter vergeben dynamische IP-Adressen, die sich regelmäßig ändern. Kommerzielle DynDNS-Dienste kosten oft Geld oder haben Limitierungen. Mit der eigenen Lösung habt ihr:

Volle Kontrolle über eure DNS-Einträge
Keine monatlichen Kosten (nur die Domain bei Hetzner)
Beliebig viele Subdomains ohne Aufpreis
Integration in bestehende Automatisierungen

Voraussetzungen
#

Für dieses Setup benötigt ihr:

Eine Domain, die bei Hetzner DNS verwaltet wird
Node-RED Installation
Hetzner DNS API Token

Die Architektur
#

Unser DynDNS-System besteht aus mehreren Komponenten:

IP-Erkennungsservice: Ein eigener Golang-Service unter https://unjx.de/ip
Node-RED Flow: Überwacht IP-Änderungen und aktualisiert DNS
Hetzner DNS API: Aktualisiert die DNS-Einträge automatisch

IP-Erkennungsservice in Golang
#

Zuerst habe ich einen einfachen Golang-Service entwickelt, der die öffentliche IP-Adresse des anfragenden Clients zurückgibt. Der Service läuft unter https://unjx.de/ip und gibt JSON zurück:

{
  "ip": "203.0.113.1"
}

Der Vorteil gegenüber Services wie ipify.org: Ihr habt die volle Kontrolle und könnt bei Bedarf weitere Informationen hinzufügen. Gerne könnt ihr aber auch ipify.org oder ähnliche Dienste verwenden. Sonst gibt es hier den exemplarischen Code für den eigenen IP-Service:

package main

import (
    "encoding/json"
    "net"
    "net/http"
    "strings"
)

type IPResponse struct {
    IP string `json:"ip"`
}

func getClientIP(r *http.Request) string {
    // Check X-Forwarded-For header
    xff := r.Header.Get("X-Forwarded-For")
    if xff != "" {
        ips := strings.Split(xff, ",")
        return strings.TrimSpace(ips[0])
    }

    // Check X-Real-IP header
    if ip := r.Header.Get("X-Real-IP"); ip != "" {
        return ip
    }

    // Fall back to RemoteAddr
    ip, _, _ := net.SplitHostPort(r.RemoteAddr)
    return ip
}

func ipHandler(w http.ResponseWriter, r *http.Request) {
    ip := getClientIP(r)

    response := IPResponse{
        IP: ip,
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

func main() {
    http.HandleFunc("/ip", ipHandler)
    http.ListenAndServe(":8080", nil)
}

Node-RED Flow Aufbau
#

Der Node-RED Flow ist das Herzstück unseres DynDNS-Systems. Er führt folgende Schritte aus:

1. Regelmäßige IP-Abfrage
#

// Wird jede Minute ausgeführt
// HTTP Request zu https://unjx.de/ip

2. IP-Vergleich
#

Der Flow vergleicht die neue IP mit der gespeicherten IP:

Globale Variable lesen: currentIp aus dem Flow-Speicher
Neue IP extrahieren: Aus der API-Antwort von unjx.de/ip
Vergleich durchführen: Nur bei Änderung weitermachen
Payload vorbereiten: Hetzner API-Format mit neuer IP-Adresse

Funktionslogik (Function Node):

const currentIp = global.get('currentIp');
const newIp = msg.payload.ip;

if (currentIp !== newIp) {
  msg.ip = newIp;
  msg.payload = {
    records: [{ value: newIp }],
  };
  return msg;
}

3. DNS-Update via Hetzner API
#

HTTP Request Konfiguration:

Parameter	Wert
Methode	`POST`
URL	`https://api.hetzner.cloud/v1/zones/yourdomain.com/rrsets/dyndns/A/actions/set_records`
Headers	`Authorization: Bearer YOUR_API_TOKEN` `Content-Type: application/json`
Payload	`{"records": [{"value": "203.0.113.1"}]}`

API-Endpunkt Details:

Zone: Eure Domain (z.B. example.com)
Record Name: dyndns (anpassbar)
Record Type: A (IPv4-Adresse)
Action: set_records (überschreibt bestehende Einträge)

4. Status-Überwachung
#

Der Flow überwacht den Status der DNS-Änderung in mehreren Schritten:

Schritt 1: DNS-Update initiieren

HTTP 201: DNS-Änderung erfolgreich gestartet
Andere Codes: Fehler beim API-Call

Schritt 2: 10 Sekunden warten (Delay Node)

Hetzner API benötigt Zeit zur Verarbeitung

Schritt 3: Status abfragen

URL: https://api.hetzner.cloud/v1/actions?id={action_id}
HTTP 200: Status-Abfrage erfolgreich

Schritt 4: Ergebnis prüfen

“success”: DNS-Update abgeschlossen → IP speichern
“running”: Noch in Bearbeitung → Debug-Ausgabe
“error”: Update fehlgeschlagen → Fehlerbehandlung

Hetzner DNS API Setup
#

API-Token erstellen
#

Meldet euch im Hetzner Cloud Console an
Geht zu “API-Tokens” und erstellt einen neuen Token
Gebt ihm Lese- und Schreibrechte für DNS

DNS-Zone konfigurieren
#

Erstellt einen A-Record für euren DynDNS-Eintrag:

Name: dyndns (oder beliebig)
Type: A
Value: Beliebige IP (wird automatisch überschrieben)
TTL: 60 (für schnelle Updates)

Node-RED Konfiguration
#

HTTP Request Nodes konfigurieren
#

Für alle Hetzner API-Calls müsst ihr folgende Header setzen:

Authorization: Bearer YOUR_API_TOKEN
Content-Type: application/json

Globale Variablen
#

Der Flow nutzt eine globale Variable currentIp zum Speichern der aktuellen IP:

// Setzen der IP
global.set('currentIp', msg.ip);

// Lesen der IP
const currentIp = global.get('currentIp');

Erweiterte Features
#

Fehlerbehandlung
#

Der Flow beinhaltet umfassende Fehlerbehandlung:

HTTP-Status-Code-Überprüfung
Retry-Mechanismus bei API-Fehlern
Debugging-Ausgaben für Fehlerdiagnose

Anpassbare Intervalle
#

Standardmäßig prüft der Flow jede Minute die IP. Für weniger kritische Anwendungen könnt ihr das Intervall auf 5 oder 15 Minuten erhöhen.

Sicherheitsaspekte
#

API-Token Schutz
#

Verwendet separate API-Tokens nur für DNS-Operationen
Beschränkt die Token-Rechte auf das Minimum
Rotiert die Tokens regelmäßig

Download und Installation
#

Den kompletten Node-RED Flow könnt ihr hier herunterladen:

Node-RED Flow herunterladen

Import in Node-RED
#

Öffnet Node-RED im Browser
Hamburger-Menü → Import
Wählt die heruntergeladene flows.json Datei
Passt die Konfiguration an eure Domain an

Erforderliche Anpassungen
#

Nach dem Import müsst ihr folgende Werte anpassen:

In der “Set Record” Node:

URL anpassen: https://api.hetzner.cloud/v1/zones/EURE_DOMAIN/rrsets/dyndns/A/actions/set_records
Domain ersetzen: EURE_DOMAIN durch eure tatsächliche Domain
Record-Name anpassen: dyndns kann beliebig gewählt werden

In allen Hetzner-API-Nodes:

Authorization Header: Bearer EUER_API_TOKEN
API-Token aus der Hetzner Cloud Console einfügen

IP-Service anpassen (optional):

Standard: https://unjx.de/ip (mein Service)
Alternative: https://api.ipify.org?format=json oder andere

Troubleshooting
#

Häufige Probleme
#

IP wird nicht aktualisiert:

Überprüft die API-Token-Berechtigung
Kontrolliert die DNS-Zone-Konfiguration
Schaut in die Node-RED Debug-Ausgabe

Zu häufige Updates:

Erhöht das Prüfintervall
Implementiert einen IP-Change-Threshold

API-Rate-Limits:

Reduziert die Abfrage-Häufigkeit
Implementiert exponential backoff

Debug-Tipps
#

Aktiviert Debug-Nodes für folgende Punkte:

IP-Abfrage-Antworten
Hetzner API-Antworten
Fehlermeldungen

Fazit
#

Mit diesem Setup habt ihr einen vollwertigen DynDNS-Service, der:

Zuverlässig eure IP-Änderungen erkennt
Automatisch DNS-Updates durchführt
Transparent über alle Änderungen informiert
Erweiterbar für zusätzliche Funktionen ist

Die Kombination aus Hetzner DNS API und Node-RED bietet maximale Flexibilität bei geringen Kosten. Der eigene IP-Service gibt euch zusätzliche Kontrolle und Unabhängigkeit.

Erweiterungsideen:

Multiple DNS-Records für verschiedene Services
Webhook-Integration für andere Automatisierungen
Monitoring und Alerting bei Ausfällen
Backup DNS-Provider für Redundanz

Autor

Florian Hoss

Warum eigenes DynDNS?#

Voraussetzungen#

Die Architektur#

IP-Erkennungsservice in Golang#

Node-RED Flow Aufbau#

1. Regelmäßige IP-Abfrage#

2. IP-Vergleich#

3. DNS-Update via Hetzner API#

4. Status-Überwachung#

Hetzner DNS API Setup#

API-Token erstellen#

DNS-Zone konfigurieren#

Node-RED Konfiguration#

HTTP Request Nodes konfigurieren#

Globale Variablen#

Erweiterte Features#

Fehlerbehandlung#

Anpassbare Intervalle#

Sicherheitsaspekte#

API-Token Schutz#

Download und Installation#

Import in Node-RED#

Erforderliche Anpassungen#

Troubleshooting#

Häufige Probleme#

Debug-Tipps#

Fazit#