DuckDNS per Docker: Dynamische DNS-Updates für den Heimserver automatisch einrichten¶

Veröffentlicht am 5. Oktober 2026 · Geschätzte Lesezeit: 7 Minuten

Die öffentliche IP deines Heimnetzes wechselt regelmäßig – bei vielen Providern alle 24 Stunden oder bei jedem Router-Neustart. DuckDNS aktualisiert automatisch einen kostenlosen Domainnamen (deinsubdomain.duckdns.org), sodass dein Server dauerhaft unter derselben Adresse erreichbar ist. Das ist die Grundlage für HTTPS-Zertifikate (Let's Encrypt) und den Zugriff von unterwegs. Die Einrichtung mit dem LinuxServer.io-Docker-Image dauert etwa 30 Minuten.[1][2]

Voraussetzungen

Ein Linux-Server mit Docker und Docker Compose
Ein öffentlicher Internetzugang (Provider kann IPv4 oder IPv6)
Port-Forwarding im Router für 80 und 443 (später für HTTPS)
Terminal-Zugriff mit sudo-Rechten für Router-Einstellungen reicht

1. DuckDNS-Konto anlegen¶

Öffne https://www.duckdns.org in deinem Browser und melde dich mit einem der angebotenen Konten an (Google, GitHub, Twitter, Reddit oder Persona). Es werden keine persönlichen Daten außer der E-Mail-Adresse des Anmeldeproviders gespeichert.[3]

Nach der Anmeldung siehst du ein Formular:

Gib eine Subdomain ein, z. B. meinhome
Klicke auf "add domain"
Der grüne Bestätigungstext zeigt meinhome.duckdns.org an
Kopiere den angezeigten Token – er ist der Schlüssel für API-Updates und wird nie weitergegeben

Der Token ist ein langer, zufälliger String (z. B. a7b3c9d1-e2f4-...). Bewahre ihn sicher auf – jeder, der den Token kennt, kann deine DNS-Einträge ändern.

Nur der Subdomain-Name

Der Wert für den Docker-Container ist nur der erste Teil vor .duckdns.org. Aus meinhome.duckdns.org wird SUBDOMAINS=meinhome. Eine Sub-Subdomain wie app.meinhome wird nicht unterstützt.[1]

2. Projektordner vorbereiten¶

Erstelle einen Ordner für die DuckDNS-Konfiguration und wechsle hinein:

mkdir -p ~/docker/duckdns && cd ~/docker/duckdns

3. docker-compose.yml erstellen¶

Erstelle die Datei compose.yaml im Ordner ~/docker/duckdns:

services:
  duckdns:
    image: lscr.io/linuxserver/duckdns:latest
    container_name: duckdns
    network_mode: host
    environment:
      - SUBDOMAINS=meinhome
      - TOKEN=<dein-duckdns-token>
      - TZ=Europe/Berlin
      - LOG_FILE=false
    restart: unless-stopped

Bedeutung der Einstellungen:

Abschnitt	Erklärung
`image: lscr.io/linuxserver/duckdns:latest`	Offizielles LinuxServer.io-Image, unterstützt x86-64 und arm64[1]
`network_mode: host`	Nötig für IPv6-Erkennung, optional für IPv4-only
`SUBDOMAINS=meinhome`	Deine DuckDNS-Subdomain ohne `.duckdns.org`, mehrere durch Komma getrennt
`TOKEN=<dein-duckdns-token>`	Dein persönlicher DuckDNS-Token von der Webseite – siehe Absatz unten
`TZ=Europe/Berlin`	Deine Zeitzone, z. B. `Europe/Berlin` für Mitteleuropa
`LOG_FILE=false`	Auf `true` setzen, um Update-Verlauf zu protokollieren (dann auch `volumes` nötig)

Optionales Volume für Logs (falls LOG_FILE=true):

    volumes:
      - ./config:/config

Ersetze <dein-duckdns-token> durch den echten Token von der DuckDNS-Webseite. Setzte den Wert in einfache oder doppelte Anführungszeichen, falls Sonderzeichen enthalten sind.

Token sicher behandeln

Der Token steht in Klartext in der Compose-Datei. Wer Lesezugriff auf den Server hat, kann ihn auslesen. Das LinuxServer.io-Image unterstützt den alternativen Mechanismus FILE__TOKEN, bei dem der Token aus einer separaten Datei mit chmod 600 geladen wird (siehe GitHub-README).[1] Die TOKEN=-Variable in der Compose-Datei entfällt dann – stattdessen trägst du den Pfad zur geheimen Datei bei FILE__TOKEN ein.

4. Container starten¶

Starte den Container und prüfe seine Logs:

docker compose up -d
docker logs duckdns

Eine erfolgreiche Ausgabe sieht ähnlich aus wie:

[s6-init] making user provided files available at /var/run/s6/etc...
...
Processing SUBDOMAINS meinhome
Processing TOKEN
Processing TZ Europe/Berlin
...
[cont-init.d] Executing /etc/cont-init.d/40-config...
DuckDNS started
[...]
Checking ip: OK

Die Meldung OK (oder mehrere OK-Zeilen) bestätigt, dass das Update bei DuckDNS angekommen ist. Wiederholt sich die Zeile etwa alle 5 Minuten, läuft der automatische Update-Dienst.[1]

Prüfe den Container-Status:

docker compose ps

Erwartete Ausgabe:

NAME      IMAGE                                  ...  STATUS
duckdns   lscr.io/linuxserver/duckdns:latest     ...  Up 2 minutes

5. Update manuell testen¶

Rufe die DuckDNS-API direkt auf, um zu prüfen, ob der Dienst antwortet:

curl -s "https://www.duckdns.org/update?domains=meinhome&token=<dein-duckdns-token>&ip="

Die Antwort sollte OK sein. Mit dem Parameter &verbose=true erhältst du mehr Details:

curl -s "https://www.duckdns.org/update?domains=meinhome&token=<dein-duckdns-token>&ip=&verbose=true"

Erwartete Ausgabe:

OK
203.0.113.100
UPDATED

Die erste Zeile ist OK (Erfolg), die zweite deine aktuelle öffentliche IPv4-Adresse, die dritte sagt UPDATED (geändert) oder NOCHANGE (keine Änderung).[2]

6. DNS-Auflösung prüfen¶

Prüfe von außen, ob die Domain korrekt aufgelöst wird:

dig +short meinhome.duckdns.org

Die Ausgabe sollte deine öffentliche IPv4-Adresse zeigen. Eine leere Ausgabe bedeutet, dass der DNS-Eintrag noch nicht propagiert ist – warte einige Minuten und wiederhole den Befehl.

Auf Windows oder macOS:

nslookup meinhome.duckdns.org

7. (Optional) IPv6-Unterstützung aktivieren¶

Wenn dein Internetanschluss IPv6 unterstützt, kannst du auch den AAAA-Eintrag aktualisieren lassen. Setze dazu in der Compose-Datei:

    environment:
      - UPDATE_IP=both

Gültige Werte für UPDATE_IP:[1]

Wert	Bedeutung
(weglassen)	Nur IPv4, Erkennung über DuckDNS (Standard, kein externer Dienst)
`ipv4`	Nur IPv4, Erkennung über Cloudflare whoami
`ipv6`	Nur IPv6, benötigt `network_mode: host`
`both`	IPv4 und IPv6, benötigt `network_mode: host`

Externe IP-Erkennung

Mit UPDATE_IP=ipv4, ipv6 oder both wird ein externer Dienst (Cloudflare whoami) für die IP-Erkennung verwendet. Lass UPDATE_IP weg, wenn du den externen Dienst nicht nutzen willst – dann wird nur IPv4 über DuckDNS-eigene Erkennung aktualisiert.[1]

8. (Optional) Mehrere Subdomains verwalten¶

Du kannst mehrere Subdomains durch Komma trennen – ohne Leerzeichen:

    environment:
      - SUBDOMAINS=meinhome,meinwiki,meincloud

Jede dieser Subdomains muss vorher auf duckdns.org angelegt worden sein. Der Token ist für alle Subdomains eines Kontos identisch.[2]

9. Ausblick: Nächste Schritte mit Reverse Proxy¶

Nachdem deine Domain auf deinen Server zeigt, fehlt noch der HTTPS-Proxy, der eingehende Verbindungen an die einzelnen Container weiterleitet. Typische nächste Schritte:

Traefik v3 mit automatischen Let's-Encrypt-Zertifikaten – erkennt Docker-Container automatisch per Label
Caddy mit HTTPS für einzelne Docker-Dienste – einfacher Einstieg ohne Label-System

Beide setzen voraus, dass deine Domain (meinhome.duckdns.org) auf deinen Server zeigt – genau das hast du mit diesem Artikel eingerichtet.

10. Hintergrund: Was DuckDNS automatisch macht¶

Der Docker-Container aktualisiert deine IP-Adresse alle 5 Minuten (mit zufälliger Streuung). Das ist nötig, weil sich die öffentliche IP des Heimnetzes ändern kann – ohne regelmäßiges Update würde die Domain auf eine veraltete Adresse zeigen. Der Vorgang läuft vollständig automatisch im Hintergrund.[1]

DuckDNS selbst speichert keine Verbindungsdaten und verkauft keine Nutzerinformationen. Der Dienst finanziert sich durch Spenden und Patreon-Unterstützung.[3]

11. Backup und Rückweg¶

Zum vollständigen Entfernen des Containers:

cd ~/docker/duckdns
docker compose down
rm -rf ~/docker/duckdns

Dein DuckDNS-Konto bleibt bestehen. Die DNS-Einträge veralten nach spätestens 5 Minuten, da keine weiteren Updates mehr gesendet werden.

Kompletter Rückbau des Kontos:

Auf duckdns.org anmelden
Die Subdomain löschen (Drei-Strich-Menü → Konto löschen)
Der DNS-Eintrag ist sofort ungültig

Für einen Umstieg auf einen anderen DDNS-Anbieter (z. B. afraid.org, dynv6) ersetzt du einfach den Container – Router und Reverse Proxy müssen nur die neue Domain kennen.

12. Risiken¶

Nicht als Produktiv-Domain für geschäftskritische Dienste

DuckDNS ist ein kostenloser Dienst ohne garantierte Funktion. Historische Ausfälle haben gezeigt, dass DuckDNS zeitweise nicht erreichbar war. Für wirklich geschäftskritische Dienste ist ein bezahlter DDNS-Dienst oder eine feste IP die bessere Wahl.

Host-Netzwerkmodus: network_mode: host setzt den Container direkt ins Host-Netzwerk ohne Isolation. Das LinuxServer.io-Image gilt als vertrauenswürdig, das Restrisiko bleibt aber dokumentierbar. Wer maximale Isolation wünscht, lässt network_mode: host weg – dann funktioniert aber nur IPv4 ohne externe Erkennung.
Token-Kompromittierung: Der Token steht in der Compose-Datei. Sichere den Zugriff auf den Projektordner (chmod 700 ~/docker/duckdns). Wer den Token kennt, kann beliebige IP-Adressen für deine Domain eintragen.
Datenhaltung bei DuckDNS: DuckDNS speichert E-Mail, Token und IP-Adressen in einer privaten Datenbank. Es werden keine Daten verkauft und keine Verbindungsdaten protokolliert. Die Übertragung läuft über HTTPS (256-Bit-SSL).[3]

13. Typische Fehler¶

Falscher SUBDOMAINS-Wert: Statt meinhome wird meinhome.duckdns.org oder eine Sub-Subdomain wie app.meinhome gesetzt. Der Container unterstützt nur den ersten Teil vor .duckdns.org.[1]
Token mit Leerzeichen oder Zeilenumbruch: Beim Kopieren aus der Webseite kann ein abschließender Zeilenumbruch oder ein Leerzeichen mitkopiert werden. Den Token direkt aus der Browser-Oberfläche kopieren – nicht aus einer Textdatei.
Port-Forwarding vergessen: DuckDNS aktualisiert den A-Record, aber ohne Port-Forwarding im Router (80 und 443 an die Server-IP) kommt kein Verkehr am Server an. Prüfe die Router-Konfiguration.
IPv6 ohne host networking: Bei UPDATE_IP=both oder ipv6 ohne network_mode: host kann der Container die IPv6-Adresse nicht ermitteln. Entweder network_mode: host setzen oder auf IPv4 beschränken.[1]
Firewall blockiert eingehende Verbindungen: Auch wenn Port-Forwarding im Router gesetzt ist, kann eine Firewall auf dem Server (UFW, iptables) die eingehenden Verbindungen blockieren. Prüfe mit sudo ufw status.

14. Quellen¶

Fertig¶

Dein DuckDNS-Container läuft und aktualisiert deine Domain automatisch. Prüfe diese Punkte:

docker compose ps zeigt duckdns mit Status Up
docker logs duckdns enthält regelmäßige OK-Zeilen (ca. alle 5 Minuten)
dig +short meinhome.duckdns.org zeigt deine öffentliche IPv4-Adresse
Port 80 und 443 sind im Router an die Server-IP weitergeleitet

Deine Adresse meinhome.duckdns.org zeigt nun dauerhaft auf deinen Heimserver – unabhängig von IP-Änderungen des Providers. Im nächsten Schritt richtest du einen Reverse Proxy mit Let's Encrypt ein (siehe Abschnitt 9).