Aller au contenu
English

Pannes et ruée sur le cache

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

Où nous en sommes

Dans les deux dernières leçons, nous avons planifié le cache et construit des clés qui ne mélangent jamais les réponses de deux personnes. Mais un cache a aussi ses mauvais moments. Il peut être vide quand une foule pose la même nouvelle question, ou il peut être en panne ou lent. Dans cette leçon, nous gardons les réponses correctes et nous protégeons le fournisseur dans ces moments, en commençant par une boulangerie à l'ouverture.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Gardez les réponses correctes et protégez le fournisseur d’IA quand les choses vont mal. Le cache peut être vide, en panne, lent ou contenir une ancienne réponse. Empêchez une foule de requêtes de produire la même réponse au même moment.

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 après Clés et invalidation : python -m pytest affiche 148 passed, 1 deselected.
  • Valkey, PostgreSQL et Azurite en marche (docker compose up -d db azurite cache), le fournisseur simulé (python -m simulator) et l’API (fastapi dev), chacun dans son terminal.

Après cette leçon, votre projet correspond à l’instantané end-of-m03. Certaines pannes sont construites : vous arrêtez ou gelez volontairement le cache. Ces essais ont été faits sur macOS (Apple silicon); les commandes Windows n’ont pas été testées. Les durées affichées proviennent de l’ordinateur de l’auteur pendant qu’il était occupé : vos valeurs seront différentes.

Une boulangerie ouvre à sept heures, et les étagères sont vides. Vingt clients entrent et veulent tous le même nouveau gâteau. Si chaque boulanger commence un gâteau pour chaque client, vingt gâteaux vont au four. Le four est plein, les autres pains attendent, et personne n’avait besoin de dix-neuf de ces gâteaux.

Une meilleure boulangerie dit : « Un gâteau est au four. Veuillez attendre quelques minutes. » Un boulanger le prépare, et les vingt clients se partagent le résultat.

Un matin, le réfrigérateur de présentation tombe en panne. La boulangerie ne ferme pas. Elle vend directement à la sortie du four, plus lentement, jusqu’à ce que quelqu’un répare le réfrigérateur. Le réfrigérateur était une commodité, pas la boulangerie elle-même.

Un cache est vide plus souvent que vous le pensez. Il est vide après un redémarrage, car Valkey ne garde rien sur disque dans ce projet. Une clé populaire disparaît à l’expiration de son TTL. Une modification de document donne une nouvelle clé à chaque réponse en même temps. Et lors du Vendredi fou, une nouvelle promotion amène une nouvelle question que tout le monde pose.

De nombreuses requêtes cherchent alors la même clé absente au même moment. Chacune appelle le fournisseur pour obtenir la même réponse. C’est une ruée sur le cache : une foule de requêtes ne trouvent pas une clé et la rafraîchissent ensemble. Sans protection, vingt requêtes pour une nouvelle question ont envoyé 20 appels au fournisseur lors de l’essai de l’équipe du cours. Chacun de ces appels a consommé le quota, et un seul résultat était nécessaire.

L’idée : une requête calcule, les autres attendent

Section intitulée « L’idée : une requête calcule, les autres attendent »

La protection contre les ruées donne un verrou à chaque clé. La première requête qui ne trouve pas la clé prend le verrou et appelle le fournisseur. Toutes les autres requêtes qui ne trouvent pas cette clé voient le verrou et attendent le résultat dans le cache. Valkey sécurise le verrou avec une seule commande, SET key:lock token NX PX 10000 : « définir seulement s’il n’existe pas, et faire expirer après 10 secondes ». Une seule requête peut l’obtenir.

Deux groupes de 20 barres horizontales sur un axe de temps allant de 0 à 2 secondes. Protection désactivée : 20 barres bleues, chacune représentant un appel au fournisseur, de longueurs différentes entre environ 0,9 et 1,9 seconde; l'étiquette indique 20 appels au fournisseur, 1,96 s, mesuré. Protection activée : une barre bleue, le seul appel au fournisseur, se termine vers 1,1 seconde. Les 19 barres grises attendent, puis lisent la réponse en cache, et se terminent juste après; l'étiquette indique 1 appel au fournisseur, 1,22 s, mesuré.
Vingt requêtes pour une nouvelle question. Sans protection, chacune appelle le fournisseur; avec la protection, une seule l'appelle et dix-neuf attendent. Les longueurs des barres montrent la forme; les totaux sont mesurés (médianes de 5 essais).
Description textuelle du diagramme

