Como usar o Bencher no GitHub Actions

Dependendo do seu caso de uso, você pode configurar o Benchmarking Contínuo no GitHub Actions para o seu:

🐰 Certifique-se de ter criado um token da API e configurá-lo como um segredo do Repositório chamado BENCHER_API_TOKEN antes de continuar! Navegue até Seu Repositório -> Configurações -> Segredos e variáveis -> Ações -> Novo segredo do repositório. Nomeie o segredo como BENCHER_API_TOKEN e defina o valor do segredo para o seu token da API.

Ramo Base

Um pilar do Benchmarking Contínuo Estatístico é ter uma linha de base histórica para o seu ramo base. Essa linha de base histórica pode então ser utilizada para detectar regressões de desempenho em Pull Requests.

on:
  push:
    branches: main


jobs:
  benchmark_base_branch:
    name: Continuous Benchmarking with Bencher
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: bencherdev/bencher@main
      - name: Track base branch benchmarks with Bencher
        run: |
          bencher run \
          --project save-walter-white-1234abcd \
          --token '${{ secrets.BENCHER_API_TOKEN }}' \
          --branch main \
          --testbed ubuntu-latest \
          --adapter json \
          --err \
          bencher mock
  1. Crie um arquivo workflow do GitHub Actions. (ex: .github/workflows/base_benchmarks.yml)
  2. Execute em eventos de push para o ramo main. Veja a documentação on do GitHub Actions e a documentação push do GitHub Actions para uma visão geral completa. (ex: on: push: branches: main)
  3. Crie um job do GitHub Actions. (ex: jobs: benchmark_base_branch)
  4. Defina o tipo de máquina em que o trabalho será executado. Veja a documentação runs-on do GitHub Actions para uma visão geral completa. (ex: runs-on: ubuntu-latest)
  5. Faça checkout do código-fonte do seu ramo base. (ex: uses: actions/checkout@v4)
  6. Instale o CLI Bencher usando a GitHub Action. (ex: uses: bencherdev/bencher@main)
  7. Use o subcomando CLI bencher run para executar os benchmarks do seu ramo main. Veja o subcomando CLI bencher run para uma visão geral completa. (ex: bencher run)
  8. Defina a opção --project para o slug do Projeto. Veja os docs --project para mais detalhes. (ex: --project save-walter-white-1234abcd)
  9. Defina a opção --token para o segredo Repositório BENCHER_API_TOKEN. Veja os docs --token para mais detalhes. (ex: --token '${{ secrets.BENCHER_API_TOKEN }}')
  10. Defina a opção --branch para o nome do Ramo. Veja seleção de ramo para uma visão geral completa. (ex: --branch main)
  11. Defina a opção --testbed para o nome da Base de teste. Isso provavelmente deve corresponder à máquina selecionada em runs-on. Veja os docs --tested para mais detalhes. (ex: --testbed ubuntu-latest)
  12. Defina a opção --adapter para o adaptador de conjunto de benchmarks desejado. Veja adaptadores de conjunto de benchmarks para uma visão geral completa. (ex: --adapter json)
  13. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Limiares & Alertas para uma visão geral completa. (ex: --err)
  14. Especifique os argumentos do comando de benchmark. Veja comando de benchmark para uma visão geral completa. (ex: bencher mock)

Pull Requests

Para identificar regressões de desempenho em Pull Requests, você precisará executar seus benchmarks em PRs. Se você espera receber PRs apenas de branches dentro do mesmo repositório, então você pode simplesmente criar outro fluxo de trabalho para ser executado on eventos pull_request do mesmo repositório.

⚠️ Esta solução só funciona se todos os PRs forem do mesmo repositório! Veja Pull Requests de Forks abaixo.

on:
  pull_request:
    types: [opened, reopened, edited, synchronize]


