Aller au contenu
English

Choisir ce qui peut être mis en cache

  • Leçon 8
  • 50 min
  • Module 3 : Utiliser le cache sans fausser les résultats

Où nous en sommes

Dans le module 2, nous avons traité plus de billets à la fois, et nous avons vu que le quota du fournisseur ne grandit pas avec le nombre de processus. Pour avoir moins besoin du fournisseur, nous pouvons garder une copie d'un résultat et la redonner. Mais une copie envoyée à la mauvaise personne, ou conservée après être devenue incorrecte, est pire que l'absence de copie. Dans cette leçon, nous planifions quoi mettre en cache, pour qui et pour combien de temps. Pensons à une fiche au comptoir d'accueil d'un magasin.

Ce que vous saurez faire

Décidez quels résultats de l’API de billets conserver en copie, qui peut recevoir chaque copie et combien de temps elle reste correcte. Faites ce plan avant d’écrire le code du cache. Une copie envoyée à la mauvaise personne, ou conservée après être devenue incorrecte, est pire que l’absence de copie.

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

  • Le projet ~/projects/ticket-api après le module 2. python -m pytest affiche 137 passed, 1 deselected (137 tests réussis, 1 exclu). Si votre projet ne fonctionne plus, copiez l’instantané end-of-m02, comme l’explique le README des instantanés.
  • Les fichiers du cours dans ~/projects/nextia-learning-labs. Obtenez les plus récents avec git -C ~/projects/nextia-learning-labs pull.

Cette leçon ajoute un fichier, docs/cache-plan.md, et ne change aucun code. La prochaine leçon construit le cache. L’équipe du cours a mesuré les temps de ce module sur un ordinateur Apple M4 sans autre activité. Elle a utilisé le fournisseur simulé avec son quota désactivé. Vos temps seront différents, mais les tendances resteront les mêmes.

Imaginez le comptoir d’accueil d’un grand magasin. Chaque jour, environ cinquante personnes demandent « Quelles sont vos heures d’ouverture? » Au début, l’employée cherche la réponse chaque fois. Puis elle écrit la réponse sur une fiche qu’elle garde sur le comptoir. Maintenant, elle lit la fiche à voix haute en deux secondes.

Une autre question est « Où est mon colis? » L’employée cherche la réponse pour Mme Diaz et écrit « Colis 4471, en cours de livraison » sur une fiche. Puis M. Lee pose la même question. Si elle lui lit la fiche, il reçoit le numéro de colis de Mme Diaz. La question était la même, mais pas la bonne réponse.

Un jour férié, le magasin ouvre plus tard. La fiche des heures d’ouverture est maintenant incorrecte, et personne ne l’a modifiée. Chaque fiche soulève donc trois questions. Vaut-il la peine d’écrire la réponse? Qui peut l’entendre? Quand devient-elle incorrecte?

Le problème : la même réponse lente, produite encore et encore

Section intitulée « Le problème : la même réponse lente, produite encore et encore »

Ce module ajoute une fonction à l’API de billets : les clients et le personnel peuvent poser une question au service de soutien. POST /v1/answers reçoit une question et renvoie une courte réponse. L’API lit les documents que l’appelant peut consulter et, pour un client, ses derniers billets. Elle envoie ensuite le tout au fournisseur d’IA, qui rédige la réponse.

Chaque réponse demande un appel de conversation au fournisseur. Lors de l’essai mesuré, le temps médian d’une réponse du fournisseur était de 1,125 ms. Il s’agit du fournisseur simulé, dont les temps proviennent de réponses réelles enregistrées. Pour le Vendredi fou, Omar prévoit que beaucoup de personnes poseront la même douzaine de questions. Sans copie, 400 questions représentent 400 appels. Chaque appel coûte du temps, de l’argent et une part du quota de 100 requêtes de conversation par minute.

Le service de soutien a donc le même problème que l’employée : il produit la même réponse lente encore et encore.

