Como Rastrear Referências na Integração Contínua com o Bencher

A maioria dos resultados de benchmark é efêmera. Eles desaparecem assim que o seu terminal atinge o seu limite de retrocesso. Alguns sistemas de benchmark permitem armazenar os resultados, mas a maioria o faz apenas localmente. Bencher permite que você rastreie os seus benchmarks tanto de execuções locais quanto de CI e compare os resultados, enquanto ainda utiliza seu sistema de benchmark favorito.

Há duas maneiras populares de comparar resultados de benchmark quando se pratica o Benchmark Contínuo, ou seja, benchmark em CI:

• Benchmark Contínuo Estatístico
  1. Acompanhar os resultados de benchmark ao longo do tempo para criar uma base de referência
  2. Usar essa base de referência junto com Limites Estatísticos para criar um limite estatístico
  3. Compara os novos resultados com este limite estatístico para detectar regressões de desempenho
• Benchmark Contínuo Relativo
  1. Executar os benchmarks para o código de base atual
  2. Usar Limites Percentuais para criar um limite para o código de base
  3. Mudar para a nova versão do código
  4. Executar os benchmarks para a nova versão do código
  5. Comparar os resultados da nova versão do código com os resultados do código de base para detectar regressões de desempenho

Benchmarking Contínuo Estatístico

Continuando de onde paramos nos tutoriais de Início Rápido e Self-Hosted com Docker, vamos adicionar o Benchmarking Contínuo Estatístico ao nosso projeto Save Walter White.

🐰 Certifique-se de ter criado um token de API e configurado como a variável de ambiente BENCHER_API_TOKEN antes de continuar!

Primeiro, precisamos criar um novo Testbed para representar nossos runners de CI, apropriadamente nomeado ci-runner.

bencher testbed create \
--name ci-runner \
save-walter-white-1234abcd

1. Use o subcomando bencher testbed create da CLI. Veja a documentação do testbed create para mais detalhes. (ex: bencher testbed create)
2. Defina a opção --name para o nome desejado do Testbed. (ex: --name ci-runner)
3. Especifique o argumento do projeto como o slug do projeto Save Walter White. (ex: save-walter-white-1234abcd)

Em seguida, precisamos criar um novo Threshold para o nosso Testbed ci-runner:

bencher threshold create \
--branch main \
--testbed ci-runner \
--measure Latency \
--test t-test \
--upper-boundary 0.95 \
save-walter-white-1234abcd

1. Use o subcomando bencher threshold create da CLI. Veja a documentação do threshold create para mais detalhes. (ex: bencher threshold create)
2. Defina a opção --branch para o Branch padrão main. (ex: --branch main)
3. Defina a opção --branch para o novo Testbed ci-runner. (ex: --testbed ci-runner)
4. Defina a opção --measure para a Medida Latency embutida gerada pelo bencher mock. Veja a definição de Medida para mais detalhes. (ex: --measure Latency)
5. Defina a opção --test para um Threshold t-test. Veja Thresholds & Alerts para uma visão geral completa. (ex: --test t-test)
6. Defina a opção --upper-boundary para um Limite Superior de 0.95. Veja Thresholds & Alerts para uma visão geral completa. (ex: --upper-boundary 0.95)
7. Especifique o argumento do projeto como o slug do projeto Save Walter White. (ex: save-walter-white-1234abcd)

Agora estamos prontos para rodar nossos benchmarks no CI. Como cada ambiente de CI é um pouco diferente, o exemplo a seguir é mais ilustrativo do que prático. Para exemplos mais específicos, veja Benchmarking Contínuo no GitHub Actions e Benchmarking Contínuo no GitLab CI/CD.

Precisamos criar e manter uma linha de base histórica para nosso branch main benchmarkeando cada mudança no CI:

bencher run \
--project save-walter-white-1234abcd \
--branch main \
--testbed ci-runner \
--adapter json \
--err \
bencher mock

1. Use o subcomando bencher run da CLI para rodar os benchmarks do seu branch feature-branch. Veja a documentação do subcomando bencher run para uma visão geral completa. (ex: bencher run)
2. Defina a opção --project para o slug do Projeto. Veja a documentação do --project para mais detalhes. (ex: --project save-walter-white-1234abcd)
3. Defina a opção --branch para o nome do Branch padrão. Veja a seleção de branch para uma visão geral completa. (ex: --branch main)
4. Defina a opção --testbed para o nome do Testbed. Veja a documentação do --tested para mais detalhes. (ex: --testbed ci-runner)
5. Defina a opção --adapter para o adaptador de harness de benchmark desejado. Veja os adaptadores de harness de benchmark para uma visão geral completa. (ex: --adapter json)
6. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Threshold & Alerts para uma visão geral completa. (ex: --err)
7. Especifique os argumentos do comando de benchmark. Veja o comando de benchmark para uma visão geral completa. (ex: bencher mock)