jobs:
  benchmark_pr_branch:
    name: Continuous Benchmarking PRs with Bencher
    # DO NOT REMOVE: For handling Fork PRs see Pull Requests from Forks
    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
    permissions:
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: bencherdev/bencher@main
      - name: Track PR Benchmarks with Bencher
        run: |
          bencher run \
          --project save-walter-white-1234abcd \
          --token '${{ secrets.BENCHER_API_TOKEN }}' \
          --branch '${{ github.head_ref }}' \
          --branch-start-point '${{ github.base_ref }}' \
          --branch-start-point-hash '${{ github.event.pull_request.base.sha }}' \
          --testbed ubuntu-latest \
          --adapter json \
          --err \
          --github-actions '${{ secrets.GITHUB_TOKEN }}' \
          bencher mock

  1. Crie um arquivo de workflow do GitHub Actions. (ex: .github/workflows/pr_benchmarks.yml)

  2. Execute em eventos pull_request:

    • opened - Um pull request foi criado.
    • reopened - Um pull request fechado anteriormente foi reaberto.
    • edited - O título ou corpo de um pull request foi editado, ou a branch base de um pull request foi alterada.
    • synchronize - A branch de cabeçalho de um pull request foi atualizada. Por exemplo, a branch de cabeçalho foi atualizada a partir da branch base ou novos commits foram enviados para a branch de cabeçalho.

    Veja a documentação de on do GitHub Actions e documentação do pull_request do GitHub Actions para uma visão geral completa. (ex: on: pull_request: types: [opened, reopened, edited, synchronize])

  3. Crie um job no GitHub Actions. (ex: jobs: benchmark_pr_branch)

  4. Execute em eventos pull_request se e somente se o pull request for do mesmo repositório. ⚠️ NÃO REMOVA ESTA LINHA! Para lidar com PRs de Forks veja Pull Requests de Forks abaixo. (ex: if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository)

  5. Configure as permissões para o GITHUB_TOKEN para write para pull-requests. Dependendo das suas configurações do GitHub, isso pode não ser necessário. Mas para todas as organizações e repos pessoais criados após 02 Fev 2023, este é o comportamento padrão. Veja a documentação do GitHub para uma visão geral completa. (ex: permissions: pull-requests: write)

  6. Defina o tipo de máquina em que o trabalho será executado. Veja a documentação de runs-on do GitHub Actions para uma visão geral completa. (ex: runs-on: ubuntu-latest)

  7. Faça o checkout do código fonte da branch do PR. (ex: uses: actions/checkout@v4)

  8. Instale o Bencher CLI usando a GitHub Action. (ex: uses: bencherdev/bencher@main)

  9. Use o subcomando CLI bencher run para executar os benchmarks da sua branch de pull request. Veja o subcomando CLI bencher run para uma visão geral completa. (ex: bencher run)

  10. Defina a opção --project para o slug do Projeto. Veja os docs de --project para mais detalhes. (ex: --project save-walter-white-1234abcd)

  11. Defina a opção --token para o segredo Repositório BENCHER_API_TOKEN. Veja os docs de --token para mais detalhes. (ex: --token '${{ secrets.BENCHER_API_TOKEN }}')

  12. Defina a opção --branch para o nome da branch do PR usando o contexto github do GitHub Actions. Veja seleção de branch para uma visão geral completa. (ex: --branch '${{ github.head_ref }}')

  13. Defina a opção --branch-start-point para o ponto de início da Branch base do PR usando o contexto github do GitHub Actions. Veja seleção de branch para uma visão geral completa. (ex: --branch-start-point '${{ github.base_ref }}')

  14. Defina a opção --branch-start-point-hash para o hash do ponto de início da Branch base do PR usando o evento pull_request do GitHub Actions. Veja seleção de branch para uma visão geral completa. (ex: --branch-start-point-hash '${{ github.event.pull_request.base.sha }}')

  15. Defina a opção --testbed para o nome do Testbed. Isso provavelmente deve corresponder à máquina selecionada em runs-on. Veja os docs de --tested para mais detalhes. (ex: --testbed ubuntu-latest)

  16. Defina a opção --adapter para o adaptador desejado do benchmark harness. Veja adaptadores de benchmark harness para uma visão geral completa. (ex: --adapter json)

  17. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Threshold & Alerts para uma visão geral completa. (ex: --err)

  18. Defina a opção --github-actions para o token de autenticação da API do GitHub para postar resultados como um comentário no Pull Request usando a variável de ambiente GITHUB_TOKEN do GitHub Actions. Veja os docs de --github-actions para mais detalhes. (ex: --github-actions '${{ secrets.GITHUB_TOKEN }}')

  19. Especifique os argumentos do comando de benchmark. Veja comando de benchmark para uma visão geral completa. (ex: bencher mock)


