Comment utiliser Bencher dans GitHub Actions

on:
  push:
    branches: main

jobs:
  benchmark_with_bencher:
    name: Continuous Benchmarking with Bencher
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }}
      BENCHER_TESTBED: ubuntu-latest
      BENCHER_ADAPTER: json
    steps:
      - uses: actions/checkout@v3
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --branch main \
          --err \
          "bencher mock"

1. Créez un fichier workflow pour GitHub Actions. (ex: .github/workflows/benchmark.yml)
2. Exécutez sur les événements push vers la branche main. Consultez la documentation on de GitHub Actions pour une vue d’ensemble complète. Voir aussi Pull Requests ci-dessous.
3. Créez un job pour GitHub Actions. (ex: benchmark_with_bencher)
4. Le Projet doit déjà exister. Définissez le drapeau --project ou la variable d’environnement BENCHER_PROJECT avec le slug ou l’UUID du Projet (ex: BENCHER_PROJECT: save-walter-white).
5. Le jeton API doit déjà exister. Ajoutez BENCHER_API_TOKEN en tant que secret Repository. (ex: Repo -> Settings -> Secrets and variables -> Actions -> New repository secret). Définissez le drapeau --tokenou la variable d’environnement BENCHER_API_TOKEN avec le jeton API. (ex: BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }})
6. Optionnel : réglez le drapeau --testbed ou la variable d’environnement BENCHER_TESTBED amenant au slug ou à l’UUID de Testbed. (ex: BENCHER_TESTBED: ubuntu-latest) Le Testbed doit déjà exister. Si ce n’est pas défini, le Testbed localhost sera utilisé.
7. Optionnel : réglez le drapeau --adapter ou la variable d’environnement BENCHER_ADAPTER avec le nom de l’adaptateur désiré. (ex: BENCHER_ADAPTER: json) Si ce n’est pas défini, l’Adaptateur magic sera utilisé. Consultez les adaptateurs de harnais de benchmark pour une vue d’ensemble complète.
8. Extraites votre code source. (ex: uses: actions/checkout@v3)
9. Installez le CLI de Bencher en utilisant GitHub Action. (ex: uses: bencherdev/bencher@main)
10. Suivez vos benchmarks avec la sous-commande CLI bencher run:
    1. Optionnel : réglez le drapeau --branch ou la variable d’environnement BENCHER_BRANCH avec le slug ou l’UUID de la Branche. (ex: --branch main). La Branche doit déjà exister. Si ce n’est pas défini, la branche main sera utilisée.
    2. Paramétrez la commande pour échouer si une Alerte est générée. (ex: --err) Pour qu’une Alerte soit générée, un Seuil doit déjà exister.
    3. Exécutez vos benchmarks et générez un Account à partir des résultats. (ex: "bencher mock")

Pull Requests

Pour détecter la régression de performance dans les Pull Requests, vous devrez exécuter vos benchmarks sur les PRs. Si vous prévoyez uniquement d’avoir des PRs provenant de branches au sein du même dépôt, vous pouvez simplement modifier l’exemple ci-dessus pour également exécuter on sur les événements pull_request.

⚠️ Cette solution ne fonctionne que si toutes les PRs proviennent du même dépôt! Voir Pull Requests à partir de Forks ci-dessous.

on:
  push:
    branches: main
  pull_request:

jobs:
  benchmark_with_bencher:
    name: Continuous Benchmarking with Bencher
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }}
      BENCHER_TESTBED: ubuntu-latest
      BENCHER_ADAPTER: json
    steps:
      - uses: actions/checkout@v3
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --if-branch "$GITHUB_REF_NAME" \
          --else-if-branch "$GITHUB_BASE_REF" \
          --else-if-branch main \
          --github-actions ${{ secrets.GITHUB_TOKEN }} \
          --err \
          "bencher mock"

1. Exécutez sur les événements push à la branche main et sur les événements pull_request. Il est important de limiter l’exécution on push uniquement à certaines branches selectionnées (ex: main) pour empêcher les pushes vers les branches de PR de s’exécuter deux fois!
2. Au lieu d’utiliser toujours la branche main, utilisez les variables d’environnement par défaut de GitHub Action pour :
   1. Utiliser des données de branche actuelles si elles existent déjà. (ex: --if-branch "$GITHUB_REF_NAME")
   2. Créer un clone des données et des seuils de la branche cible de la PR si cela existe déjà. (ex: --else-if-branch "$GITHUB_BASE_REF")
   3. Sinon, créez un clone des données et des seuils de la branche main. (ex: --else-if-branch main)
   4. Il existe plusieurs options pour définir la branche du projet. Voir la sélection de branche pour une vue d’ensemble complète.
