Domain Watchdog: Dein eigener „Scharfschütze“ für Wunsch-Domains (Self-Hosted)

Ein selbstgehosteter RDAP-Monitor mit Auto-Buy-Funktion, der Wunsch-Domains kontinuierlich beobachtet und bei Verfügbarkeit über Registrar-APIs in Millisekunden registriert. Docker-first, leichtgewichtig und ohne klassische WHOIS-Limits.

Kernfunktionen

RDAP statt WHOIS: Standardisierte, maschinenlesbare Domain-Daten ohne fragile Parser.
Watchlist und Historie: Statuswechsel (z. B. Pending Delete → Available) nachvollziehen.
Auto-Buy („Sniper“): Anbindung an Namecheap, Porkbun, InternetBS, Dynadot u. a.
Benachrichtigungen: E-Mail, Slack, Discord, Webhooks.
Self-Hosted: Volle Datenhoheit, einfache Updates via Docker Compose.

Architektur und Protokolle

Backend mit Postgres als persistenter Store.
Redis/Valkey als Queue/Cache für Polling und Jobs.
RDAP-Bootstrap gemäß IANA; Fallback für ccTLDs via manuelle Registry-Mappings.
Web-UI auf Port 8080 (lokal).

Voraussetzungen

Docker und Docker Compose v2
Freie Ports: 8080 (Web), 5432 (DB, intern), 6379 (Redis/Valkey, intern)
Grundlegende CLI-Kenntnisse
Registrar-API-Keys (optional, für Auto-Buy)

Installation

Schritt 1: Repository klonen

git clone https://github.com/maelgangloff/domain-watchdog.git
cd domain-watchdog

Schritt 2: Konfiguration anlegen

cp .env .env.local

Passen Sie .env.local an. Wichtige Punkte:

REDIS_HOST auf den Compose-Service-Namen setzen (häufig valkey oder redis), niemals localhost.
POSTGRES_*-Werte konsistent zu docker-compose.yml halten.
APP_URL (z. B. http://localhost:8080) setzen.

Minimalbeispiel:

cat > .env.local <<'EOF'
APP_URL=http://localhost:8080
 
POSTGRES_DB=app
POSTGRES_USER=app
POSTGRES_PASSWORD=change-me
 
REDIS_HOST=valkey
REDIS_PORT=6379
EOF

Schritt 3: Container starten

docker compose up -d

Warten Sie ca. 60 Sekunden, bis Postgres initialisiert und IANA-Bootstrapdaten geladen sind.

Essenzieller ccTLD-Fix (RDAP-Mappings nachtragen)

Die IANA-Listen enthalten nicht immer RDAP-Server für ccTLDs wie .ch oder .de. Fügen Sie die RDAP-Endpoints einmalig in die App-Datenbank ein.

.ch (SWITCH):

docker compose exec database psql -U app -d app -c \
"INSERT INTO rdap_server (url, tld_id, updated_at) VALUES ('https://rdap.nic.ch/', 'ch', CURRENT_DATE);"

.de (DENIC):

docker compose exec database psql -U app -d app -c \
"INSERT INTO rdap_server (url, tld_id, updated_at) VALUES ('https://rdap.denic.de/', 'de', CURRENT_DATE);"

.at (nic.at):

docker compose exec database psql -U app -d app -c \
"INSERT INTO rdap_server (url, tld_id, updated_at) VALUES ('https://rdap.nic.at/', 'at', CURRENT_DATE);"

Verifikation:

docker compose exec database psql -U app -d app -c \
"SELECT tld_id, url, updated_at FROM rdap_server WHERE tld_id IN ('ch','de','at');"

Hinweis:

Wenn ein Eintrag bereits existiert, kann das INSERT fehlschlagen. In diesem Fall URL per UPDATE anpassen.
Führen Sie die Befehle erst aus, nachdem der erste RDAP-Bootstrap abgeschlossen ist (ca. 1 Minute nach Start).

Zugriff

Web-UI: http://localhost:8080
Standard-Login/Onboarding siehe Projekt-README bzw. UI-Einrichtung.
Exposition ins Internet nur hinter AuthN/AuthZ (Reverse Proxy, OIDC, Basic Auth) vornehmen.

Auto-Buy („Sniper“) konfigurieren

Registrar-API in der UI unter Einstellungen → Providers hinterlegen.
Erforderliche Credentials je Registrar:
- Namecheap: API Key, Username, whitelisted IPs; Sandbox vs. Production beachten.
- Porkbun: API Key/Secret; Account-Guthaben erforderlich.
- InternetBS, Dynadot: API Key/Token; ggf. TLD-spezifische Beschränkungen.
Pro Domain in der Watchlist Auto-Buy aktivieren und Provider zuordnen.
Beachten Sie Registrierungsfenster, Registry-Limits und Anti-Abuse-Regeln.

Benachrichtigungen

Slack (Incoming Webhook), Discord (Webhook), E-Mail (SMTP) in der UI einrichten.
Pro Watchlist-Eintrag Ereignisse konfigurieren: Available, Pending Delete, Statuswechsel.
Test-Notification auslösen und Logs prüfen.

Betrieb

Update:

git pull
docker compose pull
docker compose up -d

Logs:

docker compose logs -f --tail=200 app
docker compose logs -f --tail=200 worker

Backup (Postgres):

docker compose exec -T database pg_dump -U app -d app > backup.sql

Restore:

docker compose exec -T database psql -U app -d app < backup.sql

Persistenz: Achten Sie auf Docker Volumes für Postgres und Redis/Valkey.

Fehlersuche

ccTLD wird nicht gefunden:
- RDAP-Mapping in rdap_server prüfen (siehe Verifikation).
- Nach Updates erneut IANA-Bootstrap abwarten.
Redis-Fehler (Connection refused):
- REDIS_HOST in .env.local muss Compose-Service heißen (valkey/redis).
- Container-Healthchecks prüfen: docker compose ps
Rate-Limits/429:
- Abfrageintervalle erhöhen.
- Registrars und RDAP-Server staffeln, Backoff aktivieren.
Auto-Buy schlägt fehl:
- Registrar-API-Schlüssel und IP-Whitelist prüfen.
- Konto-Guthaben und TLD-Zulassung (z. B. lokale Präsenzanforderungen) prüfen.
- Provider-Logs in der App einsehen.
Zeitprobleme:
- Host- und Container-Zeit synchronisieren (NTP/chrony).

Sicherheit

Secrets nur via .env.local/Docker Secrets; kein Commit ins Repo.
UI nicht ohne Auth ins Internet stellen.
Registrar-API-Keys restriktiv (IP-beschränkt, nur notwendige Rechte).

Hinweise zu weiteren TLDs

Für zusätzliche ccTLDs entsprechend den Registry-RDAP-Endpunkt recherchieren und per INSERT ergänzen.
Beispielmuster:

docker compose exec database psql -U app -d app -c \
"INSERT INTO rdap_server (url, tld_id, updated_at) VALUES ('https://rdap.example-registry.tld/', 'xx', CURRENT_DATE);"

Nützliche Kommandos

Container neu starten:

docker compose restart app worker

Datenbank-Shell:

docker compose exec database psql -U app -d app

Cleanup (dangling images/volumes mit Vorsicht):

docker system prune -f

Lizenz und Compliance

Nutzung gemäß Lizenz des Projekts.
Einhaltung der Terms of Service der Registries/Registrare sicherstellen.
Lokale Gesetzgebung und Registrierungsrichtlinien der TLDs beachten.

💭 Jeremys Brain

Explorer

domain-watchdog