HAProxy: Balanceador de Carga TCP/HTTP e Alta Disponibilidade

22 de março de 2026

18 min de leitura

Recente

TL;DR — Resumo Rápido

Guia completo do HAProxy para balanceamento de carga TCP e HTTP com alta disponibilidade. ACLs, health checks, SSL, stick tables e failover com keepalived VRRP.

O HAProxy é a implementação de referência para balanceamento de carga de código aberto. Enquanto o Nginx também funciona como servidor web e o Caddy prioriza a facilidade de uso, o HAProxy foi projetado especificamente para proxy e balanceamento de carga — e isso se reflete em cada benchmark. Este guia cobre a stack completa do HAProxy: arquitetura, instalação no Ubuntu e RHEL, ajuste de global e defaults, configuração de frontend/backend com ACLs, todos os algoritmos de balanceamento, health checks TCP e HTTP, terminação SSL/TLS, a página de estatísticas, stick tables, rate limiting, integração com rsyslog e uma configuração completa de keepalived VRRP para alta disponibilidade em dois nós.

Pré-requisitos

Antes de começar, verifique se você tem:

Ubuntu 22.04/24.04 ou RHEL 9/AlmaLinux 9 com acesso sudo
Pelo menos dois servidores de aplicação backend
Dois nós HAProxy (para a seção de alta disponibilidade com keepalived)
Conhecimento básico de TCP/IP e HTTP
HAProxy 2.6 ou posterior (versão LTS recomendada)

Arquitetura do HAProxy

O HAProxy é executado como um único processo orientado a eventos (ou um número configurável de processos/threads). Todo o I/O é não bloqueante e multiplexado, permitindo que o HAProxy lide com dezenas de milhares de conexões simultâneas com RAM mínima.

Um arquivo de configuração tem quatro tipos de seção principais:

global — configurações de todo o processo (maxconn, log, chroot, user/group, nbthread)
defaults — configurações padrão herdadas por todos os frontends e backends
frontend — escuta conexões de entrada; aplica ACLs e roteia tráfego para backends
backend — define o pool de servidores, algoritmo de balanceamento e parâmetros de health check
listen — combinação de frontend+backend, útil para a página de estatísticas ou proxies TCP simples

O fluxo de tráfego é: cliente → frontend → avaliação de ACLs → regra use_backend → backend → servidor.

Instalação

Ubuntu / Debian

sudo apt update
sudo apt install haproxy -y
haproxy -v

Para uma versão LTS mais recente, adicione o PPA oficial:

sudo add-apt-repository ppa:vbernat/haproxy-2.8 -y
sudo apt install haproxy=2.8.\* -y

RHEL / AlmaLinux / Rocky Linux

sudo dnf install haproxy -y
haproxy -v
sudo systemctl enable --now haproxy

Configuração Global e Defaults

Abra /etc/haproxy/haproxy.cfg e substitua o conteúdo padrão por uma base pronta para produção:

global
    log /dev/log local0
    log /dev/log local1 notice
    chroot /var/lib/haproxy
    stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners
    stats timeout 30s
    user haproxy
    group haproxy
    daemon
    maxconn 50000
    nbthread 4
    tune.ssl.default-dh-param 2048
    ssl-default-bind-ciphers ECDH+AESGCM:DH+AESGCM:ECDH+AES256:!aNULL:!MD5:!DSS
    ssl-default-bind-options no-sslv3 no-tlsv10 no-tlsv11

defaults
    log     global
    mode    http
    option  httplog
    option  dontlognull
    option  forwardfor
    option  http-server-close
    retries 3
    timeout connect  5s
    timeout client   30s
    timeout server   30s
    timeout http-keep-alive 10s
    timeout check    5s
    maxconn 3000

Parâmetros-chave explicados:

maxconn 50000 — limite global de conexões; ajuste com base na RAM disponível (~1 MB por 1000 conexões)
nbthread 4 — execute quatro threads em um sistema de quatro núcleos
option dontlognull — suprime logs de health checks sem payload
option forwardfor — injeta o cabeçalho X-Forwarded-For nas requisições proxy
retries 3 — tentativas de reconexão antes de marcar um servidor como inativo
timeout connect 5s — tempo máximo para estabelecer uma conexão TCP com um backend

Configuração de Frontend

Um frontend define no que o HAProxy escuta e para onde roteia o tráfego:

frontend http_front
    bind *:80
    bind *:443 ssl crt /etc/haproxy/certs/example.com.pem
    http-request redirect scheme https unless { ssl_fc }
    http-request set-header X-Forwarded-Proto https if { ssl_fc }

    # Definição de ACLs
    acl is_api  path_beg /api/
    acl is_static path_beg /static/ /assets/ /images/
    acl host_admin hdr(host) -i admin.example.com

    # Regras de roteamento
    use_backend api_backend    if is_api
    use_backend static_backend if is_static
    use_backend admin_backend  if host_admin
    default_backend app_backend