Un cache est un stockage rapide qui conserve une copie d’un résultat. La prochaine requête avec les mêmes entrées lit la copie au lieu de produire le résultat à nouveau. Le nom vient du mot français qui désigne une cachette : une réserve gardée à proximité.

  • Un succès de cache est une requête qui trouve sa copie. Un échec de cache n’en trouve aucune : la requête produit le résultat et conserve généralement une copie pour la prochaine requête.
  • Le taux de succès est la proportion de requêtes qui trouvent une copie.
  • Une clé est l’étiquette d’une copie. Deux requêtes partagent une copie seulement lorsqu’elles construisent la même clé.
  • Une TTL (durée de vie) indique combien de temps une copie peut rester. Ensuite, le cache la supprime.

La fiche sur le comptoir est une entrée du cache. La question que l’employée entend est la clé, et une note « jusqu’à la fin du mois » est une TTL. Un cache est toujours une copie. La base de données reste la source de vérité, et l’API doit donner une réponse correcte quand la copie manque.

Dix questions arrivent dans cet ordre. Chaque réponse du fournisseur prend environ 1 125 ms, et un succès prend environ 14 ms. La première clé comprend la question et la personne qui la pose, car la réponse d’un client mentionne son dernier billet.

Nº Qui pose la question Question Clé : question + personne Clé : question seulement
1 C-0003 Où est mon colis? échec échec
2 C-0022 Où est mon colis? échec succès : réponse de C-0003
3 C-0003 Où est mon colis? succès succès
4 personnel Comment retourner un article endommagé? échec échec
5 C-0022 Comment retourner un article endommagé? échec succès : réponse du personnel
6 C-0003 Où est mon colis? succès succès
7 C-0022 Où est mon colis? succès succès : réponse de C-0003
8 personnel Comment retourner un article endommagé? succès succès
9 C-0003 Comment retourner un article endommagé? échec succès : réponse du personnel
10 C-0022 Où est mon colis? succès succès : réponse de C-0003

Avec la clé « question + personne », 5 requêtes sur 10 sont des succès : un taux de succès de 50 %. Les dix requêtes prennent environ 5 × 1 125 + 5 × 14 = 5 695 ms au total, contre 11 250 ms sans cache. Avec « question seulement », 8 requêtes sur 10 sont des succès. Cela semble mieux, mais cinq de ces huit succès donnent à une personne la réponse d’une autre. Un taux de succès plus élevé ne vaut rien si les réponses sont incorrectes.

Ce qu’un cache peut apporter, et ce qu’il ne peut pas apporter

Section intitulée « Ce qu’un cache peut apporter, et ce qu’il ne peut pas apporter »

L’équipe du cours a mesuré le cache terminé de ce module avec 400 questions par passage, 8 à la fois, sur 5 passages. Les questions provenaient des 12 questions courantes du service de soutien. Les plus courantes revenaient plus souvent : la question numéro k avait le poids 1/k. Neuf personnes sur dix étaient des clients, parmi 40 clients fictifs. Le fournisseur était simulé et son quota désactivé, pour que le quota ne masque pas l’effet du cache.

Le taux de succès était de 46.5 %. Le temps médian était de 13.8 ms pour un succès et de 1,125 ms pour un échec : environ 80 fois plus long. Regardez maintenant l’ensemble de l’essai :

  • Sans cache
  • Avec cache
Toutes les requêtes de la charge de questions, médianes de 5 passages (fournisseur simulé, quota désactivé). La médiane a baissé d'environ 200 ms; le p95 a baissé de 50 ms.
Description textuelle du graphique

Quatre barres. Le temps de réponse médian (p50) était de 1,115 ms sans cache et de 920 ms avec cache. Le p95 était de 1,537 ms sans cache et de 1,487 ms avec cache. Les deux paires de barres ont presque la même hauteur.

Presque la moitié des réponses sont devenues 80 fois plus rapides. Pourtant, la médiane est passée seulement de 1,115 à 920 ms, et le p95 a à peine changé : de 1,537 à 1,487 ms. Triez les 400 réponses d’un passage par temps, et la raison devient claire :

