Teste de carga distribuída usando o Google Kubernetes Engine

Este tutorial explica como usar o Google Kubernetes Engine (GKE) para implantar um framework de teste de carga distribuída que utiliza vários contêineres para criar tráfego para uma API simples baseada em REST. Este tutorial testa a carga de um aplicativo da Web implantado no App Engine que expõe endpoints no estilo REST para capturar solicitações recebidas de HTTP POST.

É possível usar o mesmo padrão para criar frameworks de teste de carga para diversos de cenários e aplicativos, como sistemas de mensagens, sistemas de gerenciamento de fluxo de dados e sistemas de banco de dados.

Objetivos

  • Definir as variáveis do ambiente para controlar a configuração da implantação.
  • Criar um cluster do GKE.
  • Realizar o teste de carga.
  • Opcionalmente, ampliar o número de usuários ou o padrão para outros casos de uso.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud Platform:

  • Google Kubernetes Engine
  • App Engine
  • Cloud Build
  • Cloud Storage

Use a calculadora de preços para gerar uma estimativa de custo com base no uso do projeto. Novos usuários do GCP são qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar Cloud Build, Compute Engine, Container Analysis, and Container Registry APIs.

    Ativar as APIs

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Exemplo da carga de trabalho

O diagrama abaixo mostra um exemplo de carga de trabalho em que as solicitações vão do cliente para aplicativo.

Solicitações do cliente para o aplicativo.

Para moldar essa interação, é possível usar o Locust, uma ferramenta de teste de carga distribuída baseada em Python que pode distribuir solicitações por vários caminhos de destino. Por exemplo, com o Locust, essa distribuição é feita para os caminhos /login e /metrics. A carga de trabalho é moldada como um conjunto de tarefas no Locust.

Arquitetura

Essa arquitetura envolve dois componentes principais:

  • A imagem do contêiner do Locust no Docker
  • O mecanismo de orquestração e gerenciamento de contêineres

A imagem do contêiner do Locust no Docker contém o software Locust. O Dockerfile, que você recebe ao clonar o repositório do GitHub que acompanha este tutorial, usa uma imagem Python básica e inclui scripts para iniciar o serviço do Locust e executar as tarefas. Para ficar mais próxima das situações reais dos clientes, cada tarefa do Locust tem um peso. Por exemplo, o registro ocorre uma vez a cada mil solicitações de cliente.

O GKE fornece orquestração e gerenciamento de contêineres. Com o GKE, é possível especificar o número de nós de contêiner que fornecem a base para seu framework de teste de carga. Também é possível organizar seus workers de teste de carga em pods e especificar quantos pods você quer que o GKE continue executando.

Para implantar as tarefas de teste de carga, faça o seguinte:

  1. Implante um mestre de teste de carga.
  2. Implante um grupo de workers de teste de carga. Com esses workers, é possível criar uma quantidade substancial de tráfego para fins de teste.

O diagrama a seguir mostra o conteúdo dos nós mestre e de trabalho.

O mestre contém o servidor da API, programados e gerenciador. Cada um dos dois nós contém Kublet, um proxy e uma imagem do Docker com quatro pods.

Sobre o mestre de testes de carga

O mestre do Locust é o ponto de entrada para executar as tarefas de teste de carga. A configuração do mestre do Locust especifica vários elementos, incluindo as portas a serem expostas pelo contêiner:

  • 8089 para a interface da Web
  • 5557 e 5558 para comunicação com workers

Essas informações serão usadas depois na configuração dos workers do Locust.

Você implanta um serviço para garantir que as portas expostas possam ser acessadas por outros pods no cluster por meio de hostname:port. As portas expostas também podem ser referenciadas por um nome descritivo.

Você usa um serviço para permitir que os workers do Locust descubram com facilidade e se comuniquem com segurança com o mestre, mesmo que ele falhe e seja substituído por um novo pod pela implantação. O serviço também inclui uma diretiva para criar uma regra de encaminhamento externo no nível do cluster de modo que o tráfego externo possa acessar os recursos do cluster.