Finalmente, estamos prontos para detectar regressões de desempenho no CI. É assim que rastrearemos o desempenho de um novo branch de funcionalidades, chamado feature-branch, no CI:

bencher run \
--project save-walter-white-1234abcd \
--branch feature-branch \
--branch-start-point main \
--branch-start-point-hash 32aea434d751648726097ed3ac760b57107edd8b \
--branch-reset \
--testbed ci-runner \
--adapter json \
--err \
bencher mock

1. Use o subcomando bencher run da CLI para rodar os benchmarks do seu branch feature-branch. Veja a documentação do subcomando bencher run para uma visão geral completa. (ex: bencher run)
2. Defina a opção --project para o slug do Projeto. Veja a documentação do --project para mais detalhes. (ex: --project save-walter-white-1234abcd)
3. Defina a opção --branch para o nome do Branch de funcionalidades. Veja a seleção de branch para uma visão geral completa. (ex: --branch feature-branch)
4. Defina a opção --branch-start-point para o ponto de início do Branch de funcionalidades. Veja a seleção de branch para uma visão geral completa. (ex: --branch-start-point main)
5. Defina a opção --branch-start-point-hash para o hash git do ponto de início do Branch de funcionalidades. Veja a seleção de branch para uma visão geral completa. (ex: --branch-start-point-hash 32ae...dd8b)
6. Defina a flag --branch-reset para sempre redefinir o Branch para o ponto de início. Isso evitará deriva de dados de benchmark. Veja a seleção de branch para uma visão geral completa. (ex: --branch-reset)
7. Defina a opção --testbed para o nome do Testbed. Veja a documentação do --tested para mais detalhes. (ex: --testbed ci-runner)
8. Defina a opção --adapter para o adaptador de harness de benchmark desejado. Veja os adaptadores de harness de benchmark para uma visão geral completa. (ex: --adapter json)
9. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Threshold & Alerts para uma visão geral completa. (ex: --err)
10. Especifique os argumentos do comando de benchmark. Veja o comando de benchmark para uma visão geral completa. (ex: bencher mock)

Na primeira vez que este comando for executado no CI, ele criará o Branch feature-branch já que ele ainda não existe. O novo feature-branch usará o Branch main no hash 32aea434d751648726097ed3ac760b57107edd8b como seu ponto de início. Isso significa que feature-branch terá uma cópia de todos os dados e Thresholds do Branch main para comparar os resultados do bencher mock para a primeira e todas as execuções subsequentes.

Benchmarking Contínuo Relativo

Continuando de onde paramos nos tutoriais Início Rápido e Docker Auto Hospedado, vamos adicionar o Benchmarking Contínuo Relativo ao nosso projeto Salve Walter White.

🐰 Certifique-se de ter criado um token de API e configurado como a variável de ambiente BENCHER_API_TOKEN antes de continuar!

Primeiro, precisamos criar um novo Testbed para representar nossos executores CI, apropriadamente chamado de ci-runner.

bencher testbed create \
--name ci-runner \
save-walter-white-1234abcd

1. Use o subcomando CLI bencher testbed create. Veja a documentação testbed create para mais detalhes. (ex: bencher testbed create)
2. Defina a opção --name para o nome desejado do Testbed. (ex: --name ci-runner)
3. Especifique o argumento do projeto como o slug do projeto Salve Walter White. (ex: save-walter-white-1234abcd)

O Benchmarking Contínuo Relativo executa uma comparação lado a lado de duas versões do seu código. Isso pode ser útil ao lidar com ambientes de CI/CD ruidosos, onde os recursos disponíveis podem ser altamente variáveis entre as execuções. Neste exemplo, estaremos comparando os resultados da execução na branch main com os resultados de execução em uma branch de recurso chamada feature-branch. Como cada ambiente de CI é um pouco diferente, o seguinte exemplo destina-se a ser mais ilustrativo do que prático. Para exemplos mais específicos, veja Benchmarking Contínuo no GitHub Actions e Benchmarking Contínuo no GitLab CI/CD.

