- Accueil
- Centre d'apprentissage
- Qu'est-ce qu'une barrière qualité ?
Qu'est-ce qu'une barrière qualité ?
Mis à jour le
Une barrière qualité décide si un changement passe ou échoue avant fusion ou déploiement. Ce qu'elle vérifie, ce qui la distingue d'une vérification et comment la concevoir.
Sur cette page
Une barrière qualité est une décision de réussite ou d'échec qu'un changement de code doit franchir avant de passer à l'étape suivante, par exemple être fusionné ou déployé. Elle compare des preuves concernant le changement (résultats de tests, constats de revue, approbations, décisions de politique) à des règles convenues à l'avance, et bloque automatiquement le changement lorsque ces preuves sont insuffisantes. Ce qui en fait une barrière plutôt qu'un rapport, c'est son application : une barrière en échec arrête le changement.
D'où viennent les barrières qualité
L'idée est plus ancienne que l'intégration continue. La gestion de projet utilise depuis longtemps des revues de passage de phase (stage gates) : un projet ne passe d'une phase à la suivante qu'après une revue au regard de critères définis. L'industrie manufacturière a des points d'inspection qu'une pièce doit franchir avant que l'assemblage se poursuive.
Dans le logiciel, le terme s'est répandu avec les outils d'analyse statique qui permettent aux équipes de définir des seuils, comme aucun nouveau problème critique ou une couverture de tests minimale sur le nouveau code, et qui indiquent si le projet les respecte ou non. Les hébergeurs Git ont appliqué la même idée aux pull requests avec la protection de branche : une branche peut exiger que certaines vérifications de statut réussissent, ainsi qu'un certain nombre d'approbations, avant qu'une fusion soit autorisée.
Aujourd'hui, une barrière qualité désigne en général une combinaison de ces éléments : des preuves automatisées issues de la CI, des constats d'outils de revue de code et des approbations humaines, évalués ensemble à un point défini du pipeline de livraison.
Ce que vérifie une barrière qualité
Les barrières sont construites à partir de preuves. Les types courants sont :
- Build. Le code compile et l'artefact peut être produit.
- Tests. La suite de tests a réussi sur cette version exacte du changement.
- Couverture. La couverture de tests atteint un seuil, souvent uniquement sur le code nouveau ou modifié.
- Constats de revue. Aucun problème ouvert au-dessus d'un seuil de gravité, qu'il provienne de l'analyse statique, de la revue par IA ou des outils de sécurité.
- Dépendances et licences. Aucune licence interdite et aucun composant vulnérable connu au-dessus d'un seuil.
- Approbations. Une ou plusieurs personnes, autres que l'auteur, ont approuvé le changement.
- Politique. Le changement ne touche pas de chemins protégés, ou il dispose de l'approbation supplémentaire que ces chemins exigent.
- Promotion. Le changement a été déployé dans un environnement antérieur, comme le staging, avant la production.
Toutes les barrières n'ont pas besoin de tous ces éléments. Une barrière avant fusion se concentre en général sur les tests, la revue et l'approbation. Une barrière avant la production y ajoute la promotion et les vérifications de livraison.
Barrières qualité et vérifications
Les deux termes sont souvent employés de manière approximative. La distinction mérite d'être conservée, car c'est elle qui décide de ce qui arrête réellement un mauvais changement.
| Aspect | Vérification | Barrière qualité |
|---|---|---|
| Ce qu'elle produit | Un résultat : réussi, échoué, une liste de problèmes | Une décision : autorisé ou refusé, avec les raisons |
| Entrées | La sortie d'un seul outil | Plusieurs preuves combinées |
| Seuil | Souvent implicite, ou réglé dans l'outil | Explicite et convenu : quelles gravités et quels résultats bloquent |
| Effet d'un échec | Affiché sur la pull request ; peut être ignoré | Le changement ne peut pas avancer tant que les preuves ne changent pas |
| En cas d'erreur | Souvent affichée comme neutre ou ignorée | Doit refuser : l'absence de verdict n'est pas une réussite |
| Où elle se trouve | Dans l'outil qui l'a exécutée | À un point que tout chemin vers la production doit franchir |
| Piste d'audit | Le journal de l'outil, s'il est conservé | La décision, ses raisons et toute dérogation, conservées avec le changement |
Une vérification fait partie d'une barrière dès que quelque chose refuse d'avancer à cause de son résultat.
Les propriétés d'une bonne barrière qualité
Elle reste fermée en cas d'erreur. Si un exécuteur de tests plante, qu'une revue dépasse son délai ou que le service de la barrière est injoignable, le changement est refusé. Une barrière qui laisse passer les changements en cas d'erreur est discrètement désactivée au moment où vous en avez le plus besoin.
L'absence de preuve n'est pas une réussite. Un changement sans exécution de tests, sans revue ou sans SBOM n'a pas passé ces vérifications. La barrière le bloque ou montre clairement le manque. Elle n'affiche jamais un résultat manquant en vert.
Les preuves correspondent à la version. Une exécution de tests sur un commit antérieur ne dit rien du commit actuel. Si le changement est modifié après l'exécution de ses tests ou après son approbation, ces résultats ne doivent plus compter.
Les raisons sont lisibles. « Refusé » ne suffit pas. La barrière doit indiquer quel constat, quel test ou quelle règle a arrêté le changement, pour que l'auteur puisse agir.
Tous les chemins passent par la même barrière. Si une fusion depuis la console est soumise à la barrière mais qu'une fusion sur l'hébergeur Git ne l'est pas, la barrière a une porte dérobée. La même évaluation doit pouvoir être appelée depuis la CI.
Les dérogations sont rares et enregistrées. Il arrive qu'une équipe doive livrer malgré un constat. Ce doit être une décision de tri explicite prise par une personne habilitée, conservée avec le changement, et non une vérification désactivée.
Les seuils fonctionnent comme un cliquet. Commencez par des règles que la base de code peut respecter aujourd'hui, puis resserrez-les. Une barrière qui échoue sur chaque changement est vite contournée.
Les barrières qualité pour le code écrit par l'IA
Les agents IA changent l'économie de la revue. Ils peuvent produire plus de changements qu'une équipe ne peut en lire ligne par ligne, et chaque changement peut sembler plausible tout en étant subtilement faux. Les barrières comptent davantage dans ce contexte, pour trois raisons.
Premièrement, la confiance de l'auteur n'est pas une preuve. Un agent qui annonce que les tests devraient réussir formule une affirmation ; une exécution de tests enregistrée sur le changement exact est une preuve. Les barrières doivent lire des enregistrements produits en exécutant réellement les choses, pas le résumé de l'agent.
Deuxièmement, la revue doit avoir réellement eu lieu. La revue par IA peut échouer sans bruit, en dépassant son délai ou en renvoyant un texte qui n'est pas un résultat exploitable. Une barrière doit distinguer « revu, rien trouvé » de « non revu ».
Troisièmement, la séparation des tâches. La personne qui a demandé un changement à l'agent en est, de fait, l'auteur. Elle ne doit pas être la seule à l'approuver quand quelqu'un d'autre peut le faire. Consultez Comment les agents IA s'intègrent-ils au cycle de vie logiciel ? pour savoir où cette approbation a sa place.
Concevoir des barrières qualité
- Cartographiez le chemin vers la production. Listez toutes les façons dont un changement peut atteindre votre branche principale et votre environnement de production : fusions depuis la console, fusions sur l'hébergeur Git, pushs directs, scripts de livraison. Une barrière ne protège que les chemins qui la franchissent.
- Choisissez les points de barrière. La plupart des équipes ont besoin d'au moins une barrière avant la fusion et d'une autre avant la production.
- Listez les preuves pour chaque point. Tests sur la version actuelle, constats de revue, approbations, licences, déploiement antérieur. Notez d'où vient chaque élément.
- Fixez des seuils explicites. Par exemple : bloquer sur les constats de gravité high et critical, sur tout test en échec et sur une revue manquante. Écrivez les règles là où l'équipe peut les lire.
- Tranchez les cas de preuves manquantes. Que se passe-t-il sans tests, sans SBOM ou sans revue ? Décidez-le délibérément, et n'affichez jamais une preuve manquante comme une réussite.
- Faites en sorte qu'elle reste fermée en cas d'erreur. Les erreurs de la barrière refusent le changement et le disent.
- Exposez-la à la CI. Rendez la même décision accessible à votre pipeline, pour que les fusions effectuées hors de vos outils puissent y être soumises.
- Définissez le tri et les dérogations. Qui peut écarter un constat, et comment c'est enregistré.
- Passez la barrière elle-même en revue. Regardez ce qu'elle a bloqué et ce qui lui a échappé. Resserrez les seuils à mesure que la base de code s'améliore.
Comment AI CodeOps s'y prend
Dans AI CodeOps, chaque changement produit par l'IA passe une barrière qualité avant de devenir une pull request, puis à nouveau avant que la console ne le fusionne. Le changement est retenu si la revue des constats par IA ne s'est pas terminée, si un constat de gravité high ou critical est encore open, acknowledged ou in progress, ou si les tests du projet échouent dans le bac à sable. Un résultat de test ne compte que pour la version sur laquelle il a été exécuté. Une personne doit approuver, et la personne qui a lancé la session ne peut pas émettre le vote d'approbation tant qu'un autre approbateur existe dans l'espace de travail. Les politiques de l'espace de travail peuvent refuser la pull request ou exiger cette approbation pour les chemins sensibles. Les barrières sont conçues pour rester fermées en cas d'erreur, avec quelques exceptions documentées.
Votre CI peut demander un verdict à la même barrière pour une pull request ou un commit, avec une clé API de l'espace de travail, et ajouter des règles plus strictes à chaque appel :
curl -s -X POST "https://<your-console>/api/release/check" \
-H "Authorization: Bearer $WORKSPACE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"pullRequestURL":"https://github.com/acme/checkout/pull/42","blockingSeverity":"medium","requireDeployedTo":"staging"}'
Une réponse de refus, réduite aux champs principaux :
{
"allowed": false,
"evidenceComplete": true,
"summary": "HIGH security: Coupon code is passed to the pricing query without validation",
"reasons": [
"HIGH security: Coupon code is passed to the pricing query without validation",
"Not yet deployed to \"staging\" — promote there before releasing"
],
"testFailures": [],
"coverageShortfall": null,
"priorEnvironmentMissing": { "required": "staging" },
"requiredGatesPassed": true,
"missingRequiredWorkflows": []
}
Le point de terminaison renvoie HTTP 200 dans les deux cas, lisez donc allowed. Un changement sans session correspondante est refusé, et une erreur d'évaluation renvoie allowed: false. Les autres options comprennent minCoveragePct, requiredWorkflows, blockOnInFlight et disallowedLicenses, qui contrôle le dernier SBOM enregistré du projet. La vérification refuse aussi lorsque des preuves manquent : un changement de code sans résultat de test comportant des décomptes, un seuil de couverture sans couverture signalée, et une règle de licence sans SBOM. Un projet sans suite de tests s'en dispense avec Don't run tests for this project dans ses paramètres.
Consultez Barrières qualité pour le code IA pour la vue d'ensemble, Barrières qualité pour le tri et l'endroit où les résultats apparaissent, et la référence de l'API pour chaque champ.
Pour aller plus loin
- Fail-open ou fail-closed : comment des barrières finissent par laisser passer en cas d'erreur, comment trancher les cas de preuves manquantes, et comment rester fermé en cas d'erreur sans bloquer les livraisons.
- Barrières de couverture de tests : seuils de projet, couverture du nouveau code et cliquets, ce que la couverture ne peut pas prouver, et ce qu'il faut lui associer.
Questions fréquentes
Quelle est la différence entre une barrière qualité et une vérification de CI ?
Une vérification rapporte un résultat. Une barrière transforme un ou plusieurs résultats en une décision appliquée qui empêche le changement d'avancer. Une vérification ne devient une barrière que lorsque quelque chose refuse de continuer quand elle échoue.
Une barrière qualité doit-elle rester ouverte ou fermée en cas d'erreur ?
Fermée. Si la barrière ne peut pas rendre de verdict, parce qu'un outil a planté ou qu'une preuve manque, elle doit refuser le changement. Une barrière qui laisse passer en cas d'erreur cesse de fonctionner précisément quand quelque chose ne va pas.
Une approbation humaine est-elle une barrière qualité ?
Elle peut en être une. Une approbation est une preuve au même titre qu'un résultat de test, et une barrière peut l'exiger. La plupart des équipes combinent des preuves automatisées avec au moins une approbation d'une personne autre que l'auteur.
Et si un projet n'a pas de tests ?
Décidez-le explicitement. Certaines barrières bloquent en l'absence de tests, d'autres seulement sur des tests en échec. Dans les deux cas, un résultat manquant ne doit jamais être affiché ni compté comme une réussite.
Qui doit pouvoir passer outre une barrière ?
Aussi peu de personnes que possible, et chaque dérogation doit être enregistrée avec une raison. Préférez corriger ou trier les preuves plutôt que contourner la barrière.