Grafana k6 - usando JS para testes de carga
Tags: testing, javascript, tutorial, k6
Published: 2022-08-22 01:51:00

Atualmente uma das melhores maneiras de testar e simular o comportamento da sua API em mar aberto é com testes de carga.

Várias ferramentas estão disponíveis na nossa comunidade [JMeter](https://jmeter.apache.org), [Katalon](https://katalon.com), [Postman](https://www.postman.com) são algumas das principais.

Vamos falar de uma ferramenta especial nesse artigo, ela é fácil, _open source_ e muito simples de configurar.

Se até pro espaço nosso querido JavaScript já foi... Claro que vamos ter ele por aqui quando o assunto é **teste de carga**.

{% twitter 1561509981941284864%}


**_- Ladies and gentlemen i present you k6!_**


<hr>
## k6

![logotipo k6](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fr6yi9t6iu0mdaty4a55.png)

[k6](https://k6.io) é uma ferramenta _open source_ desenvolvido pelo time do Grafana Labs, focada em realização de testes de carga orientado a objetivos.

Usando o k6, você pode testar a confiabilidade e o desempenho de seus sistemas e detectar regressões e problemas de desempenho mais cedo. 

### How it works

k6 trabalha com o conceito de usuários virtuais (VUs) que executam scripts. Eles são essencialmente loops `while(true)` paralelos.

Os scripts devem conter, no mínimo, uma função padrão exportada - isso define o ponto de entrada para suas VUs, semelhante à função `main()` em várias linguagens.

Para cada bateria de teste é necessário especificar quantos **_VUs_** serão utilizados além dos **_scripts_** que executaram as chamadas e suas regras.

- **_scripts_** - escritos em JavaScript devem exportar uma função _default_ que servirá como _main_ para a bateria de testes.

- **_VUs_** - ou _virtual users_ são usuários gerados pelo k6 em tempo de execução que farão requisicões HTTP em _looping_ durante todo o tempo da bateria de testes.

### Key features

- **CLI** com APIs amigáveis ​​ao desenvolvedor.
- **JavaScript ES2015/ES6** - com suporte para módulos locais e remotos
- **Checks e Thresholds** - para testes de carga orientados para objetivos e fáceis de automatizar

<hr>
## Hands on
![hackerman](https://c.tenor.com/ruSOhVUzF_oAAAAd/hackerman.gif)

Uma das características principais do k6 é que ele possui uma alta integração com diversos serviços de _cloud_ e _observability_ do mercado.

Para esse artigo vamos utilizar alguma delas, são elas: 

- **Grafana Dashboards**
- **Influx DB**
- **Docker**

> recomendo fortemente a leitura da documentação oficial do [k6](https://k6.io/docs/) que além de muito abrangente é recheada de exemplos de demonstrações de utilização.

## Let's code


![arquitetura](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wrfb3a34yboyv79pjftd.png)

A imagem acima demonstra como vamos estruturar nosso projeto, com a ajuda do Docker vamos preparar um ambiente que nos fornecerá toda a infraestrutura necessária e também recursos para a visualização dos resultados em tempo real.

Todo o código desenvolvido para esse artigo foi **publicado em meu GitHub** e poderá ser acessado nesse [repositório](https://github.com/pgsilva/k6-load-test).


### O que vamos testar?

Durante esse artigo vamos fazer uma bateria de testes usando a API pública [The Star Wars API](https://swapi.dev) como _backend_ e simularemos alguns cenários usando o k6 e acompanharemos via _dashboard_ todas as requisições  realizadas e suas métricas publicadas.

**_app.js_**

```js
import http from 'k6/http'
import { check, sleep } from 'k6'

/** 
 * etapas do nosso teste:
 * os primeiros 30 segundos teremos um aumento de 0 a 20 usuarios acessando a api
 * em seguida um periodo de 1m e 30s com o pico de 20 usuarios fazendo requisicoes em loop infinito
 * depois gradativamente os usuarios vao deixar de acessar a api de 20 até chegarem a 0 em 20 segundos
 * **/
export const options = {
    stages: [
        { duration: '30s', target: 20 },
        { duration: '1m30s', target: 20 },
        { duration: '20s', target: 0 },
    ],
}

export default function () {
    const id = Math.floor(Math.random() * 10) + 1
    const url = `http://swapi.dev/api/people/${id}`

    console.log(`calling [${url}]`)
    const response = http.get(url) //requisicao

    check(response, { "status is 200": (r) => r.status === 200 }) //validacao se ocorreu tudo certo
    sleep(1) //intervalo entre as chamadas
}
```
> nesse cenário estamos fazendo pouquíssimas requisições (em média é realizada aproximadamente 200 requisições em 2m 20s) mas em um cenário com mais de 200 VUs conseguimos chegar a 150 req/segundo e um total de aproximadamente 2000 em 5 minutos.

Fica o convite para fazer um teste mais parrudo e ver como o k6 se sai. 😎

> para os demais arquivos de configuração do _dashboard_ sugiro utilizar as métricas mais convenientes para o cenário especifico, nesse artigo acabei expondo todas.

<hr>

## Run

```sh
docker compose up -d influxdb grafana
```
Vamos primeiro subir os contêineres que utilizaremos para a visualização dos resultados.

```sh
docker compose run k6
```
Executando o `run` vamos começar a visualizar as primeiras chamadas sendo realizadas para a API.

![gif its happening](https://i.giphy.com/media/huJmPXfeir5JlpPAx0/giphy.webp)

 Podemos visualizar em _runtime_ a execução na url http://localhost:3000/d/k6/k6-load-testing-results

![resultados do teste](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5zzb59ww4ctfxfaokgbo.png)

<hr>

##Conclusão 

Com certeza k6 é uma excelente ferramenta para testes de performance uma ótima opção para substituir o JMeter por exemplo.

Com uma série de integrações disponíveis e a facilidade de escrever cenários, regras e validações a etapa de testes de carga que normalmente é custosa e demorada consegue ser muito mais rápida e iterativa com o time.

Não pense que a utilização de JavaScript faz o k6 ter uma performance inferior aos demais, sua performance é excelente e ficará limitada apenas a _hardware_ e conexão disponíveis com a opção até mesmo de ser executado em _clusteres_.

Com a possibilidade de escrevermos _scripts_ com limites e regras de aceitação, além da possibilidade de gerarmos lógicas e manipulação de variáveis durante os testes fica bem difícil não querer experimentar um pouco dessa ferramenta.

Recomendo fortemente a utilização do k6 para testes de carga, stress e performance e recomendo também a leitura da documentação oficial.