> 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-1/how-to/how-to-deploy-a-load-balancer.md).

# Comment déployer un Répartiteur de charge

Un Répartiteur de charge répartit les requêtes entre plusieurs Serveurs, de sorte qu’aucun ne soit surchargé et que le service reste debout même si l’un d’eux tombe en panne.

Dans ce tutoriel, vous créez une règle d’équilibrage sur un pool d’au moins deux Serveurs du même Abonnement.

> #### 👍 Ce que tu obtiens
>
> Une règle d’équilibrage publiant un service sur une IP publique et répartissant le trafic entre les Serveurs de votre choix.

### Comment s’intègre l’équilibrage

Le trafic arrive sur une IP et un port publics, et le Répartiteur de charge le répartit entre les Serveurs du pool selon un algorithme. Pour que cela fonctionne, tous les Serveurs du pool doivent fournir la même chose : l’équilibrage distribue la charge, il ne synchronise pas le contenu.

> #### 📘 Répartit la charge, ce n’est pas de la Haute disponibilité totale
>
> L’équilibrage améliore la disponibilité et absorbe les pics, mais il ne rend pas votre service infaillible.&#x20;
>
> Si un Serveur du pool fournit quelque chose de différent des autres, le Client verra des réponses incohérentes. Conservez le même contenu et la même configuration sur tous.

### Avant de commencer

* Se connecter à la plateforme de Plenit avec un Utilisateur disposant des Autorisations d’administration sur l’Organisation.
* Avoir au moins **deux Serveurs** déployés dans le même Abonnement. Vous pouvez créer la règle avant de les ajouter et les incorporer ensuite.

### Étape 1. Accédez à Répartiteurs de charge

1. Entre dans l'abonnement de **Serveurs** depuis sa carte.
2. Ouvre la sous-section **Répartiteurs de charge** du menu latéral gauche.

{/\* 📸 CAPTURE 1 · menu latéral avec la sous-section Répartiteurs de charge \*/}

