Balanceamento de carga interno usando HAProxy no Google Compute Engine

Esta solução oferece um passo a passo sobre como configurar balanceadores de carga internos que usam HAProxy em uma instância dedicada do Compute Engine para distribuir solicitações HTTP entre um conjunto de três instâncias que executam o servidor da Web Apache.

Um balanceador de carga aceita o tráfego de rede de entrada e o distribui entre um grupo de servidores de aplicativos. Por exemplo, o serviço de balanceamento de carga do Google Compute Engine distribui o tráfego de entrada da Internet para um grupo de instâncias do Google Compute Engine. O diagrama a seguir mostra como o balanceamento de carga de rede do Google Compute Engine funciona.

Diagrama descrevendo o balanceamento de carga de rede do Compute Engine

Um balanceador de carga interno distribui o tráfego em uma rede particular que não está exposta à Internet. O balanceamento de carga interno é útil não apenas para aplicativos da intranet, onde todo o tráfego permanece em uma rede particular, mas também para aplicativos da Web complexos, onde um front-end envia solicitações para servidores de back-end usando uma rede particular.

Use o Google Compute Engine para criar seu próprio balanceador de carga interno usando um balanceador de carga de software. Uma maneira de implementar esse balanceador de carga é usando o HAProxy, um balanceador de carga de software de código aberto, em uma instância do Google Compute Engine. O diagrama a seguir oferece uma descrição de alto nível de como usar o HAProxy para balanceamento de carga interno no Google Cloud Platform.

Diagrama geral do HAProxy como um balanceador de carga interno

As setas verdes no diagrama representam o tráfego em uma rede particular. O servidor HAProxy atua como um balanceador de carga interno porque não está exposto à Internet. O servidor HAProxy recebe solicitações na rede particular e as distribui em um grupo de servidores de back-end acessíveis somente por endereços IP internos.

Essa solução cria um total de cinco instâncias do Google Compute Engine: uma para o HAProxy, três servidores Apache de back-end e uma instância micro para testes. O diagrama a seguir mostra como as cinco instâncias interagem.

Diagrama detalhado do HAProxy como um balanceador de carga interno

Considerações de confiabilidade

A execução do HAProxy na própria instância apresenta um único ponto de falha. Portanto, usaremos a Instance Group Manager API do Google Compute Engine, atualmente na versão beta, para manter o balanceador de carga em execução. O Instance Group Manager monitora o status da instância do Google Compute Engine do HAProxy e recria a instância caso ela pare de ser executada.

Porém, mesmo que a instância subjacente do servidor HAProxy esteja em execução, o serviço de balanceamento de carga do HAProxy poderá não estar. Para garantir que o serviço HAProxy reinicie em caso de falha, usaremos systemd, um utilitário de gerenciamento de sistema que faz parte da instalação padrão do Debian 9.

Objetivos

  • Configurar três servidores Apache de back-end.
  • Configurar um grupo de instâncias gerenciadas de uma instância do Google Compute Engine executando o HAProxy.
  • Configurar uma microinstância do Google Compute Engine com um endereço IP externo para teste.
  • Configurar o HAProxy para carregar o tráfego de balanceamento de carga para os servidores Apache de back-end.

Pré-requisitos

  1. Crie um novo projeto do Console do Google Cloud Platform para facilitar a limpeza.

  2. Use o Console do Google Cloud Platform para ativar o Compute Engine e as APIs Instance Group Manager.

  3. Instale o Google Cloud SDK.

  4. Configure seu espaço de trabalho para tornar os comandos menos detalhados. Substitua os valores do seu projeto por project-id e my-zone nos comandos a seguir.

    me@local:~$ gcloud config set project project-id
    me@local:~$ gcloud config set compute/zone my-zone
    

Criar um grupo de três servidores Apache de back-end

Você pode usar um balanceador de carga interno para distribuir o tráfego para uma grande variedade de recursos de computação, como servidores de banco de dados, caches de valores-chave e servidores da Web. Nesta solução, usamos um grupo de três servidores da Web que executam o servidor da Web Apache. Em uma solução subsequente, demonstraremos como usar um balanceador de carga interno com um grupo de servidores de back-end de escalonamento automático.

Criar uma imagem personalizada que contenha o servidor Apache

