Balanceamento de carga HTTP

Introdução

Neste laboratório, você aprenderá os fundamentos do balanceamento de carga usando o HAProxy.

Imagine um banco com apenas um caixa. A fila fica muito longa e os clientes começam a reclamar. Para resolver o problema, o banco abre várias janelas de atendimento. Porém, agora é necessário ter um gerente na porta para encaminhar cada cliente à próxima janela disponível.

Neste cenário:

O gerente do banco é o balanceador de carga (HAProxy).
Os caixas são os servidores de backend (servidores web simulados).
Os clientes são o tráfego web.

Você criará essa estrutura no Linux. Serão criados dois servidores web simulados, e o HAProxy será configurado para dividir o tráfego entre eles usando o round-robin, um dos algoritmos de balanceamento mais simples.

O round-robin é útil como modelo mental inicial porque mostra a finalidade básica de um balanceador de carga: distribuir requisições sucessivas entre vários backends saudáveis, em vez de enviar tudo para uma única máquina.

Ao final deste laboratório, você será capaz de:

Executar servidores web simples em Python.
Configurar o HAProxy para aceitar tráfego (Frontend) e enviá-lo aos servidores (Backend).
Observar o balanceamento de carga em funcionamento.

Preparar os terminais

Para testar um balanceador de carga, primeiro precisamos de algo para balancear! Precisamos executar dois servidores web separados ao mesmo tempo. Como um servidor em execução ocupa o terminal — ele continua executando até ser interrompido — não podemos digitar novos comandos na mesma janela.

Por isso, precisamos abrir abas adicionais no terminal. Pense nisso como abrir várias abas no navegador para consultar sites diferentes ao mesmo tempo.

Na prática, esta etapa separa as funções do sistema. Os servidores Python simulam a camada da aplicação, enquanto o terminal principal continua sendo o plano de controle do próprio balanceador de carga.

Você tem um terminal aberto no momento (Terminal). Abra mais dois:

Localize o ícone + (mais) na interface do terminal.
Clique nele duas vezes para abrir o Terminal 1 e o Terminal 2.

Usaremos os terminais desta forma:

Terminal: nosso centro de controle (para configurar o HAProxy).
Terminal 1: executará o Servidor 1.
Terminal 2: executará o Servidor 2.

Iniciar o Servidor 1

Agora iniciaremos o primeiro "caixa" (Servidor 1). Em vez de instalar um software completo de servidor web, usaremos uma ferramenta integrada ao Python que transforma qualquer diretório em um site.

Mude para o Terminal 1.

Primeiro, acesse o diretório que preparamos para o Servidor 1.

cd ~/project/server1

Agora, inicie o servidor. Vamos configurá-lo para escutar na porta 8001. Pense em uma porta como o número de um apartamento. O computador é o prédio, e a porta 8001 é a porta específica onde o Servidor 1 está localizado.

python3 -m http.server 8001

Você verá uma mensagem contendo Serving HTTP on 0.0.0.0 port 8001. Isso significa que o servidor está em execução e aguardando visitantes. Esse terminal agora está "ocupado"; portanto, não digite mais nada nele.

Iniciar o Servidor 2

Vamos iniciar o segundo "caixa" (Servidor 2) para termos outro servidor com o qual dividir o trabalho.

Mude para o Terminal 2.

Acesse o diretório do Servidor 2.

cd ~/project/server2

Inicie este servidor em uma porta diferente, a 8002. Não podemos usar a 8001 porque o Servidor 1 já está usando essa porta — duas famílias não podem morar no mesmo apartamento 8001.

python3 -m http.server 8002

Agora você tem dois servidores web independentes em execução. Um exibe "Response from Server 1" (na porta 8001), e o outro exibe "Response from Server 2" (na porta 8002).

Configurar o Frontend

Agora que os servidores estão prontos, vamos configurar o "gerente do banco" (HAProxy) para encaminhar o tráfego a eles.

É aqui que começa a separação entre frontend e backend. Um frontend descreve como os clientes chegam ao HAProxy, enquanto um backend descreve o grupo de servidores que efetivamente tratará o trabalho.

Volte para o Terminal.

Vamos começar do zero fazendo backup da configuração antiga e criando uma nova.

sudo mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.bak
sudo nano /etc/haproxy/haproxy.cfg

Copie e cole o texto a seguir no editor. Ele define o Frontend. O Frontend é a face pública do balanceador de carga: é onde os clientes (usuários) chegam.

global
    log /dev/log    local0
    log /dev/log    local1 notice
    daemon