3. Paramétrez le jeton d’authentification de l’API GitHub. (ex: --github-actions ${{ secrets.GITHUB_TOKEN }}). Lorsque cette option est définie dans le cadre d’une pull request, alors les résultats seront ajoutés à la pull request sous forme de commentaire. Ceci utilise la variable d’environnement GITHUB_TOKEN des GitHub Actions.
4. Consultez la documentation bencher run pour une vue d’ensemble complète de toutes les façons de configurer le commentaire de pull request avec les drapeaux --ci-*.

Pull Requests à partir de Forks

Si vous prévoyez d’accepter les pull requests à partir de forks, comme c’est souvent le cas dans les projets open source publics, alors vous devrez gérer les choses un peu différemment. Pour des raisons de sécurité, les secrets tels que votre BENCHER_API_TOKEN et le GITHUB_TOKEN ne sont pas disponibles dans GitHub Actions pour les PRs de fork. C’est-à-dire que si un contributeur externe ouvre une PR à partir d’un fork, l’exemple ci-dessus ne fonctionnera pas. Il y a trois options pour les PRs de fork :

• Tester la PR de Fork à partir de la Branche Cible
• Tester la PR de Fork à partir de la Branche Cible avec Réviseurs Nécessaires
• Tester la PR de Fork et Télécharger à partir de la Branche par Défaut

Tester la PR de Fork à partir de la Branche Cible

on:
  push:
    branches: main
  pull_request_target:

jobs:
  benchmark_main_with_bencher:
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    name: Benchmark main with Bencher
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }}
      BENCHER_TESTBED: ubuntu-latest
      BENCHER_ADAPTER: json
    steps:
      - uses: actions/checkout@v3
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --branch main \
          --err \
          "bencher mock"

  benchmark_pr_with_bencher:
    if: github.event_name == 'pull_request_target'
    name: Benchmark PR with Bencher
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_ADAPTER: json
      BENCHER_TESTBED: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          repository: ${{ github.event.pull_request.head.repo.full_name }}
          persist-credentials: false
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --if-branch "${{ github.event.pull_request.head.ref }}" \
          --else-if-branch "${{ github.event.pull_request.base.ref }}" \
          --else-if-branch main \
          --github-actions "${{ secrets.GITHUB_TOKEN }}" \
          --token "${{ secrets.BENCHER_API_TOKEN }}" \
          --err \
          "bencher mock"

1. Exécutez sur les événements push à la branche main et sur les événements pull_request_target.
2. Créez un job qui s’exécute uniquement pour les événements push à la branche main. À part la condition if, ce job est presque identique à l’exemple original ci-dessus.
3. Créez un job qui s’exécute uniquement pour les événements pull_request_target.
   1. Extraites la branche de pull request.
   2. Transmettez directement tous les secrets. Utilisez --token ${{ secrets.BENCHER_API_TOKEN }} au lieu de la variable d’environnement BENCHER_API_TOKEN.
   3. Exécutez et suivez vos benchmarks de pull request avec bencher run.

Cette configuration fonctionne parce que pull_request_target s’exécute dans le contexte de la branche cible de la pull request, où les secrets tels que votre BENCHER_API_TOKEN et le GITHUB_TOKEN sont disponibles. Par conséquent, ce workflow ne s’exécutera que s’il existe sur la branche cible. Évitez de définir des secrets comme des variables d’environnement, comme BENCHER_API_TOKEN. Au lieu de cela, passez explicitement le jeton API à bencher run. (ex: --token ${{ secrets.BENCHER_API_TOKEN }}) Voir ce document du GitHub Security Lab et cet article de blog sur la prévention des requêtes pwn pour une vue d’ensemble complète.

Tester la PR de Fork à partir de la Branche Cible avec Réviseurs Nécessaires

on:
  push:
    branches: main
  pull_request_target:

jobs:
  benchmark_main_with_bencher:
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    name: Benchmark main with Bencher
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }}
      BENCHER_TESTBED: ubuntu-latest
      BENCHER_ADAPTER: json
    steps:
      - uses: actions/checkout@v3
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --branch main \
          --err \
          "bencher mock"

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

  benchmark_pr_with_bencher:
    needs: benchmark_pr_requires_review
    name: Benchmark PR with Bencher
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_ADAPTER: json
      BENCHER_TESTBED: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          repository: ${{ github.event.pull_request.head.repo.full_name }}
          persist-credentials: false
      - uses: bencherdev/bencher@main
      - name: Track Benchmarks with Bencher
        run: |
          bencher run \
          --if-branch "${{ github.event.pull_request.head.ref }}" \
          --else-if-branch "${{ github.event.pull_request.base.ref }}" \
          --else-if-branch main \
          --github-actions "${{ secrets.GITHUB_TOKEN }}" \
          --token "${{ secrets.BENCHER_API_TOKEN }}" \
          --err \
          "bencher mock"