Le groupe du haut montre l’essai sans protection. Il compte 20 barres bleues, chacune pour un appel au fournisseur, dont les longueurs varient comme les durées du fournisseur. Le lot se termine quand l’appel le plus lent se termine. Le groupe du bas montre l’essai avec protection. Une barre bleue représente le seul appel. Les 19 barres grises représentent les requêtes qui attendent, puis lisent la réponse en cache. Les totaux mesurés sont de 20 appels en 1,96 seconde sans protection, et de 1 appel en 1,22 seconde avec protection.

La protection a aussi accéléré le lot. Sans elle, les vingt réponses sont prêtes seulement quand le plus lent des vingt appels au fournisseur se termine. Avec elle, il y a un appel, plus au maximum 50 ms pendant que les autres vérifient à nouveau le cache. Le fournisseur simulé ne ralentit pas sous la charge. Le vrai fournisseur ralentissait : les réponses prenaient environ 7 % plus de temps avec 16 appels en cours. Une vraie ruée est donc pire que cet essai.

Appels ayant atteint le fournisseur simulé, médianes de 5 essais. La protection a réduit 20 appels à 1.
Description textuelle du graphique

Deux barres. Sans protection contre les ruées, 20 requêtes pour la même nouvelle question ont envoyé 20 appels au fournisseur, en 1.96 secondes. Avec la protection, elles ont envoyé 1 appel, en 1.22 secondes.

La protection se trouve dans ticket_api/cache.py et answers.py depuis la dernière leçon. Le verrou stocke un jeton (token) aléatoire pour que seul son propriétaire puisse le retirer :

ticket_api/cache.py (Cache.lock and Cache.unlock, the core)
async def lock(self, key: str, seconds: float) -> str | None:
"""A token if this caller may compute the value of `key`; None if another does."""
token = uuid.uuid4().hex
if await self.client.set(f"{key}:lock", token, nx=True, px=int(seconds * 1000)):
return token
return None
async def unlock(self, key: str, token: str) -> None:
# Delete the lock only if it is still ours (it may have expired and been taken).
script = ("if redis.call('get', KEYS[1]) == ARGV[1] then "
"return redis.call('del', KEYS[1]) else return 0 end")
await self.client.eval(script, 1, f"{key}:lock", token)

Pourquoi ce jeton? Le verrou expire après CACHE_LOCK_SECONDS (10 s), pour qu’une requête qui plante ne le garde pas indéfiniment. Mais une requête très lente peut encore travailler quand son verrou expire et qu’une autre requête le prend. Sans jeton, la requête lente supprimerait alors le verrou de l’autre requête. Le petit script compare et supprime en une seule étape dans Valkey, donc rien ne peut arriver entre les deux.

Les autres requêtes attendent dans answers.wait_for. Toutes les 50 ms, chacune relit la clé, pendant au maximum CACHE_LOCK_SECONDS. Quand la réponse apparaît, elle la renvoie avec X-Cache: wait (attente). Si la requête qui calcule échoue, celles qui attendent ne trouvent rien. Chacune continue de vérifier pendant 10 secondes, puis appelle elle-même le fournisseur. Ce comportement vient de la lecture du code; l’équipe du cours ne l’a pas mesuré.

Que doit faire l’API quand Valkey ne répond pas? Il y a deux choix. Un service bloque en cas de panne lorsqu’il refuse de fonctionner sans une dépendance, par exemple avec 503. Il continue en cas de panne lorsqu’il fonctionne sans cette dépendance. Pour un cache, la réponse découle de la première leçon : un cache est une copie. L’API doit donner une réponse correcte sans lui. L’API de billets de soutien continue donc en cas de panne.

Trois états. « Le cache répond : résultats trouvés, absents, attentes. » En cas d'erreur ou sans réponse après 50 ms, passage à « Ignorer le cache pendant 5 s : chaque requête interroge le fournisseur, X-Cache : off ». Puis « 5 s plus tard : réessayer le cache ». S'il répond, retour au premier état; s'il échoue, retour à l'état qui ignore le cache. Une note en dessous : pendant que le cache est ignoré, un nouveau billet ne peut pas incrémenter la génération. Si le cache revient avec ses données, une ancienne réponse peut être servie jusqu'à l'expiration de son TTL (600 s). Un cache redémarré est vide, donc il ne sert aucune ancienne réponse.
Continuer en cas de panne : une erreur de cache rend chaque résultat absent pendant 5 secondes, puis l'API réessaie. Les réponses restent correctes; le fournisseur fait le travail supplémentaire.
Description textuelle du diagramme

