Aller au contenu
English

Responsabilité et soutien

  • Leçon 4
  • 50 min
  • Module 1 : Définir la responsabilité opérationnelle

Où nous en sommes

Dans les deux leçons précédentes, nous avons listé les parties du service et donné un objectif à chaque parcours utilisateur. Mais la semaine dernière, des personnes pouvaient régler le problème, et personne n'avait la responsabilité de le détecter. Dans cette leçon, nous attribuons un responsable à chaque partie et à chaque objectif, et nous notons qui appeler en premier, comme la feuille près de la porte d'un immeuble.

Ce que vous saurez faire

La semaine dernière, certaines personnes auraient pu régler l’incident, mais personne n’avait la responsabilité de le détecter. Attribuez chaque partie du service et chaque objectif à un responsable. Couvrez les données, le modèle, l’infrastructure et les communications clients. Notez qui appeler en premier.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet à l’instantané end-of-m01, avec la télémétrie enregistrée dans data/telemetry/. Pas de Docker.

Dans un immeuble d’appartements, une feuille près de la porte d’entrée indique qui appeler. Une fuite d’eau : le concierge, M. Diaz, puis le numéro d’urgence de l’entreprise de plomberie s’il ne répond pas. Une odeur de gaz : la compagnie de gaz, immédiatement, à toute heure. L’ascenseur : l’entreprise d’ascenseurs. Pour chaque problème qui touche les résidents, le gestionnaire de l’immeuble affiche une note dans le hall.

La feuille ne dit pas qui a causé la fuite. Elle dit qui agit en premier, puis qui agit si cette personne ne peut pas le faire. Sans elle, dix résidents voient l’eau dans l’escalier. Chacun pense que quelqu’un d’autre a déjà appelé.

Le problème : tout le monde l’a vu, personne n’en était responsable

Section intitulée « Le problème : tout le monde l’a vu, personne n’en était responsable »

Reprenons la semaine dernière, du point de vue des personnes. Ce récit est construit à partir de la relecture d’exercice : les chiffres sont réels, les conversations ne le sont pas.

  • L’équipe d’Omar a changé ASSISTANT_PROMPT pour assistant-v3 un lundi. Elle a vu que l’API répondait encore 202, puis ses membres sont rentrés chez eux.
  • Tomás a regardé le tableau de bord mardi. Le panneau des brouillons valides était rouge, à 89 %. Il a pensé : « C’est le modèle. L’équipe de Priya surveille le modèle. »
  • Priya travaillait sur les données d’évaluation. Personne ne lui avait dit que la requête avait changé.
  • Amira était responsable de l’API. L’API fonctionnait bien.
  • Les agents de Grace ont remarqué moins de brouillons. Mais les billets de soutien sans équipe n’apparaissent dans aucune liste d’agent. Le système les rend invisibles par conception.
  • Mercredi, un client a téléphoné au sujet d’une poêle fissurée.

Chaque personne a agi de façon raisonnable. Personne n’avait une responsabilité disant : « Vous agissez quand le SLO des brouillons consomme son budget. » Le panneau rouge n’avait aucun responsable.

Le responsable d’une partie ou d’un objectif est la personne qui prend les décisions et qu’on appelle en premier en cas d’échec. Pas une équipe : une personne, avec un nom. Le responsable n’a pas à tout régler seul. Son rôle est d’agir en premier : examiner, décider, corriger ou appeler la personne suivante.

Trois idées accompagnent cette responsabilité :

  • Chaque partie et chaque objectif ont exactement un responsable. Deux responsables, c’est comme aucun : chacun attend l’autre.
  • Chaque responsable a un remplaçant. Les gens dorment, prennent des vacances et tombent malades. Le remplaçant reçoit les appels quand le responsable ne peut pas.
  • Un chemin d’escalade. Quand la cause se trouve dans la partie d’une autre personne, le premier responsable appelle cette personne. Quand le problème touche les clients, quelqu’un les informe.

Un service d’IA comprend quatre domaines qui nécessitent des responsables : données, modèle, infrastructure et communications clients. On oublie facilement le quatrième, alors que les clients en ressentent les effets.