Deux bandes horizontales, chacune représentant 400 réponses triées de la plus rapide à la plus lente. Première bande, avec cache : les 46,5 % à gauche sont des réponses du cache, avec une médiane de 13,8 ms; les 53,5 % à droite sont des échecs, avec une médiane de 1 125 ms. Un repère à 50 % se trouve parmi les échecs, juste après les succès : p50 = 920 ms, un échec rapide. Un repère à 95 % se trouve près de l'extrémité droite : p95 = 1 487 ms, un échec lent. Deuxième bande, sans cache : chaque réponse est un échec, avec une médiane de 1 115 ms; le repère p50 indique 1 115 ms et le repère p95, 1 537 ms.
Avec 46,5 % de succès, la réponse du milieu et les réponses lentes sont toutes des échecs. Un cache rend les succès rapides; il ne rend pas un échec plus rapide.
Description textuelle du diagramme

Chaque bande représente 400 réponses, les plus rapides à gauche. Avec le cache, les succès occupent les 46,5 % à gauche de la bande. Le p50 est la réponse du milieu, à 50 %. Cette position dépasse les succès, donc le p50 est l’un des échecs les plus rapides : 920 ms. Le p95 est la réponse à 95 %, loin dans les échecs : 1 487 ms. Sans cache, toute la bande représente des échecs, avec un p50 de 1 115 ms et un p95 de 1 537 ms.

Un centile choisit une position dans la liste triée. Avec moins de 50 % de succès, la position du milieu reste un échec. Le p95 reste un échec jusqu’à ce que plus de 95 % des requêtes trouvent une copie. La question d’Omar, « Que verront les clients? », a donc une réponse honnête. Environ la moitié reçoivent une réponse en 14 ms plutôt qu’en une seconde, et les réponses les plus lentes restent aussi lentes.

Ce que le cache économise vraiment, c’est du travail. Au passage médian, seulement 214 questions sur 400 ont appelé le fournisseur, plutôt que toutes les 400 questions. Pour le Vendredi fou, cela économise du quota et de l’argent. Les réponses les plus lentes nécessitent d’autres outils : une file d’attente au module 4, et des délais d’expiration au module 5.

Classer les résultats : quoi, pour qui, combien de temps

Section intitulée « Classer les résultats : quoi, pour qui, combien de temps »

Amira ne met pas tout en cache. Chaque copie nécessite une règle pour sa clé, une règle pour déterminer quand elle devient périmée, et de la mémoire. Elle pose donc quatre questions pour chaque résultat de l’API :

Un parcours de gauche à droite. Un résultat de l'API mène à la question « Est-il lent ou coûteux à produire? » Si non : ne pas mettre en cache, le produire coûte peu. Si oui : « Est-il demandé à nouveau avec les mêmes entrées? » Si non : ne pas mettre en cache, aucune copie ne sera utilisée. Si oui : « Qui peut le voir? », et sa portée entre dans la clé, par exemple customer:C-0022 ou staff. Ensuite : « Qu'est-ce qui le rend périmé? », et une version ou une génération entre dans la clé, avec une TTL. Ensuite : mettre en cache.
Quatre questions pour chaque résultat. Les deux premières déterminent si une copie vaut la peine. Les deux dernières déterminent sa clé et sa durée de vie.
Description textuelle du diagramme

Les deux premières questions peuvent terminer le parcours par « ne pas mettre en cache ». Un résultat peu coûteux à produire ne gagne rien à avoir une copie. Un résultat jamais redemandé avec les mêmes entrées laisse une copie que personne ne lit. Les deux dernières questions n’arrêtent pas le parcours; elles ajoutent des éléments à la clé. « Qui peut le voir? » ajoute la portée d’identité de l’appelant. « Qu’est-ce qui le rend périmé? » ajoute une version ou une génération, et fixe une TTL comme limite.

