AI CodeOps

Barrières qualité dans GitHub Actions : configurations pour 10 stacks

Matt · · Mis à jour le · 13 min de lecture · Guides

Barrières qualité GitHub Actions à copier pour 10 stacks : tests, seuil de couverture, SBOM, politique de licences, secrets, et le réglage AI CodeOps associé.

Dans GitHub Actions, une barrière qualité est un job qui fait échouer la pull request quand une règle n'est pas respectée, et dont on fait une vérification requise pour que le bouton de fusion reste verrouillé jusqu'à ce qu'il réussisse. Les recettes ci-dessous donnent à dix stacks les cinq mêmes barrières : tests, seuil de couverture, SBOM CycloneDX, politique de licences et détection de secrets, chacune avec le réglage AI CodeOps correspondant. Copiez une fois les jobs communs, ajoutez le job de tests de votre stack, et rendez les vérifications obligatoires.

Ce dont une barrière de fusion a besoin

Quand des agents IA ouvrent des pull requests, la revue cesse d'être le goulet d'étranglement et devient le maillon faible. Une équipe qui relisait cinq changements par jour peut désormais en recevoir cinquante. Les gens se fatiguent. Une barrière, non. Chaque recette de cet article bloque une pull request sur cinq points :

  1. Tests. La suite doit réussir.
  2. Un seuil de couverture. Une couverture des lignes inférieure au seuil fait échouer. Toutes les recettes utilisent 80% ; choisissez le vôtre.
  3. Un SBOM. Un SBOM CycloneDX est généré pour chaque changement et conservé comme artefact. Un SBOM vide fait échouer.
  4. Une politique de licences. Une pull request qui ajoute une dépendance sous une licence que vous n'avez pas autorisée échoue.
  5. Une détection de secrets. Un commit du changement qui contient un secret fait échouer.

Les constats de gravité high bloquent aussi : le job de licences échoue sur les vulnérabilités connues des nouvelles dépendances, et pour les changements AI CodeOps, la barrière de livraison bloque sur les constats ouverts.

Ce sont de simples workflows. Ils fonctionnent sans aucun produit, le nôtre compris. Chaque version d'action et chaque paramètre ci-dessous ont été vérifiés le 24 octobre 2026 dans le README de l'action concernée, et les seuils Node et Go ont été exécutés en local au-dessus et en dessous de la limite. Exécutez tout de même chacun sur une branche avant d'en faire une vérification requise. Le guide Qu'est-ce qu'une barrière qualité ? explique ce qu'est une barrière et comment la concevoir ; cet article, lui, fournit les configurations.

Deux règles derrière chaque recette

Rester fermée en cas d'erreur. Une barrière qui ne peut pas s'exécuter doit échouer, pas réussir. Il n'y a aucun continue-on-error ni aucun || true dans ces fichiers. Si l'outil de SBOM ne trouve rien, le job échoue. Si le chiffre de couverture ne peut pas être lu, le job échoue.

Garder le seuil dans le workflow. La plupart des outils permettent de définir un seuil de couverture dans un fichier de configuration : vitest.config.ts, pyproject.toml, .coveragerc. Ce fichier se trouve à côté du code : le changement qui fait baisser la couverture peut donc abaisser le seuil dans le même diff. Un agent IA à qui l'on demande de « faire passer la CI » le fera parfois exactement. Quand un outil propose une option de ligne de commande ou une variable d'environnement, ces recettes y définissent le seuil, dans .github/workflows/. Ajoutez ensuite .github/ à CODEOWNERS, pour que modifier une barrière nécessite la revue d'un propriétaire.

Les trois jobs communs

Secrets, SBOM et licences sont identiques pour toutes les stacks. Les voici une fois pour toutes. Chaque recette se termine par ces trois jobs, sans modification.

secrets:
  name: Secrets scan
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v7
      with:
        fetch-depth: 0
        persist-credentials: false
    - name: gitleaks
      env:
        RANGE: ${{ github.event_name == 'pull_request' && format('{0}..{1}', github.event.pull_request.base.sha, github.event.pull_request.head.sha) || format('{0}..{1}', github.event.before, github.sha) }}
      run: >-
        docker run --rm -v "$PWD:/repo" ghcr.io/gitleaks/gitleaks:v8.30.1
        git /repo --redact --verbose --log-opts="$RANGE"