Un flux de gauche à droite. Le service de billets de Larkfield mène à quatre domaines. Données : la politique et les documents de la boutique, Grace; les données d'évaluation, Priya; l'index, Tomás. Modèle : la requête de triage et les modèles de conversation et de plongement, Priya. Infrastructure : l'API, le processus et le cache, Amira; PostgreSQL et la télémétrie, Mei; le fournisseur d'IA et les coûts, Kwame. Communications clients : l'état du service, les réponses et la gravité des préjudices, Grace. Une flèche pointillée relie les mises en production au service. Omar en est responsable et décide selon les preuves, sans les remplacer.
Les quatre domaines de responsabilité du service de Larkfield, et les responsables de chaque partie. Omar est responsable des mises en production, pas d'un composant.
Description textuelle du diagramme

Le service comprend quatre domaines. Données : Grace est responsable de la politique et des documents de la boutique, car elle rédige les règles. Priya est responsable des données d’évaluation; Tomás, de l’index de récupération. Modèle : Priya est responsable de la requête et des deux modèles, car elle mesure leur qualité. Infrastructure : Amira est responsable de l’API, du processus et du cache. Mei est responsable de PostgreSQL et du stockage de télémétrie; Kwame, du contrat du fournisseur et des coûts. Communications clients : Grace. Omar est responsable des mises en production. Il décide quoi livrer selon les preuves fournies par la barrière, sans les remplacer.

Prenons le SLO des brouillons. Sa responsable, dans operations/slos.toml, est Amira. Supposons que son taux de consommation dépasse 7 : SEV-2, selon le calcul de la leçon précédente. Suivez l’appel :

  1. On appelle Amira en premier. Elle est responsable du SLO et du processus, donc elle peut voir les tâches. Elle exécute ops summary et voit no_answer: 187 (aucune réponse : 187). Beaucoup de réponses sont vides.
  2. La cause se trouve dans la requête. Les réponses vides viennent du modèle, pas de son code. Elle appelle la responsable de la requête : Priya. Priya voit que assistant-v3 est en production. Elle sait que l’évaluation disait NE PAS LIVRER.
  3. Le problème touche les clients. Dix billets nécessitant une personne n’ont été transmis à personne. C’est SEV-1. Amira appelle Grace, qui retrouve ces billets et contacte les clients.

Trois personnes, chacune appelée pour une raison. Personne n’a eu à deviner. Le diagramme montre le cheminement complet.

Un flux de haut en bas. Un SLO consomme rapidement son budget, ou une alerte se déclenche. Une question : quel SLO? Acceptation, brouillon ou délai de réponse mène à Amira (code, processus, cache). Qualité mène à Priya (requête, modèles). Sécurité (SEV-1) mène à Grace (communications clients). Sources des réponses mène à Tomás (index de récupération). Coûts mène à Kwame (fournisseur, coûts). Depuis Amira, trois flèches : vers Priya si la cause est la requête ou un modèle; vers Mei si la cause est la base de données ou le stockage de télémétrie; vers Kwame si la cause est le fournisseur. Des flèches pointillées partent de Priya, Mei, Kwame, Tomás et Grace vers une case : le problème touche les clients; le responsable appelle Grace, et Grace les informe.
Qui appeler en premier pour chaque objectif, puis qui appeler ensuite. Chaque flèche se termine par le nom d'une personne.
Description textuelle du diagramme

Commencez en haut : un SLO consomme son budget ou une alerte se déclenche. Le SLO détermine qui appeler en premier. Amira prend les trois parcours qui passent par son code : acceptation, brouillon et délai de réponse. Priya prend la qualité; Grace, la sécurité; Tomás, les sources des réponses; Kwame, les coûts. Amira est appelée en premier pour le plus grand nombre de SLO. Elle trouve donc souvent une cause dans la partie de quelqu’un d’autre. Ce peut être la requête ou un modèle (Priya), la base de données ou la télémétrie (Mei), ou le fournisseur (Kwame). La personne responsable de l’incident appelle Grace dès que le problème touche les clients.

Les responsables figurent déjà dans les deux fichiers des leçons précédentes. L’inventaire attribue un responsable à chaque partie; les objectifs attribuent un responsable à chaque SLO. Interrogez l’outil ops pour une personne :

Fenêtre de terminal
python -m ops inventory --owner Grace
kind component owner first sign of a failure
------ ------------------------------------------------ ----- ---------------------------------------------------------
data support policy (inside the prompt) Grace replies that state an old rule; agents rewrite the drafts
data shop documents Grace a document changes and answers still quote the old text
people customer communication (status message, replies) Grace customers ask where their answer is
3 components, 1 owners: Grace.

