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 Estatístico Contínuo

Dando continuidade ao que foi visto nos tutoriais Início Rápido e Auto- Hospedagem com Docker, vamos adicionar o Benchmarking Contínuo Estatístico ao nosso projeto Salvar Walter White.

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

Primeiro, precisamos criar um novo Testbed para representar nossos runners de CI, apropriadamente chamado 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 Salvar Walter White. (ex: save-walter-white-1234abcd)

Em seguida, precisamos criar um novo Limiar para 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 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 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 Latência incorporada, que é gerada pelo bencher mock. Veja a definição de Medida para detalhes. (ex: --measure Latency)
5. Defina a opção --test para um Limiar de t-test. 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.95. Veja Limiares & Alertas para uma visão completa. (ex: --upper-boundary 0.95)
7. Especifique o argumento do projeto como o slug do projeto Salvar Walter White. (ex: save-walter-white-1234abcd)

Agora estamos prontos para executar 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 nossa branch main executando benchmarks de todas as mudanças no CI:

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

1. Use o subcomando CLI bencher run para executar os benchmarks da sua branch 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 padrão. Veja seleção de branch para uma visão completa. (ex: --branch main)
4. Defina a opção --testbed para o nome do Testbed. Veja a documentação --tested 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 opção --err para falhar o comando se um Alerta for gerado. Veja Limiares & 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)

Finalmente, estamos prontos para detectar regressões de desempenho no CI. Assim é como acompanharíamos o desempenho de uma nova branch de recurso, chamada feature-branch, no CI:

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

1. Use o subcomando CLI bencher run para executar os benchmarks da sua branch 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 --branch-start-point para o ponto de início da branch de recurso. Veja seleção de branch para uma visão completa. (ex: --branch-start-point main)
5. Defina a opção --branch-start-point-hash para o hash git do ponto de início da branch de recurso. Veja seleção de branch para uma visão completa. (ex: --branch-start-point-hash 32ae...dd8b)
6. Defina a opção --testbed para o nome do Testbed. Veja a documentação --tested para mais detalhes. (ex: --testbed ci-runner)
7. 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)
8. Defina a opção --err para falhar o comando se um Alerta for gerado. Veja Limiares & Alertas para uma visão completa. (ex: --err)
9. 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 for executado no CI, ele criará a branch feature-branch uma vez que ela ainda não existe. A nova feature-branch usará a 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 Limiares da branch main para comparar os resultados do bencher mock contra, 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 ➡