Tunnel VPN WireGuard avec Docker sur Debian

Introduction

WireGuard est un protocole VPN moderne, rapide et minimaliste qui s’impose aujourd’hui face aux solutions historiques comme OpenVPN ou IPsec. Il repose sur de la cryptographie moderne, une configuration simple et des performances excellentes grâce à son intégration au kernel Linux.

L’objectif de ce guide est de mettre en place un serveur WireGuard dans un container Docker sur une machine Debian. Cette approche apporte une meilleure isolation du service par rapport au système hôte, facilite la maintenance et les mises à jour, tout en permettant au container d’avoir accès au LAN pour router le trafic des clients VPN.

graph TD
    subgraph Internet [Zone Internet]
        Client["💻 Client VPN\n(WireGuard)"]
    end

    subgraph Debian [Serveur Debian]
        direction TB
        Docker["🐳 Container WireGuard\n10.0.0.1/24"]
        Host["Hôte Debian\nIP publique :51820"]
    end

    subgraph LAN [Réseau Local]
        Router["Routeur / Box\n192.168.1.1"]
        Devices["Appareils LAN\n192.168.1.x"]
    end

    Client -- "UDP :51820 (chiffré)" --> Host
    Host -- "réseau Docker (macvlan/bridge)" --> Docker
    Docker -- "routage IP" --> Router
    Router -.-> Devices

Prérequis

Avant de commencer, assurez-vous d’avoir :

Une machine Debian (11 Bullseye ou 12 Bookworm) accessible depuis internet
Un port UDP ouvert sur votre box/pare-feu (par défaut 51820)
Docker et Docker Compose installés
Un accès root ou sudo sur le serveur
Optionnellement : un nom de domaine ou une IP publique fixe (ou un service DDNS)

Étape 1 : Préparer le système hôte

Activer le forwarding IP

Pour que le serveur puisse router les paquets des clients VPN vers le LAN, le forwarding IP doit être activé sur l’hôte Debian.

sudo nano /etc/sysctl.conf

Décommentez ou ajoutez la ligne suivante :

net.ipv4.ip_forward=1

Appliquez immédiatement sans redémarrer :

sudo sysctl -p

Vérifiez que c’est bien actif :

sysctl net.ipv4.ip_forward
# Doit afficher : net.ipv4.ip_forward = 1

Installer Docker

Si Docker n’est pas encore installé :

# Dépendances
sudo apt update && sudo apt install -y ca-certificates curl gnupg

# Ajout du dépôt officiel Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installation
sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Vérifiez que Docker fonctionne :

sudo docker run --rm hello-world

Étape 2 : Préparer la structure des fichiers

Créez un répertoire dédié pour WireGuard :

sudo mkdir -p /opt/wireguard/config
cd /opt/wireguard

La structure finale sera :

/opt/wireguard/
├── docker-compose.yml
└── config/
    ├── wg0.conf          # généré automatiquement
    └── peer_*/           # configs clients (générées automatiquement)

Étape 3 : Configurer Docker Compose

On utilise l’image linuxserver/wireguard, qui est maintenue activement et gère automatiquement la génération des clés et des configurations clients.

Créez le fichier docker-compose.yml :

sudo nano /opt/wireguard/docker-compose.yml

services:
  wireguard:
    image: lscr.io/linuxserver/wireguard:latest
    container_name: wireguard
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Paris
      # Adresse publique du serveur (IP ou nom de domaine)
      - SERVERURL=votre.domaine.ou.ip.publique
      # Port UDP exposé
      - SERVERPORT=51820
      # Nombre de clients à pré-générer
      - PEERS=3
      # Noms des clients (optionnel, remplace peer1, peer2...)
      - PEERDNS=auto
      # Sous-réseau du tunnel VPN
      - INTERNAL_SUBNET=10.13.13.0
      # Autoriser l'accès au LAN depuis les clients
      - ALLOWEDIPS=0.0.0.0/0
      - LOG_CONFS=true
    volumes:
      - ./config:/config
      - /lib/modules:/lib/modules:ro
    ports:
      - 51820:51820/udp
    # Accès au réseau de l'hôte pour router vers le LAN
    network_mode: host
    sysctls:
      - net.ipv4.conf.all.src_valid_mark=1
    restart: unless-stopped

Note sur network_mode: host : On utilise ici le mode réseau host pour que le container partage directement la stack réseau de l’hôte Debian. C’est la méthode la plus simple pour permettre au container de router le trafic vers le LAN sans configuration réseau Docker complexe. Cela signifie que le container voit toutes les interfaces de l’hôte.

Variables importantes

