Self-host VPN sur Raspberry Pi 5 : guide WireGuard complet 2026

Un Raspberry Pi 5 8 GB fait un excellent serveur WireGuard always-on. Attends-toi à un débit de l'ordre de ton upload domestique (souvent ~80 Mbps), une consommation autour de 6-8W, et un coût total sur 5 ans inférieur à un seul abonnement NordVPN annuel. Ce guide donne toutes les commandes, dans l'ordre, sans omission.

Pour savoir si un Pi 5 est le bon choix vs un VPS cloud ou Tailscale, commence par notre comparatif des meilleures solutions VPN auto-hébergées 2026.

Pourquoi Raspberry Pi 5 pour un VPN maison

Un Raspberry Pi 5 à 80 € vs un VPS à 5 €/mois - l'amortissement est atteint en 16 mois. Après, c'est du bénéfice pur moins 10-12 €/an d'électricité.

Mais ce n'est pas que le prix. Les raisons concrètes qui font choisir un Pi plutôt qu'un VPS :

• Contrôle total du hardware et des logs - Rien ne sort de ta maison. Un VPS, même chiffré, implique un prestataire qui gère le hyperviseur.
• LAN access natif - Depuis ta connexion VPN, tu accèdes à tes NAS, imprimantes, caméras IP directement par IP locale. Impossible avec un VPS.
• Co-installation Pi-hole - Blocage publicités DNS pour tous tes appareils mobiles, partout dans le monde. Une liste de blocage classique élimine une part significative des requêtes DNS (le chiffre exact s'affiche sur le dashboard Pi-hole).
• Apprentissage réseau concret - La meilleure façon de comprendre NAT, IP forwarding, PKI et WireGuard, c'est de tout configurer soi-même.

Les limites honnêtes : tu es dépendant de la connexion et de l'électricité à domicile. Pour un VPN critique en déplacement professionnel, voir la section maintenance.

Matériel nécessaire

Voici une configuration matérielle typique pour ce montage, avec des prix EUR indicatifs début 2026 :

Pourquoi 8 GB de RAM ? Si tu co-installes Pi-hole + éventuellement un serveur Nextcloud ou Home Assistant, le 4 GB peut être juste. Avec 8 GB, tu es tranquille pour 3 ans d'évolution du setup.

Pourquoi l'alimentation officielle 27W ? Le Pi 5 sous charge VPN + Pi-hole peut tirer jusqu'à 12W sur le rail USB-C. Une alimentation 15W cheap entraîne des throttling CPU silencieux (undervoltage). L'officielle garantit une tension stable.

Ethernet obligatoire : ne mets jamais un serveur VPN sur WiFi. La latence supplémentaire (2-5 ms) et les micro-déconnexions WiFi rendent le tunnel instable. Câble direct sur la box.

Setup OS - Raspberry Pi OS 64-bit

Flash de la carte

1. Télécharger Raspberry Pi Imager (Windows/Mac/Linux)
2. Sélectionner Raspberry Pi OS Lite 64-bit (Bookworm - Debian 12) - pas besoin de desktop
3. Cliquer sur la roue crantée (options avancées) :
   • Hostname : vpn-pi
   • Activer SSH : clé publique (coller ta clé ~/.ssh/id_ed25519.pub)
   • Username : eric (pas pi, qui est désactivé par défaut depuis 2022)
   • Locale : Europe/Paris, clavier fr
4. Flasher sur la microSD. Insérer dans le Pi, brancher Ethernet, démarrer.

Premier accès SSH et IP statique

# Depuis ton Mac/PC, trouver l'IP du Pi sur le réseau local
ssh eric@vpn-pi.local

# IP statique dans /etc/dhcpcd.conf
sudo nano /etc/dhcpcd.conf

Ajouter en fin de fichier :

interface eth0
static ip_address=192.168.1.10/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1

sudo reboot
# Reconnexion sur IP fixe :
ssh eric@192.168.1.10

Firewall UFW

sudo apt install -y ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp          # SSH (à changer si tu modifies le port)
sudo ufw allow 51820/udp       # WireGuard
sudo ufw enable
sudo ufw status verbose

Installation WireGuard

Packages et génération des clés

sudo apt update && sudo apt upgrade -y
sudo apt install -y wireguard qrencode

# Génération des clés serveur
wg genkey | sudo tee /etc/wireguard/server_private.key | wg pubkey | sudo tee /etc/wireguard/server_public.key
sudo chmod 600 /etc/wireguard/server_private.key

# Afficher les clés
SERVER_PRIVKEY=$(sudo cat /etc/wireguard/server_private.key)
SERVER_PUBKEY=$(sudo cat /etc/wireguard/server_public.key)
echo "Privée: $SERVER_PRIVKEY"
echo "Publique: $SERVER_PUBKEY"

Configuration du serveur wg0.conf

sudo nano /etc/wireguard/wg0.conf

[Interface]
Address = 10.8.0.1/24
ListenPort = 51820
PrivateKey = <SERVER_PRIVKEY>

# NAT - remplace eth0 par ton interface (vérifier avec: ip route | grep default)
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

IP Forwarding et démarrage

# Activer le forwarding IP
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Démarrer WireGuard
sudo systemctl enable --now wg-quick@wg0
sudo wg show  # doit afficher l'interface wg0 active

Configuration réseau - box, DuckDNS, MTU

Port forwarding sur la box

Chaque FAI a son interface. Les deux FAI les plus courants :

Freebox (Révolution/Ultra) : http://mafreebox.freebox.fr → Paramètres → Mode avancé → Réseau → Port forwarding. Ajouter : IP source = 192.168.1.10, protocole UDP, port externe 51820, port interne 51820.

Livebox Orange : http://192.168.1.1 → Réseau → NAT/PAT → Nouvelle règle. Même configuration.

Tester depuis un autre réseau (4G mobile) : nc -zvu TON_IP_PUBLIQUE 51820.

DuckDNS - DNS dynamique gratuit

# Créer un compte sur duckdns.org, noter ton token
# Créer le script de mise à jour
mkdir -p ~/duckdns
cat > ~/duckdns/duck.sh <&lt; 'EOF'
#!/bin/bash
echo url="https://www.duckdns.org/update?domains=monvpn&token=TON_TOKEN&ip=" | curl -k -o ~/duckdns/duck.log -K -
EOF
chmod +x ~/duckdns/duck.sh

# Cron toutes les 5 minutes
(crontab -l 2>/dev/null; echo "*/5 * * * * ~/duckdns/duck.sh >/dev/null 2>&1") | crontab -

Optimisation MTU

Par défaut WireGuard utilise MTU 1420. Si tu vois des paquets fragmentés :

# Test fragmentation
ping -M do -s 1392 8.8.8.8

# Si ça échoue, ajouter dans [Interface] du wg0.conf côté serveur :
# MTU = 1380

Pour le détail complet des templates WireGuard et des cas MTU, consulte notre guide des templates de configuration WireGuard.

Setup clients - Mac, Windows, iOS, Android

Générer une config client

# Côté serveur, pour chaque client :
CLIENT_PRIVKEY=$(wg genkey)
CLIENT_PUBKEY=$(echo $CLIENT_PRIVKEY | wg pubkey)

cat <&lt; EOF
[Interface]
PrivateKey = $CLIENT_PRIVKEY
Address = 10.8.0.2/32
DNS = 10.8.0.1

[Peer]
PublicKey = $SERVER_PUBKEY
Endpoint = monvpn.duckdns.org:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
EOF

Ajouter le client dans le serveur :

sudo wg set wg0 peer $CLIENT_PUBKEY allowed-ips 10.8.0.2/32
sudo wg-quick save wg0  # persiste la config

QR Code pour iOS et Android

# Sauvegarder la config client dans un fichier
cat > /tmp/client1.conf <&lt; 'EOF'
[Interface]
PrivateKey = CLIENT_PRIVKEY_ICI
Address = 10.8.0.2/32
DNS = 10.8.0.1

[Peer]
PublicKey = SERVER_PUBKEY_ICI
Endpoint = monvpn.duckdns.org:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
EOF

# Afficher le QR code dans le terminal
qrencode -t ansiutf8 &lt; /tmp/client1.conf

# Supprimer après scan (ne pas laisser trainer les clés privées)
rm /tmp/client1.conf

Scanner avec l'app WireGuard officielle (iOS App Store / Google Play). La connexion s'établit en <2 secondes.

macOS et Windows : télécharger l'app WireGuard officielle, importer le fichier .conf directement.

Pour comparer avec l'alternative Tailscale qui supprime toute cette config manuelle, lire le guide exit node Tailscale. Et pour creuser les différences Cloudflare WARP vs ton setup Pi, voir WARP vs WireGuard self-host.

Optimisations et maintenance

Auto-update non-supervisé

sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure --priority=low unattended-upgrades
# Choisir "Oui" pour activer les mises à jour de sécurité automatiques

Monitoring avec journalctl

# Logs WireGuard en temps réel
sudo journalctl -u wg-quick@wg0 -f

# Voir les peers connectés et leurs stats
sudo wg show

# Trafic par peer (bytes reçus/envoyés)
sudo wg show all dump

fail2ban contre les scans SSH

sudo apt install -y fail2ban

cat | sudo tee /etc/fail2ban/jail.local <&lt; 'EOF'
[sshd]
enabled = true
port = 22
maxretry = 3
bantime = 3600
findtime = 600
EOF

sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd

Backup de la config WireGuard

# Backup hebdomadaire automatique sur clé USB ou NAS local
cat | crontab -l | { cat; echo "0 3 * * 0 sudo cp -r /etc/wireguard ~/backup/wg-$(date +%Y%m%d)"; } | crontab -

Swap si 4 GB de RAM

Si tu utilises le modèle 4 GB avec Pi-hole + WireGuard actifs :

sudo dphys-swapfile swapoff
sudo nano /etc/dphys-swapfile  # Modifier CONF_SWAPSIZE=1024
sudo dphys-swapfile setup
sudo dphys-swapfile swapon

Surveiller la température

Avec un boîtier passif type Argon NEO 5, un Pi 5 reste typiquement dans les 40 °C sous charge VPN + Pi-hole. Sans boîtier il chauffe bien plus - le throttling CPU commence à 80°C, donc un dissipateur ou un boîtier est recommandé.

# Température en temps réel
watch -n 2 vcgencmd measure_temp

Pour une vue complète de la configuration réseau avancée dont tu auras besoin si tu fais tourner plusieurs clients simultanément, voir notre guide VPN Contabo avec WireGuard en setup multi-clients - les concepts NAT sont identiques sur Pi.

À quoi s'attendre : un débit de l'ordre de ton upload domestique, une latence ajoutée de quelques millisecondes côté LAN, une consommation de ~6-8W, et une bonne sécurité avec fail2ban et SSH par clé. Un point à anticiper : une coupure électrique à la maison fait tomber le tunnel - un petit onduleur (ex. APC 500VA) le maintient pendant les micro-coupures.

Pour connecter vos pairs rapidement, notre générateur de configuration WireGuard gratuit construit une config serveur et client cohérente dans votre navigateur, prête à déposer sur le Pi.