A performance de uma aplicação é tão importante quanto sua funcionalidade. Mesmo a melhor das aplicações pode falhar se não conseguir atender às expectativas de tempo de resposta ou escalabilidade. É aqui que entram os testes de performance, uma etapa essencial no ciclo de desenvolvimento para garantir que sua aplicação consiga lidar com diferentes níveis de carga e usuários simultâneos.

Integrar testes de performance aos pipelines de CI/CD (Integração e Entrega Contínua) permite identificar problemas cedo, antes que eles cheguem aos usuários finais. Neste artigo exploramos como usar o JMeter e o K6, duas ferramentas populares para testes de performance, em pipelines automatizados.

O que são testes de performance?

Testes de performance são processos que avaliam como um sistema se comporta sob diferentes condições de carga, como o número de usuários simultâneos ou o volume de transações. Eles ajudam a identificar gargalos, validar a escalabilidade e garantir a confiabilidade de uma aplicação.

Os principais tipos de testes de performance incluem:

  • Teste de carga: avalia como o sistema lida com uma quantidade específica de usuários ou transações.
  • Teste de estresse: verifica os limites do sistema, aumentando gradualmente a carga até que ocorra uma falha.
  • Teste de capacidade: determina o número máximo de usuários que o sistema pode suportar enquanto mantém o desempenho aceitável.
  • Teste de pico: analisa o comportamento do sistema durante períodos de aumento repentino de carga.

Por que automatizar testes de performance?

Integrar testes de performance aos pipelines de CI/CD traz benefícios significativos:

  • Detecção precoce de problemas: identificar problemas de performance antes que eles impactem os usuários.
  • Feedback contínuo: garantir que cada alteração de código não degrade o desempenho.
  • Redução de custos: corrigir problemas de performance em estágios iniciais do desenvolvimento é mais barato do que resolvê-los em produção.
  • Escalabilidade garantida: simular condições reais de uso regularmente ajuda a garantir que sua aplicação esteja pronta para crescer.

Testes de performance com JMeter

O JMeter é uma das ferramentas mais populares para testes de performance. Ele suporta uma ampla variedade de protocolos, incluindo HTTP, HTTPS, FTP e até mesmo serviços de mensagens.

Configurando um teste no JMeter

  1. Baixe e instale o JMeter a partir do site oficial.
  2. Crie um novo plano de teste e adicione um Thread Group, que define o número de usuários simultâneos e o período de execução.
  3. Adicione um HTTP Request Sampler para configurar as requisições que serão testadas.
  4. Use Listeners como o “View Results in Table” para visualizar os resultados.

Automatizando com JMeter no pipeline

O JMeter pode ser facilmente integrado ao pipeline usando a CLI (Command Line Interface) ou ferramentas como o Maven. Um exemplo de comando para executar um teste seria:

				
					jmeter -n -t teste.jmx -l resultados.jtl -e -o relatório/

Esse comando executa um teste no modo não interativo, gera resultados em um arquivo .jtl e cria um relatório HTML. No pipeline, você pode configurar uma etapa que executa esse comando após o build ou os testes unitários.

Exemplo de integração com GitLab CI/CD

				
					performance_tests:
  stage: test
  image: openjdk:11
  script:
    - apt-get update && apt-get install -y jmeter
    - jmeter -n -t teste.jmx -l resultados.jtl -e -o relatorio/
  artifacts:
    paths:
      - relatorio/

Simplicidade e eficiência para testes com K6

O K6 é uma ferramenta leve e focada em desenvolvedores para realizar testes de carga e performance. Ele se destaca por sua integração com pipelines e pela facilidade de escrita de scripts em JavaScript.

Criando um teste com K6

  1. Instale o K6 a partir do site oficial ou usando um gerenciador de pacotes.
  2. Crie um script em JavaScript para definir os cenários de teste. Por exemplo:
				
					import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
  stages: [
    { duration: '1m', target: 10 }, // 10 usuários em 1 minuto
    { duration: '2m', target: 50 }, // Aumenta para 50 usuários
    { duration: '1m', target: 0 },  // Reduz para 0 usuários
  ],
};

export default function () {
  let res = http.get('https://minhaaplicacao.com');
  check(res, { 'status é 200': (r) => r.status === 200 });
  sleep(1);
}

Automatizando com K6 no pipeline

A execução de testes K6 é simples e pode ser integrada diretamente a um pipeline. Um exemplo de configuração para GitHub Actions:

				
					name: Performance Tests

on: [push]

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v2
      - name: Install K6
        run: |
          sudo apt-get update
          sudo apt-get install -y k6
      - name: Run K6 Test
        run: k6 run script.js

Essa configuração executa os testes toda vez que há um push no repositório, garantindo que alterações no código não degradem o desempenho.

Comparando JMeter e K6

Enquanto o JMeter é uma ferramenta mais robusta, com suporte a diversos protocolos e um ambiente gráfico rico, o K6 é focado em simplicidade, integração com pipelines e suporte moderno. A escolha depende das necessidades do projeto:

  • Use JMeter se precisar de suporte a protocolos específicos ou testes complexos.
  • Use K6 para pipelines modernos e testes de performance baseados em JavaScript.

Acelere a sua carreira conosco!

A Mentoria DevOps é um programa de mentoria de 12 meses com encontros semanais ao vivo, com um grupo seleto e restrito, onde estaremos do seu lado para mantê-lo relevante e atualizado no mercado de tecnologia, aprendendo e implementando as melhores práticas e ferramentas de DevOps.

Clique aqui para aplicar para a Mentoria

Conclusão

Testes de performance são uma etapa essencial no desenvolvimento de software. Ferramentas como JMeter e K6 permitem simular condições reais de uso, identificar gargalos e garantir que sua aplicação seja confiável e escalável.

Integrar esses testes aos pipelines de CI/CD traz benefícios como feedback contínuo, detecção precoce de problemas e maior confiança na qualidade do produto final. Escolha a ferramenta que melhor atende às suas necessidades, configure seus scripts e veja como o desempenho da sua aplicação pode ser levado a um novo nível.