Hébergement de services personnels derrière un reverse proxy Nginx / Traefik

Quand on commence à héberger ses propres services (blog, monitoring, analytics, LLM) on se retrouve vite avec une dizaine d’applications à exposer sur le web. Les faire toutes écouter sur des ports différents, c’est ingérable. La solution : un reverse proxy.

J’ai testé Nginx et Traefik pour centraliser l’accès à mes services. Voici mon retour d’expérience et la configuration que j’utilise.

Pourquoi un reverse proxy ?

Le principe est simple : un seul point d’entrée (ports 80 et 443) qui distribue les requêtes vers les bons services en fonction du nom de domaine ou du chemin.

!3fpixy3fpixy3fpi.png

Avantages : un seul certificat SSL, une seule configuration réseau, et on peut ajouter l’authentification, le rate limiting, le caching au même endroit.

Option 1 : Nginx

Nginx est un classique solide. Simple, performant, documenté.

Installation

# docker-compose.yml
nginx:
  image: nginx:alpine
  ports:
    - "80:80"
    - "443:443"
  volumes:
    - ./nginx.conf:/etc/nginx/nginx.conf
    - ./ssl:/etc/nginx/ssl
    - ./htpasswd:/etc/nginx/htpasswd
  restart: unless-stopped

Configuration

Un exemple complet avec plusieurs services, SSL et authentification :

events {}

http {
  # SSL global
  ssl_certificate /etc/nginx/ssl/cert.pem;
  ssl_certificate_key /etc/nginx/ssl/key.pem;
  ssl_protocols TLSv1.2 TLSv1.3;

  # Blog
  server {
    server_name blog.exemple.com;
    location / {
      proxy_pass http://blog:8080;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
    }
  }

  # Umami (avec authentification de base)
  server {
    server_name stats.exemple.com;
    auth_basic "Accès restreint";
    auth_basic_user_file /etc/nginx/htpasswd;

    location / {
      proxy_pass http://umami:3000;
      proxy_set_header Host $host;
    }
  }

  # Open WebUI
  server {
    server_name ollama.exemple.com;
    location / {
      proxy_pass http://open-webui:3001;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
      proxy_set_header Host $host;
    }
  }
}

Gestion des WebSockets

Certains services (Open WebUI, Beszel) utilisent des WebSockets. Il faut ajouter les headers spécifiques :

location /ws/ {
  proxy_pass http://service:port;
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
}

Nginx est parfait pour un petit nombre de services statiques. Mais quand j’ai commencé à en ajouter un par semaine, la maintenance du fichier de configuration est devenue fastidieuse.

Option 2 : Traefik

Traefik est un reverse proxy moderne conçu pour les conteneurs. Il détecte automatiquement les nouveaux services et génère la configuration tout seul.

Installation

traefik:
  image: traefik:v3
  ports:
    - "80:80"
    - "443:443"
    - "8080:8080"  # Dashboard
  volumes:
    - /var/run/docker.sock:/var/run/docker.sock
    - ./traefik.yml:/traefik.yml
    - ./acme.json:/acme.json

Configuration

# traefik.yml
api:
  dashboard: true

entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entrypoint:
          to: websecure
  websecure:
    address: ":443"

certificatesResolvers:
  letsencrypt:
    acme:
      email: admin@exemple.com
      storage: acme.json
      httpChallenge:
        entryPoint: web

providers:
  docker:
    exposedByDefault: false

Labels Docker

Le gros avantage de Traefik, c’est qu’on configure chaque service avec des labels Docker. Plus besoin de toucher au fichier de config principal :

umami:
  image: ghcr.io/mikecao/umami:latest
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.umami.rule=Host(`stats.exemple.com`)"
    - "traefik.http.routers.umami.tls=true"
    - "traefik.http.routers.umami.tls.certresolver=letsencrypt"
    - "traefik.http.services.umami.loadbalancer.server.port=3000"

Pour ajouter un nouveau service, je créé juste un bloc de labels :

beszel:
  image: henrygd/beszel:latest
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.beszel.rule=Host(`monitor.exemple.com`)"
    - "traefik.http.routers.beszel.tls=true"
    - "traefik.http.routers.beszel.tls.certresolver=letsencrypt"
    - "traefik.http.services.beszel.loadbalancer.server.port=8090"

Traefik gère Lets Encrypt automatiquement : plus de renouvellement manuel des certificats, plus de fichier de config à éditer.

Middlewares

Traefik permet d’ajouter des comportements (authentification, rate limiting, headers) via des middlewares :

# middleware pour l'authentification Basic
labels:
  - "traefik.http.middlewares.auth.basicauth.users=admin:$$2y$$..."
  - "traefik.http.routers.umami.middlewares=auth"

# middleware pour la compression
  - "traefik.http.middlewares.compress.compress=true"

# middleware pour les headers de sécurité
  - "traefik.http.middlewares.secure.headers.sslredirect=true"
  - "traefik.http.middlewares.secure.headers.stsincludesubdomains=true"

Comparatif Nginx vs Traefik

Mon choix : Traefik

J’ai commencé avec Nginx et j’étais satisfait. Mais en passant de 3 à 12 services, la gestion des certificats et l’édition manuelle des server blocks sont devenues une charge. J’ai migré vers Traefik et je ne regrette pas.

La configuration déclarative via les labels Docker est un vrai gain de productivité. Je déploie un nouveau docker-compose.yml avec les labels Traefik, et le service est accessible en HTTPS en 30 secondes.

Conclusion

Que vous choisissiez Nginx ou Traefik, l’important est d’avoir un reverse proxy centralisé. Il simplifie la gestion des certificats, la sécurité et l’accès à vos services.

Pour un homelab qui évolue, je recommande Traefik. Pour un déploiement stable avec peu de services, Nginx est plus que suffisant.

Et vous, quel reverse proxy utilisez-vous pour vos services personnels ?