> For the complete documentation index, see [llms.txt](https://docs.plenit.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.plenit.com/fr/productos/servers-2/how-to/how-to-configure-wireguard-for-multiple-vpn-connections.md).

# Comment configurer WireGuard pour plusieurs connexions VPN depuis un Réseau privé

Lorsque plusieurs utilisateurs se connectent depuis le même Réseau privé derrière NAT, **L2TP ne prend en charge qu'une session simultanée**.

Dans ce guide, vous installez **WireGuard**, un VPN à tunnel chiffré, pour accepter plusieurs clients à la fois sans les exposer à Internet.

> #### 👍 Ce que tu obtiens
>
> Un serveur WireGuard dans votre Abonnement acceptant plusieurs connexions simultanées depuis un Réseau privé, avec le port ouvert dans le Pare-feu de Plenit.

### Pourquoi WireGuard

L2TP derrière NAT regroupe toutes les connexions d'un même Réseau public en une seule session. WireGuard fonctionne sur UDP et traite **chaque Client comme un pair indépendant** avec sa propre paire de clés, ainsi plusieurs utilisateurs du même Réseau se connectent sans se gêner.&#x20;

Le modèle de clés est comme celui de SSH : chaque extrémité possède une clé privée (qu'elle garde) et une clé publique (qu'elle partage avec l'autre côté).

### Avant de commencer

* Se connecter à la plateforme de Plenit avec une Organisation active.
* Avoir un Abonnement de **Serveurs** ou **Remote Desktop** avec un serveur Linux.
* Avoir préparé l'équipement Client où vous installerez WireGuard.

### Étape 1. Installez WireGuard sur le serveur Linux

L'installation varie selon la distribution. Sous CentOS, avec l'Utilisateur root :

```bash
yum install yum-utils epel-release
yum-config-manager --setopt=centosplus.includepkgs=kernel-plus --enablerepo=centosplus --save
sed -e 's/^DEFAULTKERNEL=kernel$/DEFAULTKERNEL=kernel-plus/' -i /etc/sysconfig/kernel
yum install kernel-plus wireguard-tools
reboot
```

Sous Ubuntu, la commande de base est :

```bash
sudo apt install wireguard
```

Générez la paire de clés du serveur : la privée reste sur le serveur et la publique sera utilisée par les clients.

```bash
wg genkey | tee server_private.key | wg pubkey > server_public.key
```

### Étape 2. Installez le Client

Dans cet exemple, le Client est Windows. Téléchargez l'installateur depuis le site web de WireGuard et exécutez-le en tant qu'administrateur. Si l'installateur principal échoue, utilisez le paquet MSI du Client Windows.

{/\* 📸 CAPTURE 1 · fenêtre de WireGuard après l'installation sur le Client \*/}

![Installation de WireGuard terminée sur l'équipement Client](https://REEMPLAZA-URL/servidores-howto-wireguard-01.png)

### Étape 3. Créez le tunnel sur le Client

Avec WireGuard ouvert, appuyez sur **Add Tunnel → Add empty tunnel…**. Le Client génère sa paire de clés et affiche une configuration initiale que vous complétez avec cette structure :

```bash
[Interface]
PrivateKey = <CLÉ_PRIVÉE_CLIENT>
Address = 10.0.0.2/32
DNS = 192.168.1.1

[Peer]
PublicKey = <CLÉ_PUBLIQUE_SERVEUR>
AllowedIPs = 0.0.0.0/0
Endpoint = <IP_PUBLIQUE_SERVEUR>:51820
```

| Champ                  | Ce qu'il indique                                                                                                   |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `PrivateKey`           | Clé privée du Client                                                                                               |
| `Address`              | IP interne du Client à l'intérieur du tunnel (une plage privée, p. ex. `10.0.0.2/32`)                              |
| `DNS`                  | Serveur DNS du Réseau                                                                                              |
| `Clé publique`         | Clé publique du serveur WireGuard                                                                                  |
| `IPs autorisées`       | Quel trafic est acheminé par le VPN. Avec `0.0.0.0/0` tout passe ; avec un sous-réseau concret, seulement celui-ci |
| `Point de terminaison` | Adresse IP publique et port du serveur (UDP 51820)                                                                 |

{/\* 📸 CAPTURE 2 · configuration du tunnel terminée sur le Client \*/}

![Configuration finale du tunnel sur le Client](https://REEMPLAZA-URL/servidores-howto-wireguard-02.png)

### Étape 4. Enregistre le Client sur le serveur

Le serveur ne laisse passer que les clients qu'il connaît. Ajoutez le Client à la section `[Peer]` de la configuration du serveur, ou à chaud avec :

```bash
wg set wg0 peer <CLAVE_PUBLICA_Client> allowed-ips <IP_INTERNA_Client>
```

Où `<CLÉ_PUBLIQUE_Client>` c'est la clé que le Client a générée et `<IP_INTERNE_CLIENT>` l’adresse IP interne qui sera utilisée dans le tunnel (la même `Address` de l'étape 3).

### Étape 5. Ouvre le port dans le Pare-feu de Plenit

WireGuard écoute sur **UDP 51820**. Sans ce port ouvert, le Client ne se connecte pas même si le tunnel est correctement configuré. Dans l'Abonnement de Serveurs, clique sur **Nouvelle règle** et configure-la :

1. Sélectionne le Réseau par lequel le service se connecte.
2. Définis l'origine des connexions. Si tu peux, filtre les IP autorisées au lieu de les ouvrir à toutes.
3. Protocole **UDP**.
4. Adresse IP publique par laquelle WireGuard se connecte.
5. Port public **51820**.
6. Adresse IP et port privés correspondants.

{/\* 📸 CAPTURE 3 · règle de Pare-feu avec protocole UDP et port 51820 \*/}

![Règle de Pare-feu pour le port UDP 51820 de WireGuard](https://REEMPLAZA-URL/servidores-howto-wireguard-03.png)

> #### 👍 Filtre la source autant que possible
>
> Restreindre les IP sources dans la règle réduit l'exposition par rapport à laisser le port ouvert à tout Internet.

### Étape 6. Valide la connexion

Active le tunnel dans le Client. Sur le serveur, confirme qu'il y a un handshake avec chaque peer :

```shell
wg show
```

Un `dernier handshake` récent et compteurs de `transfert` qui montent indiquent que le tunnel est actif. Depuis le Client, vérifiez également que vous sortez avec l’IP publique du serveur.

Si cela ne se lève pas, vérifiez :

* Les clés publiques du serveur et du Client sont correctement échangées.
* Le Client est enregistré sur le serveur (section `[Peer]` ou `wg set`).
* Le Pare-feu de Plenit permet **UDP 51820**.
* Le `Point de terminaison` pointe vers la bonne IP publique du serveur.

### Limitations et sécurité

* Ce guide résout la limite de sessions L2TP lorsque plusieurs utilisateurs partagent un Réseau privé derrière un NAT.
* Avec WireGuard, il ne suffit pas de l'installer : il faut enregistrer chaque Client sur le serveur et ouvrir le port UDP 51820.
* Avec `AllowedIPs = 0.0.0.0/0`, tout le trafic du client passe par le VPN.
* Filtrer l'origine dans le Pare-feu réduit la surface d'exposition.

### Conclusion

Avec WireGuard en place, un Réseau privé derrière un NAT cesse d'être limité à une seule session : chaque utilisateur entre comme un peer propre.

La clé du déploiement repose sur trois éléments qui doivent s'emboîter : les clés correctement croisées entre Client et serveur, l'enregistrement du peer sur le serveur et le port UDP 51820 ouvert. Pour ajouter d'autres Clients, répète l'enregistrement du tunnel sur le Client (Étape 3) et son enregistrement sur le serveur (Étape 4).

<br>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.plenit.com/fr/productos/servers-2/how-to/how-to-configure-wireguard-for-multiple-vpn-connections.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