Variable	Description
`SERVERURL`	IP publique ou nom de domaine que les clients utiliseront pour se connecter
`SERVERPORT`	Port UDP (défaut : `51820`)
`PEERS`	Nombre de configs clients à générer automatiquement
`INTERNAL_SUBNET`	Sous-réseau du tunnel VPN (doit être différent de votre LAN)
`ALLOWEDIPS`	Routes poussées aux clients — `0.0.0.0/0` = tout le trafic passe par le VPN

Si vous voulez que seul le trafic LAN passe par le VPN (split tunnel), remplacez ALLOWEDIPS par votre plage LAN, ex : 192.168.1.0/24.

Étape 4 : Démarrer le serveur

cd /opt/wireguard
sudo docker compose up -d

Vérifiez que le container tourne :

sudo docker ps
sudo docker logs wireguard

Les configurations clients sont générées automatiquement dans ./config/peer_*/. Pour afficher le QR code du premier client directement dans le terminal :

sudo docker exec -it wireguard /app/show-peer 1

Vous pouvez aussi récupérer directement le fichier .conf :

sudo cat /opt/wireguard/config/peer_1/peer_1.conf

Étape 5 : Ouvrir le port sur votre box

Sur votre box internet (Freebox, Livebox, etc.), ajoutez une règle de redirection de port (NAT) :

Protocole : UDP
Port externe : 51820
IP destination : IP locale de votre serveur Debian (ex : 192.168.1.10)
Port destination : 51820

Si votre IP publique change régulièrement, configurez un service DDNS (DuckDNS, Cloudflare, etc.) et renseignez le nom de domaine dans SERVERURL.

Étape 6 : Configurer les clients

Sur Linux / macOS

Installez WireGuard :

# Debian/Ubuntu
sudo apt install wireguard

# macOS (Homebrew)
brew install wireguard-tools

Copiez le fichier peer_1.conf sur le client et activez la connexion :

sudo wg-quick up /chemin/vers/peer_1.conf

Pour se déconnecter :

sudo wg-quick down /chemin/vers/peer_1.conf

Sur Windows

Téléchargez le client officiel depuis wireguard.com, importez le fichier .conf et activez le tunnel.

Sur Android / iOS

Scannez le QR code généré avec l’étape précédente depuis l’application WireGuard officielle (disponible sur le Play Store et l’App Store).

Étape 7 : Vérifier le tunnel

Depuis un client connecté, vérifiez que vous atteignez le LAN :

# Ping le routeur / box
ping 192.168.1.1

# Ping un appareil du LAN
ping 192.168.1.50

# Vérifier votre IP publique (doit être celle du serveur)
curl ifconfig.me

Côté serveur, pour voir les peers connectés et leur trafic :

sudo docker exec -it wireguard wg show

Exemple de sortie :

interface: wg0
  public key: <clé publique du serveur>
  private key: (hidden)
  listening port: 51820

peer: <clé publique du client>
  endpoint: <IP client>:XXXXX
  allowed ips: 10.13.13.2/32
  latest handshake: 5 seconds ago
  transfer: 1.23 MiB received, 4.56 MiB sent

Étape 8 : Ajouter des clients supplémentaires

Pour ajouter de nouveaux clients sans recréer le container, modifiez la valeur de PEERS dans le docker-compose.yml et relancez :

sudo docker compose down
# Modifiez PEERS=5 dans docker-compose.yml
sudo docker compose up -d

Les nouvelles configs seront générées dans config/peer_4/ et config/peer_5/.

Vous pouvez aussi nommer vos peers avec PEERS=laptop,phone,tablette pour obtenir des dossiers peer_laptop/, peer_phone/, etc.

Maintenance et mises à jour

Pour mettre à jour l’image WireGuard :

cd /opt/wireguard
sudo docker compose pull
sudo docker compose up -d

Pour consulter les logs en temps réel :

sudo docker logs -f wireguard

Pour arrêter le serveur :

sudo docker compose down

Conclusion

Vous avez maintenant un serveur VPN WireGuard fonctionnel, isolé dans un container Docker sur votre machine Debian, avec accès complet à votre LAN depuis n’importe où sur internet.

Cette architecture offre plusieurs avantages :

Isolation : le processus WireGuard tourne dans un container et non directement sur l’hôte
Facilité de maintenance : une seule commande pour mettre à jour ou redémarrer
Portabilité : la configuration est entièrement dans /opt/wireguard/config, facile à sauvegarder

Pour aller plus loin, vous pouvez coupler ce VPN avec le durcissement SSH présenté dans l’article dédié, pour n’autoriser les connexions SSH que depuis l’interface VPN.