La portée d’identité est le groupe d’appelants qui peuvent recevoir la même copie. Dans ce projet, elle vaut customer:C-0022 pour un client, ou staff (personnel) pour le personnel du service de soutien. Les réponses d’Amira pour les résultats de Larkfield se trouvent dans docs/cache-plan.md :

Résultat Mettre en cache? Portée dans la clé TTL Ce qui le rend périmé
Catégories de billets non : fixes dans le code, ne coûtent rien – – une nouvelle mise en production
Texte d’un document non : sa lecture est rapide – – une nouvelle version
Plongement du texte d’un billet oui aucune nécessaire 24 heures jamais incorrect; un nouveau modèle reçoit une nouvelle clé
Classification et brouillon de réponse d’un billet non : produits une fois et stockés dans PostgreSQL – – –
Réponse à une question oui customer:<id> ou staff 10 minutes un nouveau billet ou message de ce client; toute modification d’un document
Billets semblables à un billet pas maintenant : la recherche prend quelques millisecondes – – –

Deux lignes demandent une explication. Le plongement (embedding) d’un texte dépend seulement du texte et du modèle. Seul un appelant qui possède déjà le texte peut construire sa clé. La copie ne révèle donc rien de nouveau, et aucune portée n’est nécessaire. La classification n’est pas du tout un cache. Elle est produite une fois par billet et enregistrée dans la table ai_runs, comme trace de ce que l’IA a dit. Un enregistrement est la source de vérité; un cache est une copie que vous pouvez perdre.

« Pourquoi ne pas tout mettre en cache? » demande Sam. Parce que chaque copie peut être incorrecte de deux façons : pour la mauvaise personne, et au mauvais moment. Chacune coûte aussi de la mémoire. Et le cache devient un service supplémentaire qui peut tomber en panne, le sujet de Pannes et ruée sur le cache.

Exercice guidé : lire le plan et prédire le taux de succès

Section intitulée « Exercice guidé : lire le plan et prédire le taux de succès »

Avant de construire un cache, prédisez à quelle fréquence il peut trouver une copie. La première demande de chaque clé est toujours un échec, et chaque répétition pourrait être un succès. Le meilleur taux de succès possible est donc 1 − (clés différentes ÷ requêtes). Vous n’avez pas besoin de l’API pour cela.

  1. Dans ~/projects/ticket-api, avec l’environnement virtuel actif, copiez le plan depuis l’instantané end-of-m03 :

    Fenêtre de terminal
    cp ../nextia-learning-labs/C21/snapshots/end-of-m03/docs/cache-plan.md docs/
  2. Ouvrez docs/cache-plan.md dans VS Code. Lisez la ligne « Réponse à une question », et les trois règles à la fin du fichier.

  3. Créez un fichier hitrate.py dans ~/projects, à côté du dossier du projet, et non dedans. C’est un outil pour cette leçon seulement. Collez ce code. Il construit le même mélange de questions que l’essai mesuré, avec les mêmes germes aléatoires :

    ~/projects/hitrate.py
    """How often could a cache answer, for the question mix of this course? (No API needed.)"""
    import random
    QUESTIONS = [
    "Where is my parcel and how do I track it?", "How do I return a damaged item?",
    "When will I get my refund?", "How do I reset my password?", "Can I change or cancel my order?",
    "How does the warranty work?", "Do you deliver large items like sheds?", "How do gift cards work?",
    "What are your opening hours?", "How do I change my email address?",
    "Is my garden furniture covered if it breaks?", "How do I use a discount code?",
    ]
    WEIGHTS = [1 / (k + 1) for k in range(len(QUESTIONS))] # question k is asked with weight 1/k
    for seed in range(1, 6):
    rng = random.Random(seed)
    asks = []
    for _ in range(400):
    question = rng.choices(QUESTIONS, weights=WEIGHTS)[0]
    who = f"customer:C-{rng.randint(1, 40):04d}" if rng.random() < 0.9 else "staff"
    asks.append((question, who))
    # The first ask of each key is a miss; every repeat could be a hit.
    by_question = 1 - len({q for q, _ in asks}) / len(asks)
    by_question_and_who = 1 - len(set(asks)) / len(asks)
    print(f"pass {seed}: key = question only {by_question:.1%} | key = question + who {by_question_and_who:.1%}")
  4. Prédisez les deux taux de succès. Puis exécutez le fichier depuis le dossier du projet : python ../hitrate.py.