Pull Requests a Partir de Forks

Se você planeja aceitar pull requests de forks, como é frequentemente o caso em projetos open source públicos, então você precisará lidar com as coisas de maneira um pouco diferente. Por razões de segurança, secrets como seu BENCHER_API_TOKEN e o GITHUB_TOKEN não estão disponíveis no GitHub Actions para PRs de forks. Isso quer dizer que, se um contribuidor externo abrir um PR a partir de um fork, o exemplo acima não funcionará. Existem duas opções para PRs de forks:

Veja este artigo do GitHub Security Lab e este post do blog sobre a prevenção de solicitações de pwn para uma visão geral completa.

Benchmark de Forks de PR e Upload a partir do Branch Padrão

Esta é a maneira segura e sugerida de adicionar Benchmarking Contínuo para pull requests de forks. Ela requer dois workflows separados. O primeiro workflow executa e armazena em cache os resultados do benchmark no contexto de pull_request. Nenhum segredo, como o seu BENCHER_API_TOKEN e o GITHUB_TOKEN estão disponíveis lá. Então, um segundo workflow faz o download dos resultados do benchmark armazenados em cache no contexto de workflow_run e os envia para o Bencher. Isso funciona porque o workflow_run executa no contexto do branch padrão do repositório, onde segredos como o seu BENCHER_API_TOKEN e o GITHUB_TOKEN estão disponíveis. O número do pull request, o branch de origem e o branch base usados no workflow pull_request inicial também devem ser explicitamente passados para o workflow workflow_run, já que eles não estão disponíveis lá. Esses workflows só serão executados se existirem no branch padrão. Veja usando dados do workflow de disparo para uma visão completa.

name: Run and Cache Benchmarks


on:
  pull_request:
    types: [opened, reopened, edited, synchronize]


jobs:
  benchmark_fork_pr_branch:
    name: Run Fork PR Benchmarks
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Mock Benchmarking
        run: |
          /bin/echo '{ "bencher::mock_0": { "latency": { "value": 1.0 } } }' > benchmark_results.json
      - name: Upload Benchmark Results
        uses: actions/upload-artifact@v4
        with:
          name: benchmark_results.json
          path: ./benchmark_results.json
      - name: Upload GitHub Pull Request Event
        uses: actions/upload-artifact@v4
        with:
          name: event.json
          path: ${{ github.event_path }}

  1. Crie um arquivo de workflow do GitHub Actions. (ex: .github/workflows/run_fork_pr_benchmarks.yml)

  2. Dê um nome a este workflow para que ele possa ser referenciado pelo segundo workflow. (ex: name: Executar e Armazenar em Cache os Benchmarks)

  3. Execute em eventos de pull_request:

    • opened - Um pull request foi criado.
    • reopened - Um pull request previamente fechado foi reaberto.
    • edited - O título ou corpo de um pull request foi editado, ou o branch base de um pull request foi alterado.
    • synchronize - O branch de origem de um pull request foi atualizado. Por exemplo, o branch de origem foi atualizado a partir do branch base ou novos commits foram enviados para o branch de origem.

    Veja a documentação do GitHub Actions on e documentação do GitHub Actions pull_request para uma visão completa. (ex: on: pull_request: types: [opened, reopened, edited, synchronize])

  4. Crie um job no GitHub Actions. (ex: jobs: benchmark_fork_pr_branch)

  5. Defina o tipo de máquina que o job será executado. Veja a documentação do GitHub Actions runs-on para uma visão completa. (ex: runs-on: ubuntu-latest)

  6. Faça checkout do código fonte do branch do PR do fork. (ex: uses: actions/checkout@v4)

  7. Execute seus benchmarks e salve os resultados em um arquivo. (ex: /bin/echo '{ ... }' > benchmark_results.json)

  8. Envie o arquivo de resultados do benchmark como artefato. (ex: uses: actions/upload-artifact@v4)

  9. Envie o objeto de evento de pull_request como artefato. (ex: uses: actions/upload-artifact@v4)

