Stressify.jl Performance Testing

Introdução

Há aproximadamente dois anos atuo como QA Especialista no Grupo Casas Bahia exclusivamente voltado para Testes de Performance, a fim de garantir que a performance das aplicações da empresas estejam aptas para receber um fluxo alto de usuários e que a usabilidade da aplicação não seja prejudicada.

Durante essa minha jornada (desde outras empresas atuando como QA) atuei com várias ferramentas de teste de performance, como exemplo, JMeter, Gatling, Locust e K6, percebendo sempre prós e contras de todas essas ferramentas, como sabemos dentro da área de desenvolvimento de software não temos uma bala de prata, então cada ferramenta se adapta melhor as necessidades daquele projeto ou empresa.

Bom, após um tempo atuando na ferramenta K6, comecei a participar mais atuante da comunidade do Grafana K6 (recomendo a todos que tenham domínio de uma determinada ferramenta, faça isso), pois, além de estar aprendendo mais ainda com perguntas interessantes, você estará auxiliando outros profissionais com sua experiência.

Nessa comunidade comecei a perceber que um dos grandes pontos que os profissionais QAs ou de outras áreas procuravam, eram formas de gerar dados a partir de execução do teste, saindo daqueles resultados normais como trhoughput requests, response time, errors requests e voltando para dados estatísticos como média, mediana, P(90), P(95), desvio padrão e etc. Assim me veio a determinada idéia, como posso criar uma ferramenta de testes de performance que além de ser performática em sua execução consiga trazer mais insights estatísticos para o profissional, bem como, dando liberdade a partir da linguagem de gerar novas métricas, assim surgiu o Stressify.jl que é o tema deste texto de hoje.

Linguagem de Programação Julia

Pós a introdução me veio em mente explicar, por que a linguagem de programação Julia?

A linguagem Julia apareceu para mim no ano de 2016 em uma iniciação científica na Universidade Tecnológica Federal do Paraná, na qual nosso objetivo era mitigar a utilização de ferramentas open source para cálculos numéricos e científicos e durante a iniciação percebi o quão poderosa é a linguagem.

Julia foi criada por Jeff Bezanson, Stefan Karpinski, Viral B. Shah e Alan Edelman, e lançada publicamente em 2012. O principal objetivo de Julia é combinar a facilidade de uso de linguagens como Python e R com a performance de linguagens de baixo nível como C e Fortran. Ela é especialmente popular na comunidade científica devido à sua capacidade de lidar com grandes volumes de dados e cálculos complexos de maneira eficiente.

Características Principais:

  • Performance: Julia é compilada just-in-time (JIT), o que significa que o código é compilado em tempo de execução, permitindo uma performance próxima à de linguagens compiladas estáticas.
  • Facilidade de Uso: A sintaxe de Julia é clara e expressiva, tornando-a acessível para programadores de diferentes níveis de experiência.
  • Paralelismo e Concorrência: Julia tem suporte nativo para programação paralela e concorrente, facilitando a utilização de múltiplos núcleos de CPU ou até mesmo de GPUs.
  • Sistema de Tipos Dinâmico: Apesar de ser dinâmica, Julia permite a declaração opcional de tipos, o que pode aumentar a performance quando necessário.
  • Ecossistema de Pacotes: Julia tem um gerenciador de pacotes robusto chamado Pkg, com uma ampla variedade de pacotes para diversas aplicações, especialmente em ciência de dados, estatística, e machine learning.

Agora que apresentei um pouco mais da linguagem de Programação Júlia e o porque de sua utilização vou mostrar como usar a ferramenta Stressify.jl

Como usar o Stressify.jl?

O primeiro ponto que trago a vocês que o foco da ferramenta foi ser de simples instalação, desenvolvimento, execução e geração de report.

Instalação

Como dito na parte da linguagem Júlia sobre o ecossistemas de pacotes, a Julia contém uma comunidade atuante e democrática, facilitando a criação dos pacotes e utilização, desta forma, para o Stressify o que você precisa é:

  1. Instalação da linguagem Julia: A documentação é muito clara e a linguagem possui para todos os sistemas operacionais, desde Linux até Windows, no link acima coloquei a parte de como fazer o download e instalação.
  2. Após instalado a linguagem Julia crie uma pasta onde irá adicionar seus scripts de teste e no terminal digite o comando julia, assim você estará acessando a parte de interpretação da linguagem, seu terminal ficara parecido com isto:

 

_
   __ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.11.2 (2024-12-01)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia>
  1. Dentro do REPL da linguagem Julia digite using Pkg e depois Pkg.add("Stressify") aguarde alguns minutos que estará instalado a ferramenta.
  2. Agora vamos desenvolver os scripts!

Usando Docker

Caso você possua domínio do Docker e tenha instalado em sua máquina é mais simples ainda, basta executar o comando docker pull jfilhogn/stressify:latest que estará baixando a imagem oficial da ferramenta Stressify. Após baixado e dentro do diretório que você desenvolveu os scripts que será explicando no tópico abaixo execute o comando docker run --rm jfilhogn/stressify:latest seuscript.jl , pronto estará executando seu teste!

Criando os scripts.