Afficher le résultat attendu
pass 1: key = question only 97.0% | key = question + who 45.2%
pass 2: key = question only 97.0% | key = question + who 48.0%
pass 3: key = question only 97.0% | key = question + who 47.0%
pass 4: key = question only 97.0% | key = question + who 46.5%
pass 5: key = question only 97.0% | key = question + who 44.5%

Les nombres sont les mêmes sur chaque ordinateur, car les germes aléatoires fixent le mélange. Le passage médian donne 46,5 %, le taux de succès atteint par le vrai cache. Le cache mesuré a donc trouvé une copie chaque fois qu’il le pouvait. La clé « question seulement » atteindrait 97 % : avec seulement 12 questions, seules 12 demandes sur 400 sont des premières demandes. Cette clé est incorrecte, comme le petit exemple l’a montré. L’écart entre 97 % et 46,5 % est le prix de clés correctes.

Changez une ligne de hitrate.py, et faites une prédiction avant de l’exécuter.

  1. Le Vendredi fou attire plus de clients. Remplacez rng.randint(1, 40) par rng.randint(1, 400) : 400 clients différents posent les 400 questions. Le taux de succès avec « question + personne » augmente-t-il ou diminue-t-il?
  2. Remettez 40. Maintenant, les mêmes 40 clients posent des questions dix fois plus souvent : remplacez range(400) par range(4000).
Afficher la réponse
  1. Il tombe entre 12,7 % et 17,5 % dans les cinq passages. Plus de personnes signifie plus de clés différentes, et la première demande de chaque clé est un échec. La clé « question seulement » reste à 97 %, car elle ignore qui pose la question.
  2. Il monte à environ 88 %, car les mêmes clés reviennent encore et encore. Dans le vrai cache, la TTL et les générations de la prochaine leçon limitent cela. Une copie vit au maximum 10 minutes, et un nouveau billet d’un client rend ses copies périmées. Notez donc le mélange avec chaque taux de succès que vous rapportez. Un taux de succès appartient à la charge de travail, pas au cache seul.

Erreur courante

Le plan oublie une entrée de la réponse

Symptôme (construit) : une cliente ouvre un nouveau billet, puis demande « Où est mon colis? » La réponse mentionne encore son billet précédent. L’auteur a créé ce cas volontairement, avec l’invalidation du cache désactivée. Seule la TTL de 10 minutes pouvait donc mettre fin à la copie.

Constructed: no invalidation (the TTL only)
before: cache miss: The document "Help centre: frequently asked questions" has the details. Your latest ticket is T-30194 (open): Change my email address.
new ticket T-500001 for C-0003
after: cache hit: The document "Help centre: frequently asked questions" has the details. Your latest ticket is T-30194 (open): Change my email address.

Cause : la réponse dépend des derniers billets de la cliente, mais le plan ne le précisait pas. La copie a été créée avant que T-500001 existe, et elle reste jusqu’à 10 minutes.

Diagnostic : notez toutes les entrées du résultat. Ici, ce sont la question, les documents que l’appelant peut lire, ses billets, la requête (prompt) et le modèle. Pour chaque entrée, demandez : « Quel événement la modifie? » Une entrée sans événement dans la colonne « Ce qui le rend périmé » prépare une future réponse périmée.

Correction : ajoutez l’événement au plan, comme le fait la ligne dans docs/cache-plan.md : « un nouveau billet ou message de ce client ». La prochaine leçon transforme cet événement en code. Une TTL plus courte ne suffit pas à corriger le problème. Elle réduit seulement la durée de vie de la réponse incorrecte.

