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

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:

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:

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. 

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.

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:

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!