# Connecter un domaine personnalisé

> Faites pointer votre propre domaine vers une app web hébergée sur Daki grâce à Cloudflare comme reverse proxy — avec HTTPS gratuit et redirection de port personnalisé. Inclut une alternative avancée avec Cloudflare Tunnel (cloudflared).

Vous voulez que votre app web soit accessible à `yourdomain.com` au lieu d'une adresse `hostname:port` ? Ce guide vous montre comment faire pointer votre propre domaine vers un serveur Daki en utilisant **Cloudflare** comme reverse proxy gratuit. Cloudflare gère le HTTPS pour vous et transmet les visiteurs au port personnalisé sur lequel votre app écoute.

> **Info:** Les domaines personnalisés nécessitent une **offre payante**. Ils reposent sur un port accessible publiquement, et seules les offres payantes (Bronze, Silver, Gold et les offres de serveurs de jeu) incluent des ports publics. Les serveurs Free Tier ne peuvent pas recevoir de connexions entrantes : un domaine personnalisé ne peut donc pas y fonctionner. Voir [Offres payantes](https://daki.cc/fr/wiki/guides/paid-plans) et [Réseau et allocations](https://daki.cc/fr/wiki/guides/network-allocations).

## Ce que vous allez apprendre

- Pourquoi un domaine personnalisé sur Daki nécessite un reverse proxy comme Cloudflare
- Comment faire pointer votre domaine vers votre serveur avec un enregistrement DNS proxifié
- Comment activer le HTTPS gratuit pour votre domaine
- Comment transmettre le trafic au port de votre app avec une Origin Rule
- Une alternative avancée avec Cloudflare Tunnel (`cloudflared`)

---

## Prérequis

- Un serveur en **offre payante** avec une allocation publique — voir [Offres payantes](https://daki.cc/fr/wiki/guides/paid-plans)
- Un **nom de domaine** vous appartenant (enregistré chez le registrar de votre choix, par ex. Namecheap, GoDaddy, IONOS, Cloudflare Registrar)
- Un compte [Cloudflare](https://dash.cloudflare.com/sign-up) gratuit
- Une **app web** (HTTP/HTTPS) en cours d'exécution, à l'écoute sur le port d'allocation de votre serveur

> **Avertissement:** Votre app doit se lier à `0.0.0.0` (toutes les interfaces) sur votre port d'allocation — **pas** à `127.0.0.1` / `localhost`. Une app liée uniquement à localhost n'est pas accessible depuis l'extérieur du conteneur, et le proxy ne pourra pas s'y connecter. La plupart des frameworks acceptent un argument d'hôte (par ex. `app.run(host="0.0.0.0", port=...)` dans Flask, ou `HOST=0.0.0.0` pour beaucoup d'apps Node.js).

---

## Pourquoi vous avez besoin de Cloudflare

Daki utilise des **adresses IP partagées** entre ses nœuds, et votre app écoute sur un **port** non standard (l'allocation attribuée à votre serveur). Deux problèmes en découlent :

- Les visiteurs s'attendent à atteindre `https://yourdomain.com` sur le port HTTPS standard (443) — et non `yourdomain.com:4129`.
- Vous voulez un certificat HTTPS valide sans avoir à en gérer un vous-même.

Placer Cloudflare devant votre serveur règle les deux. Cloudflare agit comme **reverse proxy** : les navigateurs se connectent à Cloudflare en HTTPS sur le port 443, et Cloudflare transmet la requête à votre serveur sur votre port personnalisé. Vous bénéficiez d'un SSL gratuit et d'une URL propre, et l'adresse IP réelle de votre serveur reste masquée.

> **Remarque:** Cette méthode fonctionne pour les **apps web HTTP/HTTPS** (sites, API, dashboards, webhooks). Elle ne fonctionne **pas** avec les services TCP/UDP bruts, comme la plupart des serveurs de jeu — le proxy standard de Cloudflare ne gère que HTTP(S). Pour les services non HTTP, utilisez la méthode [Cloudflare Tunnel](#advanced-alternative-cloudflare-tunnel-cloudflared) ci-dessous ou contactez le [support](https://daki.cc/fr/wiki/guides/support).

---

## Trouver l'IP et le port de votre serveur

Il vous faut deux valeurs de l'onglet **Network** du [Portail](https://daki.cc/fr/wiki/guides/portal) :

| Valeur | Où la trouver | Exemple |
| :--- | :--- | :--- |
| **Server IP** | L'adresse IP vers laquelle le nom d'hôte de votre serveur pointe (affichée dans l'onglet **Network**). Si seul un nom d'hôte est affiché, vous pouvez le résoudre — par ex. `ping eu-node1.daki.cc` — ou demander au [support](https://daki.cc/fr/wiki/guides/support). | `203.0.113.10` |
| **Allocation port** | Le port affiché à côté de votre nom d'hôte dans l'onglet **Network**. Votre app doit écouter sur ce port. | `4129` |

Nous utiliserons ces valeurs d'exemple tout au long du guide. **Remplacez-les par les vôtres** partout où elles apparaissent. Pour en savoir plus sur les allocations, voir [Réseau et allocations](https://daki.cc/fr/wiki/guides/network-allocations).

---

## Partie 1 : configuration de Cloudflare

**Étape 1: Ajoutez votre domaine à Cloudflare**

1. Créez un compte gratuit sur [dash.cloudflare.com](https://dash.cloudflare.com/sign-up) (ou connectez-vous).
2. Cliquez sur **Add a site** et saisissez votre domaine (par ex. `yourdomain.com`).
3. Sélectionnez le plan **Free** lorsque cela vous est demandé.
4. Cloudflare vous donnera **deux serveurs de noms** (par ex. `xxx.ns.cloudflare.com`).
5. Connectez-vous à l'interface de votre **registrar de domaine**, trouvez les paramètres de serveurs de noms / DNS de votre domaine, et remplacez les serveurs de noms existants par les deux fournis par Cloudflare.

> **Remarque:** Les modifications de serveurs de noms peuvent prendre de quelques minutes à 24 heures pour se propager. Cloudflare vous envoie un e-mail dès que votre domaine est actif. Vous pouvez poursuivre les étapes suivantes en attendant.

**Étape 2: Créez un enregistrement DNS**

Dans le tableau de bord Cloudflare de votre domaine, allez dans **DNS → Records** et cliquez sur **Add record** :

| Champ | Valeur |
| :--- | :--- |
| **Type** | `A` |
| **Name** | `@` (représente le domaine racine, `yourdomain.com`) |
| **IPv4 address** | L'IP de votre serveur (exemple : `203.0.113.10`) |
| **Proxy status** | **Proxied** (nuage orange ☁️) |

Cliquez sur **Save**.

> **Astuce:** Le statut **nuage orange (Proxied)** est essentiel : il fait passer le trafic par Cloudflare, pour que le SSL et la réécriture de port de la partie 2 fonctionnent. Un nuage gris (DNS only) contournerait entièrement Cloudflare et exposerait l'IP de votre serveur. Pour servir aussi `www.yourdomain.com`, ajoutez un second enregistrement proxifié avec le nom `www`.

**Étape 3: Configurez SSL/TLS**

1. Allez dans **SSL/TLS → Overview**.
2. Réglez le mode de chiffrement sur **Flexible**.

**Flexible** signifie que le trafic entre le visiteur et Cloudflare est chiffré (HTTPS), tandis que Cloudflare se connecte à votre app en HTTP simple sur votre port personnalisé. C'est le bon choix lorsque votre app sert du HTTP simple — ce qui est le cas de la plupart des apps sur un port personnalisé.

> **Remarque:** Si votre app gère son propre TLS (c'est-à-dire qu'elle sert directement du **HTTPS** sur son port), choisissez **Full** à la place. Attention : **Flexible** ne chiffre pas la connexion entre Cloudflare et votre serveur ; pour un trafic sensible, privilégiez **Full** avec du HTTPS sur votre app.

---

## Partie 2 : transmettre le trafic au port de votre app

Comme votre app tourne sur un port personnalisé (par ex. `4129`) plutôt que sur les ports standard 80/443, vous devez indiquer à Cloudflare quel port utiliser lorsqu'il se connecte à votre serveur. Une **Origin Rule** fait exactement cela : elle réécrit le port de destination des requêtes entrantes.

**Étape 1: Créez une Origin Rule**

1. Dans le tableau de bord Cloudflare, allez dans **Rules → Origin Rules**.
2. Cliquez sur **Create Origin Rule**.
3. Configurez la règle :

| Paramètre | Valeur |
| :--- | :--- |
| **When incoming requests match** | Hostname **equals** `yourdomain.com` |
| **Then... Rewrite to** | **Destination Port** → `4129` (votre port d'allocation) |

4. Cliquez sur **Save** (ou **Deploy**).

> **Réussi:** Une fois le DNS propagé, votre app est accessible à **`https://yourdomain.com`** — Cloudflare la sert en HTTPS et transmet le trafic à votre serveur sur le port `4129`.

---

## Vérifier que ça fonctionne

1. Assurez-vous que votre serveur est **en marche** et que votre app écoute sur le port d'allocation (vérifiez l'onglet **Console**).
2. Ouvrez `https://yourdomain.com` dans votre navigateur.
3. Vous devriez voir votre app se charger en HTTPS avec un cadenas valide.

Si elle ne se charge pas tout de suite, laissez au DNS un peu plus de temps pour se propager, puis consultez [Problèmes courants](#common-issues) ci-dessous.

---

## Alternative avancée : Cloudflare Tunnel (cloudflared)

Au lieu d'ouvrir un port public et de faire pointer un enregistrement A vers votre serveur, vous pouvez exécuter **`cloudflared`** — le client de tunnel de Cloudflare — à côté de votre app. Il ouvre une connexion **sortante** vers Cloudflare et transmet le trafic à votre app localement : l'IP et le port de votre serveur restent donc cachés, et vous n'avez besoin ni d'enregistrement DNS A, ni d'Origin Rule.

> **Remarque:** **Comment l'environnement Daki influence cette méthode.** L'onglet Startup vous donne deux commandes — une [**commande d'installation**](https://daki.cc/fr/wiki/guides/startup-settings) (exécutée une fois à la configuration ou à la réinstallation) et une **commande de démarrage** (exécutée à chaque lancement) — et vous pouvez ouvrir un shell en réglant temporairement la commande de démarrage sur `bash`. Mais votre serveur est un **conteneur, et non une VM Linux complète** : il n'y a pas d'`apt`, vous ne pouvez pas enregistrer un service système, et un tunnel lancé à la main dans la console s'arrête au redémarrage du serveur. L'approche fiable consiste donc à intégrer le tunnel **au démarrage de votre propre app** — télécharger le binaire `cloudflared` à l'exécution et le lancer comme processus enfant à côté de votre app, piloté par une variable d'environnement.

**Étape 1: Créez le tunnel**

1. Dans le tableau de bord **Zero Trust** de Cloudflare, allez dans **Networks → Tunnels**, cliquez sur **Create a tunnel**, puis choisissez **Cloudflared**.
2. Donnez-lui un nom et **copiez le token de tunnel** affiché par Cloudflare (la longue chaîne après `--token` dans sa commande d'installation).
3. Ajoutez un **Public Hostname** au tunnel :
   - **Domain :** `yourdomain.com`
   - **Service :** `http://localhost:4129` (le port local de votre app)

**Étape 2: Stockez le token dans .env**

Ajoutez le token au fichier `.env` de votre serveur (voir [Variables d'environnement](https://daki.cc/fr/wiki/guides/environment-variables)) pour qu'il n'apparaisse jamais dans votre code source :

```

CLOUDFLARE_TUNNEL_TOKEN=your_tunnel_token_here

```

**Étape 3: Lancez le tunnel depuis votre code**

Ajoutez un petit lanceur qui télécharge `cloudflared` au premier lancement et le démarre à côté de votre app, puis définissez ce lanceur comme **commande de démarrage**. Il ne démarre le tunnel que si `CLOUDFLARE_TUNNEL_TOKEN` est défini, ainsi le même code fonctionne en local sans token.

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

Enregistrez le fichier sous `start.js`, puis définissez votre commande de démarrage sur `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 / autres (start.sh)**

Enregistrez le fichier sous `start.sh`, puis définissez votre commande de démarrage sur `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

```

> **Astuce:** Pour éviter de retélécharger le binaire à chaque démarrage, vous pouvez déplacer le téléchargement dans votre [commande d'installation](https://daki.cc/fr/wiki/guides/startup-settings) et ne garder que la logique de lancement dans la commande de démarrage. Les exemples ci-dessus peuvent déjà être exécutés à chaque démarrage : ils sautent le téléchargement dès que le binaire existe.

**Compromis :**

| | Proxy Cloudflare (parties 1–2) | Cloudflare Tunnel (cloudflared) |
| :--- | :--- | :--- |
| Difficulté de configuration | Plus simple (tableau de bord uniquement) | Plus avancée (intégrée au démarrage de votre app) |
| Expose l'IP / le port du serveur | Masqués derrière le proxy | Totalement masqués (sortant uniquement) |
| Nécessite un port public / une Origin Rule | Oui | Non |
| Utilise les ressources du serveur | Aucune sur votre serveur | Lance un processus supplémentaire |

---

## Problèmes courants

**Le site ne se charge pas du tout**

Le DNS est peut-être encore en cours de propagation. Les modifications de serveurs de noms peuvent prendre jusqu'à 24 heures (généralement bien moins). Vérifiez dans Cloudflare que le statut de votre domaine est **Active** et que l'**enregistrement A** existe et est **Proxied** (nuage orange). Vous pouvez suivre la propagation avec un outil comme [dnschecker.org](https://dnschecker.org).

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

Cloudflare ne parvient pas à joindre votre app. Vérifiez, dans l'ordre :
- Votre **serveur est en marche** et l'app a entièrement démarré (vérifiez l'onglet **Console**).
- L'**Origin Rule** réécrit le port vers votre **port d'allocation** exact.
- L'**IP de l'enregistrement A** correspond à l'IP de votre serveur.
- Votre app se lie à **`0.0.0.0`**, et non à `127.0.0.1` / `localhost`.

**Too many redirects / ERR_TOO_MANY_REDIRECTS**

Il s'agit généralement d'une incompatibilité de mode SSL. Si votre app force le HTTPS alors que Cloudflare se connecte à elle en HTTP, une boucle de redirection se produit. Soit vous configurez votre app pour servir du HTTP simple (et vous utilisez **Flexible**), soit votre app sert du HTTPS et vous passez Cloudflare en **Full** dans **SSL/TLS → Overview**.

**Ça fonctionne en http:// mais pas en https://**

Assurez-vous que votre enregistrement DNS est **Proxied** (nuage orange) et que le mode **SSL/TLS** est défini (Flexible ou Full). Avec un nuage gris (DNS only), le SSL de Cloudflare est contourné.

**Mon serveur de jeu / mon service non HTTP ne fonctionne pas**

Le proxy standard de Cloudflare ne gère que HTTP/HTTPS. Pour les services TCP/UDP bruts comme la plupart des serveurs de jeu, cette méthode ne s'applique pas. Connectez-vous à votre serveur directement avec son nom d'hôte et son port (voir [Réseau et allocations](https://daki.cc/fr/wiki/guides/network-allocations)), ou contactez le [support](https://daki.cc/fr/wiki/guides/support) pour d'autres options.

**Dois-je obligatoirement utiliser Cloudflare ?**

Non. Cloudflare est l'option gratuite la plus simple, mais tout reverse proxy capable de transmettre vers un port personnalisé convient (par ex. un tunnel via `cloudflared`, ou votre propre Nginx / Caddy devant l'app). Cloudflare est recommandé car il fournit un SSL gratuit, masque l'IP de votre serveur et ne nécessite aucun logiciel supplémentaire sur votre serveur pour la méthode du proxy.

---

## Étapes suivantes

- [Réseau et allocations](https://daki.cc/fr/wiki/guides/network-allocations) — Trouvez votre nom d'hôte et votre port, et ajoutez d'autres allocations.
- [Offres payantes](https://daki.cc/fr/wiki/guides/paid-plans) — Passez à une offre payante pour obtenir un port public.
- [Variables d'environnement](https://daki.cc/fr/wiki/guides/environment-variables) — Lisez votre port depuis une variable d'environnement dans le code.
- [Obtenir de l'aide](https://daki.cc/fr/wiki/guides/support) — Contactez le support si vous êtes bloqué.

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