> 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/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 seule 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 vous obtenez
>
> Un serveur WireGuard dans votre Abonnement acceptant plusieurs connexions simultanées depuis un Réseau privé, avec le port ouvert sur 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 peer indépendant** avec sa propre paire de clés, de sorte que plusieurs Utilisateurs du même Réseau se connectent sans se gêner.

Le modèle de clés est comme celui de SSH : chaque extrémité a une clé privée (qu'elle conserve) 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é la machine Client où vous installerez WireGuard.

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

L'installation varie selon la distribution. Dans 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'ordinateur Client](https://reemplaza-url/servidores-howto-wireguard-01.png)

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

Avec WireGuard ouvert, cliquez sur **Ajouter un tunnel → Ajouter un tunnel vide…**. 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>
Adresse = 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                                                                                              |
| `Adresse`    | IP interne du Client dans le tunnel (un Réseau privé, p. ex. `10.0.0.2/32`)                                       |
| `DNS`        | Serveur DNS du Réseau                                                                                             |
| `PublicKey`  | Clé publique du serveur WireGuard                                                                                 |
| `AllowedIPs` | Quel trafic est acheminé via le VPN. Avec `0.0.0.0/0` tout passe ; avec un sous-réseau précis, seulement celui-là |
| `Endpoint`   | IP publique et port du serveur (UDP 51820)                                                                        |

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

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

### Étape 4. Enregistrez 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 <CLÉ_PUBLIQUE_CLIENT> allowed-ips <IP_INTERNE_CLIENT>
```

Où `<CLÉ_PUBLIQUE_CLIENT>` est la clé générée par le Client et `<IP_INTERNE_CLIENT>` l'adresse IP interne qu'il utilisera dans le tunnel (la même `Adresse` qu'à l'Étape 3).

### Étape 5. Ouvrez le port sur 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 bien configuré. Dans l'Abonnement des Serveurs, cliquez sur **Nouvelle règle** et configurez-la :

1. Sélectionnez le Réseau par lequel le service se connecte.
2. Définissez l'origine des connexions. Si vous le pouvez, filtrez les IP autorisées au lieu de les ouvrir à toutes.
3. Protocole **UDP**.
4. IP publique par laquelle WireGuard se connecte.
5. Port public **51820**.
6. 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)

> #### 👍 Filtrez toujours l'origine si vous le pouvez
>
> Restreindre les IP sources dans la règle réduit l'exposition par rapport à laisser le port ouvert à tout Internet.

### Étape 6. Validez la connexion

Activez le tunnel sur le Client. Sur le serveur, confirmez qu'il y a un handshake avec chaque peer :

```shell
wg show
```

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

Si ça ne démarre pas, vérifiez :

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

### Limites et sécurité

* Ce guide résout la limite de sessions de L2TP lorsque plusieurs Utilisateurs partagent un Réseau privé derrière NAT.
* WireGuard ne suffit pas à 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 déployé, un Réseau privé derrière NAT n'est plus limité à une seule session : chaque Utilisateur se connecte comme un peer propre.

La clé du déploiement tient en trois pièces qui doivent s'assembler : les clés correctement croisées entre le Client et le serveur, l'enregistrement du peer sur le serveur et le port UDP 51820 ouvert. Pour ajouter d'autres Clients, répétez 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
