# Procédure HTTPS Homelab avec Infomaniak & Let's Encrypt

**Objectif** : Mettre en place du HTTPS automatique sur ton homelab avec gestion des certificats Let's Encrypt, DNS chez Infomaniak et reverse proxy conteneurisé.

**Public cible** : Débutant à avancé en homelab, utilisant Proxmox/LXC ou Docker.

---

## ⚠️ **ÉTAT ACTUEL (17/07/2026) - CE QUI RESTE À FAIRE**

> **✅ DÉJÀ DÉPLOYÉ ET FONCTIONNEL :**
> - **CT 200** (192.168.0.100) renommé en **traefik-proxy** (anciennement traefik-new)
> - Docker et Docker Compose installés sur CT 200
> - **Traefik v2.10** déployé avec configuration Let's Encrypt **PRODUCTION** (plus de staging)
> - **Port forwarding TCP 80/443** configuré sur le routeur → 192.168.0.100
> - **Ancien CT 104 supprimé** ✅
> - **HA activé** pour CT 200 ✅
> - Réseau Docker `traefik_network` créé
> - Fichiers de configuration mis à jour dans `/opt/traefik/`
> - Documentation whoami créée dans `service-whoami.md`

> **🔄 À FAIRE POUR FINALISER :**
> 1. ❌ **Déployer les fichiers mis à jour** : Copier les fichiers depuis `traefik-config/` vers `/opt/traefik/` sur CT 200
> 2. ❌ **Renommer le container** : Exécuter `docker rename traefik-new traefik-proxy` (si pas déjà fait)
> 3. ❌ **Redémarrer Traefik** : `cd /opt/traefik && docker-compose down && docker-compose up -d`
> 4. ❌ **Créer le CNAME test.peis.fr** chez Infomaniak (CNAME → lab.peis.fr)
> 5. ❌ **Déployer les services** : `docker-compose -f docker-compose-whoami.yml up -d` et `docker-compose -f docker-compose-ha.yml up -d`
> 6. ❌ **Valider depuis l'extérieur** : Tester https://test.peis.fr et https://ha.peis.fr depuis un réseau externe (4G)