L’API se trouve dans l’un de trois états. Normalement, le cache répond. Quand un appel au cache échoue ou dépasse CACHE_TIMEOUT (50 ms), l’API ignore le cache pendant 5 secondes. Pendant ce temps, chaque requête interroge le fournisseur et répond avec X-Cache: off (cache désactivé). Après 5 secondes, la prochaine requête réessaie le cache. S’il répond, le cache est de retour; sinon, l’API l’ignore pendant encore 5 secondes. La note explique le seul risque : une modification survenue pendant que le cache est inaccessible ne peut pas incrémenter la génération.

Continuer en cas de panne a un coût. Chaque requête ne trouve rien en cache, donc le fournisseur les reçoit toutes. Dans l’essai médian de l’exécution mesurée, 214 questions sur 400 ont appelé le fournisseur avec le cache. Sans cache, les 400 l’auraient appelé. C’est presque deux fois plus de quota utilisé au pire moment. Le module 5 ajoute les outils qui protègent le fournisseur lui-même : les délais d’expiration et un disjoncteur.

Le délai d’expiration compte autant que la décision. Un GET sur Valkey prenait une durée médiane de 178 µs dans les mesures de l’équipe du cours. CACHE_TIMEOUT vaut 50 ms, soit environ 280 fois plus. L’API traite donc un cache en retard comme un cache en panne. Elle l’ignore ensuite pendant 5 secondes pour éviter que chaque requête attende encore 50 ms.

Une réponse périmée : quand un événement est manqué

Section intitulée « Une réponse périmée : quand un événement est manqué »

Il existe un cas que cette stratégie ne règle pas. Un nouveau billet incrémente la génération du client avec une commande au cache. Si le cache ne répond pas à ce moment, l’incrément est perdu. L’API le consigne et continue : le billet lui-même est enregistré dans PostgreSQL, et c’est ce qui compte. L’auteur a volontairement gelé le cache pendant que C-0003 ouvrait un billet, puis l’a remis en marche :