![Accès à la sous-section Répartiteurs de charge](https://REEMPLAZA-URL/servidores-howto-lb-01.png)

### Étape 2. Créez une nouvelle règle

S’il n’y a pas encore de règles, vous verrez l’Écran initial pour en créer une ; si elles existent déjà, vous verrez la liste. Sélectionnez la **Réseau** sur lequel vous allez créer la règle et appuyez sur **Nouvelle règle**.

{/\* 📸 CAPTURE 2 · sélection du Réseau et du bouton Nouvelle règle \*/}

![Création d’une nouvelle règle d’équilibrage sur un Réseau](https://REEMPLAZA-URL/servidores-howto-lb-02.png)

### Étape 3. Configurez le Réseau, l’IP et les ports

1. Choisissez le Réseau avec **Sélectionnez le réseau**.
2. Sélectionnez une **IP publique** des options disponibles pour ce Réseau.
3. Définissez le **Protocole** (`TCP` ou `UDP`), le **Port public** (par lequel les requêtes arrivent depuis Internet, par exemple `80` ou `443`) et le **Port privé** (vers lequel elles sont redirigées en interne).
4. Clique **Suivant**.

> #### 🚧 Un port, une seule Utilisation par Réseau
>
> Au sein d’un même Réseau, un port ne peut être utilisé qu’une seule fois : il ne peut pas y avoir deux règles pour le même port dans le même espace de Réseau.

{/\* 📸 CAPTURE 3 · champs IP publique, protocole et ports \*/}

![Configuration de l’IP publique, du protocole et des ports](https://REEMPLAZA-URL/servidores-howto-lb-03.png)

### Étape 4. Définissez quels Réseaux auront accès

Indiquez depuis quelles IPs il est possible d’accéder au service publié :

* **Tous**: accès depuis n’importe quel Réseau. C’est l’option la moins sûre.
* **Spécifier**: accès uniquement depuis les IPs ou plages que vous indiquez.

Avec **Spécifier**, saisissez l’IP ou la plage autorisée (vous pouvez en ajouter plusieurs) et appuyez sur **Suivant**.

{/\* 📸 CAPTURE 4 · option Spécifier avec l’IP ou la plage autorisée \*/}

![Définition des Réseaux ayant accès au service publié](https://REEMPLAZA-URL/servidores-howto-lb-04.png)

### Étape 5. Choisissez l’algorithme et l’affinité

Sélectionnez comment les requêtes sont réparties entre les Serveurs du pool :

| Algorithme          | Ce que cela fait                                                      | Quand cela convient                                            |
| ------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------- |
| Round Robin         | Répartit à tour de rôle, de manière circulaire                        | Cas général, Serveurs équivalents                              |
| Moins de connexions | Envoie chaque requête au serveur ayant le moins de connexions actives | Requêtes de durée inégale                                      |
| Source              | Affecte selon l’IP d’origine                                          | Lorsqu’un même Client doit toujours aller vers le même serveur |

Ensuite, décidez si vous activez les **règles d’affinité**. Activez-les si l’application conserve l’état de la session sur le serveur lui-même et ne le partage pas entre machines ; si vous le faites, renseignez **Taille de la table (KB)** et **Expiration(s)**. Clique **Suivant**.

> 📘 L’affinité maintient le Client sur le même serveur
>
> Sans état partagé entre les serveurs, répartir à l’aveugle peut interrompre la session d’un Utilisateur en plein milieu de sa navigation. L’affinité l’évite en l’attachant à un serveur, au prix d’une répartition un peu moins uniforme.

{/\* 📸 CAPTURE 5 · sélection de l’algorithme et de l’option d’affinité \*/}

![Sélection de l’algorithme de répartition et de l’affinité](https://REEMPLAZA-URL/servidores-howto-lb-05.png)

### Étape 6. Sélectionnez les Serveurs du pool

Choisissez les machines qui répondront aux requêtes. Appuyez sur chaque élément qui apparaît comme **Non sélectionné** et attribuez-lui l’IP correspondante. Un serveur correctement ajouté affiche une coche et un contour marqué de la couleur de Plenit. Lorsque vous avez terminé, appuyez sur **Créer la règle**.

{/\* 📸 CAPTURE 6 · sélection des Serveurs du pool avec la coche d’ajout \*/}

![Sélection des Serveurs qui forment le pool du Répartiteur de charge](https://REEMPLAZA-URL/servidores-howto-lb-06.png)

### Étape 7. Vérifiez que la règle a été créée

Pendant la création, vous verrez un message du type `Serveurs : création du Répartiteur de charge ...` et, à la fin, un autre confirmant qu’elle a été créée correctement. La règle apparaît dans la liste, même s’il vous faudra peut-être rafraîchir l’Écran.

Pour vérifier que le service répond réellement, testez l’endpoint public depuis l’extérieur. Sous Linux ou macOS :

```bash
curl -I http://<IP-PUBLIQUE>:<PORT-PUBLIC>
```

Sous Windows, depuis PowerShell :

```powershell
Test-NetConnection <IP-PUBLIQUE> -Port <PORT-PUBLIC>
```

Et sur chaque serveur du pool, confirmez que le service écoute sur le port privé. Sous Linux :

```bash
ss -tlnp | grep <PORT-PRIVÉ>
```

Sous Windows :

```powershell
netstat -ano | findstr <PORT-PRIVÉ>
```

### Si quelque chose ne colle pas

| Symptôme                                     | Cause probable                                   | Que faire                                                      |
| -------------------------------------------- | ------------------------------------------------ | -------------------------------------------------------------- |
| Impossible de créer la règle à cause du port | Ce port est déjà utilisé sur le Réseau           | Utilisez un autre port public ou libérez celui qui existe déjà |
| L’endpoint public ne répond pas              | Aucun serveur du pool n’écoute sur le port privé | Vérifiez avec `ss` / `netstat` que le service est démarré      |
| Un Utilisateur perd sa session en naviguant  | Répartition sans état partagé                    | Activez l’affinité ou partagez l’état entre les Serveurs       |

### Conclusion

Avec cela, vous disposez d’un service publié derrière un Répartiteur de charge qui répartit le trafic entre plusieurs serveurs, ce qui lisse les pics et maintient le service même si une machine tombe en panne. L’équilibrage donne vraiment son plein potentiel lorsque le pool est homogène et que vous choisissez l’algorithme adapté à votre charge : vous cessez alors de répartir les requêtes à l’aveugle et commencez à les répartir avec discernement.


---

# 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-1/how-to/how-to-deploy-a-load-balancer.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.