sbom:
  name: SBOM (CycloneDX)
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v7
      with:
        persist-credentials: false
    - uses: anchore/sbom-action@v0
      with:
        path: .
        format: cyclonedx-json
        output-file: sbom.cdx.json
        upload-artifact: false
    - name: The SBOM lists components
      run: jq -e '(.components // []) | length > 0' sbom.cdx.json
    - uses: actions/upload-artifact@v7
      with:
        name: sbom-cyclonedx
        path: sbom.cdx.json

licenses:
  name: License policy
  if: github.event_name == 'pull_request'
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v7
      with:
        persist-credentials: false
    - uses: actions/dependency-review-action@v5
      with:
        config-file: ./.github/dependency-review-config.yml

Quelques choix méritent une explication.

Gitleaks depuis son image, pas depuis son action. Le binaire gitleaks est sous licence MIT et ne demande aucune clé. L'action GitHub de gitleaks, elle, exige une clé de licence des organisations. Exécuter l'image officielle, épinglée sur une version, évite la clé et vous laisse maître de la version. L'analyse ne porte que sur les commits qu'ajoute le changement, de la base de la pull request à sa tête : une ancienne fuite ailleurs dans l'historique ne bloque donc pas le changement du jour. Placez un .gitleaks.toml à la racine du dépôt pour ajuster les règles ; l'image le prend en compte.

Syft pour chaque SBOM. anchore/sbom-action exécute Syft sur le checkout et écrit du JSON CycloneDX. Syft lit les lockfiles de toutes les stacks de cet article : package-lock.json, requirements.txt, go.sum, Gemfile.lock, pom.xml, packages.lock.json et Cargo.lock. L'étape jq -e fait échouer le job quand le SBOM ne contient aucun composant, ce qui signifie qu'aucun lockfile n'a été trouvé. Un SBOM vide qui passe est pire que pas de SBOM du tout.

Dependency review pour les licences. compare la pull request à sa base et échoue sur toute nouvelle dépendance dont la licence ne figure pas sur votre liste. Trois points à connaître. Elle a besoin du graphe des dépendances de GitHub, activé pour les dépôts publics et qui nécessite GitHub Advanced Security pour les dépôts privés. Elle vérifie les dépendances que la pull request ajoute ou modifie, pas celles déjà présentes. Et si elle ne parvient pas à détecter une licence, elle le signale mais n'échoue pas.

La liste des licences se trouve dans .github/dependency-review-config.yml :

allow-licenses:
  - MIT
  - Apache-2.0
  - BSD-2-Clause
  - BSD-3-Clause
  - ISC
  - 0BSD
  - Zlib
  - Unlicense
  - CC0-1.0
  - BlueOak-1.0.0
  - Python-2.0
  - MPL-2.0
fail-on-severity: high

C'est une liste d'autorisation, à dessein. L'option deny-licenses de l'action est dépréciée, et une liste d'interdiction laisse passer toutes les licences auxquelles vous n'avez pas pensé. La liste ci-dessus est un exemple de politique permissive, pas un avis juridique. La même action échoue aussi sur les vulnérabilités connues des nouvelles dépendances ; fail-on-severity: high fixe ce niveau.

Chaque workflow commence de la même façon : il s'exécute sur pull_request et sur les pushes vers main, avec permissions: contents: read et rien de plus.

Les dix stacks

Pour chaque stack ci-dessous, seules les étapes de son job tests sont montrées. Placez-les sous jobs.tests.steps, donnez au job name: Tests and coverage floor, ajoutez les trois jobs communs, et vous avez le workflow complet. Chaque job tests commence par la même étape de checkout ; elle n'est montrée qu'une fois, dans la première recette.