Depois de implantar o mestre do Locust, é possível abrir a interface da Web usando o endereço IP público da regra de encaminhamento externo. Após a implantação dos workers do Locust, inicie a simulação e veja as estatísticas agrupadas nessa interface.

Sobre os workers de teste de carga

Os workers do Locust executam as tarefas de teste de carga. Use uma única implantação para criar vários pods. Esses pods são distribuídos no cluster do Kubernetes. Cada um deles usa variáveis de ambiente para controlar informações de configuração, por exemplo, os nomes dos hosts do sistema em teste e do mestre do Locust.

No diagrama a seguir, veja a relação entre o mestre e os workers do Locust.

O mestre do Locust fica na parte superior de uma hierarquia com vários workers abaixo dele.

Como inicializar variáveis comuns

É preciso definir diversas variáveis que controlam onde os elementos da infraestrutura serão implantados.

  1. Abra o Cloud Shell:

    Abrir o Cloud Shell

    Todos os comandos do terminal neste tutorial são executados a partir do Cloud Shell.

  2. Defina as variáveis de ambiente:

    REGION=us-central1
    ZONE=${REGION}-b
    PROJECT=$(gcloud config get-value project)
    CLUSTER=gke-load-test
    TARGET=${PROJECT}.appspot.com
    SCOPE="https://www.googleapis.com/auth/cloud-platform"
    
  3. Defina a zona padrão e ID do projeto para que não seja necessário especificar esses valores em todos os comandos subsequentes:

    gcloud config set compute/zone ${ZONE}
    gcloud config set project ${PROJECT}
    

Como configurar o ambiente

  1. Clone o repositório de amostra do GitHub:

    git clone https://github.com/GoogleCloudPlatform/distributed-load-testing-using-kubernetes
    
  2. Altere o diretório de trabalho para o repositório clonado:

    cd distributed-load-testing-using-kubernetes
    

Como criar o cluster do GKE

  1. Crie o cluster do GKE:

    gcloud container clusters create $CLUSTER \
       --zone $ZONE \
       --scopes $SCOPE \
       --enable-autoscaling --min-nodes "3" --max-nodes "10" \
       --scopes=logging-write \
       --addons HorizontalPodAutoscaling,HttpLoadBalancing
    
  2. Conecte-se ao cluster do GKE:

    gcloud container clusters get-credentials $CLUSTER \
       --zone $ZONE \
       --project $PROJECT
    

Como criar a imagem do Docker

  1. Crie a imagem do Docker e armazene-a no Container Registry do seu projeto:

    gcloud builds submit \
        --tag gcr.io/$PROJECT/locust-tasks:latest docker-image
    
  2. Verifique se a imagem do Docker está no repositório de contêiner do seu projeto:

    gcloud container images list | grep locust-tasks
    

    A saída terá a seguinte aparência:

    gcr.io/[PROJECT]/locust-tasks
    Only listing images in gcr.io/[PROJECT]. Use --repository to list images in other repositories.
    