> **ℹ️ ACCÈS UTILE :**
> - **Dashboard Traefik** : https://traefik.peis.fr (admin/admin123)
> - **Service Whoami** : https://test.peis.fr (à créer)
> - **Home Assistant** : https://ha.peis.fr (déjà dans DNS)
> - **SSH CT 200** : `ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.100`
> - **Dossier Traefik** : `/opt/traefik/`
> - **Logs Traefik** : `docker logs traefik-proxy`
>
> **💡 NOTES :**
> - Le 404 sur 192.168.0.100 est **normal** : Traefik répond uniquement aux noms d'hôte configurés. Utilisez les noms de domaine ou ajoutez une entrée dans votre fichier hosts : `192.168.0.100 traefik.peis.fr test.peis.fr ha.peis.fr`
> - Mot de passe dashboard : admin/**admin123** (hash bcrypt dans la config)
> - Email Let's Encrypt : **theo@peis.fr** (déjà configuré en production)

---

## 📌 Tes informations personnalisées

- **Domaine principal** : `peis.fr` (hébergé chez Infomaniak sur IP `128.65.195.180`)
- **IP publique homelab** : `82.67.139.7`
- **Sous-domaine racine homelab** : `lab.peis.fr` → `82.67.139.7`
- **Email Let's Encrypt** : **theo@peis.fr** ✅

> ✅ **Email déjà configuré** dans les fichiers de configuration.

> ✅ **Important** : `peis.fr` et `www.peis.fr` restent hébergés chez Infomaniak (IP `128.65.195.180`). Seuls les sous-domaines pointant vers `82.67.139.7` seront gérés par ton homelab.

---

## 🔍 Analyse de ta configuration DNS actuelle

Ton DNS est **déjà bien configuré** chez Infomaniak. Voici ce que j'ai analysé :

### ✅ Ce qui est correct et à GARDER
| Enregistrement | Type | Valeur | Destination |
|--------------|------|--------|-------------|
| `peis.fr` | A | `128.65.195.180` | Site web Infomaniak |
| `www.peis.fr` | A | `128.65.195.180` | Site web Infomaniak |

### ✅ Ce qui est prêt pour ton homelab
| Enregistrement | Type | Valeur | Résolution finale |
|--------------|------|--------|------------------|
| `lab.peis.fr` | A | `82.67.139.7` | **82.67.139.7** |
| `traefik.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |
| `ha.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |
| `nas.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |
| `frigate.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |
| `mqtt.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |
| `proxmox.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |
| `freebox.peis.fr` | CNAME | `lab.peis.fr` | **82.67.139.7** |

> ✅ **Conclusion** : Tous tes sous-domaines homelab pointent vers `82.67.139.7`. **Aucune modification DNS n'est nécessaire** pour commencer !

---

## 📋 Sommaire

1. [Prérequis](#-prérequis)
2. [Architecture recommandée](#-architecture-recommandée)
3. [Étape 1 : Configuration DNS chez Infomaniak](#-étape-1-configuration-dns-chez-infomaniak)
4. [Étape 2 : Déploiement du Reverse Proxy (Traefik)](#-étape-2-déploiement-du-reverse-proxy-traefik)
5. [Étape 3 : Configuration Let's Encrypt](#-étape-3-configuration-lets-encrypt)
6. [Étape 4 : Ajout de services derrière le proxy](#-étape-4-ajout-de-services-derrière-le-proxy)
7. [Étape 5 : Sécurisation avancée](#-étape-5-sécurisation-avancée)
8. [Alternative : Nginx Proxy Manager](#-alternative-nginx-proxy-manager)
9. [Dépannage](#-dépannage)
10. [Maintenance](#-maintenance)

---

## 🎯 Prérequis

### Matériel & Accès
- ✅ **Nom de domaine** acheté chez Infomaniak : **`peis.fr`**
- ✅ **IP publique statique** : **`82.67.139.7`** (ou dynamique avec DDNS) pour ton homelab
- ✅ **Sous-domaine homelab** : `lab.peis.fr` → `82.67.139.7` (déjà configuré chez Infomaniak)
- ✅ **Port forwarding** configuré sur ton routeur :
  - Port **80** (HTTP) → IP de ton serveur proxy
  - Port **443** (HTTPS) → IP de ton serveur proxy
- ✅ **Accès SSH** à ton serveur Proxmox ou conteneur LXC/Docker
- ✅ **Docker** ou **Podman** installé (pour le reverse proxy)

### Connaissances nécessaires
- Bases de Linux (commandes `docker`, `curl`, `dig`)
- Configuration DNS de base
- Notions de réseaux (ports, NAT)

---

## 🏗️ Architecture recommandée

```
Internet
    ↓ (DNS: lab.peis.fr → 82.67.139.7)
Routeur (Port Forwarding 80/443)
    ↓
Proxmox (192.168.0.94)
    ↓
Container LXC "traefik-proxy" - CT 200 (IP: 192.168.0.100, HA: ✅)
    ├─ Traefik v2.10 (Reverse Proxy + Let's Encrypt **PRODUCTION**)
    │
    ├─ Service 1: Nextcloud → https://nextcloud.peis.fr (CNAME lab.peis.fr)
    ├─ Service 2: Home Assistant → https://ha.peis.fr (CNAME lab.peis.fr)
    ├─ Service 3: Proxmox → https://proxmox.peis.fr (CNAME lab.peis.fr)
    ├─ Service 4: Traefik Dashboard → https://traefik.peis.fr (CNAME lab.peis.fr)
    ├─ Service Test: Whoami → https://test.peis.fr (CNAME lab.peis.fr)
    └─ Service N: ...
```

> ✅ **Configuration DNS actuelle validée** :
> - `peis.fr` et `www.peis.fr` → `128.65.195.180` (Infomaniak - inchangé)
> - `lab.peis.fr` → `82.67.139.7` (ton homelab)
> - `traefik.peis.fr`, `nas.peis.fr`, `ha.peis.fr`, `frigate.peis.fr`, `mqtt.peis.fr`, `proxmox.peis.fr`, `freebox.peis.fr` → CNAME `lab.peis.fr`
> - `test.peis.fr` → **À créer** (CNAME `lab.peis.fr`)
> 
> → **Tous ces sous-domaines pointent déjà vers ton IP `82.67.139.7` et sont prêts pour le HTTPS !**

---

## 🌐 Étape 1 : Configuration DNS chez Infomaniak

**Objectif** : Créer les enregistrements DNS nécessaires pour pointer vers ton homelab et permettre la validation Let's Encrypt.

### 1.1. Accéder à l'interface Infomaniak
1. Connecte-toi à [https://manager.infomaniak.com](https://manager.infomaniak.com)
2. Sélectionne ton domaine dans **"Hébergement" → "Domaines"**
3. Clique sur **"Gérer le domaine"** → **"DNS"**

### 1.2. ✅ Ta configuration DNS est déjà correcte

**Ne modifie PAS** les enregistrements suivants (ils sont nécessaires pour ton site Infomaniak) :

| Type  | Nom          | Valeur          | TTL  | ⚠️ À GARDER |
|-------|--------------|-----------------|------|-------------|
| A     | `@`          | `128.65.195.180` | 5 min | Site Infomaniak |
| A     | `www`        | `128.65.195.180` | 5 min | Site Infomaniak |

**Tes sous-domaines homelab sont déjà configurés** :

| Type  | Nom          | Valeur          | TTL  | ✅ Pour Homelab |
|-------|--------------|-----------------|------|-----------------|
| A     | `lab`        | `82.67.139.7` | 1 min | IP Homelab |
| CNAME | `traefik`     | `lab.peis.fr` | 1 h | → 82.67.139.7 |
| CNAME | `ha`         | `lab.peis.fr` | 1 h | → 82.67.139.7 |
| CNAME | `proxmox`    | `lab.peis.fr` | 1 h | → 82.67.139.7 |
| CNAME | `nas`        | `lab.peis.fr` | 1 h | → 82.67.139.7 |
| CNAME | `frigate`    | `lab.peis.fr` | 1 h | → 82.67.139.7 |
| CNAME | `mqtt`       | `lab.peis.fr` | 1 h | → 82.67.139.7 |
| CNAME | `freebox`    | `lab.peis.fr` | 1 h | → 82.67.139.7 |

> ✅ **Aucune modification DNS nécessaire** pour commencer ! Tous tes sous-domaines CNAME pointent déjà vers ton IP `82.67.139.7`.

### 1.3. Ajouter des sous-domaines supplémentaires (optionnel)

Si tu veux ajouter d'autres services, crée simplement un **CNAME vers `lab.peis.fr`** :

| Type  | Nom          | Valeur          | TTL  |
|-------|--------------|-----------------|------|
| CNAME | `nextcloud`  | `lab.peis.fr` | Auto |
| CNAME | `grafana`    | `lab.peis.fr` | Auto |
| CNAME | `portainer`  | `lab.peis.fr` | Auto |
| CNAME | `pve`        | `lab.peis.fr` | Auto |

> 💡 **Pourquoi CNAME ?** Tous tes sous-domaines CNAME vers `lab.peis.fr` hériteront automatiquement de l'IP `82.67.139.7`. Si tu changes l'IP de ton homelab, il suffira de modifier uniquement l'enregistrement A de `lab.peis.fr`.

### 1.4. Vérifier la propagation DNS

```bash
# Vérifier que peis.fr pointe vers Infomaniak (128.65.195.180)
 dig +short peis.fr
 # Vérifier que lab.peis.fr et ses CNAME pointent vers 82.67.139.7
 dig +short lab.peis.fr
 dig +short traefik.peis.fr
 dig +short ha.peis.fr
 dig +short proxmox.peis.fr

# Sur Windows (cmd)
nslookup peis.fr
nslookup lab.peis.fr
nslookup traefik.peis.fr
nslookup ha.peis.fr
```

**Attends 5-15 minutes** si tu as ajouté de nouveaux sous-domaines.

> ✅ **Si tout pointe correctement, passe directement à l'Étape 2 !**

### 1.5. ❌ Wildcard DNS : À ÉVITER dans ton cas

**Ne crée PAS** d'enregistrement wildcard `*.peis.fr` → `82.67.139.7` car :
- **Conflit avec ton site Infomaniak** : `peis.fr` et `www.peis.fr` doivent rester sur `128.65.195.180`
- **Let's Encrypt refusera** : Impossible d'obtenir un certificat wildcard si la racine ne pointe pas vers ton serveur
- **Validation échouera** : Le challenge DNS ou HTTP ne fonctionnera pas

> ✅ **Solution** : Utilise des certificats individuels pour chaque sous-domaine (HTTP ou DNS Challenge)

---

## 🚀 Étape 2 : Déploiement du Reverse Proxy (Traefik)

**Pourquoi Traefik ?**
- ✅ **Automatisation** : Détection automatique des services
- ✅ **Let's Encrypt intégré** : Gestion des certificats SSL
- ✅ **Dashboard** : Interface web pour le monitoring
- ✅ **Configuration dynamique** : Pas besoin de redémarrer pour ajouter un service
- ✅ **Support Docker** : Intégration native avec les conteneurs

### 2.1. Préparer l'environnement Docker

Sur ton serveur (Proxmox ou LXC) :

```bash
# Installer Docker si ce n'est pas déjà fait
apt update && apt install -y docker.io docker-compose

# Vérifier que Docker fonctionne
 docker --version
 docker run hello-world

# Créer un réseau Docker dédié pour Traefik
 docker network create traefik_network
```

### 2.2. Créer la configuration Traefik

Crée un dossier pour Traefik :

```bash
mkdir -p /opt/traefik/{config,certs,logs}
cd /opt/traefik
```

#### Fichier `docker-compose.yml`

```yaml
version: '3.8'

services:
  traefik:
    image: traefik:v2.10
    container_name: traefik
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./config/traefik.yml:/etc/traefik/traefik.yml:ro
      - ./config/dynamic.yml:/etc/traefik/dynamic.yml:ro
      - ./certs:/etc/traefik/certs
      - ./logs:/var/log/traefik
    networks:
      - traefik_network
    labels:
      - "traefik.enable=true"
      # Dashboard (accès sécurisé)
      - "traefik.http.routers.traefik.rule=Host(`traefik.peis.fr`)"
      - "traefik.http.routers.traefik.service=api@internal"
      - "traefik.http.routers.traefik.entrypoints=websecure"
      - "traefik.http.routers.traefik.tls=true"
      - "traefik.http.routers.traefik.middlewares=auth"
      - "traefik.http.middlewares.auth.basicauth.users=admin:$$apr1$$9Cv/OMGj$$ZomWQzuQbL.3TRCS81A1g/"

networks:
  traefik_network:
    external: true
```

> 🔒 **Note** : Le mot de passe pour le dashboard est `admin` / `admin123` (à changer !). Pour générer un hash : `htpasswd -nb admin admin123 | openssl passwd -apr1 -stdin`
> **URL du dashboard pour toi** : https://traefik.peis.fr

#### Fichier `config/traefik.yml`

```yaml
# Configuration globale
api:
  dashboard: true
  insecure: false

# Entrypoints (ports d'entrée)
entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
  websecure:
    address: ":443"

# Providers (sources de configuration)
providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    network: traefik_network
  file:
    filename: /etc/traefik/dynamic.yml
    watch: true

# Certificats SSL
certificatesResolvers:
  letsencrypt:
    acme:
      email: ton-email@peis.fr
      storage: /etc/traefik/certs/acme.json
      httpChallenge:
        entryPoint: web
      # Pour wildcard, utiliser dnsChallenge (voir Étape 3.3)
      # dnsChallenge:
      #   provider: infomaniak

# Logs
log:
  level: INFO
  filePath: /var/log/traefik/traefik.log

accessLog:
  filePath: /var/log/traefik/access.log
```

#### Fichier `config/dynamic.yml` (configuration dynamique)

```yaml
# Middlewares globaux
http:
  middlewares:
    # Redirection HTTP → HTTPS
    redirect-to-https:
      redirectScheme:
        scheme: https
        permanent: true
    
    # Compression
    compress:
      compress: {}
    
    # Headers de sécurité
    security-headers:
      headers:
        frameDeny: true
        sslRedirect: true
        browserXssFilter: true
        contentTypeNosniff: true
        forceSTSHeader: true
        stsIncludeSubdomains: true
        stsPreload: true
        stsSeconds: 31536000
        customResponseHeaders:
          X-Robots-Tag: "none,noarchive,nosnippet,notranslate,noimageindex"

# Routers par défaut
tcp:
  routers: {}
  services: {}

udp:
  routers: {}
  services: {}
```

### 2.3. Lancer Traefik

```bash
cd /opt/traefik
docker-compose up -d
```

### 2.4. Vérifier que Traefik fonctionne

```bash
# Vérifier les logs
docker logs traefik

# Vérifier que le conteneur est en bonne santé
docker ps

# Accéder au dashboard (après avoir configuré le HTTPS)
# https://traefik.peis.fr
```

---

## 🔐 Étape 3 : Configuration Let's Encrypt

**Objectif** : Obtenir des certificats SSL automatiques et les renouveler.

### 3.1. Prérequis pour Let's Encrypt

- ✅ **Port 80 ouvert** sur ton routeur
- ✅ **Domaine configuré** chez Infomaniak (Étape 1)
- ✅ **Traefik en cours d'exécution** (Étape 2)

### 3.2. Configuration HTTP Challenge (recommandé pour débuter)

Modifie `config/traefik.yml` pour activer le HTTP Challenge :

```yaml
certificatesResolvers:
  letsencrypt:
    acme:
      email: ton-email@peis.fr
      storage: /etc/traefik/certs/acme.json
      httpChallenge:
        entryPoint: web
```

> ✅ **Avantage** : Simple à configurer, fonctionne avec tous les hébergeurs.
> ❌ **Inconvénient** : Nécessite que le port 80 soit accessible.

### 3.3. Configuration DNS Challenge (alternative au HTTP Challenge)

**Note pour ton setup** : Comme `peis.fr` pointe vers Infomaniak et non vers ton homelab, **tu ne peux PAS utiliser de certificat wildcard** (`*.peis.fr`). Cependant, le DNS Challenge reste utile si :
- Tu veux éviter d'ouvrir le port 80 sur ton routeur
- Tu préfères une validation plus discrète

> ✅ **Dans ton cas** : Utilise soit :
> - **HTTP Challenge** (plus simple, nécessite port 80 ouvert)
> - **DNS Challenge** (sans wildcard, pour chaque sous-domaine individuel)

Pour configurer le DNS Challenge pour chaque sous-domaine :

#### 3.3.1. Créer un token API Infomaniak

1. Va dans [Infomaniak Manager](https://manager.infomaniak.com)
2. **Compte** → **API** → **Créer une clé API**
3. Donne un nom (ex: `Traefik-LE`)
4. Sélectionne **Lecture/Écriture** sur **Domaines**
5. Copie la **clé API** (format : `ABC123-456DEF-789GHI`)

#### 3.3.2. Configurer Traefik pour DNS Challenge

Modifie `config/traefik.yml` :

```yaml
certificatesResolvers:
  letsencrypt:
    acme:
      email: ton-email@peis.fr
      storage: /etc/traefik/certs/acme.json
      dnsChallenge:
        provider: infomaniak
        delayBeforeCheck: 0

# Configuration du provider Infomaniak
providers:
  # ... (autres providers)
  acme:
    dnsChallenge:
      providers:
        infomaniak:
          apiToken: "TA_CLE_API_INFOMANIAK"
```

Remplace `TA_CLE_API_INFOMANIAK` par ta clé API.

> ✅ **Avantage** : Permet les certificats wildcard, pas besoin d'ouvrir le port 80.
> ❌ **Inconvénient** : Plus complexe à configurer.

### 3.4. Redémarrer Traefik

```bash
cd /opt/traefik
docker-compose down && docker-compose up -d
```

### 3.5. Tester l'obtention d'un certificat

Ajoute un service de test (ex: whoami) pour vérifier que Let's Encrypt fonctionne :

> ✅ **Utilise `test.peis.fr`** : Crée un CNAME `test` → `lab.peis.fr` chez Infomaniak (requis)

#### Fichier `docker-compose-whoami.yml`

```yaml
version: '3.8'

services:
  whoami:
    image: traefik/whoami
    container_name: whoami
    restart: unless-stopped
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.whoami-http.rule=Host(`test.peis.fr`)"
      - "traefik.http.routers.whoami-http.entrypoints=web"
      - "traefik.http.routers.whoami-http.middlewares=redirect-to-https@file"
      - "traefik.http.routers.whoami.rule=Host(`test.peis.fr`)"
      - "traefik.http.routers.whoami.entrypoints=websecure"
      - "traefik.http.routers.whoami.tls=true"
      - "traefik.http.routers.whoami.tls.certresolver=letsencrypt"
      - "traefik.http.services.whoami.loadbalancer.server.port=80"
    networks:
      - traefik_network

networks:
  traefik_network:
    external: true
```

Lance le service :

```bash
docker-compose -f docker-compose-whoami.yml up -d
```

#### Vérifier le certificat

1. Accède à `https://test.peis.fr`
2. Vérifie que le cadenas 🔒 apparaît dans la barre d'adresse
3. Clique sur le cadenas pour voir les détails du certificat (Let's Encrypt)

#### Vérifier dans les logs

```bash
docker logs traefik-proxy | grep -i "certificate"
```

Tu devrais voir :
```
legolog: [INFO] [test.peis.fr] acme: Obtaining bundled SAN certificate
legolog: [INFO] [test.peis.fr] acme: Validations succeeded
```

---

## 📦 Étape 4 : Ajout de services derrière le proxy

**Objectif** : Configurer tes services pour qu'ils soient accessibles via HTTPS.

### 4.1. Structure type d'un service

Chaque service doit :
1. Être sur le même réseau Docker que Traefik (`traefik_network`)
2. Avoir les labels Docker appropriés pour Traefik
3. Ne **pas** exposer de ports directement (Traefik s'en charge)

### 4.2. Exemple 1 : Nextcloud

#### Fichier `docker-compose-nextcloud.yml`

```yaml
version: '3.8'

services:
  nextcloud:
    image: nextcloud:latest
    container_name: nextcloud
    restart: unless-stopped
    volumes:
      - /opt/nextcloud/data:/var/www/html/data
      - /opt/nextcloud/config:/var/www/html/config
    environment:
      - NEXTCLOUD_TRUSTED_DOMAINS=nextcloud.peis.fr
    labels:
      - "traefik.enable=true"
      # Router HTTP → HTTPS
      - "traefik.http.routers.nextcloud-http.rule=Host(`nextcloud.peis.fr`)"
      - "traefik.http.routers.nextcloud-http.entrypoints=web"
      - "traefik.http.routers.nextcloud-http.middlewares=redirect-to-https"
      # Router HTTPS
      - "traefik.http.routers.nextcloud.rule=Host(`nextcloud.peis.fr`)"
      - "traefik.http.routers.nextcloud.entrypoints=websecure"
      - "traefik.http.routers.nextcloud.tls=true"
      - "traefik.http.routers.nextcloud.tls.certresolver=letsencrypt"
      # Service
      - "traefik.http.services.nextcloud.loadbalancer.server.port=80"
    networks:
      - traefik_network
    # Pas de ports exposés !

networks:
  traefik_network:
    external: true
```

### 4.3. Exemple 2 : Home Assistant

#### Fichier `docker-compose-ha.yml`

```yaml
version: '3.8'

services:
  homeassistant:
    image: homeassistant/home-assistant:latest
    container_name: homeassistant
    restart: unless-stopped
    volumes:
      - /opt/homeassistant/config:/config
      - /etc/localtime:/etc/localtime:ro
    environment:
      - TZ=Europe/Zurich
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.ha-http.rule=Host(`ha.peis.fr`)"
      - "traefik.http.routers.ha-http.entrypoints=web"
      - "traefik.http.routers.ha-http.middlewares=redirect-to-https"
      - "traefik.http.routers.ha.rule=Host(`ha.peis.fr`)"
      - "traefik.http.routers.ha.entrypoints=websecure"
      - "traefik.http.routers.ha.tls=true"
      - "traefik.http.routers.ha.tls.certresolver=letsencrypt"
      - "traefik.http.services.ha.loadbalancer.server.port=8123"
    networks:
      - traefik_network

networks:
  traefik_network:
    external: true
```

### 4.4. Exemple 3 : Proxmox VE (accès web)

Proxmox utilise le port 8006. Pour l'exposer via Traefik :

> 💡 **Note** : Dans ta config DNS, `proxmox.peis.fr` existe déjà (CNAME → lab.peis.fr). Tu peux :
> - Soit créer un CNAME `pve` → `lab.peis.fr` chez Infomaniak
> - Soit remplacer `pve.peis.fr` par `proxmox.peis.fr` dans la configuration ci-dessous

#### Fichier `docker-compose-proxmox.yml`

```yaml
version: '3.8'

services:
  proxmox-proxy:
    image: nginx:alpine
    container_name: proxmox-proxy
    restart: unless-stopped
    volumes:
      - ./config/proxmox-nginx.conf:/etc/nginx/nginx.conf:ro
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.pve-http.rule=Host(`pve.peis.fr`)"
      - "traefik.http.routers.pve-http.entrypoints=web"
      - "traefik.http.routers.pve-http.middlewares=redirect-to-https"
      - "traefik.http.routers.pve.rule=Host(`pve.peis.fr`)"
      - "traefik.http.routers.pve.entrypoints=websecure"
      - "traefik.http.routers.pve.tls=true"
      - "traefik.http.routers.pve.tls.certresolver=letsencrypt"
      - "traefik.http.services.pve.loadbalancer.server.port=80"
    networks:
      - traefik_network

networks:
  traefik_network:
    external: true
```

#### Fichier `config/proxmox-nginx.conf`

```nginx
user  nginx;
worker_processes  auto;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    upstream proxmox {
        server 192.168.0.94:8006;  # IP de ton serveur Proxmox
    }

    server {
        listen 80;
        server_name proxmox.peis.fr;

        location / {
            proxy_pass https://proxmox;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            
            # Désactiver la vérification SSL en amont (Proxmox utilise un cert auto-signé)
            proxy_ssl_verify off;
        }
    }
}
```

> ⚠️ **Important** : Proxmox utilise un certificat auto-signé par défaut. Pour éviter les avertissements, tu peux :
> 1. Importer le certificat Let's Encrypt dans Proxmox (via l'interface web)
> 2. Ou désactiver la vérification SSL comme ci-dessus (moins sécurisé)

### 4.5. Exemple 4 : Service avec authentification

Pour ajouter une authentification basique à un service :

```yaml
labels:
  - "traefik.enable=true"
  - "traefik.http.routers.mon-service.rule=Host(`mon-service.peis.fr`)"
  - "traefik.http.routers.mon-service.entrypoints=websecure"
  - "traefik.http.routers.mon-service.tls=true"
  - "traefik.http.routers.mon-service.tls.certresolver=letsencrypt"
  - "traefik.http.routers.mon-service.middlewares=auth"
  - "traefik.http.middlewares.auth.basicauth.users=admin:$$apr1$$9Cv/OMGj$$ZomWQzuQbL.3TRCS81A1g/"
```

---

## 🔒 Étape 5 : Sécurisation avancée

### 5.1. Configurer les headers de sécurité

Modifie `config/dynamic.yml` pour ajouter plus de sécurité :

```yaml
http:
  middlewares:
    security-headers:
      headers:
        # Prévention des attaques
        frameDeny: true
        sslRedirect: true
        browserXssFilter: true
        contentTypeNosniff: true
        forceSTSHeader: true
        stsIncludeSubdomains: true
        stsPreload: true
        stsSeconds: 31536000
        
        # Politiques de sécurité
        customRequestHeaders:
          X-Forwarded-Proto: "https"
        customResponseHeaders:
          X-Robots-Tag: "none,noarchive,nosnippet,notranslate,noimageindex"
          X-Content-Type-Options: "nosniff"
          X-Frame-Options: "DENY"
          X-XSS-Protection: "1; mode=block"
          Referrer-Policy: "strict-origin-when-cross-origin"
          Permissions-Policy: "camera=(), microphone=(), geolocation=()"
```

### 5.2. Bloquer l'accès au dashboard Traefik depuis l'extérieur

Modifie les labels du conteneur Traefik dans `docker-compose.yml` :

```yaml
labels:
  - "traefik.enable=true"
  - "traefik.http.routers.traefik.rule=Host(`traefik.peis.fr`) && ClientIP(`192.168.0.0/16`)"
  - "traefik.http.routers.traefik.service=api@internal"
  - "traefik.http.routers.traefik.entrypoints=websecure"
  - "traefik.http.routers.traefik.tls=true"
  - "traefik.http.routers.traefik.middlewares=auth"
```

> ⚠️ **Note** : Remplace `192.168.0.0/16` par ton réseau local.

### 5.3. Configurer le rate limiting

Ajoute dans `config/dynamic.yml` :

```yaml
http:
  middlewares:
    rate-limit:
      rateLimit:
        average: 100
        burst: 50
        period: 1m
```

Puis applique-le à tes services :

```yaml
labels:
  - "traefik.http.routers.mon-service.middlewares=rate-limit"
```

### 5.4. Configurer le fail2ban pour Traefik

Installe fail2ban sur ton hôte :

```bash
apt install -y fail2ban
```

Crée un filtre pour Traefik :

```bash
# Fichier /etc/fail2ban/filter.d/traefik.conf
[Definition]
failregex = ^.* "<HOST>.*" 401
            ^.* "<HOST>.*" 403
            ^.* "<HOST>.*" 404
ignoreregex =
```

Crée une prison :

```bash
# Fichier /etc/fail2ban/jail.d/traefik.conf
[traefik]
enabled = true
port = 80,443
filter = traefik
logpath = /opt/traefik/logs/access.log
maxretry = 3
findtime = 10m
bantime = 1h
```

Redémarre fail2ban :

```bash
systemctl restart fail2ban
```

---



## 🛠️ Dépannage

### Problèmes courants

| Problème | Cause possible | Solution |
|----------|-----------------|----------|
| **Certificat non généré** | Port 80 bloqué | Vérifie le port forwarding et le firewall |
| **Erreur DNS** | Enregistrement DNS manquant | Attends la propagation (`dig peis.fr`) |
| **404 sur le dashboard** | URL incorrecte | Vérifie `traefik.peis.fr` |
| **Let's Encrypt rate limit** | Trop de demandes | Attends 1 semaine ou utilise le staging |
| **Traefik ne détecte pas les services** | Réseau Docker incorrect | Vérifie `networks: traefik_network` |
| **Port déjà utilisé** | Conflit avec un autre service | `netstat -tulnp \| grep 80` |

### Utiliser le staging de Let's Encrypt

Pour éviter de bloquer ton IP pendant les tests, utilise le staging :

```yaml
certificatesResolvers:
  letsencrypt:
    acme:
      email: ton-email@peis.fr
      storage: /etc/traefik/certs/acme.json
      httpChallenge:
        entryPoint: web
      # Ajoute ceci pour le staging
      caServer: https://acme-staging-v02.api.letsencrypt.org/directory
```

### Vérifier les logs Traefik

```bash
# Voir les logs en temps réel
docker logs -f traefik

# Filtrer les erreurs
docker logs traefik | grep -i error

# Vérifier les certificats obtenus
docker exec traefik cat /etc/traefik/certs/acme.json | jq
```

### Tester la connectivité

```bash
# Tester le port 80
curl -v http://peis.fr

# Tester le port 443
curl -vk https://peis.fr

# Tester depuis l'extérieur (via un VPN ou un smartphone en 4G)
curl -v https://test.peis.fr
curl -v https://ha.peis.fr
```

### Vérifier le port forwarding

Depuis un réseau externe (pas ton réseau local) :

```bash
# Tester le port 80
nc -zv 82.67.139.7 80

# Tester le port 443
nc -zv 82.67.139.7 443
```

Si ça ne fonctionne pas :
1. Vérifie ton routeur (port forwarding)
2. Vérifie le firewall de ton serveur (`ufw status`)
3. Vérifie que Docker écoute bien sur 0.0.0.0 (`docker ps`)

---

## 🧹 Maintenance

### Renouvellement automatique des certificats

Let's Encrypt renouvelle automatiquement les certificats **30 jours avant expiration**. Traefik gère cela automatiquement.

### Vérifier la date d'expiration

```bash
docker exec traefik cat /etc/traefik/certs/acme.json | jq -r '.letsencrypt.Account.Email, .letsencrypt.Certificates[].Domain.Main, .letsencrypt.Certificates[].Certificate.ExpiresAt'
```

### Sauvegarder les certificats

```bash
# Sauvegarder le dossier certs
cd /opt/traefik
tar -czvf traefik-certs-$(date +%Y%m%d).tar.gz certs/

# Copier sur un autre serveur
scp traefik-certs-*.tar.gz user@backup-server:/backups/
```

### Mettre à jour Traefik

```bash
cd /opt/traefik
docker-compose pull
docker-compose up -d --remove-orphans
```

### Nettoyer les anciens conteneurs

```bash
# Lister les conteneurs arrêtés
docker ps -a --filter "status=exited"

# Supprimer les conteneurs arrêtés
docker container prune

# Supprimer les images non utilisées
docker image prune -a
```

---

## 📊 Exemple complet de configuration

Voici un exemple complet avec plusieurs services :

### Structure des fichiers

```
/opt/traefik/
├── config/
│   ├── traefik.yml
│   ├── dynamic.yml
│   └── proxmox-nginx.conf
├── certs/
│   └── acme.json
├── logs/
├── docker-compose.yml
├── docker-compose-whoami.yml
├── docker-compose-nextcloud.yml
└── docker-compose-ha.yml
```

### Commandes pour tout déployer

```bash
# Créer le réseau
 docker network create traefik_network

# Lancer Traefik
cd /opt/traefik
docker-compose up -d

# Lancer les services
 docker-compose -f docker-compose-whoami.yml up -d
 docker-compose -f docker-compose-nextcloud.yml up -d
 docker-compose -f docker-compose-ha.yml up -d
```

---

## 📚 Ressources utiles

### Outils en ligne
- [Let's Encrypt Status](https://letsencrypt.status.io/) - Vérifier l'état du service
- [SSL Labs Test](https://www.ssllabs.com/ssltest/) - Tester la qualité de ton HTTPS
- [DNS Checker](https://dnschecker.org/) - Vérifier la propagation DNS
- [HTPasswd Generator](https://hostingcanada.org/htpasswd-generator/) - Générer des mots de passe pour Traefik

### Documentation officielle
- [Traefik Documentation](https://doc.traefik.io/traefik/)
- [Let's Encrypt Documentation](https://letsencrypt.org/docs/)
- [Infomaniak API Documentation](https://developer.infomaniak.com/)
- [Docker Documentation](https://docs.docker.com/)

### Communautés
- r/homelab (Reddit)
- r/selfhosted (Reddit)
- [Traefik GitHub](https://github.com/traefik/traefik)

---

## ✅ Checklist finale

- [ ] Nom de domaine acheté chez Infomaniak (`peis.fr`)
- [ ] Enregistrements DNS configurés (`lab.peis.fr` → `82.67.139.7`, CNAME pour sous-domaines → `lab.peis.fr`)
- [ ] Port forwarding 80/443 configuré sur le routeur (`82.67.139.7:80/443`)
- [ ] Docker installé sur le serveur
- [ ] Réseau `traefik_network` créé
- [ ] Traefik déployé et accessible
- [ ] Certificats Let's Encrypt obtenus (HTTP ou DNS Challenge)
- [ ] Dashboard Traefik sécurisé (authentification + accès restreint)
- [ ] Services configurés avec HTTPS
- [ ] Sauvegarde des certificats et configurations
- [ ] Tests de connectivité depuis l'extérieur

---

## 🎉 Félicitations !

Ton homelab est maintenant **100% sécurisé avec HTTPS** ! 🔒

- Tous tes services sont accessibles via `https://nom-service.peis.fr`
- Les certificats sont **automatiquement renouvelés** par Let's Encrypt
- Tu peux ajouter de nouveaux services **sans toucher à la configuration SSL**

**Prochaines étapes possibles** :
- [ ] Configurer un **VPN** (WireGuard) pour un accès sécurisé
- [ ] Ajouter un **monitoring** (Grafana + Prometheus)
- [ ] Configurer des **sauvegardes automatiques**
- [ ] Explorer **Authelia** pour une authentification centralisée

---

*Documentation générée pour ton homelab avec ❤️ par Mistral Vibe*