TL;DR — Resumo Rápido

Domine o Grafana k6 para testes de carga e performance. Usuários virtuais, thresholds, cenários, integração CI/CD, testes de browser e dashboards Grafana.

O Grafana k6 é uma ferramenta de teste de carga focada no desenvolvedor que executa scripts JavaScript em um runtime Go de alto desempenho. Isso proporciona reprodutibilidade de testes como código, controle de versão e integração fluida com CI/CD. Este guia cobre desde o primeiro smoke test até cenários de produção com métricas personalizadas, testes de browser e dashboards Grafana.

Pré-requisitos

  • Node.js não é necessário — k6 tem seu próprio runtime JavaScript integrado (Goja, motor ES6+ baseado em Go).
  • k6 instalado — Homebrew, apt, Docker ou binário de release.
  • Conhecimento básico de JavaScript — funções, objetos, loops.
  • Um serviço alvo — qualquer API HTTP, servidor WebSocket ou endpoint gRPC.

Arquitetura do k6

k6 executa scripts JavaScript dentro de um runtime Go. Cada usuário virtual (VU) é uma goroutine leve que executa sua função default em um loop. Conceitos-chave:

  • VUs — Usuários virtuais concorrentes. Cada um executa seu script independentemente.
  • Iterações — Uma execução da função default por um VU.
  • Checks — Asserções (como status === 200). Checks com falha NÃO interrompem o teste.
  • Thresholds — Critérios de aprovação/falha (como p(95) < 250). Violá-los encerra k6 com código 99.
  • Métricas — Integradas (http_req_duration, http_reqs, vus) e personalizadas (Trend, Counter, Gauge, Rate).

Protocolos integrados:

ProtocoloMóduloNotas
HTTP/1.1 e HTTP/2k6/httpNegociação automática de HTTP/2
WebSocketk6/experimental/websocketsSuporte completo a frames WS
gRPCk6/net/grpcUnário e streaming
Redisk6/experimental/redisVia extensão xk6-redis
Browserk6/browserChromium real via Playwright

Tipos de Teste de Carga

Smoke test — verificar se o script funciona

export const options = { vus: 1, duration: '30s' };

Load test — tráfego normal esperado

export const options = {
  stages: [
    { duration: '2m', target: 100 }, // rampa até 100 VUs
    { duration: '5m', target: 100 }, // platô
    { duration: '2m', target: 0   }, // descida
  ],
};

Stress test — além da capacidade normal

export const options = {
  stages: [
    { duration: '2m', target: 100 },
    { duration: '5m', target: 200 },
    { duration: '2m', target: 300 }, // além do normal
    { duration: '5m', target: 300 },
    { duration: '2m', target: 0   },
  ],
};

Spike test — pico súbito

export const options = {
  stages: [
    { duration: '10s', target: 1000 }, // pico instantâneo
    { duration: '1m',  target: 1000 },
    { duration: '10s', target: 0    }, // queda instantânea
  ],
};

Soak test — duração estendida (encontrar vazamentos de memória)

export const options = {
  stages: [
    { duration: '5m', target: 100 },
    { duration: '8h', target: 100 }, // soak de 8 horas
    { duration: '5m', target: 0   },
  ],
};

Breakpoint test — encontrar o limite

export const options = {
  stages: [{ duration: '2h', target: 20000 }],
  thresholds: {
    http_req_failed: [{ threshold: 'rate<0.01', abortOnFail: true }],
  },
};

Thresholds e Métricas Personalizadas

import { Trend, Rate } from 'k6/metrics';

const apiLatency = new Trend('api_latency', true);
const apiErrors  = new Rate('api_errors');

export const options = {
  thresholds: {
    http_req_duration: ['p(95)<250'],
    http_req_failed:   ['rate<0.01'],
    api_latency:       ['p(99)<500'],
  },
};

k6 vs Outras Ferramentas

FerramentaLinguagemProtocolosModelo VUCI/CD
k6JavaScriptHTTP, WS, gRPC, BrowserGoroutineNativo
JMeterXML/GUIHTTP, JMS, FTP, JDBCThreadPlugin
GatlingScala/DSLHTTP, WSAtor assíncronoMaven/Gradle
LocustPythonHTTP, customCorrotina asyncCLI
ArtilleryYAML/JSHTTP, WSNode.jsNativo
wrkLuaApenas HTTPEpollManual

Integração CI/CD com GitHub Actions

name: Load Test
on:
  push:
    branches: [main]
jobs:
  k6-load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run k6 load test
        uses: grafana/k6-action@v0.3.1
        with:
          filename: tests/load/api.js
          flags: --vus 50 --duration 2m
        env:
          BASE_URL: ${{ secrets.STAGING_URL }}

k6 termina com código 99 ao violar um threshold, fazendo o passo do Actions falhar automaticamente.

Resumo

  • k6 executa JavaScript em runtime Go — VUs leves, testes como código, compatível com Git.
  • Tipos de teste — smoke, load, stress, spike, soak, breakpoint — cada um para um risco diferente.
  • Thresholds impõem aprovação/falha no CI; abortOnFail interrompe testes de breakpoint descontrolados.
  • Cenários com executors separam o controle da taxa de chegada da contagem de VUs.
  • SharedArray parametriza grandes conjuntos de dados sem sobrecarga de memória por VU.
  • Dashboard Grafana 2587 visualiza resultados em tempo real a partir da saída do InfluxDB.

Artigos Relacionados