Chaque stack a aussi un réglage AI CodeOps. Une session AI CodeOps exécute la Test command de votre projet (définie sur le projet sous Plan → Projects) sur son changement, dans un bac à sable, et enregistre le résultat ; la barrière de livraison de votre CI peut alors exiger minCoveragePct: 80. La session n'enregistre la couverture que si la commande affiche un résumé que lit AI CodeOps : une ligne TOTAL de pytest-cov ou de coverage.py, un tableau All files de Vitest, de Jest ou de l'exécuteur de tests de Node, ou une ligne Coverage: 85%. Elle est stockée sous forme de nombre entier, arrondi à l'inférieur : 79.6% échoue donc face à un seuil de 80. Une exécution sans résumé de couverture ne peut pas être comparée à un seuil, si bien que la barrière de livraison la refuse quand minCoveragePct est défini. Vérifiez que la page d'exécution affiche un chiffre de couverture avant d'ajouter le seuil.

Next.js

- uses: actions/checkout@v7
  with:
    persist-credentials: false
- uses: actions/setup-node@v7
  with:
    node-version: 24
    cache: npm
- run: npm ci
- run: npx vitest run --coverage.enabled --coverage.thresholds.lines=80
- run: npm run build

Vitest est l'exécuteur de tests unitaires que met en place la documentation de Next.js. Ajoutez @vitest/coverage-v8 aux dépendances de développement que liste le guide. next build vérifie aussi les types. Vitest n'exécute pas les Server Components async : ceux-ci ont besoin de tests de bout en bout et ne compteront pas dans ce seuil.

Réglage AI CodeOps : Test command npx vitest run --coverage.enabled --coverage.thresholds.lines=80. Le reporter texte de Vitest affiche le tableau All files, et AI CodeOps en prend la première colonne, qui correspond aux instructions (statements), pas aux lignes.

Node.js

- run: npm ci
- run: node --test --experimental-test-coverage --test-coverage-lines=80

L'exécuteur de tests intégré à Node dispose d'une option de seuil depuis Node 22.8. En dessous du seuil, l'exécution se termine avec le code 1 et une ligne comme Error: 53.85% line coverage does not meet threshold of 80%. La couverture y est encore marquée comme expérimentale. Le checkout et setup-node sont identiques à ceux de Next.js.

Réglage AI CodeOps : Test command node --test --experimental-test-coverage --test-coverage-lines=80. Le rapport de l'exécuteur se termine par une ligne all files, que lit AI CodeOps.

Python / Django

- uses: actions/setup-python@v7
  with:
    python-version: "3.13"
    cache: pip
- run: pip install -r requirements.txt coverage
- run: python manage.py makemigrations --check --dry-run
- run: coverage run --source=. manage.py test
- run: coverage report --fail-under=80

La vérification des migrations échoue quand un modèle a changé sans migration. C'est une étape qu'un agent oublie facilement. Placez les règles omit pour les migrations et les settings dans .coveragerc, mais gardez --fail-under sur la ligne de commande.

Réglage AI CodeOps : Test command coverage run --source=. manage.py test && coverage report --fail-under=80. La ligne TOTAL du rapport porte le pourcentage.

FastAPI

- run: pip install -r requirements.txt -r requirements-dev.txt
- run: pytest --cov=app --cov-report=term-missing --cov-fail-under=80

Installez Python comme pour Django. requirements-dev.txt contient pytest, pytest-cov et httpx, nécessaire au TestClient de FastAPI. Remplacez --cov=app par votre package.

Réglage AI CodeOps : Test command pytest --cov=app --cov-fail-under=80. La ligne TOTAL de pytest-cov porte le pourcentage.

Go

- uses: actions/setup-go@v7
  with:
    go-version-file: go.mod
- run: go vet ./...
- run: go test -race -coverprofile=coverage.out ./...
- name: 80% statement coverage floor
  run: |
    total=$(go tool cover -func=coverage.out | awk '/^total:/ { sub("%", "", $3); print $3 }')
    echo "Total coverage: ${total:-none}%"
    awk -v t="$total" 'BEGIN { exit !(t != "" && t + 0 >= 80) }' || { echo "::error::Coverage ${total:-none}% is below the 80% floor"; exit 1; }

go test n'a pas d'option de seuil : l'étape lit donc la ligne total: et la compare. Sur un petit module de test à 33.3%, elle échoue avec un seuil de 80 et réussit avec un seuil de 30. Un total vide fait aussi échouer, de sorte qu'une étape de test qui n'a écrit aucun profil ne peut pas passer entre les mailles.