Cette configuration est exactement la même que Tester la PR de Fork à partir de la Branche Cible avec l’exigence supplémentaire de l’approbation d’un Réviseur Nécessaire avant chaque exécution de pull request de fork. Les pull requests du même dépôt ne nécessitent pas d’approbation. Pour configurer cela, vous devez créer deux Environnements d’Action GitHub (ex: Repo -> Settings -> Environments -> New environment). L’environnement internal ne doit avoir aucune Règles de protection de déploiement. Cependant, l’environnement external doit avoir des Réviseurs nécessaires définis comme ceux de confiance pour réviser les PRs de fork avant le benchmarking.

Tester la PR de Fork et Télécharger à partir de la Branche par Défaut

name: Run and Cache Benchmarks

on: pull_request

jobs:
  benchmark:
    name: Run Benchmarks
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Mock Benchmark
        run: echo '{"bencher::mock_0": { "latency": { "value": 1.0 }}}' &> benchmark_results.txt
      - uses: actions/upload-artifact@v3
        with:
          name: benchmark_results.txt
          path: ./benchmark_results.txt
      - uses: actions/upload-artifact@v3
        with:
          name: pr_event.json
          path: ${{ env.GITHUB_EVENT_PATH }}

name: Track Benchmarks

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

jobs:
  track_with_bencher:
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest
    env:
      BENCHER_PROJECT: save-walter-white
      BENCHER_API_TOKEN: ${{ secrets.BENCHER_API_TOKEN }}
      BENCHER_ADAPTER: json
      BENCHER_TESTBED: ubuntu-latest
      BENCHMARK_RESULTS: benchmark_results.txt
      PR_EVENT: pr_event.json
    steps:
      - name: Download Benchmark Results
        uses: actions/github-script@v6
        with:
          script: |
            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));
            }
            downloadArtifact(process.env.BENCHMARK_RESULTS);
            downloadArtifact(process.env.PR_EVENT);
      - name: Unzip Benchmark Results
        run: |
          unzip $BENCHMARK_RESULTS.zip
          unzip $PR_EVENT.zip
      - name: Export PR Context
        uses: actions/github-script@v6
        with:
          script: |
            let fs = require('fs');
            let prEvent = JSON.parse(fs.readFileSync(process.env.PR_EVENT, {encoding: 'utf8'}));
            fs.appendFileSync(process.env.GITHUB_ENV, `PR_NUMBER=${prEvent.number}`);
            fs.appendFileSync(process.env.GITHUB_ENV, `PR_HEAD=${prEvent.pull_request.head.ref}`);
            fs.appendFileSync(process.env.GITHUB_ENV, `PR_BASE=${prEvent.pull_request.base.ref}`);
      - uses: bencherdev/bencher@main
          - name: Track Benchmarks with Bencher
            run: |
              bencher run \
              --if-branch "${{ env.PR_HEAD }}" \
              --else-if-branch "${{ env.PR_BASE }}" \
              --else-if-branch main \
              --github-actions "${{ secrets.GITHUB_TOKEN }}" \
              --ci-number "${{ env.PR_NUMBER }}" \
              --err \
              --file $BENCHMARK_RESULTS

1. Créez un fichier de workflow Exécutez et Cachez les Benchmarks.
2. Exécutez vos benchmarks sur les événements pull_request.
3. Sauvegardez les résultats des benchmarks dans un fichier et téléchargez-les comme un artefact.
4. Téléchargez l’événement pull_request comme un artefact.
5. Créez un second fichier de workflow, Suivez les Benchmarks.
6. Enchaînez Suivez les Benchmarks à Exécutez et Cachez les Benchmarks avec l’événement workflow_run.
7. Extrayez les données nécessaires de l’événement pull_request en cache.
8. Suivez les résultats de benchmark en cache avec bencher run.
9. Créez un troisième fichier de workflow et utilisez l’exemple initial ci-dessus pour exécuter sur les événements push à la branche main.

Cette configuration fonctionne parce que workflow_run s’exécute dans le contexte de la branche par défaut du dépôt, où les secrets tels que votre BENCHER_API_TOKEN et le GITHUB_TOKEN sont disponibles. Par conséquent, ces workflows ne s’exécuteront que s’ils existent sur la branche par défaut. Voir l’utilisation de données provenant du workflow déclencheur pour une vue d’ensemble complète. Le numéro de pull request, la branche de tête et la branche de base utilisés dans le workflow initial doivent être explicitement transmis car ils ne sont pas disponibles à l’intérieur de workflow_run.

🐰 Félicitations ! Vous avez appris à utiliser Bencher dans GitHub Actions ! 🎉

Continuez : Vue d’ensemble du Benchmarking ➡