Locust: Introdução a um framework de testes de performance em Python

Neste artigo você vai ver:

Nada melhor do que conhecer uma ferramenta de testes de performance para ter o melhor processo de Nada melhor do que conhecer mais uma ferramenta de testes de performance para ter o melhor processo de desenvolvimento de software possível, não é mesmo? Por isso, hoje vamos conhecer mais sobre o Locust, suas vantagens e desvantagens, além de como executar um teste introdutório utilizando essa ferramenta.

Afinal, o que é Locust?

De acordo com a própria documentação, Locust é uma ferramenta de teste de performance fácil de usar, programável através de scripts e escalonável. Define-se o comportamento de seus usuários que farão as requisições através de código Python independente de interface gráfica e verbosidade de código ou linguagem mais verbosa e restritiva. 

De acordo com sua documentação, o Locust nasceu de uma frustração com as soluções existentes e utilizadas no mercado. Aparentemente, nenhuma ferramenta de teste de carga existente estava bem equipada para gerar uma carga realista em um site dinâmico onde a maioria das páginas tinha conteúdo diferente para usuários diferentes. As ferramentas existentes usavam interfaces gráficas não intuitivas ou arquivos de configuração detalhados para declarar os testes. 

O Locust utiliza uma abordagem diferente. Em vez de arquivos de configuração ou interfaces, profissionais de desenvolvimento obtêm uma estrutura Python que permite definir o comportamento de seus usuários usando código Python.

Pré requisitos:

  • Python 3+ instalado;
  • Alguma IDE ou editor de texto de preferência.

A página do Locust traz outras informações, além do link para a sua documentação.

Vantagens do Locust

Dentre as principais vantagens de adotar o Locust temos, por exemplo:

  • Se você já conhece a linguagem Python, em pouco tempo conseguirá desenvolver scripts de testes de performance ou carga com o Locust;
  • É escalável: dá suporte a centenas de milhares de usuários simultâneos facilitando a execução de testes em ambientes distribuídos (Por exemplo: várias máquinas executando os mesmos testes);
  • Possui interface gráfica que apresenta os resultados dos testes em tempo real e  permite  que se altere  a carga de dados durante a execução do teste.

Desvantagens do Locust

Por mais interessante que a ferramenta seja, sempre podemos encontrar pontos de melhoria. Por exemplo, o Locust não possui suporte nativo para assertions

Outro aspecto interessante e que pode ser um ponto negativo, é que a velocidade do código depende de como quem é QA vai desenvolvê-lo, por exemplo, pessoas mais iniciantes na linguagem podem não desenvolver soluções performáticas. 

Deve-se verificar também que se você precisa simular uma carga específica com alguns padrões de ramp-up personalizados, caso não possua experiência prévia ou exemplos que podem ser reaproveitados, pode-se gastar muito tempo na criação desses padrões, e em outra ferramenta mais conhecida, seria uma tarefa mais fácil.

Configurando uma API localmente

Para que possamos começar a usar a nossa ferramenta de teste de performance, podemos criar um servidor local com alguns serviços simples que irão servir de alvo para nosso teste.

Aqui, iremos utilizar o Flask, que é um framework Python utilizado para a construção de aplicativos web.

  1. Em uma pasta de escolha, crie um ambiente virtual para o app Flask executando o comando no terminal: python3 -m venv nome_do_ambiente_virtual (o meu é venv mesmo).
  2. Ative o ambiente virtual de acordo com seu sistema operacional. No Ubuntu, execute o comando no terminal: source nome_do_ambiente_virtual/bin/activate.
  3. Instale o Flask no seu ambiente virtual com o comando pip install flask.
  4. Copie e cole o código abaixo em um arquivo nome_arquivo.py na raiz da pasta do projeto do flask.
from flask import Flask
 
app = Flask(__name__)
 
@app.route('/name/<name>')
def get_name(name):
   return f"Olá, você digitou o nome: {name}" 
 
 
if __name__ == '__main__':
   app.run(debug=True)

Este arquivo python criará um servidor com um único serviço no endereço http://127.0.0.1:5000/name/<nome> e retornará o texto “Olá, você digitou o nome: <nome>.

Execute o comando python3 nome_do_arquivo.py e acesse a URL passando algum parâmetro, por exemplo: http://127.0.0.1:5000/name/Teste e você deverá ver a tela:

A imagem exibe a tela com caminho 127.0.0.1:5000/name/Teste e nela a mensagem “Olá, você digitou o nome: Teste”.

