> 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 un 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 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 un 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, de sorte que 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 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êt le poste client sur lequel vous installerez WireGuard.

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

L’installation varie selon la distribution. Sur 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
```

Sur Ubuntu, la commande de base est :

```bash
sudo apt install wireguard
```

Générez la paire de clés du serveur : la clé privée reste sur le serveur et la clé 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 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 le poste client](https://REEMPLAZA-URL/servidores-howto-wireguard-01.png)

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

Avec WireGuard ouvert, cliquez 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 que cela indique                                                                                            |
| ---------------------- | -------------------------------------------------------------------------------------------------------------- |
| `PrivateKey`           | Clé privée du client                                                                                           |
| `Address`              | IP interne du client dans le tunnel (une plage privée, par ex. `10.0.0.2/32`)                                  |
| `DNS`                  | Serveur DNS du réseau                                                                                          |
| `PublicKey`            | Clé publique du serveur WireGuard                                                                              |
| `AllowedIPs`           | Quel trafic est routé par le VPN. Avec `0.0.0.0/0` tout passe ; avec un sous-réseau précis, seulement celui-ci |
| `Point de terminaison` | 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’IP interne qu’il utilisera dans le tunnel (la même `Address` de l’étape 3).

### Étape 5. Ouvrez 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 bien configuré. Dans l’abonnement de 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 possible, 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 l’origine dès que possible
>
> Restreindre les IP d’origine dans la règle réduit l’exposition par rapport au fait de 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 pair :

```shell
wg show
```

Un `latest handshake` récent et des compteurs de `transfer` qui augmentent indiquent que le tunnel est actif. Depuis le client, vérifiez également que vous sortez avec l’IP publique du serveur.

S’il 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 autorise **UDP 51820**.
* L' `Point de terminaison` pointe vers l’IP publique correcte du serveur.

### Limitations et sécurité

* Ce guide résout la limite de sessions de L2TP lorsque plusieurs utilisateurs partagent un réseau privé derrière un NAT.
* Il ne suffit pas d’installer WireGuard : 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 n’est plus limité à une seule session : chaque utilisateur entre comme son propre pair.

La clé du déploiement repose sur trois éléments qui doivent s’emboîter : les clés correctement croisées entre le client et le serveur, l’enregistrement du pair sur le serveur et le port UDP 51820 ouvert. Pour ajouter davantage de clients, répétez la création 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/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.