Réglage AI CodeOps : Test command go test -coverprofile=coverage.out ./... && go tool cover -func=coverage.out. go tool cover -func se termine par une ligne total:, qu'AI CodeOps lit comme une ligne TOTAL.

Ruby on Rails

- uses: ruby/setup-ruby@v1
  with:
    bundler-cache: true
- run: bin/rails db:prepare
  env:
    RAILS_ENV: test
- run: bin/rails test
  env:
    RAILS_ENV: test
    PARALLEL_WORKERS: "1"
    COVERAGE_MIN: "80"

Tout en haut de test/test_helper.rb :

require "simplecov"
SimpleCov.start "rails" do
  minimum_coverage Integer(ENV.fetch("COVERAGE_MIN", "80"))
end

SimpleCov n'a pas de seuil en ligne de commande : le workflow le transmet donc dans une variable d'environnement. Un seul worker garde la suite dans un seul processus, pour que SimpleCov la voie en entier.

Réglage AI CodeOps : Test command bin/rails test, avec COVERAGE_MIN défini comme ci-dessus. SimpleCov affiche une ligne du type Line Coverage: 85.0% à la fin de l'exécution.

Java / Spring Boot (Maven)

- uses: actions/setup-java@v6
  with:
    distribution: temurin
    java-version: "21"
    cache: maven
- run: ./mvnw -B verify -Dcoverage.minimum=0.80

Ajoutez jacoco-maven-plugin 0.8.15 à pom.xml avec les goals prepare-agent, report et check, et une règle BUNDLE sur LINE COVEREDRATIO avec <minimum>${coverage.minimum}</minimum>. check est rattaché à la phase verify : le build échoue donc sous le seuil. Avec Gradle, le graphe des dépendances de GitHub ne voit le build que par la soumission de dépendances (dependency submission) : mettez-la en place avant de vous fier au contrôle de licences.

Réglage AI CodeOps : JaCoCo écrit son rapport dans des fichiers, pas dans la console : l'exécution d'une session enregistre donc la réussite ou l'échec, mais aucune couverture. Gardez le seuil dans le build Maven ; le build échoue sous ce seuil dans tous les cas. Laissez minCoveragePct hors de l'appel à la barrière de livraison pour cette stack : sans couverture enregistrée, la barrière refuserait chaque changement.

.NET

- uses: actions/setup-dotnet@v6
  with:
    dotnet-version: "10.0.x"
- run: dotnet restore --locked-mode
- run: dotnet test --no-restore /p:CollectCoverage=true /p:Threshold=80 /p:ThresholdType=line /p:ThresholdStat=total

Ajoutez coverlet.msbuild à chaque projet de test et définissez RestorePackagesWithLockFile sur true, pour disposer de fichiers packages.lock.json pour --locked-mode et pour Syft. ThresholdStat=total vérifie la solution entière au lieu de chaque module. Un piège : coverlet.msbuild fonctionne avec VSTest, la plateforme par défaut, et ne collecte rien sous Microsoft.Testing.Platform. Si votre global.json active cette plateforme, utilisez sa propre extension de couverture.

Réglage AI CodeOps : comme avec JaCoCo, comptez sur le Threshold du build lui-même pour faire échouer l'exécution ; vérifiez la page d'exécution de la session avant de définir aussi minCoveragePct.

Rust

- run: rustup update stable
- uses: taiki-e/install-action@cargo-llvm-cov
- run: cargo clippy --all-targets --all-features -- -D warnings
- run: cargo llvm-cov --all-features --workspace --fail-under-lines 80

C'est la configuration qu'utilise l'exemple de CI de cargo-llvm-cov lui-même, plus l'option de seuil. Commitez Cargo.lock, y compris pour les bibliothèques, pour que le SBOM et le contrôle de licences voient les versions exactes.

Réglage AI CodeOps : Test command cargo llvm-cov --workspace --fail-under-lines 80. L'option fait échouer l'exécution sous le seuil ; vérifiez sur la page d'exécution quel pourcentage la session a enregistré avant de définir aussi minCoveragePct.

Monorepo

