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.
Leçon 10 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAPannes et ruée sur le cache
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
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 main
Ce que vous devez savoir
- Les clés, les générations, les TTL et la vie d’une réponse en cache, vus dans Clés et invalidation.
- Le quota du fournisseur de 100 requêtes de clavardage par minute, vu dans Limites des dépendances.
Ce qu’il vous faut sur votre ordinateur
- Le projet après Clés et invalidation :
python -m pytestaffiche148 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 à l’ouverture
Section intitulée « Une boulangerie à l’ouverture »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.
Le problème : une ruée sur le cache
Section intitulée « Le problème : une ruée sur le cache »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.
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.
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.
Larkfield : la protection dans le code
Section intitulée « Larkfield : la protection dans le code »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 :
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é.
Quand le cache est en panne : continuer sans lui
Section intitulée « Quand le cache est en panne : continuer sans lui »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.
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:6379Aprè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.
Exercice guidé : une ruée, puis un cache en panne
Section intitulée « Exercice guidé : une ruée, puis un cache en panne »-
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/Fenêtre de terminal Copy-Item ..\nextia-learning-labs\C21\snapshots\end-of-m03\scripts\stampede.py scripts\ -
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. -
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 devFenêtre de terminal $env:CACHE_STAMPEDE_GUARD = "false"; fastapi dev -
Exécutez de nouveau
python -m scripts.stampede, deux fois. -
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. -
Arrêtez le cache :
docker compose stop cache. Posez ensuite deux fois la question de C-0003 avec la commandecurlde Clés et invalidation, étape 7. Regardez le terminal de l’API. -
Exécutez
python -m scripts.cache stats. -
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: 20Vos 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 itSur 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.
À vous : un verrou plus court que le travail
Section intitulée « À vous : un verrou plus court que le travail »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: 20Avec 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 :
- 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
GETnormal. - 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. - 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érification des connaissances
Section intitulée « Vérification des connaissances »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.
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
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.
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
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é.
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 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 … NXavec un jeton et une expiration de 10 secondes). Une requête fait le calcul; les autres attendent et répondent avecX-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, etpython -m pytestaffiche148 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