Siga estas etapas para criar uma imagem personalizada para os servidores de back-end.

  1. Crie uma instância do Compute Engine para usar como base para a imagem personalizada.

    me@local:~$ gcloud compute instances create apache-base --image-project debian-cloud --image-family debian-9
    
  2. Faça login na instância e instale o Apache2.

    me@local:~$ gcloud compute ssh apache-base
    apache-base:~$ sudo apt-get update && sudo apt-get install -y apache2
    apache-base:~$ exit
    
  3. Encerre a instância, mas mantenha o disco de inicialização.

    me@local:~$ gcloud compute instances delete apache-base --keep-disks boot
    
  4. Crie a imagem personalizada usando o disco de origem recém-criado.

    me@local:~$ gcloud compute images create apache-base-image --source-disk apache-base
    

Criar três servidores Apache de back-end baseados na imagem personalizada

Execute o comando a seguir para criar três servidores de back-end que estejam executando o servidor Apache.

me@local:~$ gcloud compute instances create apache1 apache2 apache3 \
--image apache-base-image --no-address \
--metadata startup-script='#! /bin/bash
cat << _EOF_ > /var/www/html/index.html
This is $(hostname)
_EOF_'

A opção --no-address gera instâncias sem endereços IP externos. A opção --metadata inclui um script de inicialização que edita a página inicial de cada servidor Apache para que ele imprima o nome da instância. Isso torna mais fácil verificar se o balanceador de carga está distribuindo solicitações para os três servidores de back-end.

O Google Compute Engine retorna os nomes dos servidores e os endereços IP internos. Anote os endereços IP internos de cada um dos três servidores de back-end. Eles serão necessários para o arquivo de configuração HAProxy.

Criar uma microinstância para teste

Como o balanceador de carga e os servidores de back-end não têm endereços IP externos, eles não podem ser testados na sua máquina de desenvolvimento. Siga estas etapas para criar uma microinstância com um endereço IP externo para testar os servidores de back-end e o balanceador de carga.

  1. Crie a instância de teste com --machine-type definido para f1-micro.

    me@local:~$ gcloud compute instances create test-instance --machine-type f1-micro
    
  2. Estabeleça uma conexão SSH com a instânciatest-instance:
    gcloud compute ssh test-instance
  3. Use curl para verificar os servidores de back-end da Web.

    me@test-instance:~$ curl apache1
    me@test-instance:~$ curl apache2
    me@test-instance:~$ curl apache3
    me@test-instance:~$ exit
    

Criar um balanceador de carga interno executando o HAProxy

Nesta solução, o serviço HAProxy é executado em uma instância dedicada do Google Compute Engine. Para reduzir o risco de ter um único ponto de falha, tomamos medidas para proteger a integridade da instância do Google Compute Engine e do próprio serviço HAProxy.

Para garantir que a instância subjacente do Google Compute Engine continue em execução, usaremos um grupo de instâncias gerenciadas. Se a instância do HAProxy estiver em um grupo de instâncias gerenciadas, o Instance Group Manager verificará o status do servidor e recriará a instância, caso pare de executar. O Instance Group Manager recria a imagem, mesmo que você use o comando gcloud compute instances ou a Compute Engine API para parar ou encerrar a instância. No entanto, se você usar o gcloud compute instance-groups managed delete-instances ou a Instance Group Manager API para excluir a instância, a instância permanecerá excluída.

Você pode criar um grupo de instâncias gerenciadas em três etapas. Primeiro, crie uma imagem personalizada. Em segundo lugar, use a imagem personalizada para criar um modelo de instância. Em terceiro lugar, use o modelo de instância para criar um grupo de instâncias gerenciadas.

Para garantir que o serviço HAProxy continue funcionando, verifique se o arquivo de configuração da unidade do serviço HAProxy está configurado para sempre reiniciar. Se configurado corretamente, o systemd reiniciará imediatamente um serviço se o processo for encerrado, sair ou expirar.

Siga estas etapas para criar a imagem personalizada do HAProxy, o modelo de instância e o grupo de instâncias gerenciadas.

