Générer des runbooks avec un LLM, sous contrôle humain
Utiliser un LLM pour rédiger des brouillons de runbooks à partir des alertes et des post-mortems, avec revue humaine et sans accès à la production.
Dans la plupart des équipes, une bonne partie des alertes n'a pas de runbook, ou en a un qui décrit une architecture disparue depuis deux migrations. Tout le monde sait qu'il faudrait les écrire ; personne n'a le temps entre deux incidents. Un LLM est bon pour une partie précise de ce travail : rassembler des informations éparses (la règle d'alerte, les dashboards, les post-mortems, la documentation d'architecture) et les ranger dans un format constant. Il est mauvais pour l'autre partie : savoir si la commande qu'il propose est correcte dans votre environnement, avec vos namespaces, vos labels et vos droits.
D'où une règle simple, qui structure tout le reste : le modèle rédige des brouillons, il n'exécute rien, et rien de ce qu'il produit n'est publié sans qu'un ingénieur l'ait relu, testé et pris à son compte.
Générer à froid, pas pendant l'incident
Il existe deux usages très différents des LLM en astreinte. Le premier consiste à interroger un assistant pendant l'incident pour qu'il propose un diagnostic ou une commande. Le second consiste à produire les procédures en amont, en dehors de toute pression, pour qu'elles soient relues avant d'être utiles. Cet article traite du second, et ce n'est pas un hasard.
À trois heures du matin, avec un service dégradé, la capacité de relecture critique d'un ingénieur est au plus bas. C'est précisément le moment où une commande plausible mais fausse a le plus de chances d'être exécutée telle quelle. Générer les runbooks à froid remet la relecture là où elle peut être sérieuse : dans une pull request, avec du temps, un environnement de test et un second relecteur. Pendant l'incident, l'ingénieur d'astreinte suit une procédure déjà validée, pas une suggestion fraîche.
Cela ne rend pas les assistants en incident inutiles, mais leur profil de risque est différent et demande d'autres garde-fous. Mélanger les deux usages dans le même outil est la meilleure façon de perdre la discipline de revue.
Ce que l'on fournit au modèle, et ce qu'on lui retire
La qualité du brouillon dépend presque entièrement du contexte. Un modèle à qui l'on donne seulement le nom d'une alerte produira un runbook générique, rédigé avec assurance, et inutile. Le contexte utile tient en quelques éléments :
- la définition complète de l'alerte : expression, seuils, durée, labels et annotations
- le gabarit de runbook de l'équipe, avec ses sections obligatoires
- les post-mortems où cette alerte a joué un rôle, et les procédures déjà validées de services voisins
- la documentation d'architecture du service et les liens vers ses dashboards
Ce qu'on retire compte autant. Les post-mortems et les tickets contiennent régulièrement des choses qui n'ont rien à faire dans une requête vers un fournisseur de modèle : extraits de logs avec des adresses e-mail, identifiants de clients, parfois un jeton collé par erreur. La divulgation d'informations sensibles figure en deuxième position du Top 10 OWASP pour les applications LLM. Un filtrage automatique avant envoi est utile mais imparfait ; nous recommandons de ne jamais transmettre de logs bruts et de constituer le contexte à partir de documents déjà destinés à être partagés en interne. Il faut aussi savoir où partent les données, combien de temps le fournisseur les conserve et sous quel contrat, avant d'envoyer le premier post-mortem.
Le second risque est moins intuitif. Tout texte injecté dans le contexte peut contenir des instructions que le modèle suivra. C'est l'injection de prompt indirecte : un user-agent forgé dans un log, un commentaire dans un ticket ouvert par un tiers, une description de PR. Dans un pipeline de rédaction, la conséquence la plus probable est une étape de remédiation détournée, glissée dans un document qui a l'air propre. OWASP le dit clairement : aucune méthode de prévention n'est infaillible, on ne peut qu'en limiter l'impact. Ici, l'impact est limité par construction, puisque le modèle n'agit sur rien, à condition que la revue lise réellement chaque commande.
Un format qui rend la relecture possible
Un brouillon difficile à relire sera mal relu. Le gabarit doit donc servir le relecteur autant que l'astreinte. Trois exigences, posées dans les instructions données au modèle, changent beaucoup la qualité de la revue : chaque étape cite sa source (un post-mortem, une page de documentation), toute information absente du contexte est marquée explicitement au lieu d'être inventée, et les actions qui modifient l'état du système sont séparées du diagnostic en lecture seule.
# Runbook : ApiHighErrorRate
Alerte : ApiHighErrorRate (prometheus/rules/api.yaml)
Brouillon généré : modèle, version, date, sources utilisées
Relu et testé par : <nom>, le <date>
## Symptômes et impact
## Diagnostic (lecture seule)
## Remédiation (modifie l'état : préconditions et retour arrière)
## Escalade
Marqueur obligatoire pour toute information non sourcée : [À VÉRIFIER]
Le marqueur est vérifiable mécaniquement : un contrôle en CI refuse la fusion tant qu'il en reste un. C'est un garde-fou modeste, mais il empêche un relecteur pressé d'approuver un document qui avoue lui-même ne pas savoir.
Les hallucinations qui coûtent cher en exploitation
En exploitation, une hallucination ressemble rarement à une absurdité. Elle a l'air juste. Une option de kubectl qui n'existe pas, un nom de métrique presque correct, un label que votre stack n'utilise pas, un namespace déduit par analogie, une commande de redémarrage là où le post-mortem recommandait précisément de ne pas redémarrer. OWASP classe ce risque sous le nom de désinformation (LLM09), et insiste sur la confiance excessive qu'inspire un texte bien rédigé.
La seule parade fiable est l'exécution. Chaque requête PromQL du runbook doit renvoyer des données sur l'environnement réel, chaque commande de diagnostic doit être jouée en recette, chaque étape de remédiation doit avoir été répétée au moins une fois, par exemple lors d'un exercice d'astreinte. Un runbook que personne n'a déroulé n'est pas validé, quel que soit son auteur.
La revue humaine, concrètement
« Revue humaine » ne veut rien dire tant qu'on n'a pas précisé qui relit et ce que la relecture engage. Nous recommandons que le relecteur soit un ingénieur qui connaît le service et a déjà tenu son astreinte, désigné via le fichier CODEOWNERS du dépôt des runbooks, plutôt que la personne d'astreinte du moment, qui a d'autres priorités. En approuvant, il devient l'auteur : le runbook est le sien, le modèle n'est qu'une source parmi d'autres.
Le risque principal de ce dispositif est connu : le biais d'automatisation. Un texte fluide, bien structuré et sourcé appelle l'approbation. Les contrôles mécaniques (marqueurs résolus, liens valides, présence de l'annotation runbook_url sur l'alerte) ne remplacent pas la lecture, mais ils évitent que la revue se réduise à un coup d'œil. Le reste tient à la culture d'équipe : une PR de runbook généré se relit comme une PR de code qui touche à la production, parce que c'en est une, exécutée par un humain plutôt que par une machine.
Ce que l'IA ne fait pas
Le périmètre du modèle est volontairement étroit, et il doit l'être techniquement, pas seulement dans une politique écrite. C'est ce qu'OWASP appelle l'agentivité excessive : trop de fonctions, trop de permissions, trop d'autonomie. Concrètement :
- aucun accès aux clusters, aux comptes cloud ni aux outils d'exécution, même en lecture
- aucun secret dans le contexte ni dans l'environnement du job de génération
- un jeton limité à l'ouverture de pull requests sur le dépôt des runbooks, sans droit de fusion
- une journalisation de chaque génération : sources fournies, modèle et version, sortie brute, relecteur
La journalisation sert à autre chose qu'à l'audit. Le jour où l'on découvre qu'une version de modèle produisait systématiquement une mauvaise option sur une commande, elle permet de retrouver tous les runbooks concernés au lieu de les relire tous.
Maintenir plutôt que produire
Le stock de runbooks se périme plus vite qu'il ne se constitue. Le meilleur usage du modèle sur la durée n'est peut-être pas la rédaction initiale mais la mise à jour : quand une règle d'alerte change, ou après un post-mortem, le pipeline propose un diff du runbook concerné, que le propriétaire du service relit comme le reste. Un diff ciblé se relit mieux qu'un document entier.
Pour suivre l'effort, deux indicateurs suffisent : la part des alertes critiques couvertes par un runbook relu, et la date de dernière validation de chacun. Le premier dit si la couverture progresse, le second si elle se dégrade en silence.
Il reste des cas où la génération n'a pas sa place. Une bascule de reprise d'activité, une restauration de base de données, toute procédure rare dont l'erreur est irréversible mérite d'être écrite par les personnes qui l'ont conçue et répétée en conditions réelles. Et quand une alerte n'a ni post-mortem ni documentation derrière elle, le modèle n'a rien à synthétiser : il comblera les vides, et c'est exactement ce qu'on veut éviter. Dans ce cas, le vrai travail est de documenter le service, pas de générer son runbook.
Need help with this topic?
Our engineers can audit your context and propose a concrete action plan.