Devops
Por Craft XP
22 de Junho de 2026

K6: Testes de Carga e Performance — Da Automação à Integração Contínua em Pipelines CI/CD

O que é o K6 e por que ele se destaca?

O K6 é uma ferramenta de código aberto para testes de carga e performance, desenvolvida pela Grafana Labs. Diferente de ferramentas tradicionais como JMeter ou Locust, o K6 foi projetado desde o início com uma mentalidade developer-first e CI/CD-first, permitindo que equipes de desenvolvimento e operações escrevam scripts de teste em JavaScript puro e os executem tanto localmente quanto em pipelines de automação.

Combinando uma engine de alta performance baseada em Go, uma API enxuta e familiar para quem já programa em JavaScript, e relatórios detalhados de métricas, o K6 se tornou a escolha preferida de times que praticam DevOps e SRE para validar o comportamento de APIs, microsserviços e sistemas web sob carga.

Principais Características

Scripts em JavaScript (ES6+): escreva testes com a mesma linguagem do seu front-end, sem necessidade de XML ou configurações complexas
Alta performance nativa: engine escrita em Go, capaz de gerar centenas de milhares de requisições por segundo com uso mínimo de recursos
Métricas embutidas: coleta automática de latência (p90, p95, p99), taxa de erro e throughput sem configuração adicional
Integração CI/CD nativa: executa perfeitamente em GitHub Actions, GitLab CI, Jenkins e qualquer pipeline Unix com saída de código de saída (exit code) para falha/ sucesso
Extensões com k6x: ecossistema de extensões em Go para protocolos customizados como gRPC, Redis, MySQL e WebSocket
Exportação de métricas: integração direta com Prometheus, InfluxDB, Datadog, New Relic e Grafana Cloud

Primeiros Passos: Instalação e Script Básico

A instalação do K6 é simples em qualquer sistema operacional. No Linux, basta um comando:

# Ubuntu/Debian
sudo apt update && sudo apt install k6 -y

# macOS (Homebrew)
brew install k6

# Docker (qualquer plataforma)
docker pull grafana/k6

Com o K6 instalado, crie seu primeiro script de teste. Vamos simular o acesso concorrente a uma API REST:

// test.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const errorRate = new Rate('errors');
const requestDuration = new Trend('request_duration');

export const options = {
  stages: [
    { duration: '30s', target: 20 },  // Rampa: sobe até 20 VUs
    { duration: '1m', target: 20 },   // Patamar: 20 usuários por 1 minuto
    { duration: '30s', target: 0 },   // Descida: volta a zero
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% das requisições abaixo de 500ms
    errors: ['rate<0.05'],             // Erros abaixo de 5%
  },
};

export default function () {
  const res = http.get('https://api.exemplo.com/users');
  
  check(res, {
    'status é 200': (r) => r.status === 200,
    'tempo de resposta < 300ms': (r) => r.timings.duration < 300,
  });

  errorRate.add(res.status !== 200);
  requestDuration.add(res.timings.duration);

  sleep(1);
}

Execute o teste com um comando simples no terminal:

k6 run test.js

Métricas Essenciais: o Que Observar

O K6 expõe métricas detalhadas a cada execução. As mais importantes são:

http_req_duration: tempo total da requisição (DNS + conexão + TLS + resposta). Use os percentis p90, p95 e p99 para entender a experiência real do usuário
http_req_failed: taxa de falhas. Deve idealmente ser zero para endpoints saudáveis
http_req_throughput: requisições por segundo. Revela o ponto de saturação do sistema
vus: número de usuários virtuais simultâneos ativos
iterations: total de iterações completadas, indicador de produtividade do teste

Com essas métricas, é possível estabelecer SLOs (Service Level Objectives) precisos e acionar alertas automáticos quando a performance degrada.

Integração Contínua com GitHub Actions

Uma das vantagens mais poderosas do K6 é sua integração direta com pipelines CI/CD. Veja um exemplo de workflow no GitHub Actions:

