Skip to content

Installation Serveur Systemd

Ces étapes sont indépendantes de la distribution

Note

Nécessite d'avoir le paquet wireguard installé.

  1. Générez un fichier de configuration WireGuard valide dans /etc/wireguard/wg0.conf.
  2. Note : Il peut être nécessaire de remplacer le nom d'hôte de l'Endpoint par l'adresse IP du serveur, car la résolution DNS peut ne pas être opérationnelle au moment où systemd initialise l'interface.
  3. Ajoutez le service WireGuard à systemd : 
    sudo systemctl enable wg-quick@wg0.service
sudo systemctl daemon-reload
  4. Démarrez le service immédiatement : 
    sudo systemctl start wg-quick@wg0
  5. Redémarrez votre système pour vérifier que la connexion automatique au démarrage fonctionne comme prévu.
  6. Vérifiez le statut du service : 
    sudo systemctl status wg-quick@wg0

Installation Serveur Docker

Configuration type avec linuxserver/wireguard.

Docker Compose

version: '3'
services:
  wireguard:
    image: lscr.io/linuxserver/wireguard:latest
    container_name: wireguard
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
      - SERVERURL=vpn.example.com
      - SERVERPORT=51820
      - PEERS=client1,client2
      - PEERDNS=auto
      - INTERNAL_SUBNET=10.13.13.0
      - ALLOWEDIPS=0.0.0.0/0
    volumes:
      - /path/to/config:/config
      - /lib/modules:/lib/modules
    ports:
      - 51820:51820/udp
    sysctls:
      - net.ipv4.conf.all.src_valid_mark=1
    restart: unless-stopped

Accès aux Conteneurs depuis le VPN

Pour que les clients VPN puissent accéder aux autres conteneurs (ex: Guacamole, Transmission) via leurs noms ou IPs internes.

Solution A : Réseau Docker Dédié (Recommandé)

Placer tous les conteneurs dans un subnet personnalisé.

Définir le réseau dans docker-compose.yaml : 

networks:
  internal_network:
    driver: bridge
    ipam:
      config:
        - subnet: 10.1.0.0/16

Connecter WireGuard et les services : 

services:
  wireguard:
    networks:
      - internal_network
    environment:
      - INTERNAL_SUBNET=10.0.251.0
      # Ajouter le subnet docker aux IPs autorisées
      - ALLOWEDIPS=100.64.0.0/10, 10.0.0.0/8, 10.1.0.0/16

  guacamole:
    networks:
      - internal_network

Accès : Les clients VPN peuvent atteindre http://guacamole:8080.

Solution B : NAT / Routing sur l'Hôte

Si WireGuard est en conteneur mais doit accéder à des services sur l'hôte ou d'autres réseaux sans être dans le même bridge.

Activer l'IP Forwarding : 

echo 'net.ipv4.ip_forward=1' | sudo tee /etc/sysctl.d/99-ipforward.conf
sudo sysctl --system

Règles Iptables (PostRouting) : 

# Autoriser le trafic entre l'interface WireGuard (wg0) et Docker (docker0)
sudo iptables -I FORWARD -i wg0 -o docker0 -j ACCEPT
sudo iptables -I FORWARD -i docker0 -o wg0 -m state --state RELATED,ESTABLISHED -j ACCEPT

# Masquerade (NAT) pour le retour des paquets
sudo iptables -t nat -A POSTROUTING -s 10.2.0.0/24 -o docker0 -j MASQUERADE

Proxy & Redirections Spécifiques (Socat / Nginx)

Si le routing est trop complexe, on peut utiliser des "rebonds".

Transmission / Services TCP simples (Socat)

Redirige un port accessible par le VPN vers le service réel. 

  socat-transmission:
    image: alpine/socat
    command: tcp-listen:9091,fork,reuseaddr tcp-connect:172.17.0.1:804
    networks:
      internal-medusa:
        ipv4_address: 10.2.1.25

Redirection de Port UDP (Relais WireGuard)

Pour relayer le port 51820 UDP d'un serveur A vers un serveur B (VPN réel).

Méthode Socat (Mode Host)

  udp-forwarder:
    image: alpine:latest
    network_mode: "host"
    sysctls:
      - net.ipv4.ip_forward=1
    command: >
      sh -c "apk add --no-cache socat && 
      socat -v UDP4-RECVFROM:51820,fork,reuseaddr UDP4-SENDTO:cibleserveur.com:51820"

Méthode Iptables (Plus performant)

Sur le serveur relais : 