name: Track Benchmarks with Bencher


on:
  workflow_run:
    workflows: [Run and Cache Benchmarks]
    types: [completed]


jobs:
  track_fork_pr_branch:
    if: github.event.workflow_run.conclusion == 'success'
    runs-on: ubuntu-latest
    env:
      BENCHMARK_RESULTS: benchmark_results.json
      PR_EVENT: event.json
    steps:
      - name: Download Benchmark Results
        uses: actions/github-script@v6
        with:
          script: |
            async function downloadArtifact(artifactName) {
              let allArtifacts = await github.rest.actions.listWorkflowRunArtifacts({
                owner: context.repo.owner,
                repo: context.repo.repo,
                run_id: context.payload.workflow_run.id,
              });
              let matchArtifact = allArtifacts.data.artifacts.filter((artifact) => {
                return artifact.name == artifactName
              })[0];
              if (!matchArtifact) {
                core.setFailed(`Failed to find artifact: ${artifactName}`);
              }
              let download = await github.rest.actions.downloadArtifact({
                owner: context.repo.owner,
                repo: context.repo.repo,
                artifact_id: matchArtifact.id,
                archive_format: 'zip',
              });
              let fs = require('fs');
              fs.writeFileSync(`${process.env.GITHUB_WORKSPACE}/${artifactName}.zip`, Buffer.from(download.data));
            }
            await downloadArtifact(process.env.BENCHMARK_RESULTS);
            await downloadArtifact(process.env.PR_EVENT);
      - name: Unzip Benchmark Results
        run: |
          unzip $BENCHMARK_RESULTS.zip
          unzip $PR_EVENT.zip
      - name: Export PR Event Data
        uses: actions/github-script@v6
        with:
          script: |
            let fs = require('fs');
            let prEvent = JSON.parse(fs.readFileSync(process.env.PR_EVENT, {encoding: 'utf8'}));
            core.exportVariable("PR_HEAD", `${prEvent.number}/merge`);
            core.exportVariable("PR_BASE", prEvent.pull_request.base.ref);
            core.exportVariable("PR_BASE_SHA", prEvent.pull_request.base.sha);
            core.exportVariable("PR_NUMBER", prEvent.number);
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --project save-walter-white-1234abcd \
          --token '${{ secrets.BENCHER_API_TOKEN }}' \
          --branch '${{ env.PR_HEAD }}' \
          --branch-start-point '${{ env.PR_BASE }}' \
          --branch-start-point-hash '${{ env.PR_BASE_SHA }}' \
          --testbed ubuntu-latest \
          --adapter json \
          --err \
          --github-actions '${{ secrets.GITHUB_TOKEN }}' \
          --ci-number '${{ env.PR_NUMBER }}' \
          --file "$BENCHMARK_RESULTS"
  1. Crie um arquivo de workflow do GitHub Actions. (ex: .github/workflows/track_fork_pr_benchmarks.yml)
  2. Nomeie este segundo workflow. (ex: name: Acompanhar Benchmarks com Bencher)
  3. Encadeie os dois workflows com o evento workflow_run. (ex: on: workflow_run: ...)
  4. Crie um job no GitHub Actions. (ex: jobs: track_fork_pr_branch)
  5. Execute este job apenas se a conclusão do workflow anterior foi um sucesso usando o evento workflow_run do GitHub Actions. (ex: if: github.event.workflow_run.conclusion == 'success')
  6. Defina o tipo de máquina que o job será executado. Veja a documentação do GitHub Actions runs-on para uma visão completa. (ex: runs-on: ubuntu-latest)
  7. Defina os nomes dos arquivos de resultados do benchmark e do evento de pull_request como variáveis de ambiente. (ex: env: ...)
  8. Faça o download dos resultados do benchmark em cache e do evento de pull_request. (ex: uses: actions/github-script@v6)
  9. Extraia os resultados do benchmark em cache e o evento de pull_request. (ex: unzip ...)
  10. Exporte os dados necessários do evento de pull_request como variáveis de ambiente. (ex: core.exportVariable(...))
  11. Instale a CLI do Bencher usando a Ação do GitHub. (ex: uses: bencherdev/bencher@main)
  12. Use o subcomando da CLI bencher run para acompanhar os benchmarks do seu branch de pull request de fork. Veja o subcomando bencher run da CLI para uma visão completa. (ex: bencher run)
  13. Defina a opção --project para o slug do Projeto. Veja os docs da opção --project para mais detalhes. (ex: --project save-walter-white-1234abcd)
  14. Defina a opção --token para o segredo Repositório BENCHER_API_TOKEN. Veja os docs da opção --token para mais detalhes. (ex: --token '${{ secrets.BENCHER_API_TOKEN }}')
  15. Defina a opção --branch para o número formatado do PR de fork usando o evento pull_request do GitHub Actions. Veja a seleção de branch para uma visão completa. (ex: --branch '${{ env.PR_HEAD }}')
  16. Defina a opção --branch-start-point para o ponto inicial do branch base do PR de fork usando o evento pull_request do GitHub Actions. Veja a seleção de ponto inicial do branch para uma visão completa. (ex: --branch-start-point '${{ env.PR_BASE }}')
  17. Defina a opção --branch-start-point-hash para o hash do ponto inicial do branch base do PR de fork usando o evento pull_request do GitHub Actions. Veja a seleção de hash do ponto inicial do branch para uma visão completa. (ex: --branch-start-point-hash '${{ env.PR_BASE_SHA }}')
  18. Defina a opção --testbed para o nome do Testbed. Isso provavelmente deve coincidir com a máquina selecionada em runs-on. Veja os docs da opção --testbed para mais detalhes. (ex: --testbed ubuntu-latest)
  19. Defina a opção --adapter para o adaptador do harness de benchmark desejado. Veja adaptadores do harness de benchmark para uma visão completa. (ex: --adapter json)
  20. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Threshold & Alerts para uma visão completa. (ex: --err)
  21. Defina a opção --github-actions para o token de autenticação da API do GitHub para postar resultados como um comentário no Pull Request usando a variável de ambiente GITHUB_TOKEN do GitHub Actions. Veja os docs da opção --github-actions para mais detalhes. (ex: --github-actions '${{ secrets.GITHUB_TOKEN }}')
  22. Defina a opção --ci-number para o número do pull request. Veja os docs da opção --ci-number para mais detalhes. (ex: --ci-number '${{ env.PR_NUMBER }}')
  23. Defina a opção --file para o caminho do arquivo de resultados do benchmark. Veja o argumento do comando de benchmark para uma visão completa. (ex: --file "$BENCHMARK_RESULTS")

