> 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/docs-pt/productos/servers-2/how-to/how-to-deploy-a-load-balancer.md).

# Como Implementar um Balanceador de carga

Um balanceador de carga distribui os pedidos entre vários servidores, de modo que nenhum fique sobrecarregado e o serviço se mantenha disponível mesmo que um falhe.

Neste tutorial crias uma regra de balanceamento sobre um pool de pelo menos dois servidores da mesma subscrição.

> #### 👍 O que obténs
>
> Uma regra de balanceamento que publica um serviço num endereço IP público e distribui o tráfego entre os servidores que escolheres.

### Como se enquadra o balanceamento

O tráfego chega a um IP e a uma porta públicos, e o balanceador distribui-o entre os servidores do pool segundo um algoritmo. Para que isto funcione, todos os servidores do pool têm de servir o mesmo: o balanceamento distribui a carga, não sincroniza o conteúdo.

> #### 📘 Distribui carga, não é Alta disponibilidade total
>
> O balanceamento melhora a disponibilidade e absorve picos, mas não torna o teu serviço infalível.&#x20;
>
> Se um servidor do pool servir algo diferente dos restantes, o cliente verá respostas inconsistentes. Mantém o mesmo conteúdo e configuração em todos.

### Antes de começar

* Iniciar sessão na plataforma da Plenit com um utilizador com permissões de administração sobre a organização.
* Ter pelo menos **dois servidores** implementados na mesma subscrição. Podes criar a regra antes de os adicionar e incorporá-los depois.

### Passo 1. Acede a Load Balancers

1. Entra na subscrição de **Servidores** a partir do respetivo cartão.
2. Abre a subseção **Load Balancers** do menu lateral esquerdo.

{/\* 📸 CAPTURA 1 · menu lateral com a subsecção Load Balancers \*/}