x-cache: miss
{"answer":"... Your latest ticket is T-30194 (open): Change my email address.","scope":"customer:C-0003",...}
HTTP/1.1 201 Created
{"ticket_id":"T-500001","customer_id":"C-0003",...
x-cache: hit
{"answer":"... Your latest ticket is T-30194 (open): Change my email address.","scope":"customer:C-0003",...,"cached":true}
WARNING ticket_api: cache invalidation of customer:C-0003 failed: Timeout reading from 127.0.0.1:6379

Après le retour du cache, C-0003 a reçu son ancienne réponse, sans T-500001. C’est toujours sa propre réponse : un événement perdu n’envoie jamais de données à la mauvaise personne. Il conserve seulement une ancienne réponse plus longtemps. C’est le deuxième rôle du TTL : limiter une réponse périmée à 10 minutes. Si 10 minutes sont trop longues pour un résultat périmé, donnez-lui un TTL plus court. Si aucun résultat périmé n’est acceptable, ne mettez pas ce résultat en cache.

  1. Copiez le dernier fichier de ce module depuis l’instantané end-of-m03 :

    Fenêtre de terminal
    cp ../nextia-learning-labs/C21/snapshots/end-of-m03/scripts/stampede.py scripts/
  2. Avec le simulateur et l’API en marche, envoyez 20 requêtes simultanées pour une nouvelle question : python -m scripts.stampede. Exécutez la commande deux fois. Chaque exécution pose une question qui n’a jamais été posée.

  3. Arrêtez l’API avec Ctrl+C. Redémarrez-la avec la protection désactivée :

    Fenêtre de terminal
    CACHE_STAMPEDE_GUARD=false fastapi dev
  4. Exécutez de nouveau python -m scripts.stampede, deux fois.

  5. Arrêtez l’API. Démarrez-la avec les paramètres par défaut : fastapi dev. Sur Windows, retirez d’abord le paramètre : Remove-Item Env:CACHE_STAMPEDE_GUARD.

  6. Arrêtez le cache : docker compose stop cache. Posez ensuite deux fois la question de C-0003 avec la commande curl de Clés et invalidation, étape 7. Regardez le terminal de l’API.

  7. Exécutez python -m scripts.cache stats.

  8. Démarrez le cache : docker compose start cache. Attendez 5 secondes, puis posez encore la même question deux fois.

Afficher le résultat attendu

Étape 2, l’exécution de l’auteur. Une requête n’a rien trouvé et a appelé le fournisseur; dix-neuf ont attendu son résultat :

20 requests for the same new question: 1.45 s, status codes {200: 20}
Cache: {'miss': 1, 'wait': 19}
Calls that reached the provider: 1

Étape 4, avec la protection désactivée. Chaque requête n’a rien trouvé et a appelé le fournisseur :

20 requests for the same new question: 1.65 s, status codes {200: 20}
Cache: {'miss': 20}
Calls that reached the provider: 20

Vos durées varieront d’une exécution à l’autre; les comptes restent les mêmes. Étape 6 : les deux réponses sont 200 avec x-cache: off (cache désactivé). La première a essayé le cache et a échoué. La seconde l’a ignoré, donc son server-timing (durées côté serveur) n’a pas de partie cache (cache). Le terminal de l’API affiche un avertissement :

WARNING ticket_api: cache not available (Error 61 connecting to 127.0.0.1:6379. Connection refused.): working without it

Sur Windows et Linux, le numéro et le texte de l’erreur diffèrent. L’étape 7 affiche The cache does not answer: … Connection refused.. With Docker: docker compose up -d cache (le cache ne répond pas; connexion refusée; avec Docker, utilisez la commande indiquée). Étape 8 : la première réponse est x-cache: miss (résultat absent), et la seconde x-cache: hit (résultat trouvé). Le cache est revenu vide, car Valkey ne garde rien sur disque ici. Un cache vide ne sert aucune ancienne réponse, donc un redémarrage préserve toujours l’exactitude.

Le verrou et l’attente durent CACHE_LOCK_SECONDS, soit 10 secondes par défaut. Une réponse du fournisseur prend environ une seconde. Prédisez ce qui arrive avec un verrou de 0,3 seconde. Combien d’appels atteignent le fournisseur? Essayez ensuite : démarrez l’API avec CACHE_LOCK_SECONDS=0.3 fastapi dev, puis exécutez python -m scripts.stampede. Après cela, redémarrez l’API avec les paramètres par défaut.

Afficher la réponse

Les 20 requêtes appellent le fournisseur, comme sans protection. Dans les trois exécutions de l’auteur : Cache: {'miss': 20} (20 résultats absents) et Calls that reached the provider: 20 (20 appels ont atteint le fournisseur) chaque fois. Les requêtes en attente abandonnent après 0,3 seconde, avant que la première réponse soit prête. Chacune appelle alors elle-même le fournisseur. Un verrou doit durer plus longtemps que le calcul normal le plus lent. Trop long est plus sûr que trop court : un long verrou compte seulement quand la requête qui calcule plante.

Erreur courante

Un cache qui bloque au lieu d'échouer

Symptôme (construit) : l’API est lente, même si le fournisseur fonctionne bien. Chaque réponse prend plus de 6 secondes, et le journal de l’API affiche cache not available (Timeout reading from …) (cache indisponible, délai de lecture dépassé). L’auteur a volontairement gelé Valkey avec docker compose pause cache. Un serveur gelé accepte la connexion, mais ne répond jamais. L’auteur a ensuite démarré l’API avec un long délai d’expiration, CACHE_TIMEOUT=5, puis exécuté python -m scripts.stampede :

20 requests for the same new question: 6.62 s, status codes {200: 20}
Cache: {'off': 20}
Calls that reached the provider: 20

Avec le délai d’expiration par défaut de 0,05 seconde et le même cache gelé, les mêmes 20 requêtes ont pris 1,67 s.

Cause : un service absent échoue vite : la connexion est refusée immédiatement. Un service bloqué est pire. Chaque requête attend tout le délai d’expiration avant d’abandonner. Ici, chaque requête arrivée en même temps a attendu 5 secondes pour le cache, puis environ une seconde pour le fournisseur.

Diagnostic : lisez l’en-tête server-timing. Une requête de l’exécution de l’auteur affichait db;dur=6.3, cache;dur=5001.8, answer;dur=1110.8 : 5 secondes ont servi à attendre le cache. Une durée cache proche de CACHE_TIMEOUT signifie que le cache ne répond pas.

Correction :

  1. Gardez un délai d’expiration court pour le cache, proche du temps nécessaire à un cache lent, mais sain. Le projet utilise 50 ms, environ 280 fois la durée d’un GET normal.
  2. Après une panne, ignorez le cache un moment, comme Cache.available() le fait pendant 5 secondes. Ainsi, une seule requête par période de 5 secondes subit le délai d’expiration.
  3. Dégelez le cache avec docker compose unpause cache, puis démarrez l’API avec les paramètres par défaut.

Quand utiliser ces protections, et ce qu’elles coûtent

Section intitulée « Quand utiliser ces protections, et ce qu’elles coûtent »

Utilisez la protection contre les ruées pour les résultats lents à produire que beaucoup de clients demandent en même temps. Ici, ce sont les réponses aux questions populaires. Elle coûte une commande de cache supplémentaire par résultat absent, quelques lectures pendant l’attente et un autre paramètre à choisir soigneusement. Pour un résultat peu coûteux, une ruée ne fait aucun mal, et la protection n’en vaut pas la peine.

Continuer en cas de panne convient à tout cache qui ne contient que des copies. Cela transfère la charge au fournisseur quand le cache est en panne, donc le fournisseur a besoin de sa propre protection. Bloquer en cas de panne convient quand les données stockées sont la seule source d’une décision. Le délai d’expiration du cache doit être court, et une panne doit suspendre les tentatives suivantes. Une invalidation manquée est le dernier risque. Le TTL le limite : choisissez donc chaque TTL comme « la durée maximale pendant laquelle une réponse périmée reste acceptable ».

Vérifiez votre compréhension

Vingt requêtes ne trouvent pas la même clé en cache en même temps. Avec le verrou, une seule appelle le fournisseur. Pourquoi le lot était-il aussi plus rapide (1,22 s contre 1,96 s)?

Afficher la réponse

Sans le verrou, le lot se termine quand le plus lent des 20 appels au fournisseur se termine. Les temps du fournisseur varient. Avec le verrou, il n’y a qu’un appel. Les autres requêtes répondent environ 50 ms après lui, lorsqu’elles lisent de nouveau le cache. Un vrai fournisseur ralentit aussi lorsque davantage d’appels sont en cours. Le fournisseur simulé ne modélise pas cet effet. L’écart peut donc être plus grand en pratique.

Vérifiez votre compréhension

Valkey s'arrête pendant 30 secondes durant le Vendredi fou. Que voient les clients et le fournisseur?

Afficher la réponse

Les clients reçoivent toujours des réponses correctes avec le statut 200, marquées X-Cache: off (cache désactivé). Les réponses auparavant trouvées en cache prennent maintenant environ une seconde au lieu de 14 ms. Le fournisseur reçoit toutes les questions plutôt qu’environ la moitié : 400 appels au lieu de 214 dans le mélange mesuré. Le quota s’épuise donc plus vite. Les délais d’expiration et le disjoncteur du module 5 doivent gérer cette situation. Après le redémarrage, le cache est vide et se remplit de nouveau.

Vérifiez votre compréhension

Faites une prédiction : une cliente ouvre un billet pendant que Valkey est momentanément bloqué. Une minute plus tard, elle pose une question. Peut-elle voir les données d'un autre client? Peut-elle voir des données anciennes?

Afficher la réponse

Elle ne peut pas voir les données d’un autre client : sa clé contient toujours sa propre portée, customer:<id>. Elle peut voir des données anciennes. L’incrémentation de la génération a échoué. Son ancienne réponse, sans le nouveau billet, reste donc utilisée jusqu’à la fin de sa durée de vie (TTL). Cela représente au plus 10 minutes après son enregistrement dans le cache. L’API a consigné cache invalidation of customer:… failed (échec de l’invalidation du cache pour customer:…). Une invalidation perdue affecte l’actualité des données, jamais l’identité.

Récapitulatif

  • Une ruée sur le cache survient quand plusieurs requêtes ne trouvent pas la même clé en cache simultanément. Sans verrou, 20 requêtes pour une nouvelle question ont produit 20 appels au fournisseur; avec le verrou, 1 appel (médianes de 5 essais).
  • La protection utilise un verrou par clé (SET … NX avec un jeton et une expiration de 10 secondes). Une requête fait le calcul; les autres attendent et répondent avec X-Cache: wait (attente du cache). Le verrou doit durer plus longtemps que le travail.
  • Le cache laisse passer les requêtes en cas de panne. Quand il est en panne ou prend plus de 50 ms, aucune requête ne trouve de réponse en cache. Chaque requête porte X-Cache: off, et l’API ignore le cache pendant 5 secondes. Les réponses restent correctes; le fournisseur reçoit toute la charge.
  • Un cache bloqué est pire qu’un cache absent. Un long délai d’expiration a fait passer le temps pour 20 réponses de 1,67 s à 6,62 s.
  • Une invalidation perdue laisse une ancienne réponse jusqu’à la fin de sa durée de vie, mais jamais celle d’une autre personne.
  • Le module 3 est terminé : votre projet correspond à l’instantané end-of-m03, et python -m pytest affiche 148 passed, 1 deselected (148 tests réussis, 1 non sélectionné). Ensuite, le travail d’IA lent passe dans une file d’attente.

Leçon suivante : Cycle de vie d'une tâche