# Installer un VPN sur un VPS Linux : WireGuard vs OpenVPN

**URL:** <https://forum.boxtoplay.com/t/installer-un-vpn-sur-un-vps-linux-wireguard-vs-openvpn/31825>\
**Category:** VPS\
**Tags:** français, vps\
**Created:** [Juillet 19, 2026, 4:57 UTC](https://forum.boxtoplay.com/t/installer-un-vpn-sur-un-vps-linux-wireguard-vs-openvpn/31825 "2026-07-19T16:57:51Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![BoxToPlay-helper](https://forum.boxtoplay.com/user_avatar/forum.boxtoplay.com/boxtoplay-helper/32/5468_2.png) [@BoxToPlay-helper](https://forum.boxtoplay.com/u/BoxToPlay-helper)\
**Post date:** [Juillet 19, 2026, 4:57 UTC](https://forum.boxtoplay.com/t/installer-un-vpn-sur-un-vps-linux-wireguard-vs-openvpn/31825/1 "2026-07-19T16:57:51Z")

</div>

![Installer un VPN sur un VPS Linux : WireGuard vs OpenVPN](https://forum.boxtoplay.com/uploads/default/original/2X/6/6e51cc002e757f3b0a1314162b93e32cda8563a7.jpeg)

## Installer un VPN sur un VPS Linux : WireGuard vs OpenVPN

Transformer un VPS (serveur privé virtuel) en VPN (réseau privé virtuel) permet de sécuriser une connexion depuis un réseau public, d’accéder à certains services internes sans les exposer à tout Internet, ou de faire sortir son trafic depuis l’adresse IP dédiée de son serveur. Le VPN chiffre la connexion entre vos appareils et le VPS, mais il ne vous rend pas anonyme : le trafic rejoint ensuite Internet depuis l’adresse IP du serveur.

Dans ce guide, nous allons voir deux options simples. [WireGuard](https://www.wireguard.com/) est le choix moderne : léger, rapide, intégré au noyau Linux sur les distributions récentes, et très agréable pour un usage quotidien. [OpenVPN](https://openvpn.net/community/) reste le pilier historique : un peu plus lourd, mais très flexible, notamment si vous devez passer par TCP ou par un port très courant comme `443`.

### Quel VPN choisir pour votre VPS ?

Pour un nouveau déploiement, commencez généralement par **WireGuard**. La configuration est plus courte, les performances sont excellentes, et les clients Windows et Linux sont simples à utiliser.

Choisissez **OpenVPN** si vous avez un besoin de compatibilité précis : réseau très filtré, obligation d’utiliser TCP, port imposé, client déjà déployé dans une organisation, ou infrastructure existante à conserver.

En pratique :

- WireGuard est recommandé pour un VPN personnel rapide et moderne.
- OpenVPN est recommandé quand la compatibilité réseau passe avant la simplicité.
- Évitez d’installer les deux sur le même VPS si vous n’en avez pas besoin.

### Prérequis

Avant de commencer, il vous faut :

- un VPS Linux avec accès root ou sudo.
- Ubuntu 24.04 ou une version récente de Debian.
- une adresse IPv4 publique ou un nom de domaine pointant vers le VPS.
- l’accès au pare-feu du VPS et, si votre hébergeur en fournit un, au pare-feu réseau externe.
- un terminal SSH fonctionnel avant toute modification du pare-feu.

Les exemples ci-dessous utilisent `203.0.113.10` comme adresse IP de documentation. Remplacez-la par l’adresse publique de votre VPS.

Les profils ci-dessous acheminent uniquement le trafic IPv4. Si votre appareil utilise IPv6, configurez-le également dans le VPN ou désactivez-le sur cette connexion afin qu’il ne contourne pas le tunnel.

### Préparer le serveur

Connectez-vous au VPS en SSH. Vérifiez que son horloge est synchronisée, car les certificats OpenVPN dépendent d’une date correcte. Activez ensuite le routage IPv4, indispensable pour que le VPS transmette le trafic du VPN vers Internet :

```bash
timedatectl status
sudo tee /etc/sysctl.d/99-vpn-forward.conf > /dev/null <<'EOF'
net.ipv4.ip_forward=1
EOF

sudo sysctl -p /etc/sysctl.d/99-vpn-forward.conf

```

La dernière commande doit afficher `net.ipv4.ip_forward = 1`. Choisissez ensuite le VPN que vous souhaitez installer et suivez uniquement la section correspondante. Les commandes utilisent les paquets d’Ubuntu 24.04 et des versions récentes de Debian. Aucun script d’installation distant n’est téléchargé.

### Installer WireGuard

Installez WireGuard et les commandes de routage utilisées par la configuration :

```bash
sudo apt update
sudo apt install -y wireguard iptables

```

Créez ensuite une paire de clés pour le serveur et une autre pour le premier ordinateur client, ici nommé `client` :

```bash
sudo install -d -m 700 /etc/wireguard
sudo sh -c 'umask 077; wg genkey > /etc/wireguard/server.key'
sudo sh -c 'wg pubkey < /etc/wireguard/server.key > /etc/wireguard/server.pub'
sudo sh -c 'umask 077; wg genkey > /etc/wireguard/client.key'
sudo sh -c 'wg pubkey < /etc/wireguard/client.key > /etc/wireguard/client.pub'

```

Créez l’interface `wg0`. Les règles `PostUp` et `PostDown` autorisent uniquement le transfert du trafic VPN et son NAT vers l’interface réseau principale. Elles ne modifient pas les règles d’entrée ni l’accès SSH.

```bash
WAN_IF=$(ip route show default | awk '{print $5; exit}')
CLIENT_PUBLIC_KEY=$(sudo cat /etc/wireguard/client.pub)

sudo tee /etc/wireguard/wg0.conf > /dev/null <<EOF
[Interface]
Address = 10.66.66.1/24
ListenPort = 51820
PostUp = wg set %i private-key /etc/wireguard/server.key
PostUp = iptables -I FORWARD 1 -i %i -o $WAN_IF -j ACCEPT; iptables -I FORWARD 1 -i $WAN_IF -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT; iptables -t nat -A POSTROUTING -s 10.66.66.0/24 -o $WAN_IF -j MASQUERADE
PostDown = iptables -C FORWARD -i %i -o $WAN_IF -j ACCEPT 2>/dev/null && iptables -D FORWARD -i %i -o $WAN_IF -j ACCEPT || true; iptables -C FORWARD -i $WAN_IF -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT 2>/dev/null && iptables -D FORWARD -i $WAN_IF -o %i -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT || true; iptables -t nat -C POSTROUTING -s 10.66.66.0/24 -o $WAN_IF -j MASQUERADE 2>/dev/null && iptables -t nat -D POSTROUTING -s 10.66.66.0/24 -o $WAN_IF -j MASQUERADE || true

[Peer]
PublicKey = $CLIENT_PUBLIC_KEY
AllowedIPs = 10.66.66.2/32
EOF

sudo chmod 600 /etc/wireguard/wg0.conf

```

Démarrez WireGuard et activez son lancement automatique avec le VPS :

```bash
sudo systemctl enable --now wg-quick@wg0

```

Créez le profil du client Windows ou Linux. La commande vous demande l’adresse IP publique ou le nom DNS du VPS afin d’éviter de laisser une valeur d’exemple dans le fichier :

```bash
SERVER_PUBLIC_KEY=$(sudo cat /etc/wireguard/server.pub)
CLIENT_PRIVATE_KEY=$(sudo cat /etc/wireguard/client.key)
read -rp "Adresse IP publique ou nom DNS du VPS : " VPN_ENDPOINT

install -m 600 /dev/null "$HOME/client.conf"
tee "$HOME/client.conf" > /dev/null <<EOF
[Interface]
PrivateKey = $CLIENT_PRIVATE_KEY
Address = 10.66.66.2/32
DNS = 1.1.1.1, 1.0.0.1

[Peer]
PublicKey = $SERVER_PUBLIC_KEY
Endpoint = $VPN_ENDPOINT:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25
EOF

unset CLIENT_PRIVATE_KEY

```

Le profil `client.conf` se trouve désormais dans votre dossier personnel. Depuis votre ordinateur Windows ou Linux, récupérez-le par SSH, puis importez-le dans l’application WireGuard :

```bash
scp utilisateur@203.0.113.10:client.conf .

```

La commande `scp` s’exécute depuis votre ordinateur. Remplacez `utilisateur` par votre compte SSH et `203.0.113.10` par l’adresse du VPS.

Sur un client Ubuntu ou Debian sans interface graphique, installez aussi `resolvconf` afin que la ligne `DNS` du profil soit appliquée par `wg-quick` :

```bash
sudo apt install wireguard resolvconf
sudo install -m 600 client.conf /etc/wireguard/client.conf
sudo wg-quick up client

```

Après l’import et la sauvegarde chiffrée du profil, supprimez les copies de la clé privée et du profil restées sur le VPS :

```bash
sudo rm -f /etc/wireguard/client.key
rm -f "$HOME/client.conf"

```

Si votre hébergeur applique un pare-feu réseau externe, autorisez `51820/udp` vers le VPS. Si UFW est déjà utilisé localement, vérifiez son état puis ajoutez le port :

```bash
sudo ufw status verbose
sudo ufw allow 51820/udp

```

Si UFW est inactif, ne l’activez pas automatiquement uniquement pour suivre ce guide. Si vous décidez de l’activer, autorisez d’abord le port SSH réellement utilisé. Avec une politique `iptables` existante, l’équivalent temporaire est :

```bash
sudo iptables -C INPUT -p udp --dport 51820 -j ACCEPT 2>/dev/null || sudo iptables -I INPUT -p udp --dport 51820 -j ACCEPT

```

Rendez cette règle persistante avec le mécanisme déjà utilisé sur votre serveur et ne mélangez pas plusieurs gestionnaires de pare-feu.

Un `ufw reload` ou une réinitialisation des règles peut retirer les règles directes de transfert et de NAT. Dans ce cas, redémarrez `wg-quick@wg0` afin de les réappliquer.

Une fois le client connecté, vérifiez le service et le dernier handshake :

```bash
sudo systemctl status wg-quick@wg0 --no-pager
sudo wg show
sudo sysctl net.ipv4.ip_forward

```

Le peer `client` doit afficher un handshake récent. Depuis l’ordinateur connecté, l’adresse IP publique doit correspondre à celle du VPS.

Créez toujours une nouvelle paire de clés et une nouvelle adresse, par exemple `10.66.66.3/32`, pour chaque appareil supplémentaire. Pour révoquer un appareil, supprimez son bloc `[Peer]` de `/etc/wireguard/wg0.conf`, puis rechargez la configuration avec `sudo systemctl restart wg-quick@wg0`. La reconnexion des autres appareils peut prendre quelques secondes après ce redémarrage.

### Installer OpenVPN

Installez OpenVPN et Easy-RSA, puis préparez l’autorité de certification, le certificat du serveur et celui du premier client :

```bash
sudo apt update
sudo apt install -y openvpn easy-rsa iptables
getent group openvpn > /dev/null || sudo groupadd --system openvpn
getent passwd openvpn > /dev/null || sudo useradd --system --gid openvpn --home-dir /nonexistent --shell /usr/sbin/nologin openvpn
sudo install -d -o root -g openvpn -m 750 /etc/openvpn/server
sudo make-cadir /etc/openvpn/easy-rsa
cd /etc/openvpn/easy-rsa

sudo ./easyrsa init-pki
sudo env EASYRSA_REQ_CN=Private-VPN-CA ./easyrsa build-ca
sudo ./easyrsa build-server-full server nopass
sudo ./easyrsa build-client-full client nopass
sudo env EASYRSA_CRL_DAYS=3650 ./easyrsa gen-crl
sudo openvpn --genkey tls-crypt /etc/openvpn/server/tc.key

sudo install -m 600 pki/ca.crt pki/private/server.key /etc/openvpn/server/
sudo install -m 644 pki/issued/server.crt /etc/openvpn/server/
sudo install -o root -g openvpn -m 640 pki/crl.pem /etc/openvpn/server/crl.pem
sudo chmod 600 /etc/openvpn/server/tc.key

```

Easy-RSA vous demande une phrase secrète pour protéger la clé privée de l’autorité de certification. Conservez-la : elle sera nécessaire pour créer ou révoquer des profils. Les clés du serveur et du client restent sans phrase secrète afin que le service et l’application puissent démarrer automatiquement. Le fichier `.ovpn` devra donc être protégé comme une clé privée.

Le compte système dédié `openvpn` limite les privilèges du service. La liste de révocation reste lisible par ce compte, contrairement aux clés privées. Sa validité est fixée à dix ans afin d’éviter l’expiration par défaut après 180 jours, qui ferait échouer les nouvelles connexions. Régénérez-la avant cette échéance et après chaque révocation.

Easy-RSA 3.1.7 génère par défaut les certificats serveur et client pour 825 jours. Vérifiez et notez leurs dates d’expiration dès l’installation :

```bash
sudo openssl x509 -in /etc/openvpn/server/server.crt -noout -enddate
sudo openssl x509 -in /etc/openvpn/easy-rsa/pki/issued/client.crt -noout -enddate

```

Planifiez leur renouvellement avant cette échéance : une CRL encore valide ne prolonge pas un certificat expiré.

Ajoutez un script local chargé uniquement du routage et du NAT OpenVPN. Il sera exécuté par systemd avec les droits nécessaires au démarrage et à l’arrêt du service :

```bash
sudo tee /etc/openvpn/server/network.sh > /dev/null <<'EOF'
#!/bin/sh
WAN_IF=$(ip route show default | awk '{print $5; exit}')
DEV=tun0

case "$1" in
  up)
    iptables -C FORWARD -i "$DEV" -o "$WAN_IF" -j ACCEPT 2>/dev/null || iptables -I FORWARD 1 -i "$DEV" -o "$WAN_IF" -j ACCEPT
    iptables -C FORWARD -i "$WAN_IF" -o "$DEV" -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT 2>/dev/null || iptables -I FORWARD 1 -i "$WAN_IF" -o "$DEV" -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
    iptables -t nat -C POSTROUTING -s 10.8.0.0/24 -o "$WAN_IF" -j MASQUERADE 2>/dev/null || iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o "$WAN_IF" -j MASQUERADE
    ;;
  down)
    iptables -C FORWARD -i "$DEV" -o "$WAN_IF" -j ACCEPT 2>/dev/null && iptables -D FORWARD -i "$DEV" -o "$WAN_IF" -j ACCEPT || true
    iptables -C FORWARD -i "$WAN_IF" -o "$DEV" -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT 2>/dev/null && iptables -D FORWARD -i "$WAN_IF" -o "$DEV" -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT || true
    iptables -t nat -C POSTROUTING -s 10.8.0.0/24 -o "$WAN_IF" -j MASQUERADE 2>/dev/null && iptables -t nat -D POSTROUTING -s 10.8.0.0/24 -o "$WAN_IF" -j MASQUERADE || true
    ;;
  *)
    exit 2
    ;;
esac
EOF

sudo chmod 700 /etc/openvpn/server/network.sh

```

Créez la configuration du serveur sur `1194/udp` :

```bash
sudo tee /etc/openvpn/server/server.conf > /dev/null <<'EOF'
port 1194
proto udp4
dev tun0
ca ca.crt
cert server.crt
key server.key
dh none
tls-crypt tc.key
crl-verify /etc/openvpn/server/crl.pem
server 10.8.0.0 255.255.255.0
topology subnet
push "redirect-gateway def1 bypass-dhcp"
push "dhcp-option DNS 1.1.1.1"
push "dhcp-option DNS 1.0.0.1"
keepalive 10 120
data-ciphers AES-256-GCM:AES-128-GCM:CHACHA20-POLY1305
tls-version-min 1.2
user openvpn
group openvpn
persist-key
persist-tun
explicit-exit-notify 1
verb 3
EOF

sudo install -d /etc/systemd/system/openvpn-server@server.service.d
sudo tee /etc/systemd/system/openvpn-server@server.service.d/firewall.conf > /dev/null <<'EOF'
[Service]
ExecStartPost=/etc/openvpn/server/network.sh up
ExecStopPost=/etc/openvpn/server/network.sh down
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now openvpn-server@server

```

Construisez enfin le profil autonome `client.ovpn` dans votre dossier personnel :

```bash
cd /etc/openvpn/easy-rsa
read -rp "Adresse IP publique ou nom DNS du VPS : " VPN_ENDPOINT
CA_CERT=$(sudo cat pki/ca.crt)
CLIENT_CERT=$(sudo sed -ne '/BEGIN CERTIFICATE/,$ p' pki/issued/client.crt)
CLIENT_KEY=$(sudo cat pki/private/client.key)
TLS_CRYPT_KEY=$(sudo cat /etc/openvpn/server/tc.key)

install -m 600 /dev/null "$HOME/client.ovpn"
tee "$HOME/client.ovpn" > /dev/null <<EOF
client
dev tun
proto udp4
remote $VPN_ENDPOINT 1194
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
verify-x509-name server name
tls-version-min 1.2
data-ciphers AES-256-GCM:AES-128-GCM:CHACHA20-POLY1305
verb 3
<ca>
$CA_CERT
</ca>
<cert>
$CLIENT_CERT
</cert>
<key>
$CLIENT_KEY
</key>
<tls-crypt>
$TLS_CRYPT_KEY
</tls-crypt>
EOF

unset CLIENT_KEY TLS_CRYPT_KEY

```

Copiez ce fichier sur votre ordinateur. Sur Windows ou Linux, importez-le dans OpenVPN Connect avec l’option d’import depuis un fichier.

```bash
scp utilisateur@203.0.113.10:client.ovpn .

```

La commande `scp` s’exécute depuis votre ordinateur. Remplacez `utilisateur` par votre compte SSH et `203.0.113.10` par l’adresse du VPS.

Après l’import et la sauvegarde chiffrée du profil, supprimez les copies de la clé privée et du profil restées sur le VPS. Le certificat public reste dans la PKI afin de pouvoir être révoqué :

```bash
sudo rm -f /etc/openvpn/easy-rsa/pki/private/client.key /etc/openvpn/easy-rsa/pki/inline/client.inline
rm -f "$HOME/client.ovpn"

```

Si votre hébergeur applique un pare-feu réseau externe, autorisez `1194/udp`. Si UFW est déjà utilisé, vérifiez son état puis ajoutez le port :

```bash
sudo ufw status verbose
sudo ufw allow 1194/udp

```

Si UFW est inactif, ne l’activez pas automatiquement uniquement pour suivre ce guide. Avec une politique `iptables` existante, l’équivalent temporaire est :

```bash
sudo iptables -C INPUT -p udp --dport 1194 -j ACCEPT 2>/dev/null || sudo iptables -I INPUT -p udp --dport 1194 -j ACCEPT

```

Rendez cette règle persistante avec le mécanisme déjà utilisé sur votre serveur.

Un `ufw reload` ou une réinitialisation des règles peut retirer les règles directes de transfert et de NAT. Dans ce cas, redémarrez `openvpn-server@server` afin de les réappliquer.

Cette configuration utilise `1194/udp`, le mode recommandé. Si un réseau bloque l’UDP et que vous devez réellement utiliser TCP sur le port `443`, vérifiez d’abord qu’aucun serveur web n’occupe ce port. Remplacez ensuite `port 1194` par `port 443` et `proto udp4` par `proto tcp-server` côté serveur. Dans le profil client, remplacez `proto udp4` par `proto tcp-client`, utilisez `remote $VPN_ENDPOINT 443` et retirez `explicit-exit-notify 1` du serveur. Autorisez enfin `443/tcp` au lieu de `1194/udp` dans les pare-feu. TCP est généralement moins performant que l’UDP et doit rester une solution de compatibilité.

Vérifiez ensuite le service et l’activation du routage :

```bash
sudo systemctl status openvpn-server@server --no-pager
sudo journalctl -u openvpn-server@server -n 50 --no-pager
sudo sysctl net.ipv4.ip_forward

```

Depuis l’ordinateur connecté, l’adresse IP publique doit correspondre à celle du VPS.

Pour révoquer le profil d’un appareil perdu, régénérez la liste de révocation et redémarrez OpenVPN :

```bash
cd /etc/openvpn/easy-rsa
sudo env EASYRSA_BATCH=1 ./easyrsa revoke client
sudo env EASYRSA_BATCH=1 EASYRSA_CRL_DAYS=3650 ./easyrsa gen-crl
sudo install -o root -g openvpn -m 640 pki/crl.pem /etc/openvpn/server/crl.pem
sudo systemctl restart openvpn-server@server

```

### Installer l’application cliente

Le serveur VPN tourne sur votre VPS, mais chaque ordinateur qui se connecte doit aussi avoir une application cliente.

Pour **WireGuard** , installez l’application officielle depuis la page de téléchargement WireGuard :

- Windows et Linux : [wireguard.com/install](https://www.wireguard.com/install/)

Pour **OpenVPN** , le client dépend de votre appareil :

- Windows et Linux : installez gratuitement [OpenVPN Connect](https://openvpn.net/client/). Ce client officiel accepte les profils `.ovpn` générés par OpenVPN Community Edition et ne nécessite aucun abonnement.
- Sur un ordinateur Linux avec NetworkManager, vous pouvez aussi installer `network-manager-openvpn` et importer le profil depuis les paramètres réseau. Cette intégration gère mieux le DNS qu’un simple lancement d’OpenVPN en ligne de commande.

Sur un ordinateur, le principe est simple : vous récupérez le fichier de configuration généré par le VPS, puis vous l’importez dans l’application cliente. WireGuard utilise un fichier `.conf`, OpenVPN utilise un fichier `.ovpn`.

### Bonnes pratiques de sécurité

Un VPN donne accès à votre réseau privé. Traitez donc chaque profil client comme une clé sensible.

- Ne partagez jamais un fichier `.conf` WireGuard ou `.ovpn` OpenVPN publiquement.
- Créez un profil différent par appareil.
- Révoquez immédiatement le profil d’un appareil perdu.
- Supprimez les copies en clair des profils laissées sur le VPS et sur votre ordinateur après leur import, sauf si elles sont conservées dans un stockage chiffré.
- Protégez la phrase secrète et une sauvegarde chiffrée de l’autorité de certification OpenVPN : sa clé privée permet de signer de nouveaux profils.
- Pour un déploiement sensible ou multi-utilisateur, conservez idéalement l’autorité de certification OpenVPN sur une machine séparée et hors ligne.
- Un tunnel complet n’est pas automatiquement un coupe-circuit : activez l’option de blocage hors VPN ou le mode VPN permanent du système client si aucune fuite ne doit être possible lors d’une coupure.
- Gardez SSH ouvert uniquement pour les adresses IP nécessaires quand c’est possible.
- Mettez le VPS à jour régulièrement.
- Conservez une copie de vos profils clients dans un stockage chiffré.

Pour un usage personnel, WireGuard sera souvent la solution la plus simple et la plus agréable. OpenVPN reste utile quand vous devez traverser un réseau restrictif ou conserver une compatibilité existante. Dans les deux cas, un VPS vous donne la liberté d’héberger votre propre passerelle privée, avec vos règles, vos ports et vos accès.

Si vous cherchez un serveur pour déployer ce type de configuration, vous pouvez partir d’un [serveur VPS BoxToPlay](https://www.boxtoplay.com/fr/serveur-vps/location-vps) avec une IP dédiée, un accès root, des sauvegardes et un pare-feu matériel configurable.