Benchmark de PRs de Fork em Relação à Branch Alvo com Revisores Obrigatórios

Para garantir que o código de um pull request de um fork é seguro, esta GitHub Action verifica se o fork é de outro repositório. Se o fork for de outro repositório, então precisará ser revisado.

⚠️ É muito, muito importante revisar cuidadosamente cada PR de fork antes de aprovar! Não fazer isso pode resultar em um pedido de comprometimento!

Se preferir não ter isso na sua consciência, veja [Benchmark de PR de Fork e Upload a partir da Branch Padrão][benchmark fork pr and upload from default branch] acima.

Para configurar este fluxo de trabalho, você precisa criar dois Ambientes de Ações do GitHub. Navegue até Seu Repositório -> Configurações -> Ambientes -> Novo ambiente. Crie dois novos ambientes, interno e externo. O ambiente interno não deve ter Regras de proteção de implantação. No entanto, o ambiente externo deve ter Revisores obrigatórios definidos para aqueles confiáveis para revisar PRs de fork antes de fazer o benchmark. Veja este post do blog para uma visão geral completa.

Esta configuração funciona porque pull_request_target é executado no contexto da branch alvo do pull request, onde segredos como seu BENCHER_API_TOKEN e o GITHUB_TOKEN estão disponíveis. Portanto, este fluxo de trabalho só será executado se existir na branch alvo. Evite definir quaisquer segredos como variáveis de ambiente, como GITHUB_TOKEN e BENCHER_API_TOKEN. Em vez disso, passe explicitamente seus segredos para bencher run.