defaults
    log     global
    mode    http
    option  httplog
    option  dontlognull
    timeout connect 5000
    timeout client  50000
    timeout server  50000

frontend http_front
    bind *:80
    default_backend http_back

Principais partes:

bind *:80: informa ao HAProxy que ele deve escutar na porta 80. A porta 80 é a porta padrão para o tráfego web (HTTP). Quando você digita o nome de um site sem informar uma porta, o navegador usa a porta 80.
default_backend http_back: informa ao HAProxy: "Quando as pessoas chegarem aqui, envie-as para o grupo chamado http_back."

Essa nomenclatura é importante porque a configuração do HAProxy funciona essencialmente como um mapa de tráfego. Os frontends recebem as conexões, e os backends representam os possíveis destinos dessas conexões.

Salve o arquivo (Ctrl+O, Enter). Você pode mantê-lo aberto, se quiser, ou, de preferência, salvá-lo e sair (Ctrl+X) para verificar seu progresso etapa por etapa.

Configurar o Backend

Agora precisamos definir esse grupo de servidores, o Backend.

Se você fechou o arquivo, abra-o novamente:

sudo nano /etc/haproxy/haproxy.cfg

Adicione as linhas a seguir ao final do arquivo:

backend http_back
    server server1 127.0.0.1:8001 check
    server server2 127.0.0.1:8002 check

O que acabamos de fazer?

backend http_back: criamos o grupo chamado http_back.
server server1 ...: adicionamos o primeiro servidor (Servidor 1) no endereço 127.0.0.1:8001 (porta 8001 do localhost).
server server2 ...: adicionamos o segundo servidor (Servidor 2) em 127.0.0.1:8002.
check: esta opção é essencial. Ela instrui o gerente a verificar periodicamente se o servidor está realmente disponível (saudável). Se um servidor falhar, o HAProxy deixará de enviar clientes para ele.

Salve o arquivo (Ctrl+O, Enter) e saia (Ctrl+X).

Verificar o balanceamento

Como o gerente deve decidir quem receberá o próximo cliente? A forma mais comum é o Round Robin. É simplesmente uma questão de "alternar os servidores".

Cliente 1 -> Servidor 1
Cliente 2 -> Servidor 2
Cliente 3 -> Servidor 1
...e assim por diante.

Vamos deixar isso explícito na configuração. Abra o arquivo de configuração uma última vez:

sudo nano /etc/haproxy/haproxy.cfg

Localize a seção backend http_back que você acabou de adicionar e insira a diretiva balance, deixando-a assim:

backend http_back
    balance roundrobin
    server server1 127.0.0.1:8001 check
    server server2 127.0.0.1:8002 check

Observação: a indentação (os espaços no início da linha) é importante para a legibilidade, embora o HAProxy seja tolerante. Tente manter o arquivo organizado.

Salve o arquivo (Ctrl+O, Enter) e saia (Ctrl+X).

Recarregar o HAProxy e testar

A configuração está pronta, mas o HAProxy ainda não a conhece. Precisamos reiniciar o serviço para aplicar as alterações.

sudo service haproxy restart

Agora é o momento da verdade! Usaremos um comando chamado curl. Pense no curl como um navegador web sem interface gráfica. Ele busca uma página web e exibe o código de texto na tela.

Vamos nos conectar ao localhost (nossa máquina) na porta padrão 80, onde o HAProxy está escutando.

Execute este comando várias vezes:

curl localhost

Você deverá ver "Response from Server 1". Execute-o novamente.

curl localhost

Agora você deverá ver "Response from Server 2".

Se quiser observar o comportamento rapidamente, execute este loop, que acessa o servidor 4 vezes seguidas:

for i in {1..4}; do
  curl localhost
  echo
done

Você deverá ver a saída alternar perfeitamente: 1, 2, 1, 2.

Isso comprova que o balanceador de carga está funcionando! Ele está recebendo suas requisições na porta 80 e dividindo o trabalho entre as portas 8001 e 8002.

Resumo

Neste laboratório, você criou com sucesso um cluster web com balanceamento de carga!

Veja o que você realizou:

Backends simulados: você usou Python para criar dois servidores web em execução, em portas diferentes (8001 e 8002).
Frontend configurado: você instruiu o HAProxy a escutar na porta web padrão (80).
Backend configurado: você registrou os dois servidores como parte do grupo de servidores.
Round Robin: você configurou uma política justa de alternância para distribuir o tráfego.

Esta é exatamente a mesma arquitetura usada por grandes sites para atender milhões de usuários, mas em uma escala menor.