> 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-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 disponible même si l'un 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 vous obtenez
>
> Une règle d'équilibrage publiant un service sur une IP publique et répartissant le trafic entre les Serveurs que vous choisissez.

### Comment s'articule l'équilibrage

Le trafic arrive sur une IP et un port publics, et le répartiteur le distribue 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.
>
> 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 Plenit avec un Utilisateur disposant d'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 intégrer ensuite.

### Étape 1. Accédez à Load Balancers

1. Entrez dans l'Abonnement de **Serveurs** depuis sa carte.
2. Ouvrez la sous-section **Load Balancers** dans le menu des serveurs.

<figure><img src="https://2336980375-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxksPMyYRDCe4qKkhbpcY%2Fuploads%2Fgit-blob-b7f21f4a8a9076dfb8340e761f32903177e22b47%2FCAPTURA%201%20y%202%C2%B7%20men%C3%BA%20lateral%20con%20la%20subsecci%C3%B3n%20Load%20Balancers%20y%20network%20con%20new%20rule%20(6).jpg?alt=media" alt=""><figcaption><p>Sous-section Équilibreurs de charge</p></figcaption></figure>

### É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 ; s'il en existe déjà, vous verrez la liste. Sélectionnez la **Réseau** sur lequel vous allez créer la règle et cliquez sur **Nouvelle règle**.

<figure><img src="https://2336980375-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxksPMyYRDCe4qKkhbpcY%2Fuploads%2Fgit-blob-76c5f4a730c361ffb60e380dc636f51eb52ba3f1%2FCAPTURA%201%20y%202%C2%B7%20men%C3%BA%20lateral%20con%20la%20subsecci%C3%B3n%20Load%20Balancers%20y%20network%20con%20new%20rule%20(7).jpg?alt=media" alt="Creación de una nueva regla de balanceo sobre una red"><figcaption><p>Création d'une nouvelle règle d'équilibrage sur un réseau</p></figcaption></figure>

### Étape 3. Configurez le réseau, l'IP et les ports

1. Choisissez le réseau avec **Sélectionner le réseau**.
2. Sélectionnez une **IP publique** des disponibles pour ce réseau.
3. Définissez le **Protocole** (`TCP` ou `UDP`), le **Public Port** (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. Appuie sur **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 réseau.

<figure><img src="https://2336980375-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxksPMyYRDCe4qKkhbpcY%2Fuploads%2Fgit-blob-52396939d55000954e23d7ccfce62da027dfa4b0%2FCAPTURA%203%20%C2%B7%20campos%20Public%20IP%2C%20Protocol%2C%20Public%20Port%20y%20Private%20Port.jpg?alt=media" alt="Configuración de IP, protocolo y puertos"><figcaption><p>Configuration de l'IP, du protocole et des ports</p></figcaption></figure>

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

Indiquez depuis quelles IP l'accès au service publié est autorisé :

* **Any**: accès depuis n'importe quel réseau. C'est l'option la moins sécurisée.
* **Specify**: accès uniquement depuis les IP ou les plages que vous indiquez.

Avec **Specify**, saisissez l'IP ou la plage autorisée (vous pouvez en ajouter plusieurs) et cliquez sur **Suivant**.

<figure><img src="https://2336980375-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxksPMyYRDCe4qKkhbpcY%2Fuploads%2Fgit-blob-f7d9c69c24d9684b74cd17ae5bbab8051929e51e%2FCAPTURA%204%20%C2%B7%20opci%C3%B3n%20Specify%20con%20la%20IP%20o%20rango%20permitido.jpg?alt=media" alt="Definición de las redes con acceso al servicio publicado"><figcaption><p>Définition des réseaux ayant accès au service publié</p></figcaption></figure>

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

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

| Algorithme        | Ce qu’il fait                                                         | Quand cela convient                                            |
| ----------------- | --------------------------------------------------------------------- | -------------------------------------------------------------- |
| Round Robin       | Répartit à tour de rôle, de manière circulaire                        | Cas général, Serveurs équivalents                              |
| Least connections | Envoie chaque requête au serveur ayant le moins de connexions actives | Requêtes de durée inégale                                      |
| Source            | Attribue selon l'IP source                                            | 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 stocke l'état de la session sur le serveur lui-même et ne le partage pas entre machines ; si vous le faites, complétez **Table size (KB)** et **Expiration(s)**. Cliquez **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 parcours. L'affinité l'évite en le liant à un serveur, au prix d'une répartition un peu moins uniforme.

<figure><img src="https://2336980375-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxksPMyYRDCe4qKkhbpcY%2Fuploads%2Fgit-blob-5f2c0f48d24b30f26284a4e56b18da43bda046a3%2FCAPTURA%205%20%C2%B7%20selecci%C3%B3n%20del%20algoritmo%20y%20la%20opci%C3%B3n%20de%20afinidad.jpg?alt=media" alt="Selección del algoritmo de reparto y la afinidad"><figcaption><p>Sélection de l'algorithme de répartition et de l'affinité</p></figcaption></figure>

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

Choisissez les machines qui répondront aux requêtes. Cliquez sur chaque élément affiché comme **Not selected** 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é, cliquez sur **Créer la règle**.

<figure><img src="https://2336980375-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxksPMyYRDCe4qKkhbpcY%2Fuploads%2Fgit-blob-4afd16fc265381462e0f003992caeda4fc6dd625%2FCAPTURA%206%20%C2%B7%20selecci%C3%B3n%20de%20los%20servidores%20del%20pool%20con%20el%20check%20de%20a%C3%B1adido.jpg?alt=media" alt="Selección de los servidores que forman el pool del balanceador"><figcaption><p>Sélection des Serveurs qui forment le pool du répartiteur</p></figcaption></figure>

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

Pendant la création, vous verrez un message du type `Servers: Creating Load Balancer ...` et, à la fin, un autre confirmant qu'elle a été créée correctement. La règle apparaît dans la liste, même si vous devrez peut-être rafraîchir l'Écran.

Pour vérifier que le service répond vraiment, testez le point de terminaison public depuis l'extérieur. Sous Linux ou macOS :

```bash
curl -I http://<IP-PUBLICA>:<PUERTO-PUBLICO>
```

Sous Windows, depuis PowerShell :

```powershell
Test-NetConnection <IP-PUBLICA> -Port <PUERTO-PUBLICO>
```

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

```bash
ss -tlnp | grep <PUERTO-PRIVADO>
```

Sous Windows :

```powershell
netstat -ano | findstr <PUERTO-PRIVADO>
```

### Si quelque chose ne va 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à |
| Le point de terminaison 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 la session lors de la navigation | 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 qui répartit le trafic entre plusieurs Serveurs, ce qui atténue les pics et maintient le service même si une machine tombe en panne. L'équilibrage donne de vrais résultats 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 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-deploy-a-load-balancer.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.