Un monorepo demande une idée de plus. Vous ne voulez pas exécuter les tests de chaque package à chaque changement, vous filtrez donc par chemin. Mais GitHub signale comme réussi un job ignoré à cause de son if, même lorsqu'il s'agit d'une vérification requise. Si web est requis et que le job qui décide de l'exécuter échoue, web est ignoré, et la pull request passe.

La solution est un job final qui s'exécute à chaque fois et lit tous les résultats :

changes:
  runs-on: ubuntu-latest
  permissions:
    contents: read
    pull-requests: read
  outputs:
    web: ${{ steps.filter.outputs.web }}
    api: ${{ steps.filter.outputs.api }}
  steps:
    - uses: actions/checkout@v7
      with:
        persist-credentials: false
    - uses: dorny/paths-filter@v4
      id: filter
      with:
        filters: |
          web:
            - 'apps/web/**'
            - 'package-lock.json'
          api:
            - 'services/api/**'

# web and api: the Next.js and FastAPI test steps above, each with
# needs: changes and if: needs.changes.outputs.<name> == 'true'

gate:
  name: Quality gates
  if: always()
  needs: [changes, web, api, secrets, sbom, licenses]
  runs-on: ubuntu-latest
  steps:
    - env:
        RESULTS: ${{ toJSON(needs.*.result) }}
      run: |
        echo "$RESULTS"
        if echo "$RESULTS" | grep -Eq '"(failure|cancelled)"'; then exit 1; fi

Ne rendez obligatoire que Quality gates. Un job ignoré ne passe désormais que si le filtre a indiqué que ce package n'a pas changé. Secrets, SBOM et licences s'exécutent toujours à chaque changement, sur tout le dépôt, et Syft trouve le lockfile de chaque package.

Réglage AI CodeOps : un monorepo a en général besoin de sa propre Test command, par exemple un script qui exécute les packages que touche un changement. Définissez-la sur le projet ; la détection automatique ne cherche qu'un script de test package.json, pytest ou Go à la racine.

En faire des vérifications requises

Un workflow qui échoue n'empêche pas une fusion à lui seul. GitHub ne bloque le bouton de fusion que sur les vérifications que vous marquez comme requises : dans la protection de branche, « toutes les vérifications de statut requises doivent réussir avant que les collaborateurs puissent fusionner des changements dans la branche protégée » (About protected branches, vérifié le 24 octobre 2026). La même page range skipped parmi les états qui satisfont une vérification requise : c'est pourquoi la recette du monorepo se termine par un job qui s'exécute toujours.

  • Exigez les vérifications. Dans la protection de branche ou un ruleset sur la branche par défaut, exigez Tests and coverage floor, Secrets scan, SBOM (CycloneDX) et License policy, ou Quality gates pour le monorepo. Une vérification n'apparaît dans le sélecteur qu'après s'être exécutée une fois : ouvrez donc d'abord une pull request de test. Les rulesets GitHub pour les agents IA détaille le ruleset lui-même.
  • Protégez les barrières. CODEOWNERS sur .github/, avec la revue des propriétaires de code obligatoire. Modifier une barrière, c'est modifier votre politique.
  • Épinglez plus strictement si besoin. Ces recettes épinglent chaque action sur sa version majeure actuelle. Pour une hygiène de supply chain plus stricte, épinglez chacune sur un SHA de commit complet et laissez Dependabot les mettre à jour.
  • Faites échouer chaque barrière une fois. Supprimez un test, ajoutez une dépendance GPL, commitez une fausse clé. Regardez chaque job passer au rouge avant de lui faire confiance quand il est vert.

La variante AI CodeOps

AI CodeOps a sa propre barrière de livraison. Elle ne lit aucun fichier de configuration dans votre dépôt. Votre CI lui pose une question par l'API, et elle répond à partir de chaque session AI CodeOps qui a touché au changement : constats ouverts, exécution de tests et couverture de la session elle-même, licences du SBOM du projet, et éventuels workflows ou promotions requis.

