# Eigene Domain verbinden

> Zeige deine eigene Domain auf eine Web-App bei Daki — mit Cloudflare als Reverse Proxy, kostenlosem HTTPS und Port-Weiterleitung. Inklusive der erweiterten Alternative Cloudflare Tunnel (cloudflared).

Soll deine Web-App unter `yourdomain.com` statt unter einer `hostname:port`-Adresse erreichbar sein? Diese Anleitung zeigt dir, wie du deine eigene Domain mit **Cloudflare** als kostenlosem Reverse Proxy auf einen Daki-Server zeigen lässt. Cloudflare übernimmt HTTPS für dich und leitet Besucher an den Port weiter, auf dem deine App lauscht.

> **Info:** Eigene Domains erfordern einen **bezahlten Plan**. Sie setzen einen öffentlich erreichbaren Port voraus, und nur bezahlte Pläne (Bronze, Silver, Gold sowie Game-Server-Tarife) enthalten öffentliche Ports. Server im Free Tier können keine eingehenden Verbindungen empfangen, deshalb kann eine eigene Domain dort nicht funktionieren. Siehe [App- & Bot-Hosting-Pläne](https://daki.cc/de/wiki/guides/paid-plans) und [Netzwerk & Zuteilungen](https://daki.cc/de/wiki/guides/network-allocations).

## Das lernst du hier

- Warum eine eigene Domain bei Daki einen Reverse Proxy wie Cloudflare braucht
- Wie du deine Domain mit einem proxied DNS-Eintrag auf deinen Server zeigen lässt
- Wie du HTTPS für deine Domain kostenlos aktivierst
- Wie du den Traffic mit einer Origin Rule an den Port deiner App weiterleitest
- Eine erweiterte Alternative mit Cloudflare Tunnel (`cloudflared`)

---

## Voraussetzungen

- Ein Server mit **bezahltem Plan** und einer öffentlichen Zuteilung — siehe [App- & Bot-Hosting-Pläne](https://daki.cc/de/wiki/guides/paid-plans)
- Ein **Domainname**, der dir gehört (bei einem beliebigen Registrar registriert, z. B. Namecheap, GoDaddy, IONOS oder Cloudflare Registrar)
- Ein kostenloses [Cloudflare](https://dash.cloudflare.com/sign-up)-Konto
- Eine **Web-App** (HTTP/HTTPS), die läuft und auf der Zuteilung deines Servers lauscht

> **Warnung:** Deine App muss auf deiner Zuteilung an `0.0.0.0` (alle Schnittstellen) binden — **nicht** an `127.0.0.1` / `localhost`. Eine nur an localhost gebundene App ist von außerhalb des Containers nicht erreichbar, und der Proxy kann keine Verbindung aufbauen. Die meisten Frameworks akzeptieren ein Host-Argument (z. B. `app.run(host="0.0.0.0", port=...)` in Flask oder `HOST=0.0.0.0` bei vielen Node.js-Apps).

---

## Warum du Cloudflare brauchst

Daki nutzt **geteilte IP-Adressen** über seine Nodes hinweg, und deine App lauscht auf einem nicht standardmäßigen **Port** (der Zuteilung deines Servers). Daraus ergeben sich zwei Probleme:

- Besucher erwarten, `https://yourdomain.com` auf dem Standard-HTTPS-Port (443) zu erreichen — nicht `yourdomain.com:4129`.
- Du willst ein gültiges HTTPS-Zertifikat, ohne selbst eines verwalten zu müssen.

Stellst du Cloudflare vor deinen Server, lösen sich beide Probleme. Cloudflare arbeitet als **Reverse Proxy**: Browser verbinden sich per HTTPS auf Port 443 mit Cloudflare, und Cloudflare leitet die Anfrage an deinen Server auf deinem eigenen Port weiter. Du bekommst kostenloses SSL und eine saubere URL, und die echte IP deines Servers bleibt verborgen.

> **Hinweis:** Diese Methode funktioniert für **HTTP/HTTPS-Web-Apps** (Websites, APIs, Dashboards, Webhooks). Sie funktioniert **nicht** für reine TCP/UDP-Dienste wie die meisten Game Server — Cloudflares Standard-Proxy verarbeitet nur HTTP(S). Für Nicht-HTTP-Dienste nutze die unten beschriebene [Cloudflare-Tunnel](#advanced-alternative-cloudflare-tunnel-cloudflared)-Methode oder kontaktiere den [Support](https://daki.cc/de/wiki/guides/support).

---

## IP und Port deines Servers finden

Du brauchst zwei Werte aus dem Tab **Network** im [Portal](https://daki.cc/de/wiki/guides/portal):

| Wert | Wo du ihn findest | Beispiel |
| :--- | :--- | :--- |
| **Server-IP** | Die IP-Adresse, auf die der Hostname deines Servers verweist (im Tab **Network** angezeigt). Wird nur ein Hostname angezeigt, kannst du ihn auflösen — z. B. `ping eu-node1.daki.cc` — oder den [Support](https://daki.cc/de/wiki/guides/support) fragen. | `203.0.113.10` |
| **Zuteilungs-Port** | Der Port neben deinem Hostnamen im Tab **Network**. Deine App muss auf diesem Port lauschen. | `4129` |

Wir verwenden diese Beispielwerte durchgehend. **Ersetze sie überall durch deine eigenen Werte.** Mehr zu Zuteilungen findest du unter [Netzwerk & Zuteilungen](https://daki.cc/de/wiki/guides/network-allocations).

---

## Teil 1: Cloudflare einrichten

**Schritt 1: Domain zu Cloudflare hinzufügen**

1. Erstelle ein kostenloses Konto auf [dash.cloudflare.com](https://dash.cloudflare.com/sign-up) (oder melde dich an).
2. Klicke auf **Add a site** und gib deine Domain ein (z. B. `yourdomain.com`).
3. Wähle den **Free**-Plan, wenn du dazu aufgefordert wirst.
4. Cloudflare gibt dir **zwei Nameserver** aus (z. B. `xxx.ns.cloudflare.com`).
5. Melde dich bei deinem **Domain-Registrar** an, suche die Nameserver- bzw. DNS-Einstellungen für deine Domain und ersetze die bestehenden Nameserver durch die beiden von Cloudflare.

> **Hinweis:** Nameserver-Änderungen können von wenigen Minuten bis zu 24 Stunden brauchen, bis sie wirksam sind. Cloudflare schickt dir eine E-Mail, sobald deine Domain aktiv ist. Bis dahin kannst du mit den nächsten Schritten weitermachen.

**Schritt 2: DNS-Eintrag erstellen**

Gehe im Cloudflare-Dashboard für deine Domain zu **DNS → Records** und klicke auf **Add record**:

| Feld | Wert |
| :--- | :--- |
| **Type** | `A` |
| **Name** | `@` (steht für die Root-Domain `yourdomain.com`) |
| **IPv4 address** | Die IP deines Servers (Beispiel: `203.0.113.10`) |
| **Proxy status** | **Proxied** (orangefarbene Wolke ☁️) |

Klicke auf **Save**.

> **Tipp:** Der Status **Proxied** (orangefarbene Wolke) ist entscheidend — er leitet den Traffic über Cloudflare, damit SSL und das Port-Umschreiben aus Teil 2 funktionieren. Eine graue Wolke (nur DNS) würde Cloudflare komplett umgehen und deine Server-IP offenlegen. Um auch `www.yourdomain.com` anzubieten, füge einen zweiten proxied Eintrag mit dem Namen `www` hinzu.

**Schritt 3: SSL/TLS konfigurieren**

1. Gehe zu **SSL/TLS → Overview**.
2. Stelle den Verschlüsselungsmodus auf **Flexible** ein.

**Flexible** bedeutet, dass der Traffic zwischen Besucher und Cloudflare verschlüsselt ist (HTTPS), während Cloudflare sich per einfachem HTTP auf deinem eigenen Port mit deiner App verbindet. Das ist die richtige Wahl, wenn deine App einfaches HTTP spricht — und das tun die meisten Apps auf einem eigenen Port.

> **Hinweis:** Wenn deine App ihr eigenes TLS übernimmt (also **HTTPS** direkt auf ihrem Port ausliefert), wähle stattdessen **Full**. Beachte: **Flexible** verschlüsselt die Verbindung zwischen Cloudflare und deinem Server nicht; für sensiblen Traffic nutze **Full** mit HTTPS in deiner App.

---

## Teil 2: Traffic an den Port deiner App weiterleiten

Da deine App auf einem eigenen Port läuft (z. B. `4129`) statt auf dem Standard-Port 80/443, musst du Cloudflare mitteilen, welchen Port es beim Verbinden mit deinem Server verwenden soll. Eine **Origin Rule** erledigt genau das — sie schreibt den Zielport eingehender Anfragen um.

**Schritt 1: Origin Rule erstellen**

1. Gehe im Cloudflare-Dashboard zu **Rules → Origin Rules**.
2. Klicke auf **Create Origin Rule**.
3. Konfiguriere die Regel:

| Einstellung | Wert |
| :--- | :--- |
| **When incoming requests match** | Hostname **ist gleich** `yourdomain.com` |
| **Then... Rewrite to** | **Destination Port** → `4129` (der Port deiner Zuteilung) |

4. Klicke auf **Save** (oder **Deploy**).

> **Erledigt:** Sobald sich die DNS-Änderungen verbreitet haben, ist deine App unter **`https://yourdomain.com`** erreichbar — Cloudflare liefert sie über HTTPS aus und leitet den Traffic an deinen Server auf Port `4129` weiter.

---

## Prüfen, ob es funktioniert

1. Stelle sicher, dass dein Server **läuft** und deine App auf dem Zuteilungs-Port lauscht (prüfe dafür den Tab **Console**).
2. Öffne `https://yourdomain.com` in deinem Browser.
3. Du solltest deine App über HTTPS mit gültigem Schloss-Symbol sehen.

Lädt sie nicht sofort, gib dem DNS noch etwas Zeit und sieh dir dann unten [Häufige Probleme](#common-issues) an.

---

## Erweiterte Alternative: Cloudflare Tunnel (cloudflared)

Statt einen öffentlichen Port zu öffnen und einen A-Eintrag auf deinen Server zu setzen, kannst du **`cloudflared`** — Cloudflares Tunnel-Client — neben deiner App laufen lassen. Er öffnet eine **ausgehende** Verbindung zu Cloudflare und leitet den Traffic lokal an deine App weiter. So bleiben IP und Port deines Servers verborgen, und du brauchst weder einen DNS-A-Eintrag noch eine Origin Rule.

> **Hinweis:** **Wie die Daki-Umgebung das beeinflusst.** Der Tab **Startup** bietet dir zwei Befehle: einen [**Install-Befehl**](https://daki.cc/de/wiki/guides/startup-settings) (läuft einmal bei der Einrichtung bzw. Neuinstallation) und einen **Startup Command** (läuft bei jedem Boot). Außerdem kannst du eine Shell öffnen, indem du den Startup Command vorübergehend auf `bash` setzt. Dein Server ist aber ein **Container, kein vollwertiges Linux-VM**: Es gibt kein `apt`, du kannst keinen Systemdienst registrieren, und ein Tunnel, den du von Hand in der Console startest, endet beim Neustart des Servers. Der zuverlässige Weg ist daher, den Tunnel **Teil des eigenen Starts deiner App** zu machen: Lade das `cloudflared`-Binary zur Laufzeit herunter und starte es als Kindprozess neben deiner App, gesteuert über eine Umgebungsvariable.

**Schritt 1: Tunnel erstellen**

1. Gehe im Cloudflare-**Zero Trust**-Dashboard zu **Networks → Tunnels**, klicke auf **Create a tunnel** und wähle **Cloudflared**.
2. Gib dem Tunnel einen Namen und **kopiere das Tunnel-Token**, das Cloudflare anzeigt (die lange Zeichenkette nach `--token` im Installationsbefehl).
3. Füge dem Tunnel einen **Public Hostname** hinzu:
   - **Domain:** `yourdomain.com`
   - **Service:** `http://localhost:4129` (der lokale Port deiner App)

**Schritt 2: Token in der .env speichern**

Trage das Token in die `.env`-Datei deines Servers ein (siehe [Umgebungsvariablen](https://daki.cc/de/wiki/guides/environment-variables)), damit es nie in deinem Quellcode landet:

```

CLOUDFLARE_TUNNEL_TOKEN=your_tunnel_token_here

```

**Schritt 3: Tunnel aus deinem Code starten**

Füge einen kleinen Launcher hinzu, der `cloudflared` beim ersten Start herunterlädt und neben deiner App startet. Setze diesen Launcher dann als **Startup Command**. Er startet den Tunnel nur, wenn `CLOUDFLARE_TUNNEL_TOKEN` gesetzt ist, sodass derselbe Code lokal auch ohne Token problemlos läuft.

**Node.js (start.js)**

Speichere die Datei als `start.js` und setze dann deinen Startup Command auf `node start.js`:

```js

// start.js — starts your app and, if a token is set, a Cloudflare tunnel.

require("dotenv").config();



const fs = require("fs");

const path = require("path");

const { spawn, spawnSync } = require("child_process");



const CLOUDFLARED_URL =

  "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64";

const binaryPath = path.join(__dirname, "cloudflared");

const children = [];



// The container has no apt — download the binary on first run, reuse it after.

function ensureCloudflared() {

  if (fs.existsSync(binaryPath)) return binaryPath;

  console.log("[tunnel] downloading cloudflared...");

  const dl = spawnSync("curl", ["-fsSL", "-o", binaryPath, CLOUDFLARED_URL], {

    stdio: "inherit",

  });

  if (dl.status !== 0) return null;

  fs.chmodSync(binaryPath, 0o755);

  return binaryPath;

}



// Spawn a child process; if any child exits, stop the rest and quit.

function start(name, command, args) {

  const child = spawn(command, args, { stdio: "inherit", env: process.env });

  child.on("exit", (code) => {

    console.error(`[${name}] exited (${code}); shutting down`);

    for (const c of children) if (!c.killed) c.kill("SIGTERM");

    process.exit(code ?? 1);

  });

  children.push(child);

}



const token = process.env.CLOUDFLARE_TUNNEL_TOKEN?.trim();

if (token) {

  const binary = ensureCloudflared();

  if (binary) start("tunnel", binary, ["tunnel", "run", "--token", token]);

} else {

  console.log("[tunnel] CLOUDFLARE_TUNNEL_TOKEN not set; skipping tunnel");

}



// Start your app — change this to your real entry point.

start("app", "node", ["index.js"]);

```

**Python / Sonstige (start.sh)**

Speichere die Datei als `start.sh` und setze dann deinen Startup Command auf `bash start.sh`:

```bash

#!/usr/bin/env bash

# Load variables from .env into the environment.

set -a; [ -f .env ] && . ./.env; set +a



# The container has no apt — download cloudflared on first run, reuse it after.

if [ ! -x ./cloudflared ]; then

  curl -fsSL -o ./cloudflared \

    https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64

  chmod +x ./cloudflared

fi



# Start the tunnel in the background only if a token is set.

if [ -n "$CLOUDFLARE_TUNNEL_TOKEN" ]; then

  ./cloudflared tunnel run --token "$CLOUDFLARE_TUNNEL_TOKEN" &

fi



# Start your app in the foreground — change this to your real command.

exec python main.py

```

> **Tipp:** Um das Herunterladen nicht bei jedem Start zu wiederholen, kannst du den Download in deinen [Install-Befehl](https://daki.cc/de/wiki/guides/startup-settings) verschieben und im Startup Command nur die Startlogik belassen. Die Beispiele oben sind bereits so geschrieben, dass sie bei jedem Start sicher laufen — sie überspringen den Download, sobald das Binary existiert.

**Abwägungen:**

| | Cloudflare-Proxy (Teile 1–2) | Cloudflare Tunnel (cloudflared) |
| :--- | :--- | :--- |
| Schwierigkeit der Einrichtung | Einfacher (nur im Dashboard) | Fortgeschritten (in den Start deiner App eingebaut) |
| Server-IP und Port offengelegt | Hinter dem Proxy verborgen | Vollständig verborgen (nur ausgehend) |
| Braucht öffentlichen Port / Origin Rule | Ja | Nein |
| Nutzt Serverressourcen | Keine auf deinem Server | Startet einen zusätzlichen Prozess |

---

## Häufige Probleme

**Die Seite lädt überhaupt nicht**

Der DNS-Eintrag verbreitet sich vielleicht noch. Nameserver-Änderungen können bis zu 24 Stunden brauchen (meist deutlich weniger). Prüfe in Cloudflare, ob der Status deiner Domain **Active** ist und ob der **A-Eintrag** existiert und **Proxied** (orangefarbene Wolke) ist. Die Verbreitung kannst du mit einem Tool wie [dnschecker.org](https://dnschecker.org) prüfen.

**Error 522 / 523 — Connection timed out / Origin unreachable**

Cloudflare kann deine App nicht erreichen. Prüfe der Reihe nach:
- Dein **Server läuft** und die App ist vollständig gestartet (prüfe den Tab **Console**).
- Die **Origin Rule** schreibt den Port auf deinen exakten **Zuteilungs-Port** um.
- Die **IP des A-Eintrags** stimmt mit der IP deines Servers überein.
- Deine App bindet an **`0.0.0.0`**, nicht an `127.0.0.1`/`localhost`.

**Too many redirects / ERR_TOO_MANY_REDIRECTS**

Meist liegt eine Abweichung im SSL-Modus vor. Erzwingt deine App HTTPS, Cloudflare verbindet sich aber per HTTP mit ihr, entsteht eine Weiterleitungsschleife. Entweder stellst du deine App auf einfaches HTTP um (und nutzt **Flexible**), oder deine App liefert HTTPS aus und du stellst Cloudflare unter **SSL/TLS → Overview** auf **Full**.

**Es funktioniert mit http://, aber nicht mit https://**

Stelle sicher, dass dein DNS-Eintrag **Proxied** (orangefarbene Wolke) ist und der **SSL/TLS**-Modus gesetzt ist (Flexible oder Full). Bei grauer Wolke (nur DNS) wird Cloudflares SSL umgangen.

**Mein Game Server bzw. nicht-HTTP-Dienst funktioniert nicht**

Cloudflares Standard-Proxy unterstützt nur HTTP/HTTPS. Für reine TCP/UDP-Dienste wie die meisten Game Server greift diese Methode nicht. Verbinde dich stattdessen direkt über Hostname und Port mit deinem Server (siehe [Netzwerk & Zuteilungen](https://daki.cc/de/wiki/guides/network-allocations)) oder frag den [Support](https://daki.cc/de/wiki/guides/support) nach anderen Möglichkeiten.

**Muss ich Cloudflare verwenden?**

Nein. Cloudflare ist die einfachste kostenlose Option, aber jeder Reverse Proxy, der an einen eigenen Port weiterleiten kann, funktioniert — etwa ein Tunnel über `cloudflared` oder dein eigener Nginx/Caddy vor der App. Cloudflare wird empfohlen, weil es kostenloses SSL bietet, deine Server-IP verbirgt und für die Proxy-Methode keine zusätzliche Software auf deinem Server braucht.

---

## Nächste Schritte

- [Netzwerk & Zuteilungen](https://daki.cc/de/wiki/guides/network-allocations) — Hostname und Port finden und weitere Zuteilungen hinzufügen.
- [App- & Bot-Hosting-Pläne](https://daki.cc/de/wiki/guides/paid-plans) — Auf einen bezahlten Plan wechseln, um einen öffentlichen Port zu bekommen.
- [Umgebungsvariablen](https://daki.cc/de/wiki/guides/environment-variables) — Deinen Port im Code aus einer Umgebungsvariable lesen.
- [Hilfe erhalten](https://daki.cc/de/wiki/guides/support) — Kontaktiere den Support, wenn du nicht weiterkommst.

---
Source: https://daki.cc/de/wiki/guides/custom-domain