CS Fundamentals Trainer · Guias
Balanceamento de carga
Camada 4 versus camada 7, uma simulação de aleatório, round robin, menos conexões e power of two choices, health checks, draining e sticky sessions.
13 min de leitura
Um load balancer fica na frente de vários servidores idênticos e distribui as requisições recebidas entre eles. Ele dá três coisas ao mesmo tempo: mais capacidade do que uma máquina, disponibilidade (um servidor morto deixa de receber tráfego) e liberdade para fazer deploys (tire os servidores um a um). A parte interessante é a escolha de qual servidor recebe cada requisição, e como o balanceador sabe quais servidores estão saudáveis. Este guia inclui uma simulação, para que as diferenças entre as políticas venham com números em vez de adjetivos.
1. Onde ele fica e o que faz
Diagram: A load balancer in front of three servers, with health checks
Seus trabalhos: escolher um backend para cada requisição ou conexão, parar de enviar tráfego a backends não saudáveis e, muitas vezes, também terminar o TLS, comprimir, limitar a taxa e adicionar cabeçalhos (veja o guia de TLS). O próprio balanceador não pode ser um ponto único de falha, então na prática há dois ou mais, compartilhando um endereço ou atrás de DNS (seção 8).
2. Camada 4 ou camada 7
| Camada 4 (transporte) | Camada 7 (aplicação) | |
|---|---|---|
| Decide usando | Endereços IP e portas | A requisição HTTP: host, caminho, cabeçalhos, cookies |
| Vê o conteúdo | não | sim |
| Custo | muito baixo (encaminha pacotes ou conexões) | mais alto (interpreta requisições, muitas vezes termina o TLS) |
Pode rotear /api e /images de forma diferente | não | sim |
| Pode repetir uma requisição que falhou em outro servidor | só no momento da conexão | sim, por requisição |
| Exemplos | AWS Network Load Balancer, HAProxy em modo TCP, IPVS | NGINX, Envoy, HAProxy em modo HTTP, AWS Application Load Balancer |
Um arranjo comum usa os dois: um balanceador de camada 4 distribui conexões por um pool de proxies de camada 7, que roteiam para os serviços. Um detalhe importa para a camada 7 e o HTTP/2: um cliente mantém uma conexão longa e multiplexa muitas requisições nela, então um balanceador de camada 4 que balanceia conexões pode mandar todas as requisições de um cliente ocupado para um só servidor. Para tráfego gRPC e HTTP/2, balanceie por requisição na camada 7.
3. Escolhendo o backend
Aqui estão as quatro políticas que você deve conhecer, e depois uma simulação que as compara.
- Aleatório (random): escolha qualquer servidor. Nenhum estado.
- Round robin: percorra os servidores em ordem. (O round robin ponderado dá uma fatia maior aos servidores maiores.)
- Menos conexões (least connections): envie ao servidor com menos requisições em andamento. Exige uma contagem por servidor.
- Power of two choices (p2c): escolha dois servidores ao acaso e envie a requisição àquele com menos requisições em andamento. Para bolas jogadas em caixas, Azar, Broder, Karlin e Upfal mostraram que escolher a mais vazia entre duas caixas aleatórias reduz a caixa mais cheia de aproximadamente log n / log log n para log log n [1]. Mitzenmacher mostrou que a mesma ideia funciona para servidores com filas, onde reduz drasticamente o tempo de espera em comparação com uma única escolha aleatória [2]. O Nginx a tem embutida como
random two least_conn[3].
Mais duas são usadas por outro motivo:
- Hash de IP ou de chave: o mesmo cliente (ou a mesma chave) vai para o mesmo servidor, o que ajuda quando os servidores guardam um cache local ou uma sessão em memória. Use consistent hashing para que adicionar um servidor mova poucas chaves.
- Ponderado / baseado em latência: prefira servidores mais rápidos ou maiores, medidos pelos tempos de resposta recentes.
O que a simulação mostra
Escrevi uma pequena simulação: 10 servidores, cada um atendendo uma requisição por vez com uma fila por ordem de chegada; as requisições chegam ao acaso, de modo que os servidores ficam 90 % ocupados em média; 200 000 requisições. Os tempos estão em unidades do tempo médio de serviço (1,0). Rodei com três tipos de requisição, todos com a mesma média de 1,0: tamanhos exatamente iguais; tamanhos com distribuição exponencial (o modelo clássico dos livros: muitas requisições curtas, algumas longas); e de cauda pesada (90 % de requisições curtas, 10 % cerca de onze vezes mais longas).
| Política | Tamanhos iguais: média / p99 | Tamanhos exponenciais: média / p99 | Cauda pesada: média / p99 |
|---|---|---|---|
| Aleatório | 5,7 / 23,1 | 10,3 / 45,1 | 25,4 / 118,7 |
| Round robin | 1,4 / 3,2 | 5,3 / 23,7 | 27,3 / 133,1 |
| Menos conexões | 1,4 / 3,0 | 1,9 / 7,7 | 3,6 / 27,2 |
| Power of two choices | 1,9 / 4,2 | 3,0 / 10,3 | 6,3 / 34,9 |
(Medianas de cinco execuções com sementes aleatórias diferentes, em unidades do tempo médio de uma requisição. A simulação é um modelo, não um benchmark de nenhum balanceador real: todos os servidores são idênticos, não há atraso de rede e a carga é alta de propósito para que as diferenças apareçam.)
O que tirar disso:
- O aleatório é ruim com carga alta: por acaso alguns servidores recebem uma sequência de requisições enquanto outros ficam parados.
- O round robin só é excelente quando as requisições são realmente parecidas. Com tamanhos exatamente iguais, é tão bom quanto menos conexões (1,4 contra 1,4) e melhor que o power of two choices (1,9), e não precisa de estado. Assim que os tamanhos variam, ele fica para trás: com tamanhos exponenciais é cerca de três vezes pior que menos conexões, e com cauda pesada não é melhor que o aleatório (27,3 contra 25,4). Quantidades iguais de requisições não são trabalho igual: um servidor que sorteia algumas requisições longas fica para trás enquanto o rodízio continua alimentando-o.
- Olhar a carga real vence quando os tamanhos variam. Menos conexões é várias vezes melhor que o aleatório e o round robin nas duas últimas colunas, e não é pior na primeira.
- O tráfego real não tem tamanhos iguais. As requisições diferem em custo, e os servidores diferem em velocidade e no quanto estão ocupados com outros trabalhos, então a coluna de tamanhos iguais é a exceção.
- O power of two choices obtém a maior parte desse benefício comparando apenas dois servidores. Isso importa em escala: menos conexões exige contagens exatas e atualizadas de todos os servidores, o que é incômodo quando há muitos balanceadores vendo cada um parte do tráfego. O p2c só precisa das contagens dos dois que escolhe, e contagens desatualizadas o prejudicam menos.
4. Health checks
Um balanceador precisa parar de enviar requisições a um servidor que caiu e voltar a enviar quando ele se recupera.
- Passivo: observe o tráfego real. Depois de N falhas ou timeouts seguidos, marque o servidor como fora por um tempo (um circuit breaker para um único backend).
- Ativo: o balanceador chama um endpoint em cada servidor, por exemplo
GET /healthza cada 5 segundos, e exige, digamos, 2 falhas para marcá-lo como fora e 3 sucessos para marcá-lo como no ar (a histerese evita oscilações).
O que o endpoint de verificação deve testar é uma decisão de design:
- Uma verificação de liveness diz "o processo está rodando". Falhar significa me reinicie.
- Uma verificação de readiness diz "posso atender tráfego agora" (aquecido, consegue alcançar o banco de dados). Falhar significa me tire da rotação, mas não me reinicie.
- Uma verificação de saúde que consulta o banco de dados fundo a cada poucos segundos em cada servidor acrescenta carga, e se o banco estiver lento todos os servidores falham na verificação ao mesmo tempo e o balanceador remove a frota inteira. Prefira verificações baratas e decida deliberadamente o que acontece quando tudo parece não saudável (a maioria dos balanceadores continua enviando tráfego mesmo assim, o que costuma ser melhor que nenhum).
Outros comportamentos que acompanham isso:
- Slow start: aumente a carga de um servidor novo ou recuperado gradualmente, para que um cache frio e pools de conexão frios não recebam a carga total.
- Connection draining: ao retirar um servidor para um deploy, pare as novas requisições, mas deixe as que estão em andamento terminarem.
- Retries: repita uma requisição que falhou em outro servidor apenas se for seguro repeti-la (idempotente), e limite as repetições, senão um sistema em dificuldade recebe mais carga justamente quando menos pode suportar. Veja o guia do rate limiter para proteger um serviço contra sobrecarga.
5. Sessões e roteamento sticky
Se cada servidor guarda a sessão de um usuário na própria memória, a segunda requisição precisa ir para o mesmo servidor ("sticky sessions", feitas por um cookie ou por hash do cliente). O custo: a carga fica menos uniforme e, quando esse servidor morre, as sessões se perdem.
A resposta melhor, em geral, é manter os servidores sem estado: ponha a sessão em um armazenamento compartilhado (Redis, um banco de dados) ou em um token assinado que o cliente guarda, para que qualquer servidor possa atender qualquer requisição. Assim o balanceador pode usar qualquer política e os servidores podem entrar e sair livremente.
6. Exemplo de configuração
A mesma ideia em duas ferramentas reais (os nomes exatos das opções estão na documentação de cada ferramenta [3][4]).
# NGINX: least connections, with passive health checking and a backup server
upstream app {
least_conn;
server 10.0.0.11:8080 max_fails=3 fail_timeout=10s;
server 10.0.0.12:8080 max_fails=3 fail_timeout=10s;
server 10.0.0.13:8080 backup;
}
server {
listen 80;
location / {
proxy_pass http://app;
proxy_next_upstream error timeout http_502 http_503; # retries; only safe for idempotent requests
proxy_next_upstream_tries 2;
}
}
# HAProxy: HTTP mode, active checks, two choices
backend app
balance random(2) # power of two choices
option httpchk GET /healthz
default-server inter 5s fall 2 rise 3 slowstart 30s
server s1 10.0.0.11:8080 check
server s2 10.0.0.12:8080 check
server s3 10.0.0.13:8080 check
7. A política em código
Selecionar um servidor são poucas linhas. Aqui está o power of two choices com uma contagem de requisições em andamento por servidor (escolha uma linguagem nas abas; sua escolha é lembrada):
import random
class Pool:
def __init__(self, servers):
self.servers = list(servers)
self.inflight = {s: 0 for s in self.servers}
def pick(self):
if len(self.servers) == 1:
return self.servers[0]
a, b = random.sample(self.servers, 2) # two distinct servers
return a if self.inflight[a] <= self.inflight[b] else b
def start(self):
s = self.pick()
self.inflight[s] += 1
return s
def finish(self, s):
self.inflight[s] -= 1
type Pool struct {
mu sync.Mutex
servers []string
inflight map[string]int
}
func (p *Pool) Start() string {
p.mu.Lock()
defer p.mu.Unlock()
a := p.servers[rand.IntN(len(p.servers))]
b := p.servers[rand.IntN(len(p.servers))] // may equal a; with many servers that is rare
s := a
if p.inflight[b] < p.inflight[a] {
s = b
}
p.inflight[s]++
return s
}
func (p *Pool) Finish(s string) {
p.mu.Lock()
p.inflight[s]--
p.mu.Unlock()
}
class Pool {
constructor(servers) {
this.servers = [...servers];
this.inflight = new Map(this.servers.map((s) => [s, 0]));
}
start() {
const a = this.servers[Math.floor(Math.random() * this.servers.length)];
const b = this.servers[Math.floor(Math.random() * this.servers.length)];
const s = this.inflight.get(b) < this.inflight.get(a) ? b : a;
this.inflight.set(s, this.inflight.get(s) + 1);
return s;
}
finish(s) {
this.inflight.set(s, this.inflight.get(s) - 1);
}
}
public class Pool
{
private readonly string[] _servers;
private readonly Dictionary<string, int> _inflight;
private readonly object _lock = new();
public Pool(IEnumerable<string> servers)
{
_servers = servers.ToArray();
_inflight = _servers.ToDictionary(s => s, _ => 0);
}
public string Start()
{
lock (_lock)
{
var a = _servers[Random.Shared.Next(_servers.Length)];
var b = _servers[Random.Shared.Next(_servers.Length)];
var s = _inflight[b] < _inflight[a] ? b : a;
_inflight[s]++;
return s;
}
}
public void Finish(string s)
{
lock (_lock) { _inflight[s]--; }
}
}
Chame sempre finish em um bloco finally, senão uma requisição que falha deixa a contagem alta para sempre.
8. Tornando o próprio balanceador altamente disponível
- Dois balanceadores, um endereço: um ativo e um standby compartilham um IP virtual que se move na falha (VRRP, usado pelo keepalived), ou ambos ficam ativos atrás de roteamento de custo igual.
- DNS: devolva vários endereços de balanceador ou use um balanceador de nuvem, que já é um serviço gerenciado e multizona. O cache de DNS significa que uma mudança leva o TTL do registro para chegar aos clientes (veja o que acontece quando você digita uma URL).
- Balanceamento global: o DNS ou o roteamento anycast envia os usuários para a região mais próxima, e cada região tem seus próprios balanceadores.
- Capacidade: o balanceador também tem limites (conexões, largura de banda, handshakes TLS por segundo). Meça-os.
9. Erros comuns
- Balancear pela contagem de requisições com custo desigual. A simulação mostra por que menos conexões ou p2c é melhor.
- Uma verificação de saúde forte ou fraca demais. Forte demais tira tudo junto; fraca demais (só "porta aberta") mantém um servidor quebrado.
- Repetir requisições não idempotentes, de modo que um pagamento é feito duas vezes.
- Retries sem limite ou orçamento, que transformam uma queda parcial em total.
- Guardar estado na memória de um único servidor e depois precisar de sticky sessions para sempre.
- Esquecer o endereço real do cliente. Atrás de um balanceador, o servidor vê o IP do balanceador. Leia o
X-Forwarded-Forou o protocolo PROXY, e confie nele apenas vindo do seu próprio balanceador. - Sem connection draining, de modo que os deploys cortam requisições em andamento.
10. Coisas a mencionar em uma entrevista
- Diga o que um balanceador dá: capacidade, disponibilidade, deploys seguros.
- Compare a camada 4 e a camada 7 e diga quando precisa de cada uma.
- Conheça as políticas e explique por que o round robin falha quando as requisições diferem e por que duas escolhas aleatórias vencem tanto o aleatório.
- Cubra health checks (ativos e passivos), draining, slow start.
- Mantenha os servidores sem estado; use sticky sessions só quando precisar.
- Lembre que o balanceador é, ele mesmo, algo que não pode falhar.
Resumo rápido
- Um load balancer distribui requisições entre servidores e remove os mortos.
- A camada 4 é rápida e cega; a camada 7 pode rotear pelo conteúdo e repetir por requisição.
- Aleatório e round robin ignoram a carga; menos conexões e power of two choices a observam e se saem muito melhor (veja a tabela).
- Health checks devem ser baratos e separar "me reinicie" de "não me envie tráfego".
- Repita apenas requisições idempotentes e poucas vezes.
- Servidores sem estado tornam tudo mais fácil do que sticky sessions.
- Torne o balanceador redundante também.
Fontes
- Yossi Azar, Andrei Broder, Anna Karlin e Eli Upfal, Balanced Allocations, SIAM Journal on Computing, 1999. O resultado de balls-into-bins por trás de duas escolhas aleatórias.
- Michael Mitzenmacher, The Power of Two Choices in Randomized Load Balancing, IEEE Transactions on Parallel and Distributed Systems, 2001. A mesma ideia para servidores com filas.
- Documentação do NGINX, HTTP load balancing e ngx_http_upstream_module.
- Documentação do HAProxy, Configuration manual (a palavra-chave
balance,option httpchke, no servidor,check,inter,fall,rise,slowstart). - Documentação do Envoy, Load balancing e as configurações da política least request.
- IETF, RFC 9110: HTTP Semantics. Quais métodos são idempotentes e, portanto, seguros de repetir.
Pratique este tema: Networking & APIs