Correspondências de ACL mais usadas:

Correspondência	Exemplo	Verifica
`path_beg`	`path_beg /api/`	URI começa com `/api/`
`path_end`	`path_end .php`	URI termina em `.php`
`hdr(host)`	`hdr(host) -i api.example.com`	Cabeçalho Host (sem distinção de maiúsculas)
`src`	`src 10.0.0.0/8`	Faixa de IP do cliente
`method`	`method POST`	Método HTTP

Configuração de Backend

Um backend define o pool de servidores e como o tráfego é distribuído:

backend app_backend
    balance roundrobin
    option httpchk GET /health HTTP/1.1\r\nHost:\ app.example.com

    server app1 10.0.0.10:8080 weight 3 maxconn 500 check inter 2s fall 3 rise 2
    server app2 10.0.0.11:8080 weight 3 maxconn 500 check inter 2s fall 3 rise 2
    server app3 10.0.0.12:8080 weight 1 maxconn 200 check inter 2s fall 3 rise 2
    server app_backup 10.0.0.20:8080 backup check inter 5s fall 2 rise 1

Algoritmos de Balanceamento

Algoritmo	Diretiva	Melhor para
Round-robin	`balance roundrobin`	Requisições curtas e uniformes
RR ponderado	`balance roundrobin` + `weight N`	Servidores de capacidade mista
Menos conexões	`balance leastconn`	Tempos de resposta variáveis
Hash de IP origem	`balance source`	Afinidade de sessão por IP do cliente
Hash de URI	`balance uri`	Servidores de cache
Hash de cabeçalho	`balance hdr(User-Agent)`	Roteamento por cabeçalho HTTP

Health Checks

Health Check TCP (padrão)

O HAProxy abre uma conexão TCP para verificar se a porta está respondendo:

backend tcp_backend
    balance leastconn
    server db1 10.0.0.30:5432 check inter 3s fall 2 rise 1
    server db2 10.0.0.31:5432 check inter 3s fall 2 rise 1

Health Check HTTP

Para backends HTTP, verifica se a aplicação retorna um código de status saudável:

backend app_backend
    option httpchk GET /health HTTP/1.1\r\nHost:\ app.example.com
    http-check expect status 200
    server app1 10.0.0.10:8080 check inter 2s fall 3 rise 2
    server app2 10.0.0.11:8080 check inter 2s fall 3 rise 2

Terminação SSL/TLS

O HAProxy termina SSL no frontend e encaminha TCP ou HTTP sem criptografia para os backends. Combine certificado e chave privada em um único PEM:

cat fullchain.pem privkey.pem > /etc/haproxy/certs/example.com.pem
chmod 600 /etc/haproxy/certs/example.com.pem

SNI multi-certificado (um diretório, HAProxy escolhe o certificado correto automaticamente):

frontend https_front
    bind *:443 ssl crt /etc/haproxy/certs/
    http-request set-header X-Forwarded-Proto https
    http-response set-header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
    default_backend app_backend

Página de Estatísticas

A página de estatísticas integrada do HAProxy fornece métricas de conexão em tempo real:

listen stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 10s
    stats auth admin:changeme
    stats show-legends
    stats show-node
    stats hide-version

Acesse em http://seu-servidor:8404/stats. Proteja essa porta com uma regra de firewall:

sudo ufw allow from 10.0.0.0/8 to any port 8404
sudo ufw deny 8404

Stick Tables para Persistência de Sessão

As stick tables rastreiam mapeamentos cliente→servidor em memória compartilhada:

backend app_backend
    balance roundrobin
    stick-table type ip size 100k expire 30m
    stick on src
    server app1 10.0.0.10:8080 check
    server app2 10.0.0.11:8080 check

Para persistência baseada em cookies:

backend app_backend
    balance roundrobin
    cookie SERVERID insert indirect nocache
    server app1 10.0.0.10:8080 cookie app1 check
    server app2 10.0.0.11:8080 cookie app2 check

Rate Limiting com Stick Tables

As stick tables do HAProxy também gerenciam rate limiting sem dependências externas:

frontend http_front
    bind *:80
    bind *:443 ssl crt /etc/haproxy/certs/
    stick-table type ip size 200k expire 10s store http_req_rate(10s)
    http-request track-sc0 src
    http-request deny deny_status 429 if { sc_http_req_rate(0) gt 100 }
    default_backend app_backend

Logging com rsyslog

O HAProxy registra em um socket syslog. Configure o rsyslog para gravar os logs em um arquivo dedicado.

Crie /etc/rsyslog.d/49-haproxy.conf:

$AddUnixListenSocket /dev/log

:programname, startswith, "haproxy" {
  /var/log/haproxy.log
  stop
}

sudo systemctl restart rsyslog
sudo systemctl restart haproxy

HAProxy com Keepalived para Failover VRRP