Mettez un résultat en cache s’il est lent ou coûteux à produire et si les mêmes entrées reviennent souvent. Vous devez aussi pouvoir nommer chaque entrée qui le modifie. Ne mettez pas en cache un résultat peu coûteux, unique à chaque requête, ou qui constitue l’enregistrement de ce qui s’est passé. Un enregistrement appartient à la base de données.

Un cache coûte de la mémoire, un service supplémentaire à exploiter et deux nouvelles façons de se tromper. Surtout, il demande de l’attention : chaque clé nécessite une portée et un moyen de devenir périmée. En échange, il économise des appels au fournisseur, du quota et de l’argent, et rend les succès très rapides. Il ne rend pas les requêtes les plus lentes plus rapides.

Vérifiez votre compréhension

Le cache a rendu 46,5 % des réponses environ 80 fois plus rapides. Pourquoi le p95 est-il passé seulement de 1 537 à 1 487 ms?

Afficher la réponse

Le p95 est la réponse à la position de 95 % quand on classe toutes les réponses par durée. Les succès de cache occupent seulement les premiers 46,5 % de la liste. La position de 95 % reste donc un échec de cache. Un cache ne rend pas un échec de cache plus rapide : il faut toujours appeler le fournisseur. Le p95 peut beaucoup baisser seulement si plus de 95 % des requêtes trouvent une copie dans le cache. Il peut aussi baisser si les échecs de cache deviennent eux-mêmes plus rapides.

Vérifiez votre compréhension

Tomás dit : « Mettez les réponses en cache selon le texte de la question. Le taux de succès serait de 97 % plutôt que de 46,5 %. » Que répondez-vous?

Afficher la réponse

Les succès supplémentaires viennent du fait qu’on sert la réponse d’une personne à d’autres personnes. Dans cette API, la réponse d’un client mentionne son propre dernier billet de soutien. Une réponse au personnel peut utiliser des documents réservés au personnel. Avec la question comme seule clé, un client recevrait le billet d’un autre client ou une réponse destinée au personnel. La clé doit inclure la portée. Le taux de succès plus bas est le prix à payer pour des réponses correctes.

Vérifiez votre compréhension

Prédisez : le service de soutien ajoute un résultat, « le nombre de billets ouverts d'un client ». Sa requête prend 2 ms. Faut-il le mettre en cache?

Afficher la réponse

Non. La première des quatre questions l’exclut : une requête de 2 ms coûte peu, donc une copie économise presque rien. La copie aurait quand même besoin de la portée customer:<id> et d’un événement qui la rend périmée. Cet événement serait chaque nouveau billet ou chaque fermeture de billet. Le coût des clés correctes dépasse le gain.

Récapitulatif

  • Un cache conserve une copie d’un résultat. Un succès de cache trouve la copie, un échec de cache produit le résultat. Une TTL limite la durée de vie d’une copie.
  • Posez quatre questions pour chaque résultat : coûte-t-il cher, se répète-t-il, qui peut le voir et qu’est-ce qui le rend périmé?
  • Dans cette API, une réponse dépend de la personne qui pose la question. Sa clé contient donc la portée d’identité : customer:<id> ou staff (personnel). Un plongement n’a pas besoin de portée.
  • Mesures : un succès de cache a pris 13,8 ms et un échec, 1 125 ms. Le taux de succès était de 46,5 %. La médiane est passée de 1 115 à 920 ms. Le p95 est passé seulement de 1 537 à 1 487 ms, car les réponses lentes sont des échecs de cache.
  • Le cache réduit les appels au fournisseur : lors du passage médian, 214 questions sur 400 ont appelé le fournisseur. La clé « question seulement » donnerait un taux de succès de 97 %, en servant des réponses incorrectes.
  • Chaque entrée d’un résultat doit avoir un événement qui rend sa copie périmée. docs/cache-plan.md contient le plan, et la prochaine leçon le met en œuvre.

Leçon suivante : Clés et invalidation