Pronto, agora temos nosso primeiro endpoint de teste. Não esqueça de deixar o terminal executando o seu código Flask.

Configurando o Locust e primeiros testes

  1. Em uma pasta crie um ambiente virtual diferente do app Flask executando o comando no terminal: python3 -m venv nome_do_ambiente_virtual (o meu é venv novamente). 
  2. Ative o ambiente virtual de acordo com seu sistema operacional. No Ubuntu, execute o comando no terminal: source nome_do_ambiente_virtual/bin/activate. 
  3. Instale o Locust no seu ambiente virtual com o comando pip install locust.

No código de teste, criaremos a classe SimpleLocustTest, que herdará da classe HttpUser e nos dá a possibilidade de realizar requests do tipo HTTP. 

Nesta classe também especificamos nossas tasks para os testes através do decorator @task e inserimos a informação do intervalo de tempo entre 1 e 3 segundos entre as requests enviadas. Crie seu script e adicione o código:

from locust import HttpUser, task, between
 
class SimpleLocustTest(HttpUser):
   wait_time = between(1, 3)
 
   @task
   def get_name(self):
       self.client.get("/name/Teste")

Execute o comando locust -f locust_script.py -H http://127.0.0.1:5000 e a interface gráfica deve aparecer no endereço http://127.0.0.1:8089/, como a imagem abaixo:

A imagem exibe o formulário para iniciar o swarm de novos usuários com os campos “number of users, spawn rate, host” e o botão “start swarming”.

Agora, você pode modificar o número de usuários máximo, a taxa de criação de novos usuários e o endereço do servidor do teste, que no nosso caso é local. Comecei o teste com 100 usuários, spawn rate de 5 e deixei o servidor do jeito que está na imagem (127.0.0.1:5000)

Analisando os resultados 

Ao clicar em start swarming com a configuração programada, a interface abre um painel com informações em tempo real sobre os endpoints testados, a quantidade de requests, a média de requests por segundo, quantidade de falhas etc. 

A imagem exibe a página com os resultados esperados contendo informações do endpoint testado, da quantidade de usuários, tempo de resposta e outras informações.

Ao clicar na aba de gráficos, podemos analisar que o tempo de resposta aumenta à medida que a quantidade de usuários aumenta, assim como a quantidade de requests por segundo.

A imagem exibe a página com os resultados em forma de gráfico: total de requests por segundo e tempo de resposta. A medida que o tempo avança a quantidade total requests por segundo também sobe

Outras abas importantes podem ser vistas, como a aba de falhas e de download data, onde podemos fazer o download da execução em csv ou do report da execução, como mostram as imagens abaixo:

A imagem exibe a página com os resultados em forma de gráfico e de formulário, também contendo informações de total requests por segundo e quantidade de falhas.
A imagem acima demonstra por meio de gráficos os números de usuários por tempo e o tempo de resposta por mediana e porcentagem.

Caso você tenha mais endpoints que queira testar, apenas crie mais funções com a notação @task. Caso você precise passar informações no request, basta passar após a URL, como o exemplo abaixo:

 @task
   def add_user(self):
       self.client.post("/new_user", json={"username":"foo",    "password":"bar"})

Conclusão 

Vamos recapitular o que fizemos nesse artigo: instalamos e configuramos um servidor Flask pequeno e com apenas uma funcionalidade, que é retornar uma string com o nome que passamos como referência. Configuramos um teste simples que realiza gets no servidor e passa apenas o mesmo nome como parâmetro. Instanciamos nosso teste e definimos quantos usuários irão consumir esse serviço criado, e, para finalizar, analisamos as saídas geradas em tempo real e seus respectivos gráficos. 

Caso seja de seu interesse continuar estudando o Locust, indico testar APIs que precisem de autenticação, gerar massa de dados aleatoriamente e procurar usar os Hooks disponíveis. Seria um desafio muito interessante.

E aí, já usa o Locust ou esse artigo foi o que te apresentou a essa ferramenta? Conta pra gente nos comentários!

Capa do artigo sobre a ferramenta de teste de carga Locust, onde se vê gráficos com linhas coloridas em um fundo azul.
Marlon de Alencar
Analista de Testes
Engenheiro de computação, mestrando em Ciências de Computação e jogador de Dota nas horas vagas.

Este site utiliza cookies para proporcionar uma experiência de navegação melhor. Consulte nossa Política de Privacidade.