Criar a imagem de base da instância do HAProxy

  1. Use a imagem do debian-9 para criar uma instância do Compute Engine.

    me@local:~$ gcloud compute instances create haproxy-base --image-project debian-cloud image-family debian-9
    
  2. Faça login na instância e instale o HAProxy.

    me@local:~$ gcloud compute ssh haproxy-base
    haproxy-base:~$ sudo apt-get update && sudo apt-get -y install haproxy
    
  3. Configure o HAProxy anexando a lista de servidores de back-end ao arquivo de configuração. Substitua internal-ip pelos endereços IP internos correspondentes anotados em uma etapa anterior.

    haproxy-base:~$ echo -e "\n\n# Listen for incoming traffic
    listen apache-lb *:80
        mode http
        balance roundrobin
        option httpclose
        option forwardfor
        server apache1 $(getent hosts apache1 | awk '{print $1}'):80 check
        server apache2 $(getent hosts apache2 | awk '{print $1}'):80 check
        server apache3 $(getent hosts apache3 | awk '{print $1}'):80 check
    " | sudo tee -a /etc/haproxy/haproxy.cfg
    

Se você esqueceu de substituir os endereços IP reais pelas três ocorrências de internal-ip antes de executar o comando, use um editor de texto para substituí-los antes de prosseguir.

Confirmar se o serviço HAProxy está configurado para sempre reiniciar.

  1. Use um editor de texto para ver um arquivo chamado haproxy-check.sh.

    haproxy-base:~$ sudo nano /lib/systemd/system/haproxy.service
    
  2. Confirme se o Restart=always está listado na seção [Service]. Se não estiver, adicione Restart=always.

    [Service]
    Environment=CONFIG=/etc/haproxy/haproxy.cfg
    ...
    Restart=always
    
  3. Saia do arquivo, salve as alterações e, em seguida, saia do shell.

    haproxy-base:~$ exit
    

Criar a imagem personalizada

Para criar uma imagem personalizada do servidor HAProxy, use o mesmo procedimento de criação da imagem personalizada do servidor Apache.

  1. Encerre a instância, mas mantenha o disco de inicialização.

    me@local:~$ gcloud compute instances delete haproxy-base --keep-disks boot
    
  2. Crie a imagem personalizada usando o disco de origem recém-criado.

    me@local:~$ gcloud compute images create haproxy-base-image --source-disk haproxy-base
    

Criar um modelo de instância do HAProxy com base na imagem personalizada

Use a opção --no-address para evitar a atribuição de um endereço IP externo.

 me@local:~$ gcloud compute instance-templates create haproxy-template \
 --image haproxy-base-image --no-address

Criar um grupo de instâncias gerenciadas chamado haproxy

A opção --base-instance-name permite definir o prefixo do nome da instância que o Instance Group Manager atribui à instância que ele cria. Neste exemplo, use o haproxy-server como prefixo. O nome da instância será haproxy-server-xxxx, em que xxxx é uma série de letras ou números.

me@local:~$ gcloud compute instance-groups managed create haproxy \
--base-instance-name haproxy-server --size 1 --template haproxy-template

Receber o nome do servidor HAProxy e testar o balanceador de carga

Depois de criar o grupo de instâncias gerenciadas, o Instance Group Manager criará a instância para você. O comando gcloud compute instances será usado para encontrar o nome da nova instância.

  1. Observe o nome da instância HAProxy, depois conecte SSH à instância test-instance.

    me@local:~$ gcloud compute instances list --filter 'name ~ haproxy-server-\w{4}' --format='get(name)'
    me@local:~$ gcloud compute ssh test-instance
    
  2. Use curl para testar o servidor proxy. Substitua haproxy-server-xxxx pelo nome do servidor proxy. Ao repetir esse comando, o resultado retornará valores de cada um dos três servidores da Web.

    me@test-instance:~$ curl haproxy-server-xxxx
    
  3. Saia do shell da instância de teste.

    me@test-instance:~$ exit
    

Testar a resiliência do balanceador de carga

Podemos apresentar dois cenários de falha para testar a resiliência do balanceador de carga. Primeiro, podemos parar a instância do Google Compute Engine do HAProxy para testar se o Instance Group Manager recriará a instância e se o script de inicialização reiniciará corretamente o serviço HAProxy. Em segundo lugar, podemos fazer login no servidor HAProxy e parar manualmente o serviço HAProxy para testar se o systemd detectará a falha e reiniciará o serviço.

