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 usandoEndereços IP e portasA requisição HTTP: host, caminho, cabeçalhos, cookies
Vê o conteúdonãosim
Customuito baixo (encaminha pacotes ou conexões)mais alto (interpreta requisições, muitas vezes termina o TLS)
Pode rotear /api e /images de forma diferentenãosim
Pode repetir uma requisição que falhou em outro servidorsó no momento da conexãosim, por requisição
ExemplosAWS Network Load Balancer, HAProxy em modo TCP, IPVSNGINX, 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.

Mais duas são usadas por outro motivo:

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íticaTamanhos iguais: média / p99Tamanhos exponenciais: média / p99Cauda pesada: média / p99
Aleatório5,7 / 23,110,3 / 45,125,4 / 118,7
Round robin1,4 / 3,25,3 / 23,727,3 / 133,1
Menos conexões1,4 / 3,01,9 / 7,73,6 / 27,2
Power of two choices1,9 / 4,23,0 / 10,36,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:

4. Health checks

Um balanceador precisa parar de enviar requisições a um servidor que caiu e voltar a enviar quando ele se recupera.

O que o endpoint de verificação deve testar é uma decisão de design:

Outros comportamentos que acompanham isso:

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

9. Erros comuns

10. Coisas a mencionar em uma entrevista

Resumo rápido

  1. Um load balancer distribui requisições entre servidores e remove os mortos.
  2. A camada 4 é rápida e cega; a camada 7 pode rotear pelo conteúdo e repetir por requisição.
  3. 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).
  4. Health checks devem ser baratos e separar "me reinicie" de "não me envie tráfego".
  5. Repita apenas requisições idempotentes e poucas vezes.
  6. Servidores sem estado tornam tudo mais fácil do que sticky sessions.
  7. Torne o balanceador redundante também.

Fontes

  1. 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.
  2. 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.
  3. Documentação do NGINX, HTTP load balancing e ngx_http_upstream_module.
  4. Documentação do HAProxy, Configuration manual (a palavra-chave balance, option httpchk e, no servidor, check, inter, fall, rise, slowstart).
  5. Documentação do Envoy, Load balancing e as configurações da política least request.
  6. IETF, RFC 9110: HTTP Semantics. Quais métodos são idempotentes e, portanto, seguros de repetir.

Pratique este tema: Networking & APIs

Mais guias