Para este texto irei apresentar um script básico para entendimento apresentando cada parte do código por tópicos. Inicialmente vamos importar a biblioteca.

using Stressify

Feito a importação da biblioteca vamos declarar os options, isto é, as configurações que queremos para o teste, como número de VUs, quantas iterações que irá executar ou se será por duração. Para este exemplo iremos usar iterações.

using Stressify

Stressify.options(
    vus = 5,
    iterations = 10,
    duration = nothing
)

Então, no código acima declaramos para nosso teste que iremos executar o teste com 5 usuários simultâneos e cada VU irá iterar pelas requisições por 10 vezes, sendo assim o endpoint que estará sendo estressado receberá um total de 50 requisições.

Feito a parte do options vamos realizar as chamadas para isto vamos fazer a seguinte parte de código.

using Stressify

Stressify.options(
    vus = 5,
    iterations = 10,
    duration = nothing
)

results = Stressify.run_test(
    Stressify.http_get("https://httpbin.org/get"),
    Stressify.http_post("https://httpbin.org/post"; payload="{\"key\": \"value\"}", headers=Dict("Content-Type" => "application/json")),
)

Declaramos uma variável resultsque receberá um dicionário com todos os resultados e métricas que o teste irá trazer e para receber essas informações usamos a função run_test que recebe dentro dela as requisições que serão feitas, sendo no exemplo uma requisição GET e POST. Seu primeiro script está pronto!

Para executar o teste basta escrever no terminal o comando julia seuscript.jl e a saída será muito próxima a isto:

================== Stressify ==================
    VUs                    :          5
    Iterações Totais       :         50
    Taxa de Sucesso (%)    :      100.0
    Taxa de Erros (%)      :        0.0
    Requisições por Segundo:       8.79
    Transações por Segundo :       8.79
    Número de Erros        :          0

---------- Métricas de Tempo (s) ----------
    Tempo Mínimo           :     0.1744
    Tempo Máximo           :     1.5394
    Tempo Médio            :     0.4666
    Mediana                :      0.394
    P90                    :     0.8338
    P95                    :     0.9099
    P99                    :     1.5394
    Desvio Padrão          :     0.2872

---------- Detalhamento de Tempos ----------
    Todos os Tempos (s)    : 1.3297, 0.3898, 0.5772, 0.5987, 0.5519, 0.3595, 0.1788, 0.3945, 0.1823, 0.3955, 0.8338, 0.8836, 0.1757, 0.7192, 0.5078, 0.3386, 0.6884, 0.3439, 0.1789, 0.3843, 1.5394, 0.3353, 0.1744, 0.4752, 0.2206, 0.3373, 0.6098, 0.3367, 0.1763, 0.7549, 0.9099, 0.389, 0.1791, 0.3985, 0.4764, 0.3511, 0.1815, 0.5019, 0.1785, 0.3935, 0.9097, 0.3951, 0.1823, 0.3905, 0.5544, 0.6412, 0.3959, 0.354, 0.1812, 0.3958
==========================================================

---------- Resultados dos Checks ----------

Aqui entra o ponto chave da ferramenta, a transparência de todos os resultados que tivemos durante a execução trazendo dados de tempo mínimo, máximo, médio, mediana, P90, P95, P99 e Desvio Padrão. Por fim traz um detalhamento de todos os tempos gerados e caso seu código tenha checks de response você irá ver também os resultados!

Talvez você possa se perguntar, esse resultado é muito parecido com outras ferramentas de teste? Contudo o grande diferencial do Stressify é utilizar a linguagem Julia e ter nativo ferramentas estatísticas, suponha que você queira saber a variação destas requisições bastaria colocar essas três linhas de código.

using Statistics
variancia = var(results["all_times"])
print("Variância: ", variancia)

Então o grande foco da ferramenta é utilizar tudo que temos disponível da linguagem Júlia para geração de métricas de performance.

A idéia do texto de hoje era trazer esse pontapé inicial de como utilizar a ferramenta Stressify, estou atuando diariamente para trazer mais melhorias para vocês, sendo os que estão mapeados para as próximas versões detalho no próximo tópico.

Para o futuro!

  • Funil de Requisição: Um dos pontos principais do teste de performance é garantir que o teste siga o que aconteça na vida real e o funil de requisição é importantíssimo, sendo necessário para garantir que um endpoint X receba a porcentagem correta de requisições comparadas a requisição Y.
  • Live Dashboard: A linguagem Julia conta com excelentes ferramentas com o foco em dashboard e visão gráfica, para as próximas versões vou trazer um formato na qual a partir da execução você consiga ver uma visão gráfica da execução dos testes com um report.
  • Uso de GPUs: A linguagem possui integração com GPU e nesse sentido nada mais interessante utilizarmos VUs de GPU para cada requisição.

E mais novidades a caminho!

É isso pessoal, este primeiro artigo venho trazer sobre essa novidade e aguardo de vocês comentários de como utilizou, por fim caso tenha gostado do artigo deem um Star no Github, ajuda e muito no discernimento da ferramenta dentro dos pacotes Júlia. Logo abaixo trago os links mais importantes juntamente com a documentação da ferramenta.