Testar a instância do HAProxy

Siga estas etapas para testar a resiliência do grupo de instâncias gerenciadas do HAProxy.

  1. Use o comando gcloud compute instances para parar a instância do HAProxy. Lembre-se de substituir haproxy-server-xxxx pelo nome do servidor proxy.

    me@local:~$ gcloud compute instances stop haproxy-server-xxxx
    
  2. Aguarde alguns minutos e depois verifique se a instância está em execução. O Instance Group Manager recriará a instância.

    me@local:~$ gcloud compute instances list
    
  3. Depois que a instância estiver sendo executada novamente, você poderá fazer login na instância de teste para verificar se o balanceador de carga está funcionando. Saia da instância de teste quando o teste for concluído.

Testar o serviço HAProxy

O teste do serviço HAProxy requer algumas etapas extras porque não é possível conectar-se diretamente à instância do HAProxy pela máquina de desenvolvimento. Mas é possível conectar-se a test-instance e usar ssh entre instâncias para acessar a instância haproxy-server-xxxx.

  1. Configure a instância para instância ssh.

    me@local:~$ eval `ssh-agent`
    me@local:~$ ssh-add ~/.ssh/google\_compute\_engine
    
  2. Conecte-se à instância de teste usando a opção ssh-flag.

    me@local:~$ gcloud compute ssh test-instance --ssh-flag="-A"
    
  3. Use ssh na instância de teste para se conectar à instância haproxy-server-xxxx (substitua o haproxy-server-xxxx pelo nome da instância do haproxy-server).

    me@test-instance:~$ ssh haproxy-server-xxxx
    
  4. Verifique o status do servidor haproxy. A saída do comando precisa incluir a palavra running, um carimbo de data/hora da inicialização do serviço mais recente e quanto tempo foi necessário.

    me@haproxy-server-xxxx:~$ sudo service haproxy status | grep Active
    
  5. Encerre o processo do servidor HAProxy para testar se o serviço HAProxy será reiniciado.

    me@haproxy-server-xxxx:~$ sudo pkill haproxy
    
  6. Verifique o status novamente para ver se o serviço HAProxy foi reiniciado. A saída precisa informar novamente se o serviço está running, mas o carimbo de data/hora da última inicialização do serviço tem que ser mais recente.

    me@haproxy-server-xxxx:~$ sudo service haproxy status | grep Active
    
  7. Saia dos shells de ambas as instâncias.

    me@haproxy-server-xxxx:~$ exit
    me@test-instance:~$ exit
    

Limpeza

Após concluir o tutorial do HAProxy, limpe os recursos criados no Google Cloud Platform para não ser cobrado por eles no futuro. As seções a seguir explicam como excluir ou desativar esses recursos.

Como excluir o projeto

A maneira mais fácil de evitar o faturamento é excluir o projeto criado para o tutorial.

Para excluir o projeto:

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Como excluir instâncias

Para excluir uma instância do Compute Engine:

  1. No Console do GCP, acesse a página "Instâncias de VM".

    Acessar a página "Instâncias de VMs"

  2. Clique na caixa de seleção ao lado da instância test-instance.
  3. Clique no botão Excluir na parte superior da página para excluir a instância.

Como excluir discos

Para excluir um disco do Compute Engine:

  1. No console do GCP, acesse a página "Discos".

    Acessar a página Discos

  2. Clique na caixa de seleção ao lado do disco que deseja excluir.
  3. Clique no botão Excluir na parte superior da página para excluir o disco.

Próximas etapas

Você viu como criar uma solução de balanceamento de carga interna usando o HAProxy em uma instância do Google Compute Engine executada em uma rede particular. Você também viu como tornar o balanceador de carga mais resiliente usando a Instance Group Manager API e o systemd para monitorar e reparar a integridade do balanceador de carga.

Estenda ou modifique esta solução para dar suporte a diferentes aplicativos de back-end como servidores de banco de dados ou armazenamentos de valor-chave. Você também pode fazer o pool de servidores de back-end escaláveis usando o recurso Google Compute Engine Autoscaler.

Para informações sobre como testar a carga de seu balanceador de carga interno, consulte Testar a carga distribuída usando kubernetes.

Leia sobre outras soluções de balanceamento de carga disponíveis no Google Cloud Platform:

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…