Primeiro, precisamos fazer checkout da branch main com git no CI:

git checkout main

Em seguida, precisamos executar nossos benchmarks na branch main no CI:

bencher run \
--project save-walter-white-1234abcd \
--branch feature-branch \
--branch-reset \
--testbed ci-runner \
--adapter json \
bencher mock

1. Use o subcomando CLI bencher run para executar seus benchmarks na branch main. Veja o subcomando CLI bencher run para uma visão completa. (ex: bencher run)
2. Defina a opção --project para o slug do Projeto. Veja a documentação --project para mais detalhes. (ex: --project save-walter-white-1234abcd)
3. Defina a opção --branch para o nome da branch de recurso. Veja seleção de branch para uma visão completa. (ex: --branch feature-branch)
4. Defina a flag --branch-reset. Veja seleção de branch para uma visão completa. (ex: --branch-reset)
5. Defina a opção --testbed para o nome do Testbed. Veja a documentação --testbed para mais detalhes. (ex: --testbed ci-runner)
6. Defina a opção --adapter para o adaptador de harness de benchmark desejado. Veja adaptadores de harness de benchmark para uma visão completa. (ex: --adapter json)
7. Especifique os argumentos do comando de benchmark. Veja comando de benchmark para uma visão completa. (ex: bencher mock)

A primeira vez que este comando é executado no CI, criará a branch feature-branch já que ela ainda não existe. A nova feature-branch não terá um ponto de partida, dados existentes ou Limiares. Nas execuções subsequentes, a versão antiga da feature-branch será renomeada e uma nova feature-branch será criada sem um ponto de partida, dados existentes ou Limiares.

Em seguida, precisamos criar um novo Limiar no CI para nossa nova branch feature-branch:

bencher threshold create \
--branch feature-branch \
--testbed ci-runner \
--measure Latency \
--test percentage \
--upper-boundary 0.25 \
save-walter-white-1234abcd

1. Use o subcomando CLI bencher threshold create. Veja a documentação threshold create para mais detalhes. (ex: bencher threshold create)
2. Defina a opção --branch para a nova branch feature-branch. (ex: --branch feature-branch)
3. Defina a opção --branch para o Testbed ci-runner. (ex: --testbed ci-runner)
4. Defina a opção --measure para a Medida Latência gerada por bencher mock. Veja a definição de Medida para detalhes. (ex: --measure Latency)
5. Defina a opção --test para um Limiar de porcentagem. Veja Limiares & Alertas para uma visão completa. (ex: --test t-test)
6. Defina a opção --upper-boundary para um Limite Superior de 0.25 (ou seja, 25%). Veja Limiares & Alertas para uma visão completa. (ex: --upper-boundary 0.25)
7. Especifique o argumento do projeto como o slug do projeto Salve Walter White. (ex: save-walter-white-1234abcd)

Então, precisamos fazer checkout da branch feature-branch com git no CI:

git checkout feature-branch

Finalmente, estamos prontos para executar nossos benchmarks da feature-branch no CI:

bencher run \
--project save-walter-white-1234abcd \
--branch feature-branch \
--testbed ci-runner \
--adapter json \
--err \
bencher mock

1. Use o subcomando CLI bencher run para executar seus benchmarks da feature-branch. Veja o subcomando CLI bencher run para uma visão completa. (ex: bencher run)
2. Defina a opção --project para o slug do Projeto. Veja a documentação --project para mais detalhes. (ex: --project save-walter-white-1234abcd)
3. Defina a opção --branch para o nome da branch de recurso. Veja seleção de branch para uma visão completa. (ex: --branch feature-branch)
4. Defina a opção --testbed para o nome do Testbed. Veja a documentação --testbed para mais detalhes. (ex: --testbed ci-runner)
5. Defina a opção --adapter para o adaptador de harness de benchmark desejado. Veja adaptadores de harness de benchmark para uma visão completa. (ex: --adapter json)
6. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Limiar & Alertas para uma visão completa. (ex: --err)
7. Especifique os argumentos do comando de benchmark. Veja comando de benchmark para uma visão completa. (ex: bencher mock)

Toda vez que este comando for executado no CI, estará comparando os resultados da feature-branch apenas com os resultados mais recentes da main.

🐰 Parabéns! Você aprendeu como rastrear referências na Integração Contínua com o Bencher! 🎉

Adicionar o Bencher ao GitHub Actions ➡

Adicionar o Bencher ao GitLab CI/CD ➡