# .github/workflows/load-test.yml
name: Teste de Carga
on:
  schedule:
    - cron: '0 6 * * 1-5' # Todos os dias úteis às 6h
  workflow_dispatch:       # Permite execução manual

jobs:
  k6-load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Executar teste de carga
        uses: grafana/k6-action@v0.3.0
        with:
          filename: tests/load/checkout-api.js
          flags: --out json=result.json
      - name: Upload de resultados
        uses: actions/upload-artifact@v4
        with:
          name: k6-results
          path: result.json

O pipeline falha automaticamente se os thresholds definidos no script não forem atendidos, impedindo que deploys sigam adiante com degradação de performance.

Simulação de Cenários Avançados

O K6 suporta padrões de carga sofisticados que vão muito além do ramp-up simples:

Stress testing: aumenta a carga progressivamente até encontrar o ponto de ruptura do sistema
Spike testing: picos repentinos de carga para testar a elasticidade de autoscaling (especialmente em Kubernetes)
Soak testing: carga moderada por horas ou dias para detectar vazamentos de memória e degradação gradual
Breakpoint testing: incrementos graduais até a falha, registrando métricas a cada patamar

// Exemplo de spike test
export const options = {
  stages: [
    { duration: '2m', target: 10 },    // Aquecimento
    { duration: '30s', target: 500 },  // Pico repentino
    { duration: '2m', target: 500 },   // Sustenta o pico
    { duration: '1m', target: 0 },     // Resfriamento
  ],
};

K6 nos Testes de Microsserviços

Em arquiteturas de microsserviços, o K6 brilha ao permitir testar cadeias completas de chamadas. Você pode simular um usuário que passa por API Gateway, serviço de autenticação, serviço de catálogo e banco de dados, medindo a latência ponta a ponta:

import { check } from 'k6';
import http from 'k6/http';

const BASE_URL = __ENV.API_URL || 'http://localhost:3000';

export default function () {
  // 1. Login
  const loginRes = http.post(`${BASE_URL}/auth/login`, {
    email: 'teste@exemplo.com',
    password: 'senha123',
  });
  check(loginRes, { 'login ok': (r) => r.status === 200 });

  const token = loginRes.json('token');

  // 2. Busca catálogo
  const catalogRes = http.get(`${BASE_URL}/catalog/products`, {
    headers: { Authorization: `Bearer ${token}` },
  });
  check(catalogRes, { 'catálogo ok': (r) => r.status === 200 });

  // 3. Finaliza compra
  const orderRes = http.post(`${BASE_URL}/orders`, JSON.stringify({
    productId: 42,
    quantity: 1,
  }), { headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` } });
  check(orderRes, { 'pedido criado': (r) => r.status === 201 });
}

Dashboard e Visualização com Grafana

O K6 pode exportar métricas em tempo real para o Prometheus, que por sua vez alimenta dashboards no Grafana. A própria Grafana Labs mantém um dashboard oficial para o K6, com visualizações de:

Gráfico de requisições por segundo ao longo do tempo
Heatmap de latência por percentil
Taxa de erro por endpoint
Uso de recursos (CPU e memória) do servidor alvo

Execute o K6 com exportação Prometheus para ver tudo ao vivo:

k6 run --out experimental-prometheus-rw test.js

Conclusão

O K6 representa uma mudança de paradigma nos testes de carga. Ao tratar scripts de performance como código versionável, integrável a pipelines CI/CD e mensurável com métricas precisas, ele coloca os testes de performance no mesmo nível de importância que os testes unitários e de integração.

Se sua equipe ainda não adotou testes de carga automatizados, o K6 é o ponto de partida ideal: gratuito, open-source, com uma curva de aprendizado baixíssima para quem já conhece JavaScript e com integração nativa com o ecossistema Grafana para observabilidade.

Comece pequeno: um script de 20 linhas testando seu endpoint crítico já vale mais do que zero testes. Automatize essa execução no pipeline e, em pouco tempo, você terá um histórico valioso de performance para tomar decisões de capacidade, escalabilidade e refatoração com dados concretos.

Devops

Entrar em contato

Entre em contato