Como implantar o aplicativo de amostra

  • Implante o aplicativo de amostra no App Engine:

    gcloud app deploy sample-webapp/app.yaml \
      --project=$PROJECT
    

    A saída tem uma aparência semelhante à seguinte:

    File upload done.
    Updating service [default]...done.
    Setting traffic split for service [default]...done.
    Deployed service [default] to [https://[PROJECT].appspot.com]
    

Como implantar os nós do mestre e de trabalho do Locust

  1. Substitua o host de destino e ID do projeto pelo endpoint implantado e pelo ID do projeto nos arquivos locust-master-controller.yaml e locust-worker-controller.yaml:

    sed -i -e "s/\[TARGET_HOST\]/$TARGET/g" kubernetes-config/locust-master-controller.yaml
    sed -i -e "s/\[TARGET_HOST\]/$TARGET/g" kubernetes-config/locust-worker-controller.yaml
    sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kubernetes-config/locust-master-controller.yaml
    sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kubernetes-config/locust-worker-controller.yaml
    
  2. Implante os nós do mestre e de trabalho do Locust

    kubectl apply -f kubernetes-config/locust-master-controller.yaml
    kubectl apply -f kubernetes-config/locust-master-service.yaml
    kubectl apply -f kubernetes-config/locust-worker-controller.yaml
    
  3. Verifique as implantações do Locust:

    kubectl get pods -o wide
    

    A saída tem uma aparência semelhante à seguinte:

    Os nós mestre e de trabalho do Locust são implantados.
  4. Verifique os serviços:

    kubectl get services
    

    A saída tem uma aparência semelhante à seguinte:

    Os serviços são implantados.
  5. Execute um loop de observação enquanto um endereço IP externo é atribuído ao serviço mestre do Locust:

    kubectl get svc locust-master --watch
    
  6. Pressione Ctrl+C para sair do loop de observação e execute o seguinte comando para anotar o endereço IP externo:

    EXTERNAL_IP=$(kubectl get svc locust-master -o jsonpath="{.status.loadBalancer.ingress[0].ip}")
    

Como testar a carga

É possível usar a interface mestre da Web do Locust para executar as tarefas de teste de carga no sistema sendo testado.

  1. Encontre o endereço IP externo do sistema:

    echo $EXTERNAL_IP
    

  2. Abra seu navegador e depois, a interface mestre da Web do Locust. Para [EXTERNAL_IP] no seguinte URL, substitua o endereço IP encontrado na etapa anterior: http://[EXTERNAL_IP]:8089.

    A interface mestre da Web do Locust abre uma caixa de diálogo para iniciar um novo sawrm e especificar o número de usuários e a taxa de geração.

  3. Especifique Number of users to simulate (ou seja, o número total de usuários a simular) como 10 e a Hatch rate (taxa de geração) com que os usuários devem ser gerados como 5 usuários por segundo.

  4. Clique em Start swarming para iniciar a simulação.

    Depois que o swarming das solicitações é iniciado, as estatísticas começam a ser agregadas para as métricas de simulação, como o número de solicitações e solicitações por segundo, como mostra a imagem abaixo:

    A interface da Web do Locust mostra que as estatísticas começam a ser agregadas.
  5. Clique em Stop para encerrar o teste.

É possível visualizar o serviço implantado e outras métricas no Console do GCP.

O painel do App Engine mostra um gráfico de uma hora de solicitações divididas por tipo.

Como aumentar o número de usuários (opcional)

Se quiser testar o aumento de carga no aplicativo, é possível adicionar usuários simulados. Antes de adicionar usuários simulados, você precisa garantir que haja recursos suficientes para suportar o aumento da carga. Com o GCP, é possível adicionar pods de worker do Locust à implantação sem precisar reimplantar os pods existentes, contanto que você tenha os recursos de VM subjacentes para suportar um número maior de pods. O cluster inicial do GKE começa com 3 nós e pode fazer o escalonamento automático para até 10 nós.

  • Aumente o pool de pods de worker do Locust para 20.

    kubectl scale deployment/locust-worker --replicas=20
    

    Demora alguns minutos para implantar e iniciar os novos pods.

Se você vir um erro de Pod não programável, será necessário adicionar mais papéis ao cluster. Para detalhes, consulte Como redimensionar o cluster do GKE.

Depois que os pods forem iniciados, retorne à interface mestre da Web do Locust e reinicie o teste de carga.

Como estender o padrão

Para estender esse padrão, é possível criar novas tarefas do Locust ou até mudar para um framework de teste de carga diferente.

É possível personalizar as métricas coletadas. Por exemplo, é possível medir as solicitações por segundo, monitorar a latência das respostas à medida que a carga aumenta ou verificar as taxas de falha de resposta e os tipos de erros.

Para mais informações, consulte a documentação do Stackdriver Monitoring.

Como fazer a limpeza

Depois que tiver terminado o tutorial, você poderá limpar os recursos criados no GCP para não haver faturamento deles no futuro.

Como excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou 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 o cluster do GKE

Se você não quiser excluir o projeto todo, execute o seguinte comando para excluir o cluster do GKE:

   gcloud container clusters delete $CLUSTER --zone $ZONE
   

A seguir

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

Enviar comentários sobre…