![Acesso à subsecção Load Balancers](https://REEMPLAZA-URL/servidores-howto-lb-01.png)

### Passo 2. Cria uma nova regra

Se ainda não houver regras, verás o ecrã inicial para criar uma; se já existirem, verás a lista. Seleciona a **Network** na qual vais criar a regra e clica em **New rule**.

{/\* 📸 CAPTURA 2 · seleção da Network e do botão New rule \*/}

![Criação de uma nova regra de balanceamento numa rede](https://REEMPLAZA-URL/servidores-howto-lb-02.png)

### Passo 3. Configura rede, IP e portas

1. Escolhe a rede com **Selecionar Rede**.
2. Seleciona uma **IP público** das disponíveis para essa rede.
3. Define o **Protocolo** (`TCP` ou `UDP`), o **Public Port** (pelo qual entram os pedidos da Internet, por exemplo `80` ou `443`) e o **Porta privada** (para a qual são reenviados internamente).
4. Clica **Seguinte**.

> #### 🚧 Uma porta, uma única utilização por rede
>
> Dentro da mesma rede, uma porta só pode ser usada uma vez: não pode haver duas regras para a mesma porta no mesmo espaço de rede.

{/\* 📸 CAPTURA 3 · campos Public IP, Protocol, Public Port e Private Port \*/}

![Configuração de IP pública, protocolo e portas](https://REEMPLAZA-URL/servidores-howto-lb-03.png)

### Passo 4. Define que redes terão acesso

Indica a partir de que IPs se pode aceder ao serviço publicado:

* **Any**: acesso a partir de qualquer rede. É a opção menos segura.
* **Specify**: acesso apenas a partir dos IPs ou intervalos que indicares.

Com **Specify**, introduz o IP ou o intervalo permitido (podes adicionar vários) e clica em **Seguinte**.

{/\* 📸 CAPTURA 4 · opção Specify com o IP ou intervalo permitido \*/}

![Definição das redes com acesso ao serviço publicado](https://REEMPLAZA-URL/servidores-howto-lb-04.png)

### Passo 5. Escolhe o algoritmo e a afinidade

Seleciona como os pedidos são distribuídos entre os servidores do pool:

| Algoritmo         | O que faz                                                   | Quando encaixa                                              |
| ----------------- | ----------------------------------------------------------- | ----------------------------------------------------------- |
| Round Robin       | Distribui por turnos, de forma circular                     | Caso geral, servidores equivalentes                         |
| Least connections | Envia cada pedido para o servidor com menos ligações ativas | Pedidos de duração desigual                                 |
| Source            | Atribui de acordo com o IP de origem                        | Quando o mesmo cliente deve ir sempre para o mesmo servidor |

Depois, decide se ativas as **regras de afinidade**. Ativa-as se a aplicação guardar o estado da sessão no próprio servidor e não o partilhar entre máquinas; se o fizeres, preenche **Table size (KB)** e **Expiration(s)**. Clica **Seguinte**.

> 📘 A afinidade mantém o cliente no mesmo servidor
>
> Sem estado partilhado entre servidores, distribuir às cegas pode interromper a sessão de um utilizador a meio da navegação. A afinidade evita isso ao prendê-lo a um servidor, em troca de uma distribuição um pouco menos uniforme.

{/\* 📸 CAPTURA 5 · seleção do algoritmo e da opção de afinidade \*/}

![Seleção do algoritmo de distribuição e da afinidade](https://REEMPLAZA-URL/servidores-howto-lb-05.png)

### Passo 6. Seleciona os servidores do pool

Escolhe as máquinas que responderão aos pedidos. Clica em cada elemento que aparece como **Not selected** e atribui-lhe o IP correspondente. Um servidor corretamente adicionado mostra um visto e o contorno assinalado com a cor da Plenit. Quando terminares, clica em **Create Rule**.

{/\* 📸 CAPTURA 6 · seleção dos servidores do pool com o visto de adicionado \*/}

![Seleção dos servidores que formam o pool do balanceador](https://REEMPLAZA-URL/servidores-howto-lb-06.png)

### Passo 7. Verifica que a regra foi criada

Durante a criação verás uma mensagem do tipo `Servers: Creating Load Balancer ...` e, no final, outra a confirmar que foi criada corretamente. A regra aparece na lista, embora possas ter de atualizar o ecrã.

Para verificar que o serviço responde mesmo, testa o endpoint público a partir do exterior. Em Linux ou macOS:

```bash
curl -I http://<IP-PÚBLICO>:<PORTA-PÚBLICA>
```

No Windows, a partir do PowerShell:

```powershell
Test-NetConnection <IP-PÚBLICO> -Port <PORTA-PÚBLICA>
```

E em cada servidor do pool, confirma que o serviço escuta na porta privada. Em Linux:

```bash
ss -tlnp | grep <PORTA-PRIVADA>
```

No Windows:

```powershell
netstat -ano | findstr <PORTA-PRIVADA>
```

### Se algo não encaixa

| Sintoma                                      | Causa provável                                  | O que fazer                                                  |
| -------------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------ |
| Não permite criar a regra por causa da porta | Essa porta já está em utilização na rede        | Usa outra porta pública ou liberta a existente               |
| O endpoint público não responde              | Nenhum servidor do pool escuta na porta privada | Verifica com `ss` / `netstat` que o serviço está em execução |
| Um utilizador perde a sessão ao navegar      | Distribuição sem estado partilhado              | Ativa a afinidade ou partilha o estado entre servidores      |

### Conclusão

Com isto tens um serviço publicado atrás de um balanceador que distribui o tráfego entre vários servidores, o que suaviza os picos e mantém o serviço mesmo que uma máquina falhe. O balanceamento funciona realmente bem quando o pool é homogéneo e escolhes o algoritmo adequado à tua carga: aí deixas de distribuir pedidos às cegas e começas a distribuir com critério.


---

# 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/docs-pt/productos/servers-2/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.