Grace n’est responsable d’aucun code, mais elle est quand même responsable de trois parties. Le tableau des SLO de ops slo contient aussi une colonne owner (responsable). Combinez les deux, et vous obtenez la feuille près de la porte :

Personne Parties (inventaire) SLO (appel en premier) Domaine
Amira ticket-api, Valkey accept, draft, answer_time infrastructure
Priya requête de triage, modèle de conversation, modèle de plongement, données d’évaluation quality modèle, données
Grace politique de soutien, documents de la boutique, communications clients safety données, communications clients
Tomás index de récupération, outils answer_sources données
Mei PostgreSQL, stockage de télémétrie – infrastructure
Kwame fournisseur d’IA budget des coûts infrastructure
Omar – (mises en production) – produit

Mei n’est responsable d’aucun SLO. C’est normal : quand la base de données tombe en panne, le SLO accept (acceptation) ou draft (brouillon) consomme son budget. On appelle Amira, puis elle appelle Mei. Tous les responsables n’ont pas besoin d’un téléavertisseur, mais chaque téléavertisseur a besoin d’un responsable.

Sam demande : « Pourquoi on appelle Amira en premier pour le SLO des brouillons, si le problème était la requête la semaine dernière? »

« Parce que la première personne doit pouvoir examiner la situation, dit Amira. Quand le SLO des brouillons consomme son budget, la cause peut être le processus, la file d’attente ou la base de données. Ça peut aussi être le fournisseur ou la requête. Je peux tout voir depuis le processus. Priya voit seulement le côté du modèle. Le premier responsable a la vue la plus large du parcours. Ce n’est pas la personne la plus susceptible d’être coupable. »

L’inventaire et les objectifs sont des fichiers pour les programmes. Les personnes ont besoin d’une page. La fiche de service de Larkfield, operations/service-brief.md, est l’exemple détaillé du module. Elle contient cinq courtes sections :

  1. Ce que fait le service, en quatre phrases.
  2. Les parcours utilisateurs et leurs objectifs : les six SLO et le budget des coûts, dans un tableau.
  3. Les niveaux de gravité : de SEV-1 à SEV-4, une ligne chacun.
  4. Les responsables : qui est responsable de quoi, en un paragraphe.
  5. Comment le service peut fonctionner sans répondre aux besoins de ses utilisateurs, la leçon de la semaine dernière.

Lisez la dernière section du fichier :

## How the service can be up and still fail its users
The accept SLO can be at 100% while the draft SLO fails: every ticket is saved, but the
assistant gives some of them no answer, so they wait for nobody. The dashboard's "uptime"
measures the first journey only.

Remarquez ce que la fiche ne contient pas : aucun diagramme d’architecture, aucun code, aucun historique. Elle répond aux questions d’une personne qui reçoit un appel la nuit. Qu’est-ce que ça fait? Que veut dire « fonctionner »? Quelle est la gravité? Qui dois-je appeler?

Quand consigner les responsabilités, et ce que cela coûte

Section intitulée « Quand consigner les responsabilités, et ce que cela coûte »

Tomás demande : « Ce n’est pas beaucoup de procédures pour sept personnes? »

Grace répond : « C’est une page. La semaine dernière, six personnes ont regardé un panneau rouge et personne n’a agi. Il aurait fallu une heure pour écrire cette page. »

Consignez les responsables dès que deux personnes partagent un service. Révisez la liste quand des personnes arrivent, partent ou changent de rôle, et à chaque mise en production. Le coût est réel, mais faible : quelqu’un doit garder les fichiers exacts. Le coût le plus important est le remplaçant. Il doit connaître la partie assez bien pour agir, donc il lui faut du temps pour l’apprendre. La responsabilité comporte aussi un risque : le responsable peut devenir la personne qu’on blâme. Dans ce cours, un responsable agit en premier; il n’est pas la cause. Tirer des leçons après un incident examine les incidents sans blâme.

Exercice guidé : comparer la fiche à la semaine dernière

Section intitulée « Exercice guidé : comparer la fiche à la semaine dernière »

Suivez ces étapes avec les fichiers de votre projet.

  1. Ouvrez operations/service-brief.md dans VS Code et lisez le tableau des parcours.
  2. Exécutez python -m ops slo data/telemetry/release-full.jsonl.gz.
  3. Pour chaque ligne de la sortie, trouvez le parcours dans la fiche. Notez : atteint ou non atteint, et qui appeler en premier.
  4. Déterminez la gravité de l’incident avec la section des niveaux de gravité de la fiche.