release-gate:
  if: startsWith(github.head_ref, 'codeops/run-')
  runs-on: ubuntu-latest
  steps:
    - env:
        AICODEOPS_API_KEY: ${{ secrets.AICODEOPS_API_KEY }}
        PR_URL: ${{ github.event.pull_request.html_url }}
        HEAD_SHA: ${{ github.event.pull_request.head.sha }}
      run: |
        body=$(jq -n --arg pr "$PR_URL" --arg sha "$HEAD_SHA" \
          '{pullRequestURL: $pr, commitSHA: $sha, blockingSeverity: "high", minCoveragePct: 80}')
        response=$(curl -sS --fail --retry 3 --max-time 30 -X POST \
          "https://console.aicodeops.dev/api/release/check" \
          -H "Authorization: Bearer $AICODEOPS_API_KEY" \
          -H "Content-Type: application/json" -d "$body") \
          || { echo "Release check unavailable: failing closed"; exit 1; }
        [ "$(echo "$response" | jq -r '.allowed')" = "true" ] \
          || { echo "$response" | jq -r '.summary, (.reasons // [])[]'; exit 1; }

Le if compte. AI CodeOps ouvre ses pull requests depuis des branches codeops/run-<id>, et la barrière refuse un changement sans session AI CodeOps : l'exécuter sur la pull request d'une personne échouerait donc toujours. Le point de terminaison répond HTTP 200 pour une autorisation comme pour un refus : l'étape lit donc allowed. Les champs sont décrits sur la page de l'API.

Une mise en garde sur minCoveragePct. Il refuse un changement dont l'exécution de tests n'a indiqué aucune couverture, car un seuil que la barrière ne peut pas vérifier ne passe pas. Si votre stack fait partie de celles où la session n'enregistre aucune couverture, comme JaCoCo plus haut, retirez ce champ du corps de la requête.

Deux mises en garde si vous ajoutez disallowedLicenses. La correspondance est exacte : GPL-3.0 ne correspond donc pas à GPL-3.0-only, et vous devez lister chaque graphie qu'utilisent vos SBOM. Par ailleurs, la vérification lit le SBOM enregistré pour le projet dans AI CodeOps. Avec une règle de licences définie et aucun SBOM enregistré, la barrière refuse, car elle ne peut pas vérifier.

L'autre moitié, c'est la politique de l'espace de travail. Ces règles imposent à tout changement de l'IA touchant aux fichiers qui définissent vos barrières d'attendre une revue approuvée :

[
  { "id": "review-ci-definitions", "action": "diff.apply", "resource": ".github/**", "decision": "ask" },
  { "id": "review-secret-scan-config", "action": "diff.apply", "resource": ".gitleaks.toml", "decision": "ask" },
  { "id": "review-vitest-config", "action": "diff.apply", "resource": "**vitest.config.*", "decision": "ask" }
]

** traverse les dossiers et * reste à l'intérieur d'un seul : **vitest.config.* correspond donc à la configuration à la racine comme dans chaque package. Utilisez ces deux moitiés en plus des barrières ordinaires, pas à leur place. Si vous préférez partir d'un workflow complet, les templates comprennent un seuil de couverture Python et une barrière de licences fondée sur le SBOM.

Une stack nous a échappé ?

PHP, Elixir, Kotlin avec Gradle et Swift sont les lacunes évidentes. Nous publierons les dix recettes dans un dépôt sous licence MIT, et nous aimerions en avoir davantage. Si vous utilisez l'une de ces stacks, proposez une recette. Il faut une exécution verte et une exécution rouge comme preuves, et vous êtes crédité avec un lien.

Les règles qu'applique chaque barrière côté AI CodeOps, et la façon de trier un changement bloqué, sont décrites dans la documentation des barrières qualité.

À retenir

  • Une barrière ne bloque une fusion qu'une fois devenue une vérification requise ; un workflow rouge, à lui seul, n'est qu'un conseil.
  • En cas d'erreur, la barrière reste fermée : pas de continue-on-error, pas de || true, et un SBOM vide ou un chiffre de couverture illisible fait échouer le job.
  • Gardez le seuil de couverture dans le workflow et placez .github/ sous CODEOWNERS, pour que le changement qui fait baisser la couverture ne puisse pas aussi abaisser le seuil.
  • Dans un monorepo, exigez un job final qui lit tous les résultats, car un job ignoré compte comme réussi.
  • AI CodeOps enregistre la couverture d'une session sous forme de nombre entier arrondi à l'inférieur : 79.6% échoue donc face à un seuil de 80.