# DNAT : Tout ce qui arrive sur 51820 -> renvoyer vers CIBLE
sudo iptables -t nat -A PREROUTING -p udp --dport 51820 -j DNAT --to-destination 10.0.250.2:51820
# SNAT : Modifier l'adresse source pour que le retour passe par le relais
sudo iptables -t nat -A POSTROUTING -p udp -d 10.0.250.2 --dport 51820 -j MASQUERADE

Migration Docker vers Podman (Pod Kubernetes)

Podman permet de faire tourner plusieurs conteneurs dans un seul Pod (partageant localhost).

Exemple Pod YAML (WireGuard + CloudflareDDNS)

apiVersion: v1
kind: Pod
metadata:
  name: wireguard-pod
spec:
  containers:
  - name: cloudflaredyndns
    image: docker.io/oznu/cloudflare-ddns
    env:
    - name: API_KEY
      value: "xxx"
  - name: wireguard
    image: docker.io/lscr.io/linuxserver/wireguard:latest
    securityContext:
      privileged: true
      capabilities:
        add: ["NET_ADMIN", "SYS_MODULE"]
    env:
      - name: PUID
        value: "1000"
    ports:
    - containerPort: 51820
      hostPort: 51820
      protocol: UDP
    volumeMounts:
    - name: config
      mountPath: /config
  volumes:
  - name: config
    hostPath:
      path: /opt/wireguard/config
Lancer avec : podman play kube pod.yaml

Gestion via Systemd (Service)

Pour lancer le Pod au démarrage.

/etc/systemd/system/wireguard-pod.service : 

[Unit]
Description=Wireguard Pod
After=network-online.target
Requires=network-online.target

[Service]
Type=simple
ExecStartPre=-/usr/bin/podman pod rm -f wireguard-pod
ExecStart=/usr/bin/podman play kube /path/to/pod.yaml
ExecStop=/usr/bin/podman pod stop wireguard-pod
Restart=always
RestartSec=60

[Install]
WantedBy=multi-user.target

Client Linux : Démarrage Automatique (via Systemd)

Injecter le fichier de configuration du client dans /etc/wireguard/wg0.conf.

Activez le service pour un démarrage automatique au boot et lancez-le immédiatement : 

sudo systemctl enable --now wg-quick@wg0

Vérifiez l'état de la connexion et du service : ```bash sudo systemctl status wg-quick@wg0 sudo wg show

Maintien de la connexion & Health Check

Si la connexion se perd au bout de quelques jours ou derrière un NAT agressif, plusieurs solutions existent pour stabiliser le tunnel.

1. PersistentKeepalive (Natif)

C'est la méthode recommandée pour maintenir les sessions NAT ouvertes. Ajoutez dans la section [Peer] de votre fichier /etc/wireguard/wg0.conf : 

[Peer]
...
PersistentKeepalive = 25

2. Health Check avec redémarrage automatique

Pour les instances critiques (ex: serveur de backup), on peut mettre en place un script qui vérifie la connectivité et redémarre le service WireGuard en cas d'échec prolongé.

A. Script de vérification (/usr/local/bin/wg-healthcheck.sh) : 

#!/bin/bash

GATEWAY="10.2.0.1" # IP de la passerelle VPN à tester
INTERFACE="wg0"

if ! ping -c 3 -W 5 $GATEWAY > /dev/null 2>&1; then
    echo "$(date): Connexion vers $GATEWAY perdue. Redémarrage de $INTERFACE..."
    systemctl restart wg-quick@$INTERFACE
fi
Rendre le script exécutable : sudo chmod +x /usr/local/bin/wg-healthcheck.sh

B. Service Systemd (/etc/systemd/system/wg-healthcheck.service) : 

[Unit]
Description=WireGuard Health Check
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/wg-healthcheck.sh

C. Timer Systemd (/etc/systemd/system/wg-healthcheck.timer) : Déclenche la vérification toutes les 5 minutes. 

[Unit]
Description=Run WireGuard Health Check every 5 minutes

[Timer]
OnBootSec=5min
OnUnitActiveSec=5min

[Install]
WantedBy=timers.target

D. Activation : 

sudo systemctl daemon-reload
sudo systemctl enable --now wg-healthcheck.timer

Client Windows : Démarrage Automatique

Si le tunnel ne monte pas au démarrage ou s'arrête.

Service Windows (Recommandé) : Plutôt que le gestionnaire de tâches. 

wireguard /installtunnelservice "C:\Path\To\conf.conf"
Cela crée un service Windows qui se lance avant l'ouverture de session.

KeepAlive : Si la connexion se coupe. Ajouter dans la config [Peer] et [Interface] : 

PersistentKeepalive = 25