Vos notes devraient se terminer ainsi : accept atteint (Amira); draft non atteint, consommation 8,21 ≥ 7, SEV-2 (Amira); quality (qualité) non atteint (Priya); safety (sécurité) avec échecs, SEV-1 (Grace); réponses : aucune donnée; coûts au-dessus du budget, SEV-3 (Kwame). L’incident est SEV-1, le niveau le plus élevé de ses parties.

À votre tour : une fiche de service pour les réponses

Section intitulée « À votre tour : une fiche de service pour les réponses »

Le site Web de Larkfield répond aussi aux questions des clients à partir des documents de la boutique (POST /v1/answers). Traitez-le comme un petit service distinct et rédigez sa fiche de service. Dites ce qu’il fait. Définissez deux ou trois parcours, chacun avec un SLI et un SLO. Dites comment vous utiliseriez les niveaux de gravité. Nommez les responsables, chacun avec un remplaçant. Utilisez seulement des parties présentes dans l’inventaire. Les chiffres de la semaine normale figurent dans les lignes answer_time (délai de réponse) et answer_sources (sources des réponses) de ops slo.

Une solution détaillée
# Service brief: answers to customers' questions
## What the service does
Customers ask a question on the website. The API finds the shop's documents that
match, through the retrieval index, and answers with sources. No person checks
the answer before the customer reads it.
## Journeys and objectives (window: one week of questions)
| Journey | SLI (good / all) | SLO |
| A customer asks a question | answers within 3 seconds | 95% |
| The answer quotes current rules | answers whose sources are the current | 99% |
| | version of each document | |
| The question finds a source | answers with at least one source found | 90% |
Normal week (measured): 470 answers, 470 within 3 s, 470 with current sources.
The third SLO is a proposal: the project does not measure it yet.
## Severity
An answer that states a wrong rule about safety or money is SEV-1 (no person
checks it). An SLO that burns 7 times too fast is SEV-2. A slow burn is SEV-3.
## Owners (backup)
Answer time: Amira (backup Mei). Sources and the index: Tomás (backup Priya).
Shop documents: Grace (backup an agent she names). Customer messages: Grace.
## How it can be up and still fail its users
Every question gets a fast answer, but after a document changes and the
index is not rebuilt, the answers quote the old rule.

Ce qui la rend bonne : chaque SLI est bons ÷ tous, avec une cible et une fenêtre. Les chiffres indiquent lesquels sont mesurés (470 sur 470) et lesquels sont proposés. Chaque responsable est une personne, avec un remplaçant. La ligne SEV-1 est propre à ce service. Ici, aucun agent ne se trouve entre la réponse et le client. Une règle erronée atteint donc directement le client. La dernière section nomme un échec que la disponibilité ne peut pas détecter. Régressions des LLM et du RAG reproduit exactement cet échec.

Erreur courante

Le responsable est la personne qui a fait le changement

Symptôme : après la semaine dernière, quelqu’un propose : « L’équipe d’Omar a changé la requête. Omar est donc maintenant responsable du SLO des brouillons. »

Cause : on confond responsabilité et blâme. La personne qui a fait le dernier changement n’est pas celle qui pourra examiner et agir en premier la prochaine fois.

Correction : gardez le responsable qui a la vue la plus large du parcours : Amira, pour les brouillons. Corrigez plutôt le processus de mise en production. Un changement de requête doit passer par une barrière et un déploiement canari. C’est le travail du cinquième module de ce cours.

Erreur courante

Le responsable est absent et n'a pas de remplaçant

Symptôme : une alerte se déclenche un samedi. Le responsable est dans un avion. L’alerte attend jusqu’au lundi.

Cause : la fiche nomme une personne pour chaque partie, sans remplaçant.

Correction : ajoutez un remplaçant pour chaque responsable et assurez-vous qu’il peut agir. Il lui faut l’accès aux tableaux de bord, à l’outil ops et au guide d’exploitation. La fiche de Larkfield dans l’instantané contient seulement les responsables. Ajouter les remplaçants fait partie de la tâche ci-dessus.

Vérifiez votre compréhension

Le SLO de qualité consomme rapidement son budget. Qui appeler en premier, et quand faut-il appeler Grace?