O keepalived executa VRRP para atribuir um IP virtual compartilhado entre dois nós HAProxy. Se o nó primário falhar, o nó de espera assume o IP virtual em um ou dois segundos.

Instalar keepalived

sudo apt install keepalived -y           # Ubuntu
sudo dnf install keepalived -y           # RHEL

Nó primário — `/etc/keepalived/keepalived.conf`

vrrp_script chk_haproxy {
    script "killall -0 haproxy"
    interval 2
    weight -20
}

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 110
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass s3cur3p4ss
    }
    virtual_ipaddress {
        192.168.1.100/24
    }
    track_script {
        chk_haproxy
    }
}

Nó de espera — `/etc/keepalived/keepalived.conf`

vrrp_instance VI_1 {
    state BACKUP
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass s3cur3p4ss
    }
    virtual_ipaddress {
        192.168.1.100/24
    }
}

sudo systemctl enable --now keepalived
ip addr show eth0 | grep 192.168.1.100

Comparativo de Balanceadores de Carga

Recurso	HAProxy	Nginx	Traefik	Envoy	AWS ALB
Balanceamento TCP	Sim (nativo)	Sim	Sim	Sim	Sim
Health checks ativos	Sim (integrado)	Só Plus	Sim	Sim	Sim
Interface de estatísticas	Integrada	stub_status	Dashboard	Admin API	CloudWatch
Rate limiting	Stick tables	limit_req	Middleware	Filters	WAF
Terminação SSL	Sim	Sim	Sim	Sim	Sim
HA/VRRP	Via keepalived	Via keepalived	Não integrado	Não integrado	Gerenciado
Pegada de recursos	Muito baixa	Baixa	Média	Alta	Gerenciado
Melhor para	TCP+HTTP HA	Web + cache	Containers	Service mesh	AWS nativo

Resumo

O HAProxy é o padrão de referência para balanceamento de carga TCP e HTTP em ambientes Linux. Principais pontos:

Ajuste maxconn, nbthread e os timeouts nas seções global e defaults antes de qualquer coisa
Construa ACLs no frontend com path_beg, hdr() e src; roteie para backends com use_backend
Escolha leastconn para APIs HTTP, roundrobin para tráfego uniforme, e source ou stick tables para persistência de sessão
Sempre adicione check inter 2s fall 3 rise 2 a cada linha de servidor e option httpchk aos backends HTTP
Termine SSL no frontend com um arquivo PEM combinado; vários certs em um diretório para SNI automático
Use stick tables para persistência de sessão e rate limiting sem dependências externas
Combine HAProxy com keepalived VRRP para failover em menos de um segundo entre dois nós

Guide & Instructions

Estimated Time: 30m

Tools Needed:

HAProxy
systemctl
keepalived

Instalar o HAProxy

Execute 'sudo apt install haproxy -y' no Ubuntu ou 'sudo dnf install haproxy -y' no RHEL/AlmaLinux e verifique com 'haproxy -v'.

Configurar as seções global e defaults

Edite /etc/haproxy/haproxy.cfg para definir maxconn, log socket, timeout connect/client/server e option httplog nos blocos global e defaults.

Definir frontends e backends

Adicione seções frontend vinculadas a IPs/portas públicas com ACLs e regras use_backend, depois seções backend com linhas de servidor e algoritmo de balanceamento.

Ativar health checks e terminação SSL

Adicione 'option httpchk GET /health' e 'check inter 2s fall 3 rise 2' por servidor. Para SSL, use bind *:443 ssl crt /etc/haproxy/certs/ no frontend.

Configurar a página de estatísticas

Adicione uma seção listen stats vinculada a uma porta de gerenciamento com stats enable, stats uri /stats e stats auth admin:password.

Configurar o keepalived para alta disponibilidade

Instale o keepalived em ambos os nós, configure a instância VRRP com um IP virtual compartilhado e defina a prioridade mais alta no nó primário.

Frequently Asked Questions

Qual é a diferença entre frontend e backend no HAProxy?

O frontend define como o HAProxy aceita conexões de entrada (bind, ACLs, protocolo), enquanto o backend define o pool de servidores que recebe o tráfego encaminhado.

Qual algoritmo de balanceamento é melhor para APIs HTTP no HAProxy?

Use leastconn para conexões longas ou APIs com tempos de resposta variáveis. Para requisições curtas e uniformes, roundrobin funciona bem. Use source ou hdr para afinidade de sessão sem stick tables.

Como o HAProxy realiza health checks nos servidores backend?

O HAProxy executa verificações passivas e ativas. Adicione 'check inter 2s fall 3 rise 2' às linhas de servidor e 'option httpchk GET /health' ao backend para verificações HTTP.

Como alcançar alta disponibilidade com dois nós HAProxy?

Execute o keepalived junto ao HAProxy em ambos os nós. O keepalived usa VRRP para compartilhar um IP virtual entre o nó ativo e o de espera, fornecendo failover automático.