Clés et invalidation
- Leçon 9
- 55 min
- Module 3 : Utiliser le cache sans fausser les résultats
Où nous en sommes
Dans la leçon précédente, nous avons planifié quels résultats mettre en cache, qui peut voir chaque copie et ce qui la rend périmée. Maintenant, nous construisons ce plan. Une clé qui oublie qui pose la question peut donner la réponse d'un client à un autre, et une copie qui attend sa TTL peut rester fausse après un changement des données. Dans cette leçon, la clé contient tout ce qui change la réponse, et un changement des données rend aussitôt les anciennes réponses introuvables, comme les étiquettes d'une étagère de pharmacie.
Leçon 9 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAClés et invalidation
1. Mesurer avant de mettre à l'échelle
2. Concurrence et limites des services
3. Utiliser le cache sans fausser les résultats
4. Files d'attente et travailleurs en arrière-plan
5. Résilience et mise à l'échelle automatique
6. Valider et justifier les changements
Ce que vous saurez faire
Construisez le cache pour que chaque clé contienne tout ce qui change la réponse, y compris l’identité de l’appelant. Ensuite, faites en sorte qu’un changement des données rende immédiatement les anciennes réponses introuvables, sans attendre leur expiration.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Le plan de cache, les succès, les échecs et les TTL, présentés dans Choisir ce qui peut être mis en cache.
- Les points de terminaison asynchrones et pourquoi un appel en attente ne doit pas bloquer le serveur, dans Travail d’E/S et travail de calcul.
- L’utilisation de plusieurs processus d’API, présentée dans Mise à l’échelle horizontale.
Ce qu’il vous faut sur votre ordinateur
- Le projet après Choisir ce qui peut être mis en cache :
python -m pytestaffiche137 passed, 1 deselected, etdocs/cache-plan.mdexiste. - Docker en cours d’exécution, avec la base de données et Azurite :
docker compose up -d db azurite.
Après cette leçon, votre projet correspond à l’instantané end-of-m03, sauf pour un script de la prochaine leçon. Testé sur macOS (Apple silicon); les commandes Windows ne sont pas testées. Le fournisseur d’IA est simulé. Les temps affichés proviennent de l’ordinateur de l’auteur pendant qu’il était occupé : vos résultats seront différents.
Une étagère à la pharmacie
Section intitulée « Une étagère à la pharmacie »Une pharmacie garde sur une étagère les ordonnances préparées, en attente de ramassage. Chaque sac porte une étiquette avec le nom du patient, le médicament et le numéro d’ordonnance. Un sac étiqueté seulement « médicament contre la toux » pourrait aller à toute personne qui en demande. C’est pourquoi le nom figure sur l’étiquette.
Parfois, le médecin change une dose. La pharmacienne ne cherche pas l’ancien sac sur l’étagère. Elle inscrit un nouveau numéro d’ordonnance. Dès lors, elle remet seulement les sacs portant ce nouveau numéro. L’ancien sac reste sur l’étagère, inutilisé, jusqu’au nettoyage hebdomadaire où elle le jette.
L’étiquette est une clé de cache. Le nouveau numéro d’ordonnance permet de ne plus utiliser les anciennes copies. Cette leçon construit les deux.
Le problème : la mauvaise personne, le mauvais moment
Section intitulée « Le problème : la mauvaise personne, le mauvais moment »La dernière leçon a montré deux façons dont une copie peut être incorrecte. Tomás a proposé une clé contenant seulement le texte de la question. Avec cette clé, la cliente C-0022 demande « Où est mon colis? » et reçoit la réponse de C-0003, avec son billet de soutien. C’est la mauvaise personne : une fuite de données privées que vous verrez ci-dessous dans une exécution réelle.
Le plan a aussi montré le mauvais moment. C-0003 ouvre un nouveau billet, mais sa réponse en cache mentionne encore l’ancien pendant un maximum de 10 minutes. Un TTL limite la durée de vie d’une réponse incorrecte. Il n’empêche pas cette réponse.
L’idée : une clé contient tout ce qui change la réponse
Section intitulée « L’idée : une clé contient tout ce qui change la réponse »Pour chaque entrée, demandez-vous : « Si elle change, la réponse peut-elle changer? » Si oui, cette entrée doit figurer dans la clé. Deux requêtes pouvant recevoir des réponses différentes doivent produire des clés différentes. Voici une vraie clé du projet, avec ses parties :
Description textuelle du diagramme
La clé comporte huit parties, séparées par des deux-points. Les deux premières indiquent à qui elle appartient et quel type de résultat elle contient. Les trois suivantes sont des versions : de l’ensemble des documents, du modèle et de la requête (prompt). Viennent ensuite la portée d’identité, customer:C-0003, et sa génération, g1. La dernière partie est un hachage de la question, après sa conversion par l’API en minuscules avec des espaces simples.
Trois parties demandent une justification :
- La portée d’identité vient de l’appelant de la requête, jamais du texte de la question. Une requête du site de la boutique pour une cliente connectée contient l’en-tête
X-Customer-ID: C-0003. Sans cet en-tête, la requête vient de l’outil du service de soutien : l’appelant est donc un membre du personnel. La clé d’API prouve que la requête vient d’une application de Larkfield; l’en-tête identifie l’appelant. Dans ce cours, l’en-tête remplace une vraie connexion, qu’ajoute le cours Accès aux fichiers et à la récupération. Sa leçon Accès aux fichiers et à la récupération applique la même règle aux clés de cache et aux autorisations. - L’API normalise la question, puis la hache. « Où est mon colis? » et « où EST mon colis? » sont la même question. Elles reçoivent donc la même clé. Le hachage transforme toute question en 32 caractères, pour que les longues questions produisent des clés courtes.
- Les versions font qu’une nouvelle requête, un nouveau modèle ou un document modifié produit de nouvelles clés. Aucune ancienne réponse n’est lue avec la nouvelle requête.
Invalidation par générations, sans suppression
Section intitulée « Invalidation par générations, sans suppression »L’invalidation consiste à ne plus utiliser les copies en cache quand les données dont elles proviennent changent. La méthode évidente est de les supprimer. Mais pour supprimer les réponses de C-0003, l’API doit d’abord trouver toutes les clés qui lui appartiennent. Avec beaucoup de clés, la recherche est lente. Pendant cette recherche, une requête peut stocker une nouvelle réponse déjà périmée.
Le projet utilise plutôt la méthode de la pharmacie : un numéro de génération par portée. Valkey conserve ta:gen:customer:C-0003, qui commence à 0. Chaque clé de réponse contient la valeur actuelle. Un nouveau billet ou message de C-0003 ajoute 1, avec une seule commande INCR (incrémenter). Voici un petit exemple où toutes les valeurs sont visibles :
| Étape | Événement | ta:gen:customer:C-0003 |
Fin de la clé | Résultat |
|---|---|---|---|---|
| 1 | C-0003 demande « Où est mon colis? » | 0 | :g0:cc3ce500… |
échec : stockage, « dernier billet T-30194 » |
| 2 | Elle pose la question à nouveau | 0 | :g0:cc3ce500… |
succès |
| 3 | Elle ouvre le billet T-500001 | 0 → 1 | – | – |
| 4 | Elle pose la question à nouveau | 1 | :g1:cc3ce500… |
échec : stockage, « dernier billet T-500001 » |
À l’étape 4, la clé a changé : l’ancienne réponse n’est donc plus jamais lue. Personne ne l’a supprimée; son TTL la retire dans les 10 minutes. Les documents fonctionnent de la même façon. La clé contient une empreinte de tous les documents. Toute modification d’un document produit donc de nouvelles clés pour toutes les réponses. Voici le parcours complet d’une question, avec l’événement qui le modifie :
Description textuelle du diagramme
Le parcours principal va de gauche à droite. L’API lit d’abord le contexte dans PostgreSQL, car la clé nécessite l’empreinte des documents. Ensuite, elle construit la clé et la demande à Valkey. Un succès donne une réponse immédiate. Un échec prend un verrou, appelle le fournisseur et stocke la réponse avec un TTL de 600 secondes. La case d’événement orange représente l’invalidation. Un nouveau billet ou message ajoute 1 à la génération de la cliente. Un document modifié change l’empreinte. Les deux produisent une nouvelle clé à la prochaine requête, et l’ancienne expire d’elle-même. Le parcours rouge, le verrou et l’attente appartiennent à la prochaine leçon.
Le TTL garde donc un rôle : il fait le nettoyage. Il retire les anciennes clés et limite la durée des données périmées quand un événement passe inaperçu. Le projet utilise 10 minutes pour les réponses (CACHE_TTL_SECONDS=600) et 24 heures pour les plongements (embeddings), qui ne sont jamais incorrects.
Pourquoi un cache partagé, et pourquoi Valkey
Section intitulée « Pourquoi un cache partagé, et pourquoi Valkey »Dans Mise à l’échelle horizontale, l’API s’exécutait avec quatre processus. Un dictionnaire Python dans chaque processus donnerait quatre caches distincts. Chacun verrait un quart des questions, ce qui réduirait le taux de succès. Pire, un nouveau billet traité par le processus 1 augmenterait la génération seulement dans ce processus. Les processus 2 à 4 continueraient à servir l’ancienne réponse.
Le cache est donc un serveur distinct que tous les processus partagent. Le projet utilise Valkey 9.1, une dérivation à code source ouvert de Redis sous licence BSD. Il utilise le même protocole : le client est donc le paquet Python redis. L’équipe du cours a mesuré les deux serveurs avec le même client. Un GET prenait un temps médian de 178,4 µs sur Valkey et de 177,7 µs sur Redis 8.8 : la même vitesse. Le choix repose sur la licence. Redis 8 est offert sous les licences AGPLv3, RSALv2 ou SSPL, et Valkey sous BSD.
Le client est asynchrone : redis.asyncio. Un appel de cache normal et bloquant dans un point de terminaison asynchrone bloquerait tout le serveur. C’est l’erreur présentée dans Travail d’E/S et travail de calcul.
Larkfield : la clé et les événements dans le code
Section intitulée « Larkfield : la clé et les événements dans le code »Le fichier ticket_api/cache.py d’Amira construit la clé à partir de ses parties :
def answer_key(scope: str, generation: int, question: str, versions: dict) -> str: """The key of a cached answer. Everything that changes the answer is in it.""" v = ":".join(f"{k}={versions[k]}" for k in sorted(versions)) return f"{PREFIX}:answer:v1:{v}:{scope}:g{generation}:{digest(normalize_question(question))}"ticket_api/answers.py prend la portée dans l’en-tête, jamais dans le corps :
def scope_of(customer_id: str | None) -> str: return f"customer:{customer_id}" if customer_id else "staff"
# in answer_question(): scope = scope_of(x_customer_id) with timer("db"): ctx = await run_in_threadpool(context, db, q.question, x_customer_id) ... versions = {"prompt": ai.ANSWER_PROMPT, "model": ai.CHAT_MODEL, "docs": ctx["docs_version"]} with timer("cache"): key = answer_key(scope, await cache.generation(scope), q.question, versions) result = await cache.get(key)La requête de contexte s’exécute avant le cache. Elle vérifie que la cliente existe et trouve les documents que l’appelant peut lire. Elle calcule aussi l’empreinte des documents pour la clé. Un succès exige donc encore ce travail de base de données. C’est pourquoi un succès prenait 13,8 ms plutôt que 1 ms. Le cache évite l’appel au fournisseur, pas le travail de base de données qui le précède.
Deux points de terminaison modifient les données dont dépendent les réponses. Chacun augmente donc la génération de la cliente après l’enregistrement :
if cache is not None: # The customer's latest tickets are part of their answers: those answers are old now. await cache.invalidate(f"customer:{new.customer_id}")add_message dans ticket_api/tickets.py fait la même chose pour la cliente du billet. Le cache de plongements dans intake.py n’a besoin ni de portée ni de génération. Sa clé contient le modèle, les dimensions et un hachage du texte exact.
Exercice guidé : construire le cache et observer les clés
Section intitulée « Exercice guidé : construire le cache et observer les clés »Vous copiez les fichiers de cette leçon depuis l’instantané, puis vous exécutez le cache et lisez ses clés. La copie ajoute ou remplace 22 fichiers, dont le README.md du projet. Si vous en avez modifié un dans un précédent exercice « À vous de jouer », gardez d’abord votre version.
-
Dans
~/projects/ticket-api, avec l’environnement virtuel actif, copiez les fichiers :Fenêtre de terminal S=../nextia-learning-labs/C21/snapshots/end-of-m03for f in .env.example compose.yaml pyproject.toml requirements.txt requirements-run.txt \requirements-lock.txt contract/openapi.json simulator/model.py ticket_api/ai.py \ticket_api/answers.py ticket_api/cache.py ticket_api/config.py ticket_api/intake.py \ticket_api/main.py ticket_api/repository.py ticket_api/tickets.py scripts/cache.py \scripts/leak_demo.py loadtest/questions.py tests/conftest.py tests/test_cache.py README.md; docp "$S/$f" "$f"doneFenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m03"$files = '.env.example', 'compose.yaml', 'pyproject.toml', 'requirements.txt', 'requirements-run.txt','requirements-lock.txt', 'contract\openapi.json', 'simulator\model.py', 'ticket_api\ai.py','ticket_api\answers.py', 'ticket_api\cache.py', 'ticket_api\config.py', 'ticket_api\intake.py','ticket_api\main.py', 'ticket_api\repository.py', 'ticket_api\tickets.py', 'scripts\cache.py','scripts\leak_demo.py', 'loadtest\questions.py', 'tests\conftest.py', 'tests\test_cache.py', 'README.md'foreach ($f in $files) { Copy-Item "$S\$f" $f } -
Ajoutez les deux lignes du cache à votre
.env. L’API utilise la base de données 0 de Valkey; les tests utilisent la base 15 et la vident :.env (add at the end) CACHE_URL=redis://127.0.0.1:6379/0TEST_CACHE_URL=redis://127.0.0.1:6379/15 -
Installez le nouveau paquet,
redis8.1.0 :python -m pip install -r requirements.txt. -
Démarrez Valkey :
docker compose up -d cache. Il écoute sur127.0.0.1:6379et ne conserve rien sur disque. -
Rechargez les données pour que les nouveaux billets commencent à T-500001 :
python -m scripts.load --reset. Exécutez ensuite les tests :python -m pytest. Le résultat attendu est148 passed, 1 deselected. -
Démarrez le fournisseur simulé dans un deuxième terminal (
python -m simulator), et l’API dans un troisième (fastapi dev). Les deux ont besoin de l’environnement virtuel. -
Posez deux fois la même question en tant que cliente C-0003 :
Fenêtre de terminal curl -i -X POST http://127.0.0.1:8000/v1/answers -H "Content-Type: application/json" \-H "X-Customer-ID: C-0003" -d '{"question": "Where is my parcel and how do I track it?"}'Fenêtre de terminal $body = '{"question": "Where is my parcel and how do I track it?"}'$r = Invoke-WebRequest -Method Post -Uri http://127.0.0.1:8000/v1/answers -ContentType "application/json" -Headers @{ "X-Customer-ID" = "C-0003" } -Body $body$r.Headers["X-Cache"]; $r.Headers["Server-Timing"]; $r.Content -
Listez les clés :
python -m scripts.cache keys. -
Posez la même question en tant que C-0022, puis une fois sans l’en-tête (en tant que membre du personnel). Listez les clés à nouveau.
-
Ouvrez un nouveau billet pour C-0003, puis posez sa question à nouveau :
Fenêtre de terminal curl -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" \-d '{"customer_id": "C-0003", "subject": "Parcel not delivered", "body": "My parcel for order LK-100200 did not arrive. Where is it?"}'Sous Windows, utilisez
Invoke-WebRequestcomme à l’étape 7, sans l’en-tête. -
Consultez sa génération :
docker compose exec cache valkey-cli get ta:gen:customer:C-0003.
Afficher le résultat attendu
Étape 7, lors de l’exécution de l’auteur (vos temps seront différents). La première réponse est un échec, avec le temps du fournisseur dans server-timing (temps du serveur). La deuxième est un succès, sans partie answer (réponse) :
HTTP/1.1 200 OK...x-cache: missserver-timing: db;dur=11.0, cache;dur=3.3, answer;dur=941.1
{"answer":"The document \"Help centre: frequently asked questions\" has the details. Your latest ticket is T-30194 (open): Change my email address.","scope":"customer:C-0003","sources":["help-centre-faq","delivery-policy"],"cached":false}
HTTP/1.1 200 OK...x-cache: hitserver-timing: db;dur=9.2, cache;dur=1.5
{"answer":"The document \"Help centre: frequently asked questions\" has the details. Your latest ticket is T-30194 (open): Change my email address.","scope":"customer:C-0003","sources":["help-centre-faq","delivery-policy"],"cached":true}La réponse est courte et simple, car le fournisseur est simulé. Elle nomme le premier document et le dernier billet de la cliente. Voici l’étape 8, puis l’étape 9 avec trois clés, une par portée :
ta:answer:v1:docs=75cf862216c3:model=chat-small:prompt=answer-v1:customer:C-0003:g0:cc3ce5009832630860551d4c6b1eb7b3 (598 s left)ta:answer:v1:docs=75cf862216c3:model=chat-small:prompt=answer-v1:customer:C-0022:g0:cc3ce5009832630860551d4c6b1eb7b3 (599 s left)ta:answer:v1:docs=75cf862216c3:model=chat-small:prompt=answer-v1:staff:g0:cc3ce5009832630860551d4c6b1eb7b3 (600 s left)La réponse de C-0022 nomme son propre billet, T-30171, une question résolue sur un boyau d’arrosage. La réponse au personnel ne contient aucun billet et utilise un document du personnel : « Réclamations au transporteur pour colis endommagés ou perdus ». À l’étape 10, le nouveau billet est T-500001. La réponse suivante est un échec qui le nomme :
x-cache: miss{"answer":"The document \"Help centre: frequently asked questions\" has the details. Your latest ticket is T-500001 (open): Parcel not delivered.","scope":"customer:C-0003",...,"cached":false}L’étape 11 affiche "1" : un nouveau billet, une augmentation. La liste contient maintenant la clé g0 de C-0003 et sa nouvelle clé g1. Rien n’a supprimé la clé g0; elle n’est plus jamais lue et expire. La liste montre aussi ta:embedding:v1:embed-small:384:…, avec 24 heures restantes, provenant du plongement du nouveau billet. Elle montre enfin ta:gen:customer:C-0003, sans expiration.
Vérification de fin : la réponse d’une cliente n’atteint jamais une autre cliente
Section intitulée « Vérification de fin : la réponse d’une cliente n’atteint jamais une autre cliente »La vérification de fin du module vous demande de montrer qu’un résultat privé ne peut pas être servi à un autre utilisateur. scripts.leak_demo exécute l’API dans le script et pose la même question en tant que C-0003, puis C-0022. Il le fait deux fois. La première fois, il substitue une mauvaise clé, volontairement : la question seulement. La deuxième fois, il utilise la clé du projet. Exécutez-le après avoir vidé le cache et masquez les lignes des journaux (logs) de l’API :
python -m scripts.cache flushpython -m scripts.leak_demo 2>/dev/nullSous Windows, écrivez 2>$null plutôt que 2>/dev/null. La sortie :
With the WRONG key (the question only): C-0003 asks -> cache miss: The document "Help centre: frequently asked questions" has the details. Your latest ticket is T-30194 (open): Change my email address. C-0022 asks -> cache hit: The document "Help centre: frequently asked questions" has the details. Your latest ticket is T-30194 (open): Change my email address.With the project's key (identity scope in the key): C-0003 asks -> cache miss: The document "Help centre: frequently asked questions" has the details. Your latest ticket is T-30194 (open): Change my email address. C-0022 asks -> cache miss: The document "Help centre: frequently asked questions" has the details. Your latest ticket is T-30171 (resolved): Question about the garden hose (25 m).Avec la mauvaise clé, C-0022 a obtenu un succès qui lui parlait du billet T-30194 de C-0003. Avec la clé du projet, sa requête a produit un échec et elle a obtenu son propre billet, T-30171. Si vous avez d’abord exécuté l’étape 10, le billet de C-0003 est T-500001 dans les deux blocs. La fuite reste la même. La suite de tests vérifie la même règle à chaque exécution :
python -m pytest tests/test_cache.py -k "never_served or without_the_scope" -vLe résultat attendu est 2 passed, 9 deselected. test_one_customers_answer_is_never_served_to_another vérifie que la réponse de C-0022 est un échec et ne contient aucun numéro de billet de C-0003. test_a_key_without_the_scope_leaks construit la mauvaise clé et vérifie que la fuite se produit. Ainsi, la démonstration ne peut pas cesser de la montrer sans qu’on le remarque.
À vous de jouer : des clés pour un service de réponses sur des documents
Section intitulée « À vous de jouer : des clés pour un service de réponses sur des documents »Concevez les clés d’un autre service, sur papier. Utilisez les quatre questions de la leçon précédente et les parties du schéma de clé.
Un conseil municipal exploite un service qui répond aux questions sur ses documents. Les résidents posent des questions sur les documents publics. Une réponse peut aussi mentionner leurs propres demandes en cours. Les employés du conseil peuvent aussi consulter les documents internes. Les réponses sont en anglais ou en gallois, selon le choix de l’appelant. Les documents changent quelques fois par semaine, et la requête a une version.
Écrivez la clé d’une réponse en cache, partie par partie. Ensuite, listez les événements qui rendent une réponse périmée et choisissez une durée de vie (TTL). Puis décidez : le plongement (embedding) d’un paragraphe de document a-t-il besoin d’une portée?
Afficher une réponse
Une bonne clé : council:answer:v1:docs=<fingerprint>:model=<model>:prompt=<version>:lang=<en|cy>:<scope>:g<generation>:<hash of the normalized question>. La portée est resident:<id> (résident) ou employee (employé). Elle vient de la connexion, jamais de la question. La langue fait partie de la clé, car elle change la réponse.
Événements : une demande nouvelle ou modifiée d’un résident augmente gen:resident:<id>. Un changement de document modifie l’empreinte, ce qui rend toutes les réponses nouvelles. Une nouvelle requête ou un nouveau modèle change sa version. Une TTL de quelques minutes à une heure limite les effets d’un événement manqué. Une durée plus courte est plus sûre pour les réponses qui mentionnent des demandes.
Le plongement d’un paragraphe n’a pas besoin de portée d’identité : il dépend seulement du texte et du modèle. Mais la recherche ne doit jamais inclure un paragraphe interne pour un résident. Cette règle appartient au filtre de recherche, pas à la clé du plongement.
Erreur courante
Tomás : « mettre les réponses en cache selon le texte de la question »
Symptôme (construit) : le taux de succès du cache semble excellent, à 97 % dans la prédiction de la leçon précédente. Une cliente signale ensuite que le service de soutien lui a parlé d’un billet qu’elle n’a jamais ouvert. La démonstration de fuite ci-dessus le montre : C-0022 a reçu le billet T-30194 de C-0003.
Cause : la clé contenait seulement la question. Deux appelants ayant des droits différents ont construit la même clé. Le deuxième a donc lu la copie du premier. Les règles d’autorisation ont déterminé la réponse au moment de sa création, pour le premier appelant. Une copie ne contient aucune règle : quiconque construit la même clé la lit.
Diagnostic :
- Listez les clés avec
python -m scripts.cache keys. Une clé sans partiecustomer:(client) oustaff(personnel) est un signal d’alerte. - Posez cette question sur le résultat : « Deux appelants peuvent-ils obtenir des réponses différentes? » Ici, oui : la réponse de chaque client mentionne ses propres billets, et les réponses au personnel utilisent ses documents.
- Examinez la réponse : le champ
scope(portée) d’une réponse en cache doit correspondre à la portée de l’appelant. Dans la démonstration, un succès du cache pour C-0022 contiendraitcustomer:C-0003.
Correction : ajoutez la portée à la clé, en la tirant de l’appelant, jamais du corps de la requête. Gardez un test qui échoue quand deux appelants partagent une copie, comme le fait tests/test_cache.py. Acceptez le taux de succès plus faible, 46,5 % au lieu de 97 % : ces succès supplémentaires étaient des réponses incorrectes.
Quand utiliser les générations et ce qu’elles coûtent
Section intitulée « Quand utiliser les générations et ce qu’elles coûtent »Utilisez une génération quand plusieurs clés dépendent d’une même donnée, comme toutes les réponses d’un client. Utilisez une version dans la clé quand le changement est global : nouvelle requête, nouveau modèle ou changement de document. Supprimez directement une clé seulement si vous savez exactement laquelle est incorrecte.
Les générations coûtent une lecture supplémentaire du cache par requête, pour connaître le numéro actuel. Les anciennes clés occupent de la mémoire jusqu’à la fin de leur TTL. Le Valkey du projet a une limite de 256 Mo. Quand il est plein, il élimine les clés utilisées le moins récemment. Un événement que l’API manque laisse tout de même une réponse périmée jusqu’à l’expiration de la TTL. C’est le sujet de la prochaine leçon.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Pourquoi l'API tire-t-elle la portée de l'en-tête X-Customer-ID, plutôt que d'un champ du corps JSON ou de la question?
Afficher la réponse
La portée doit désigner l’appelant, et seule son identité peut déterminer ce qu’il peut voir. Dans ce cours, l’en-tête représente la connexion au site Web du magasin. Le cours sur l’authentification la rend réelle. Le texte d’une question ou un champ du corps n’est qu’une donnée que n’importe quel appelant peut écrire. Si un appelant pouvait définir sa propre portée, il pourrait construire la clé d’un autre client. Il pourrait alors lire la réponse en cache de ce client.
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
Le texte d'un document change. Comment les réponses en cache deviennent-elles périmées, sans aucune suppression?
Afficher la réponse
Chaque clé de réponse contient docs=<fingerprint>, une courte empreinte de hachage des identifiants, versions et sommes de contrôle de tous les documents. Dès qu’un document change, l’empreinte change. Chaque requête construit donc une nouvelle clé et ne trouve rien dans le cache. Les anciennes clés ne sont plus jamais lues et expirent à la fin de leur TTL de 10 minutes.
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 : l'API utilise 4 processus, chacun avec son propre cache en mémoire. C-0003 ouvre un billet par le processus 1. Que peut-elle voir si sa prochaine question passe par le processus 3?
Afficher la réponse
Une ancienne réponse. Le processus 1 a augmenté la génération dans sa propre mémoire seulement. Le processus 3 a encore la génération 0 et son ancienne copie. Il peut donc servir la réponse avec son billet précédent jusqu’à la fin de sa TTL. Un cache partagé comme Valkey conserve une seule génération pour tous les processus. Chaque processus construit donc la nouvelle clé.
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
- Une clé contient tout ce qui change la réponse. Ici, cela comprend les versions des documents, du modèle et de la requête, la portée d’identité de l’appelant, une génération et l’empreinte de hachage de la question.
- La portée vient de l’appelant (
X-Customer-ID, ou le personnel si cet en-tête est absent), jamais de la question. - Invalidation par générations : un nouveau billet ou message exécute un
INCR. La clé suivante est nouvelle, et l’ancienne expire selon sa TTL. Un changement de document modifie l’empreinte. - Le cache est partagé (Valkey, licence BSD, même vitesse que Redis) et asynchrone. Tous les processus voient donc les mêmes copies et générations.
- Vérification finale : avec la mauvaise clé, C-0022 a reçu le billet T-30194 de C-0003. Avec la clé du projet, elle a obtenu le sien, T-30171.
tests/test_cache.pyle vérifie à chaque exécution.
Leçon suivante : Pannes et ruée sur le cache