Afficher la réponse

On appelle Priya en premier : operations/slos.toml lui attribue le SLO de qualité. Elle est responsable de la requête et des modèles, les causes les plus probables. Si elle trouve la cause ailleurs, par exemple dans la base de données, elle appelle sa responsable (Mei). On appelle Grace dès que le problème touche les clients. Par exemple, de mauvaises décisions ont envoyé des billets à la mauvaise équipe. Ou un billet nécessitant une personne n’a été transmis à personne : c’est SEV-1.

Vérifiez votre compréhension

Tomás dit : « La disponibilité est verte, donc tout va bien. » Répondez avec un chiffre de la semaine normale et un de la semaine dernière.

Afficher la réponse

Le SLI d’acceptation, qui représente la disponibilité, était de 100,00 % pendant les deux semaines. Il ne permet donc pas de les distinguer. Le SLI des brouillons était de 99,93 % pendant la semaine normale et de 91,79 % la semaine dernière. La semaine dernière, 197 billets n’ont reçu aucune réponse, et 10 nécessitant une personne n’ont été transmis à personne. Une disponibilité verte indique que les billets sont acceptés, pas que les clients reçoivent de l’aide.

Vérifiez votre compréhension

Vérification pratique : quels SLO relèvent d'Amira, et de combien de parties de l'inventaire Grace est-elle responsable?

Afficher la réponse

python -m ops slo data/telemetry/normal-week.jsonl.gz montre qu’Amira est responsable de accept, draft et answer_time. python -m ops inventory --owner Grace se termine par 3 components, 1 owners: Grace. (3 composants, 1 responsable : Grace). Ce sont la politique de soutien, les documents de la boutique et les communications clients.

Dans ce module, vous avez fait tourner le service en production et lu sa télémétrie enregistrée. Vous avez listé les 14 parties dont il dépend. Vous avez transformé ses parcours utilisateurs en six SLO avec des budgets d’erreur et des niveaux de gravité. Puis vous avez attribué un responsable à chaque partie et à chaque SLO. La tâche autonome du module était la fiche de service ci-dessus.

Vérifiez votre compréhension

Vérification finale : expliquez comment un système peut être disponible sans répondre aux besoins de ses utilisateurs. Appuyez-vous sur la sortie de l'outil ops pour la semaine dernière et dites qui aurait dû être appelé.

Afficher la réponse

Exécutez python -m ops slo data/telemetry/release-full.jsonl.gz. Le SLI d’acceptation est 100.00% (2,400/2,400) : le service était disponible et chaque billet a été enregistré. Mais le SLI des brouillons est 91.79% (2,203/2,400), avec un taux de consommation de 8.21. Le SLI de sécurité compte 4 échecs, et le coût est US$0.440 per 1,000 tickets (budget US$0.40, OVER) (0,440 $ US par 1 000 billets, budget de 0,40 $ US dépassé). Le SLI de disponibilité mesurait seulement le premier parcours : envoyer un billet. Le parcours du service de soutien a échoué après la réponse de l’API. La requête v3 a donné des réponses sans texte, donc les billets attendaient sans équipe. Dix billets nécessitant une personne n’ont été transmis à personne. Gravité : SEV-1 (sécurité). Appel en premier : Amira, responsable du SLO des brouillons. Ensuite, Priya, responsable de la requête, et Grace, pour les clients.

Récapitulatif

  • Un responsable est une personne qui décide pour une partie et qu’on appelle en premier. Chaque partie et chaque SLO en ont un; chaque responsable a besoin d’un remplaçant.
  • Les quatre domaines sont données, modèle, infrastructure et communications clients. Grace n’est responsable d’aucun code, mais elle est responsable du message le plus important.
  • La première personne appelée a la vue la plus large du parcours. Ce n’est pas celle qui a fait le dernier changement. Elle transmet l’incident selon sa cause et appelle Grace quand le problème touche les clients.
  • Une fiche de service rassemble les parcours, les objectifs, les niveaux de gravité et les responsables sur une page. Elle sert à la personne appelée la nuit.

Prochain module : la semaine dernière, personne ne pouvait même dire quels billets avaient reçu une réponse avec la requête v3. Vous attribuez à chaque réponse un identifiant de mise en production permettant de retrouver toutes les versions qui l’ont produite.

Leçon suivante : Lignée des artefacts