Une observabilité qui respecte la vie privée
- Leçon 10
- 50 min
- Module 3 : Instrumenter une télémétrie utile
Où nous en sommes
Dans les deux leçons précédentes, nous avons fait enregistrer par le service ce qui arrive à chaque billet, par version et avec son coût. Mais cet enregistrement copie ce que les clients ont écrit, et il peut donc le divulguer. Dans cette leçon, nous décidons ce que contient la télémétrie, nous retirons le texte privé avant qu'il quitte le service et nous mesurons le coût de chaque choix, comme une caméra de magasin qui ne doit pas filmer le terminal de paiement.
Leçon 10 sur 19 · MLOps et LLMOps : exploiter l'IA en productionUne observabilité qui respecte la vie privée
1. Définir la responsabilité opérationnelle
2. Versionner et reproduire le système
3. Instrumenter une télémétrie utile
4. Surveiller les changements de comportement
5. Mettre en production et améliorer en toute sécurité
6. Gérer les incidents et la passation
Ce que vous saurez faire
La télémétrie copie ce qui arrive au billet de chaque client. Elle peut donc divulguer ce que les clients ont écrit. Décidez ce qu’elle contient, puis retirez le texte privé avant qu’il quitte le service. Gardez moins de traces, limitez leur accès et leur durée de conservation, puis mesurez le coût de chaque choix.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Journaux, métriques et traces et Qualité et coûts.
- La minimisation des données et la conservation, dans Réduire et conserver de façon réfléchie, du cours Sécurité de l’IA, vie privée et conception responsable.
Ce qu’il vous faut sur votre ordinateur
- Votre projet à l’instantané
end-of-m03. Pour exécuter vous-même ces configurations, Docker pour PostgreSQL et Valkey, comme dans la première leçon de ce module.
Sans Docker, lisez les sorties de l’auteur ci-dessous, puis faites l’exercice guidé et la tâche à la fin. Ils utilisent seulement la télémétrie enregistrée.
La caméra dans le magasin
Section intitulée « La caméra dans le magasin »Un magasin a une caméra de sécurité à l’entrée. Elle est utile : quand un colis disparaît, le propriétaire peut voir qui est entré. Mais si elle filme aussi le terminal de paiement à la caisse, chaque enregistrement contient les NIP des clients. Les enregistrements deviennent alors un danger, tout comme les personnes qui peuvent les regarder.
Un magasin prudent pointe donc la caméra ailleurs que vers le terminal de paiement. Il garde les enregistrements pendant 30 jours, puis les supprime. Il verrouille la pièce où se trouve l’écran, et seulement deux personnes ont la clé. Il ne garde pas non plus chaque minute de chaque caméra en pleine qualité; cela remplirait les disques.
Chacun de ces choix porte un nom en télémétrie. Pointer la caméra ailleurs, c’est la minimisation : ne pas recueillir ce dont vous n’avez pas besoin. Cacher une partie de l’image, c’est le caviardage. Supprimer après 30 jours, c’est la conservation. La pièce verrouillée représente le contrôle d’accès. Garder seulement certains enregistrements, c’est l’échantillonnage.
Le problème : « tout journaliser, au cas où »
Section intitulée « Le problème : « tout journaliser, au cas où » »Tomás propose : « Mettons chaque requête et chaque réponse au complet dans les traces. Quand quelque chose brisera, nous aurons tout. »
Le service peut le faire. TELEMETRY_CAPTURE_CONTENT=true ajoute l’objet et le corps du billet, les messages envoyés au modèle, sa sortie et la réponse. L’auteur l’a exécuté en désactivant le caviardage (TELEMETRY_REDACT=false) et avec TELEMETRY_FILE=telemetry-raw/{service}.jsonl. Cette exécution a envoyé cinq billets d’exercice, puis un autre billet rédigé à la main :
curl -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" \ -d '{"customer_id": "C-0022", "subject": "Charged twice", "body": "I paid twice for one order. Please reply to sam.lee@example.com."}'Ensuite, ops privacy a analysé les deux fichiers. Cette commande compte ce qu’elle trouve, mais n’affiche jamais le texte :
python -m ops privacy telemetry-raw/ticket-api.jsonl telemetry-raw/ticket-worker.jsonlticket-api.jsonl, ticket-worker.jsonl: 6 ticketssignal KB KB per ticket------ ----- -------------log 10.1 1.68metric 23.8 3.97span 116.4 19.39all 150.3 25.04FOUND (counts only; the text is not printed): attribute ticket.subject: 6 attribute ticket.body: 6 attribute answer.text: 6 attribute gen_ai.input.messages: 6 attribute gen_ai.output.messages: 6 e-mail address: 2Le texte de chaque billet se retrouve maintenant cinq fois dans la télémétrie, et l’adresse courriel du client, deux fois. Ces fichiers vont dans Grafana, où chaque visiteur peut les consulter, dans les sauvegardes et sur un portable pour « regarder rapidement ». La base de données des billets définit qui peut les lire et quand ils sont supprimés. La télémétrie serait une deuxième copie des mêmes messages, sans ces règles.
Et « au cas où » est rarement rentable. Dans ce module, aucune réponse aux questions sur la semaine dernière n’a nécessité un seul mot d’un billet. Le résultat, les jetons, la raison de fin et la durée ont suffi.
L’idée : décider avant l’exportation, puis limiter le reste
Section intitulée « L’idée : décider avant l’exportation, puis limiter le reste »Une observabilité qui respecte la vie privée répond aux questions d’exploitation avec le moins de données personnelles possible. Elle fonctionne par couches, du code jusqu’au lecteur :
Description textuelle du diagramme
Le code est la première couche : par défaut, il décrit le billet sans son texte. L’échantillonneur élimine la plupart des traces, mais jamais les journaux ni les métriques. Chaque billet reste donc compté. Le caviardage s’exécute dans le processus, avant tout exportateur. Le texte n’atteint donc jamais un fichier ni le réseau. Après l’exportation, la conservation détermine la durée de vie des données, et le contrôle d’accès détermine qui peut les lire.
La première couche est la plus importante : décrivez l’entrée, ne la copiez pas. La première leçon de ce module présentait l’événement ticket.received avec ticket.message_chars (la longueur), ticket.language_guess et ticket.message_sha256. Ces attributs décrivent suffisamment le message pour mesurer la dérive dans le prochain module et trouver les messages répétés. Aucun ne contient les mots.
Le caviardage est la protection de secours pour le texte qui s’ajoute malgré tout. Avant l’exportation, il retire chaque attribut contenant du texte rédigé par une personne. Il masque aussi les adresses courriel et les numéros de carte dans tout autre texte. Voici la fonction redact() du projet, exécutée seule sur un ensemble d’attributs :
>>> telemetry.redact({... "ticket.body": "I paid twice for one order. Please reply to sam.lee@example.com.",... "ticket.message_chars": 64,... "note": "customer sam.lee@example.com, card 4111 1111 1111 1111",... "team": "payment"}){'ticket.message_chars': 64, 'note': 'customer [email], card [card]', 'team': 'payment'}Le corps a disparu : il figure dans la liste des attributs textuels. La note reste, mais son adresse courriel et son numéro de carte sont masqués. La longueur et l’équipe restent, car ce ne sont pas des données personnelles. Le masquage utilise des motifs et détecte seulement ce qu’ils reconnaissent. Un nom ou une adresse postale dans du texte libre passe donc inaperçu. C’est pourquoi le retrait des attributs textuels vient en premier, et le masquage en second.
Larkfield : trois configurations mesurées
Section intitulée « Larkfield : trois configurations mesurées »L’auteur a envoyé cinq autres billets d’exercice et le même billet rédigé à la main, avec le caviardage activé (TELEMETRY_CAPTURE_CONTENT=true, TELEMETRY_REDACT=true), dans telemetry-redacted/ :
ticket-api.jsonl, ticket-worker.jsonl: 6 ticketssignal KB KB per ticket------ ---- -------------log 7.4 1.23metric 21.1 3.51span 67.6 11.26all 96.0 16.00No text attribute, no e-mail address, no card number found.Rien de détecté, et les segments de trace retrouvent leur taille normale. L’équipe du cours a mesuré les trois mêmes configurations sur 200 billets chacune. La taille fixe des métriques pèse ainsi moins lourd :
Description textuelle du graphique
Trois barres. Par défaut, sans texte : 12,9 Ko par billet. Texte conservé sans caviardage : 21,6 Ko, soit deux tiers de plus. Texte conservé avec caviardage : 12,9 Ko, comme par défaut. Dans la deuxième configuration, ops privacy a trouvé l’objet, le corps, la requête, la sortie du modèle et la réponse dans les 200 billets. Dans les deux autres, la commande n’a rien trouvé.
La troisième barre illustre la leçon. Capturer le texte, puis le caviarder donne exactement le résultat par défaut, avec un risque en plus. Le texte existe brièvement dans le processus, et un seul mauvais paramètre suffit à l’exporter. Larkfield garde donc la valeur par défaut, TELEMETRY_CAPTURE_CONTENT=false, et garde le caviardage activé comme protection de secours. Quand Priya a besoin du texte d’un billet qui a échoué, elle prend son identifiant dans la télémétrie. Elle lit ensuite le billet dans la base de données des billets, selon ses propres règles d’accès.
Échantillonnage : moins de traces, chaque billet toujours compté
Section intitulée « Échantillonnage : moins de traces, chaque billet toujours compté »Les segments de trace occupent la majeure partie de l’espace : environ 11 des 12,9 Ko par billet. Un service très actif n’a pas besoin de la trace de chaque billet traité sans problème. L’échantillonnage garde les traces d’une partie seulement des billets. TELEMETRY_SAMPLE=0.1 en garde environ 1 sur 10.
La décision se prend une seule fois par trace, à partir de son identifiant, au début. Un billet garde donc tous ses segments de trace, ou aucun. Le segment du processus suit la décision de l’API, car la tâche transporte le traceparent (le contexte de la trace parente). Les journaux et les métriques ne sont jamais échantillonnés. Chaque SLI compte donc toujours chaque billet.
L’auteur a envoyé 20 billets d’exercice avec TELEMETRY_SAMPLE=0.1 et TELEMETRY_FILE=telemetry-10/{service}.jsonl, pour donner à chaque configuration ses propres fichiers :
python -m ops summary telemetry-10/ticket-api.jsonl telemetry-10/ticket-worker.jsonlRecords: 40 logs, 88 spans, 42 metric records, from +0.0 min to +0.4 minTicket requests: 20 (202: 20)Tickets triaged: 20 (ok: 20)Les 20 billets sont tous comptés, à partir de 40 événements. Les 88 segments de trace forment 4 traces de 22 segments. Donc, 4 billets sur 20 ont gardé une trace, et non 2. Une proportion de 10 % est une probabilité, pas un nombre exact. Votre nombre sera différent. La taille a baissé à 4,94 Ko par billet. L’exécution de la première leçon, avec toutes les traces, occupait 18,58 Ko par billet, pour seulement 5 billets.
Les fichiers enregistrés du cours montrent le même effet à grande échelle. La semaine normale a gardé 10 % des traces : 34 412 enregistrements pour 5 754 billets, 20,4 Mo, et 2,2 Mo après compression. La réexécution de la semaine dernière a gardé toutes les traces : 56 334 enregistrements pour 2 400 billets, 34,1 Mo, et 2,6 Mo après compression. Par billet, cela représente environ 3,5 Ko contre 14,2 Ko.
L’échantillonnage réduit le travail du processus, mais pas celui de l’API :
Description textuelle du graphique
Trois barres. Sans télémétrie, le processus terminait 238 tâches par seconde. Avec toutes les traces, 201 : 16 % de moins. Avec 10 % des traces, 229 : 4 % de moins. L’API montrait un autre résultat. Une requête de billet prenait une médiane de 2,39 ms sans télémétrie, de 3,66 ms avec toutes les traces et de 3,75 ms avec 10 %. L’API produit toujours ses journaux, ses métriques et son propre segment de trace pour chaque requête. L’échantillonnage n’a donc pas réduit son coût.
Conservation et accès : combien de temps, et qui
Section intitulée « Conservation et accès : combien de temps, et qui »La conservation désigne la durée pendant laquelle la télémétrie est gardée. Le paramètre est TELEMETRY_RETENTION_DAYS=30 : assez longtemps pour comparer cette semaine au mois dernier et analyser un incident. ops prune supprime les anciens enregistrements d’un fichier :
python -m ops prune telemetry/ticket-worker.jsonl --days 30telemetry/ticket-worker.jsonl: kept 115 records, deleted 0 older than 30 daysN’exécutez pas prune sur les fichiers enregistrés du cours dans data/telemetry/. Ils ont été enregistrés bien avant votre lecture; la commande les supprimerait donc tous. Dans Grafana, chaque système de stockage a son propre paramètre (Prometheus, Loki et Tempo), indiqué dans observability/README.md. Mei est responsable du stockage de la télémétrie. Elle configure donc ces paramètres et les vérifie.
Le contrôle d’accès détermine qui peut lire la télémétrie. Dans compose.yaml, les personnes non connectées à Grafana sont des Viewers (lecteurs). Elles peuvent consulter les tableaux de bord, mais pas les modifier ni modifier les règles d’alerte. La valeur par défaut de l’image est Admin (administrateur); le projet la change donc. Sur votre ordinateur, le compte administrateur est admin et son mot de passe est admin. Changez-le avant que quelqu’un d’autre puisse accéder au port 3000. Les fichiers demandent la même attention. Le fichier .gitignore du projet contient déjà telemetry/ : ne mettez jamais ces fichiers dans un dépôt ou un message de clavardage.
Quand échantillonner et caviarder, et à quel coût
Section intitulée « Quand échantillonner et caviarder, et à quel coût »Utilisez ces paramètres pour chaque service qui traite le texte des clients. Gardez la capture du contenu désactivée. Gardez le caviardage activé, même si le code par défaut n’envoie aucun texte. Il protège contre les erreurs de la prochaine personne qui ajoute un attribut.
Échantillonnez les traces quand leur volume devient un coût : stockage, réseau ou temps du processus. N’échantillonnez pas lorsque le trafic est faible, ni pendant le débogage : vous avez alors besoin de chaque trace. L’échantillonnage a aussi son propre coût réel. Un billet rare et lent peut n’avoir aucune trace. Pendant la semaine normale, seulement 570 billets sur 5 754 ont gardé une trace. Les grandes équipes utilisent l’échantillonnage en fin de trace (tail sampling). Le collecteur attend la fin d’une trace, puis garde chaque trace avec une erreur ou une longue durée. Ce projet ne le fait pas. Il garde les journaux de chaque billet; vous pouvez donc toujours trouver et compter un billet qui a échoué.
Une courte conservation coûte de l’historique : après 30 jours, les anciens billets ont disparu. Gardez les métriques plus longtemps que les traces si vous avez besoin de tendances : elles contiennent des nombres, pas des billets.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
Aucune trace pour le billet dont vous avez besoin
Symptôme : avec TELEMETRY_SAMPLE=0.1, la vue en cascade d’un billet affiche :
No trace for ticket T-500018: it was not sampled (TELEMETRY_SAMPLE keeps only some tickets' traces). Its logs are there: python -m ops trace.Cause : l’identifiant de trace de ce billet se trouvait hors des 10 % que l’échantillonneur conserve. Dans l’exécution de l’auteur, 16 des 20 billets n’avaient aucune trace.
Solution : utilisez les journaux du billet. La commande ops trace, présentée dans Lignée des artefacts, les lit avec le résultat, les jetons et le coût. Pour déboguer un problème, configurez temporairement TELEMETRY_SAMPLE=1.0, puis envoyez le billet à nouveau.
Erreur courante
Une valeur de hachage n'est pas anonyme
Symptôme : quelqu’un suggère que la télémétrie ne contient aucune donnée personnelle, « seulement des valeurs de hachage ».
Cause : ticket.message_sha256 et customer.ref sont des pseudonymes. Le même texte, ou le même client, donne toujours la même valeur. Quiconque possède le message d’un client peut calculer son hachage et le retrouver dans la télémétrie. De nombreuses lois sur la vie privée considèrent encore ces valeurs comme des données personnelles.
Solution : traitez quand même la télémétrie comme des données personnelles : conservation, contrôle d’accès et aucune copie hors de l’équipe. Demandez à votre responsable de la vie privée quelles règles s’appliquent à vous. Les valeurs de hachage sont volontairement courtes (16 et 10 caractères). Elles suffisent pour trouver des répétitions, mais sont moins utiles comme clé.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Tomás dit : « Journalisons chaque requête et chaque réponse au complet, au cas où. » Répondez-lui avec deux mesures de cette leçon.
Afficher la réponse
Avec la capture du texte sans caviardage, ops privacy a trouvé l’objet, le corps, la requête, la sortie du modèle et la réponse dans chaque billet. La commande a aussi trouvé deux fois l’adresse courriel du client. Chaque lecteur de Grafana et chaque copie des fichiers auraient les messages des clients, sans les règles de la base de données des billets. Cela a aussi augmenté la télémétrie de deux tiers : 21,6 Ko par billet au lieu de 12,9 Ko. Et ce n’était pas nécessaire : les résultats, les jetons, les raisons de fin et les durées répondaient à toutes les questions sur la semaine dernière.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Prédisez : vous configurez TELEMETRY_SAMPLE=0.1. Qu'arrive-t-il aux SLI accept et draft, à la vue en cascade d'un billet aléatoire et au temps par requête de l'API?
Afficher la réponse
Les SLI ne changent pas : ils viennent des journaux et des métriques, qui comptent chaque billet. Un billet aléatoire a une probabilité d’environ 10 % d’avoir une trace. Pour les autres, ops waterfall affiche « No trace … it was not sampled » (aucune trace… elle n’a pas été échantillonnée). Le temps par requête de l’API reste à peu près le même : 3,66 ms avec toutes les traces, 3,75 ms avec 10 %. Elle écrit toujours ses événements, ses métriques et son propre segment de trace. Le processus retrouve l’essentiel de sa vitesse : 229 tâches par seconde au lieu de 201.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Vérification pratique : exécutez ops privacy sur vos fichiers de télémétrie de la première leçon de ce module. Qu'affiche la commande, et pourquoi?
Afficher la réponse
python -m ops privacy telemetry/ticket-api.jsonl telemetry/ticket-worker.jsonl affiche la taille par signal et No text attribute, no e-mail address, no card number found. (aucun attribut textuel, aucune adresse courriel, aucun numéro de carte trouvé). Les paramètres par défaut n’ajoutent jamais le texte (TELEMETRY_CAPTURE_CONTENT=false), et le caviardage est activé comme protection de secours (TELEMETRY_REDACT=true). Dans l’exécution de l’auteur sur 5 billets, les fichiers occupaient 18,58 Ko par billet, surtout des segments de trace. Vos tailles seront légèrement différentes.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Exercice guidé : un billet qui a attendu 29 secondes
Section intitulée « Exercice guidé : un billet qui a attendu 29 secondes »La dernière compétence de ce module consiste à trouver une étape lente et coûteuse dans une trace. Suivez d’abord un exemple détaillé où chaque étape est visible. Le fichier provient d’une exécution d’exercice d’un module ultérieur, avec le même service.
-
Affichez la trace du billet échantillonné le plus lent :
Fenêtre de terminal python -m ops waterfall data/telemetry/canary.jsonl.gz --slowestTrace 0193d235f0d3d4ec0dcc2ee84c1571bf, ticket T-501092 (the slowest of 2400 sampled): 33 spans, 29,239 ms from first to lastspan start ms ms cost US$POST /v1/tickets 0 14.7 #(waiting in the queue) 15 15.5 #process ticket job 30 10,027.4 ############triage ERROR 32 10,018.9 ############chat chat-small ERROR 32 10,018.3 ############POST ERROR 33 10,015.6 ############process ticket job 11,691 10,029.9 ############triage ERROR 11,698 10,016.8 ############chat chat-small ERROR 11,698 10,015.3 ############POST ERROR 11,698 10,013.6 ############process ticket job 24,980 4,259.2 #####triage 24,984 4,251.0 #####chat chat-small 24,984 4,248.0 ##### 0.000388POST 24,985 4,245.2 #####embed 29,235 2.5 #cache get 29,235 0.5 #(18 database queries hidden; --all shows them)Longest step: triage, 10,019 ms (34% of the trace)Costliest step: chat chat-small, US$0.000388 of US$0.000388: 1894 tokens in, 398 out (288 of them reasoning), finish stop -
Comptez les tentatives : trois segments de trace
process ticket job(traiter la tâche du billet), donc la tâche s’est exécutée trois fois. -
Lisez les deux premières tentatives : chaque
chat chat-small ERROR(erreur de conversation avec chat-small) dure 10,0 s, le délai d’expiration du fournisseur. Elles n’ont ni coût ni jetons : aucune réponse n’est revenue. -
Lisez les intervalles : la tentative 2 commence à 11 691 ms, soit 1,6 s après la fin de la tentative 1. La tentative 3 commence à 24 980 ms, soit 3,3 s après la tentative 2. Ce sont les attentes entre les nouvelles tentatives, et
opsne dessine aucune barre pour elles. -
Lisez la troisième tentative : une réponse normale en 4,25 s, à 0,000388 $ US, avec la raison de fin
stop(arrêt). -
Additionnez : 20,0 s de délais expirés, 4,9 s d’attente entre les tentatives, 4,3 s de travail réel. Le goulot d’étranglement est l’expiration des délais, soit 69 % des 29,2 s. L’étape la plus coûteuse est le seul appel qui a fonctionné.
ops dit « Longest step : triage, 34 % » (étape la plus longue : triage, 34 %). C’est vrai pour un segment de trace, mais cela manque le motif : deux tentatives échouées de la même étape. Lisez toute la vue en cascade. Le message d’exercice du billet a plusieurs enregistrements, et la réexécution a choisi deux fois un enregistrement de plus de 10 s. C’est le problème d’expiration du délai présenté dans Qualité et coûts. Ici, il a retardé une réponse de 25 secondes.
À vous de jouer : trouvez l’étape lente et coûteuse
Section intitulée « À vous de jouer : trouvez l’étape lente et coûteuse »Exécutez python -m ops waterfall data/telemetry/shadow.jsonl.gz --slowest. Ce fichier contient un autre exercice d’un module à venir. Trouvez l’étape la plus lente et la plus coûteuse. Dites ce que la trace prouve, ce qu’elle ne peut pas expliquer et quel signal fournirait le reste. N’utilisez pas le raisonnement du modèle : vous ne pouvez pas le lire.
Une solution détaillée
La sortie commence par Trace f265715a2074a667f3e7bc9a404b3fd5, ticket T-505297 (the slowest of 588 sampled): 26 spans, 67,073 ms from first to last (trace du billet T-505297, le plus lent des 588 échantillonnés : 26 segments de trace, 67 073 ms du premier au dernier) et se termine par :
Longest step: (waiting in the queue), 26,782 ms (40% of the trace)Costliest step: chat chat-small, US$0.000388 of US$0.000388: 1894 tokens in, 398 out (288 of them reasoning), finish stopLisez-la comme dans l’exercice guidé :
| Étape | Début (ms) | Durée | Coût |
|---|---|---|---|
| Requête API | 0 | 17 ms | – |
| Attente dans la file | 17 | 26,8 s | – |
Tentative 1 : chat chat-small ERROR (erreur) |
26 803 | 10,0 s (délai dépassé) | aucun coût enregistré |
| Intervalle avant la tentative 2 (attente avant nouvel essai, file) | 36 821 | 26,0 s | – |
Tentative 2 : chat chat-small |
62 802 | 4,25 s, fin stop (arrêt) |
0,000388 $ US |
embed (plongement) |
67 060 | 8 ms (depuis le cache) | – |
Étape la plus lente : la file, 26,8 s, soit 40 % de la trace. L’intervalle avant la deuxième tentative correspond aussi à du temps dans la file. Le billet a donc attendu environ 53 secondes sur 67. Étape la plus coûteuse : le deuxième appel de triage, le seul appel avec un coût. Ici, l’étape lente et l’étape coûteuse sont différentes.
Ce que la trace prouve : le travail d’IA n’a pris qu’environ 14 s sur 67 s. Seulement 4,25 s de ce travail ont produit une réponse. La plupart du temps, le billet attendait un processus libre, pas le fournisseur.
Ce qu’elle ne peut pas expliquer : pourquoi la file était longue. Une trace montre un seul billet. Les jauges de la file les montrent tous. Dans le fichier, app.queue.depth indiquait 49 tâches en attente et 16 en cours à l’arrivée de ce billet. Cela occupait toutes les places des deux processus, soit 8 tâches chacun. Dans cet exercice, la plupart des tâches faisaient aussi un deuxième appel de triage pour un test d’un module à venir. Il s’agissait d’une exécution parallèle sans effet sur le service. Chaque tâche occupait donc sa place plus longtemps.
Quoi faire : la solution consiste à augmenter la capacité ou à réduire le travail par tâche (Amira), pas à modifier la requête.
Vérifiez votre compréhension
Vérification de fin : expliquez le goulot d'étranglement du billet T-503354 dans la reproduction de la semaine dernière, sans le raisonnement caché du modèle. Utilisez seulement ce que la trace montre.
Afficher la réponse
python -m ops waterfall data/telemetry/release-full.jsonl.gz --ticket T-503354 montre une trace de 9,2 s. L’API a pris 17 ms, et l’attente dans la file, 165 ms. L’appel de triage chat chat-small a pris 9 008 ms, soit 98 % de la trace. Il représentait tout le coût, soit 0,000650 $ US. Ses attributs expliquent pourquoi : 1 000 jetons en sortie, tous consacrés au raisonnement, et une fin length (limite de longueur). Le modèle a atteint la limite de jetons avant d’écrire la réponse. La tâche porte donc la mention ERROR (erreur) et n’a aucun plongement. Le texte du raisonnement est caché. Mais sa taille et sa durée figurent dans le segment de trace, et elles suffisent. Le goulot d’étranglement est la requête v3 avec cette limite de jetons, ce qui relève de Priya. L’API, la file, la base de données et le processus ne sont pas en cause.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif du module
Section intitulée « Récapitulatif du module »Dans ce module, vous avez rendu le service de billets observable. Dans la première leçon, vous avez ajouté OpenTelemetry. Vous avez créé des événements aux noms fixes, des métriques pour chaque billet et une trace par billet traversant la file. Dans la deuxième, vous avez réparti les résultats, les catégories d’échec, les jetons et les coûts par version de requête. Vous avez aussi trouvé où passaient le temps et l’argent d’un billet. Dans cette leçon, vous avez exclu les mots des clients de toute cette télémétrie et mesuré le coût de chaque choix.
Le service peut maintenant répondre à quatre questions pour chaque billet et chaque version. A-t-il obtenu une réponse valide? Combien de temps cela a-t-il pris? Combien cela a-t-il coûté? En cas d’échec, de quelle façon a-t-il échoué?
Récapitulatif
- Minimisez d’abord : décrivez un billet par sa longueur, sa langue estimée et son empreinte de hachage, jamais par son texte.
TELEMETRY_CAPTURE_CONTENTreste à false (faux). - Le caviardage avant l’exportation supprime les attributs textuels et masque les adresses courriel et les numéros de carte. Capturer le texte, puis le caviarder ajoute seulement du risque.
- L’échantillonnage conserve la trace d’une partie des billets; les journaux et les métriques comptent toujours chaque billet. Il a éliminé la majeure partie du coût de traçage du processus, mais aucun de celui de l’API.
- La conservation (30 jours,
ops prune) et le contrôle d’accès (Grafana Viewers, aucune copie des fichiers) limitent ce qui reste.
Prochain module : les entrées du service changent. La proportion de billets en français augmente, et les documents de la boutique changent. Vous vérifiez si les entrées ont dérivé et si cela signifie que l’assistant est devenu moins bon.
Leçon suivante : Dérive des données et dérive conceptuelle