on:
  pull_request_target:
    types: [opened, reopened, edited, synchronize]


jobs:
  fork_pr_requires_review:
    environment: ${{ (github.event.pull_request.head.repo.full_name == github.repository && 'internal') || 'external' }}
    runs-on: ubuntu-latest
    steps:
      - run: true


  benchmark_fork_pr_branch:
    needs: fork_pr_requires_review
    name: Continuous Benchmarking Fork PRs with Bencher
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          repository: ${{ github.event.pull_request.head.repo.full_name }}
          ref: ${{ github.event.pull_request.head.sha }}
          persist-credentials: false
      - uses: bencherdev/bencher@main
      - name: Track Fork PR Benchmarks with Bencher
        run: |
          bencher run \
          --project save-walter-white-1234abcd \
          --token '${{ secrets.BENCHER_API_TOKEN }}' \
          --branch '${{ github.event.number }}/merge' \
          --branch-start-point '${{ github.base_ref }}' \
          --branch-start-point-hash '${{ github.event.pull_request.base.sha }}' \
          --testbed ubuntu-latest \
          --adapter json \
          --err \
          --github-actions '${{ secrets.GITHUB_TOKEN }}' \
          bencher mock

  1. Crie um arquivo de workflow de Ações do GitHub. (ex: .github/workflows/pr_target_benchmarks.yml)

  2. Execute em eventos de pull_request:

    • opened - Um pull request foi criado.
    • reopened - Um pull request fechado anteriormente foi reaberto.
    • edited - O título ou corpo de um pull request foi editado, ou a branch base de um pull request foi alterada.
    • synchronize - A branch de cabeçalho de um pull request foi atualizada. Por exemplo, a branch de cabeçalho foi atualizada a partir da branch base ou novos commits foram enviados para a branch de cabeçalho.

    Veja a documentação on das Ações do GitHub e a documentação pull_request das Ações do GitHub para uma visão geral completa. (ex: on: pull_request: types: [opened, reopened, edited, synchronize])

  3. Crie o primeiro job das Ações do GitHub para verificar se o fluxo de trabalho requer revisão. (ex: jobs: fork_pr_requires_review)

  4. Defina o ambiente para interno se e somente se o pull request for do mesmo repositório. Caso contrário, defina o ambiente para externo, o que exigirá a aprovação de um revisor para continuar. ⚠️ NÃO REMOVA ESTA LINHA! (ex: environment: ${{ (github.event.pull_request.head.repo.full_name == github.repository && 'interno') || 'externo' }})

  5. Crie um segundo job das Ações do GitHub para executar seus benchmarks. (ex: benchmark_fork_pr_branch)

  6. Faça com que o job benchmark_fork_pr_branch precise do job fork_pr_requires_review para ser executado. ⚠️ NÃO REMOVA ESTA LINHA! Veja a documentação needs das Ações do GitHub para uma visão geral completa. (ex: needs: fork_pr_requires_review)

  7. Defina o tipo de máquina em que o job será executado. Veja a documentação runs-on das Ações do GitHub para uma visão geral completa. (ex: runs-on: ubuntu-latest)

  8. Faça checkout do código fonte do PR de fork. Como pull_request_target é executado no contexto da branch alvo do pull request,    você ainda precisa fazer checkout da branch do pull request. (ex: uses: actions/checkout@v4)

    • Especifique o repositório do PR de fork (ex: repository: ${{ github.event.pull_request.head.repo.full_name }})
    • Especifique o hash do PR de fork (ex: ref: ${{ github.event.pull_request.head.sha }})
    • Não persista suas credenciais de git (ex: persist-credentials: false)

  9. Instale o CLI do Bencher usando a Ação do GitHub. (ex: uses: bencherdev/bencher@main)

  10. Use o subcomando CLI bencher run para executar os benchmarks da branch do pull request de fork. Veja o subcomando CLI bencher run para uma visão geral completa. (ex: bencher run)

  11. Defina a opção --project para o slug do Projeto. Veja os docs da opção --project para mais detalhes. (ex: --project save-walter-white-1234abcd)

  12. Defina a opção --token para o segredo Repositório BENCHER_API_TOKEN. Veja os docs da opção --token para mais detalhes. (ex: --token '${{ secrets.BENCHER_API_TOKEN }}')

  13. Defina a opção --branch para o número formatado do PR de fork usando o evento pull_request das Ações do GitHub. Veja seleção de branch para uma visão geral completa. (ex: --branch '${{ github.event.number }}/merge')

  14. Defina a opção --branch-start-point para o ponto inicial da branch base do PR de fork usando o contexto github das Ações do GitHub. Veja seleção de branch para uma visão geral completa. (ex: --branch-start-point '${{ github.base_ref }}')

  15. Defina a opção --branch-start-point-hash para o hash do ponto inicial da branch base do PR de fork usando o evento pull_request das Ações do GitHub. Veja seleção de branch para uma visão geral completa. (ex: --branch-start-point-hash '${{ github.event.pull_request.base.sha }}')

  16. Defina a opção --testbed para o nome do Testbed. Isso provavelmente deve corresponder à máquina selecionada em runs-on. Veja os docs da opção --testbed para mais detalhes. (ex: --testbed ubuntu-latest)

  17. Defina a opção --adapter para o adaptador de harness desejado. Veja adaptadores de harness para uma visão geral completa. (ex: --adapter json)

  18. Defina a flag --err para falhar o comando se um Alerta for gerado. Veja Limiares & Alertas para uma visão geral completa. (ex: --err)

  19. Defina a opção --github-actions para o token de autenticação da API do GitHub para postar resultados como um comentário no Pull Request usando a variável de ambiente GITHUB_TOKEN das Ações do GitHub. Veja os docs da opção --github-actions para mais detalhes. (ex: --github-actions '${{ secrets.GITHUB_TOKEN }}')

  20. Especifique os argumentos do comando de benchmark. Veja comando de benchmark para uma visão geral completa. (ex: bencher mock)



🐰 Parabéns! Você aprendeu como usar o Bencher no GitHub Actions! 🎉


Continue a Aprender: Visão Geral do Benchmarking ➡

🤖 Este documento foi gerado automaticamente pelo OpenAI GPT-4. Pode não ser preciso e pode conter erros. Se você encontrar algum erro, abra um problema no GitHub.

Published: Fri, October 27, 2023 at 8:40:00 AM UTC | Last Updated: Mon, April 1, 2024 at 7:00:00 AM UTC