Contenir les défaillances
- Leçon 14
- 55 min
- Module 5 : Résilience et mise à l'échelle automatique
Où nous en sommes
Dans le module 4, la file d'attente a protégé chaque billet et refusé tôt le travail en trop, avec un délai honnête. Mais que se passe-t-il si le fournisseur d'IA cesse de répondre? Chaque processus attend, réessaie et attend encore, et ses nouvelles tentatives peuvent aggraver la panne. Dans cette leçon, nous décidons combien de temps attendre, quand réessayer et quand cesser d'appeler pendant un moment. Pensons à un appel vers un magasin dont le téléphone est en panne.
Leçon 14 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAContenir les défaillances
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
Empêchez une dépendance défaillante de mettre tout le service hors fonction. Décidez combien de temps attendre le fournisseur d’IA, quand réessayer et quand cesser de l’appeler temporairement.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- La file d’attente, le processus et les états des tâches, présentés dans Cycle de vie d’une tâche.
- Les nouvelles tentatives avec délai d’attente croissant, les tentatives et les messages non livrables. Pourquoi un code 429 ne compte pas comme tentative, dans Livraison et nouvelles tentatives.
- La limite de la file d’attente,
503 queue_full(file pleine) etRetry-After(réessayer après), dans Contre-pression.
Ce qu’il vous faut sur votre ordinateur
- Le projet
~/projects/ticket-apiaprès le module 4 :python -m pytestaffiche163 passed, 1 deselected. Si votre projet ne fonctionne plus, copiez l’instantanéend-of-m04(voir les instantanés). - PostgreSQL, Azurite et Valkey en cours d’exécution :
docker compose up -d db azurite cache. - Le clone du dépôt des laboratoires dans
~/projects/nextia-learning-labs, comme dans Exécuter la charge de travail d’IA sur votre ordinateur.
Le fournisseur d’IA de ce module est celui simulé sur votre ordinateur. Sa panne et son mode lent sont construits : le vrai fournisseur n’est pas tombé en panne pendant l’enregistrement du cours. L’équipe du cours a mesuré les valeurs de ce module sur un ordinateur Apple M4 (10 cœurs, 16 Go), sans autre activité. PostgreSQL 18.6 et Valkey 9.1.2 fonctionnaient dans Docker. Vos durées seront différentes; les tendances resteront les mêmes. Testé sur macOS (Apple silicon); les commandes Windows sont fournies, mais n’ont pas été testées.
Appeler un magasin dont le téléphone est en panne
Section intitulée « Appeler un magasin dont le téléphone est en panne »Vous appelez un magasin pour vous renseigner sur votre commande. D’habitude, quelqu’un répond après trois ou quatre sonneries. Aujourd’hui, le téléphone sonne sans arrêt. Combien de temps attendez-vous? La plupart des gens raccrochent après environ une minute. Ils ne restent pas au téléphone pendant une heure. Cette limite est un délai d’expiration.
Vous rappelez un peu plus tard, car la ligne était peut-être occupée. Une tentative de plus est raisonnable. Rappeler toutes les cinq secondes pendant une heure ne l’est pas. Vous perdez votre après-midi. Et si le système téléphonique du magasin est surchargé, vos appels aggravent la situation.
Après cinq appels sans réponse, une personne raisonnable arrête et fait autre chose. Une demi-heure plus tard, elle essaie une seule fois. Si quelqu’un répond, tout revient à la normale. Sinon, elle attend encore une demi-heure. Le panneau électrique de votre maison fonctionne de manière semblable. Quand un circuit a un défaut, le disjoncteur coupe le courant pour éviter d’autres dommages. Plus tard, vous le réactivez une fois, puis vérifiez s’il reste enclenché.
Voilà les trois idées de cette leçon : combien de temps attendre, à quelle fréquence réessayer et quand arrêter temporairement.
Le problème : un fournisseur qui ne répond pas
Section intitulée « Le problème : un fournisseur qui ne répond pas »Dans le module 4, le travail d’IA a été transféré à un processus. Un processus exécute 4 tâches à la fois. Chaque tâche fait trois appels au fournisseur : classifier, rédiger une réponse, produire un plongement (embedding). Imaginez maintenant que le fournisseur tombe en panne pendant 20 secondes. Chaque appel renvoie 503 Service Unavailable (service indisponible) après une courte attente.
Que fait le processus? Il ne sait pas que le fournisseur est en panne. Il voit une tâche échouer et planifie une nouvelle tentative, comme le module 4 le lui a appris. La tâche suivante échoue aussi, puis la suivante. Chaque échec consomme une tentative. Une tâche dispose de 5 tentatives (JOB_MAX_ATTEMPTS), puis devient un message non livrable qu’une personne doit examiner.
Comptons. Trente billets de soutien sont dans la file d’attente au début de la panne. Si chaque tâche essaie 5 fois avant la fin, le fournisseur reçoit 30 × 5 = 150 appels, qui échouent tous. Quand le fournisseur revient 20 secondes plus tard, il ne reste rien à faire : les 30 tâches sont des messages non livrables. Les clients ont écrit leurs billets, mais aucun brouillon de réponse n’arrive.
Deux choses ont mal tourné. Le processus a continué d’appeler un fournisseur clairement en panne. Il perd ainsi du temps et ajoute de la charge à un service déjà en difficulté. Et il a abandonné les tâches à cause d’un problème qui ne venait pas d’elles. Une tâche dont le billet est valide devrait attendre la fin de la panne, pas échouer définitivement pendant celle-ci.
Il y a un troisième problème, moins visible : la limite de temps. Jusqu’ici, PROVIDER_TIMEOUT était de 30 secondes. Un fournisseur qui reste bloqué, plutôt que d’échouer rapidement, occupe chaque emplacement du processus pendant 30 secondes par appel. Avec quatre emplacements bloqués pendant 30 secondes chacun, le processus ne fait presque rien pendant une demi-minute.
Idée 1 : un délai d’expiration adapté au travail
Section intitulée « Idée 1 : un délai d’expiration adapté au travail »Un délai d’expiration est la durée maximale d’attente pour un appel. Après ce délai, vous cessez d’attendre et considérez l’appel comme un échec. Il faut déterminer cette durée.
Regardez ce que le fournisseur fait normalement. L’équipe du cours a enregistré 100 appels réels pour chaque tâche, un à la fois. Le brouillon de réponse le plus lent a pris 2 172 ms, et la classification la plus lente, 2 143 ms. Un appel sans réponse après 10 secondes a donc très peu de chances d’être un appel normalement lent. C’est un signe de problème. À partir de ce module, PROVIDER_TIMEOUT vaut 10 secondes. C’est plus de quatre fois l’appel enregistré le plus lent, et le tiers des 30 secondes précédentes.
| Délai d’expiration | Un appel normalement lent (2,2 s) | Un fournisseur bloqué occupe un emplacement du processus pendant |
|---|---|---|
| 30 s (modules 1 à 4) | réussit | 30 s par appel |
| 10 s (à partir de ce module) | réussit | 10 s par appel |
| 1 s (trop court) | échoue, puis est répété inutilement | 1 s par appel |
Un délai d’expiration trop court provoque un échec que vous créez vous-même. Des appels normaux échouent, sont répétés et coûtent de l’argent deux fois. Un délai trop long transforme une dépendance bloquée en service paralysé. Fixez-le donc à partir des appels normaux les plus lents mesurés, en gardant une marge. Vérifiez-le de nouveau quand le travail change : une requête (prompt) plus longue ou un modèle plus lent change la bonne durée.
Idée 2 : répéter seulement ce qui est sûr, et peu de fois
Section intitulée « Idée 2 : répéter seulement ce qui est sûr, et peu de fois »Une nouvelle tentative consiste à répéter un appel qui a échoué. Avant de réessayer, posez une question : que se passe-t-il si le premier essai a finalement réussi, mais que la réponse s’est perdue?
| Opération | Si elle s’exécute deux fois | Réessayer? |
|---|---|---|
| Un appel au fournisseur d’IA (classifier, rédiger, produire un plongement) | Vous payez deux réponses, et rien d’autre ne change | Oui, quelques fois |
POST /v1/tickets sans Idempotency-Key |
Deux billets pour un seul message client | Non |
POST /v1/tickets avec Idempotency-Key |
Le même billet et la même tâche (module 4) | Oui |
| Une étape de tâche dont le résultat est enregistré avec l’identifiant de la tâche | L’étape enregistrée n’est pas appelée de nouveau (module 4) | Oui, par la file d’attente |
Les appels au fournisseur peuvent donc être répétés sans danger. Mais « sans danger » ne veut pas dire « gratuit ». Pendant une panne, chaque nouvelle tentative ajoute un appel à un service qui échoue déjà. Si chaque appel échoué est répété deux fois, la panne triple la charge du fournisseur au pire moment. C’est ce qu’on appelle une tempête de nouvelles tentatives.
Le projet limite les nouvelles tentatives à deux endroits. Le processus ne fait aucune nouvelle tentative rapide. Une tâche échouée retourne dans la file et y attend, avec le délai d’attente croissant du module 4. L’API fait une nouvelle tentative rapide (PROVIDER_RETRIES=1) pour POST /v1/answers, parce qu’une personne attend cette réponse. Cette tentative respecte un budget de nouvelles tentatives. Elles peuvent ajouter au plus 10 % d’appels (RETRY_BUDGET_RATIO=0.1) sur les 10 dernières secondes, avec au moins 3 toujours autorisées.
Un petit exemple montre ce budget en action. En 10 secondes, l’API fait 100 appels. Le fournisseur est en panne, donc les 100 échouent.
- Sans budget, chaque échec donne lieu à une nouvelle tentative. Le fournisseur reçoit 100 + 100 = 200 appels, qui échouent tous.
- Avec le budget de 10 %, seules 10 nouvelles tentatives sont autorisées. Le fournisseur reçoit 100 + 10 = 110 appels. Les 90 autres requêtes échouent immédiatement, sans deuxième attente.
Quand le fournisseur fonctionne bien, seuls quelques appels échouent. Le budget refuse donc très rarement une nouvelle tentative. Il intervient seulement quand beaucoup d’appels échouent ensemble, précisément quand les nouvelles tentatives font du tort.
Idée 3 : le disjoncteur
Section intitulée « Idée 3 : le disjoncteur »Le délai d’expiration et le budget permettent encore à chaque requête de faire au moins un appel. Pendant une panne de 20 secondes, cela reste beaucoup d’appels voués à l’échec, chacun avec sa propre attente. Le panneau électrique nous donne l’idée suivante.
Un disjoncteur se place devant le client du fournisseur et compte les échecs consécutifs. Dans le projet (ticket_api/resilience.py), il a trois états :
Description textuelle du diagramme
Le diagramme a trois états. Fermé est l’état normal : chaque appel va au fournisseur, et une réussite remet le compteur d’échecs à 0. Après 5 échecs consécutifs, le disjoncteur passe à l’état ouvert. Quand il est ouvert, un appel échoue immédiatement. Aucune requête n’est envoyée, donc personne n’attend l’expiration d’un délai. Après 30 secondes, le disjoncteur passe à l’état semi-ouvert et laisse passer un appel d’essai. Si l’essai réussit, le disjoncteur se referme. S’il échoue, le disjoncteur s’ouvre pour 30 secondes de plus. Une note précise ce qui constitue un échec : un délai d’expiration ou une réponse 5xx. Un code 429 n’est pas un échec ici, car un refus lié au quota ne signifie pas une panne du fournisseur. Les attentes liées au quota du module 4 s’en chargent.
Le nom vient du disjoncteur électrique. « Fermé » signifie que le circuit est complet, donc les appels passent. « Ouvert » signifie que le circuit est interrompu, donc rien ne passe. C’est l’inverse d’une porte : lisez donc les états attentivement.
Voici le disjoncteur dans l’API, lors de l’exécution de l’auteur. Le fournisseur simulé est en mode panne, et six questions arrivent l’une après l’autre :
request 1: 503 in 0.361208 srequest 2: 503 in 0.471282 srequest 3: 503 in 0.187749 srequest 4: 503 in 0.014566 srequest 5: 503 in 0.012967 srequest 6: 503 in 0.012212 sComptez les appels. Les requêtes 1 et 2 ont chacune fait un appel et une nouvelle tentative rapide : 4 échecs. La requête 3 a fait un appel, le cinquième échec consécutif, et le disjoncteur s’est ouvert avant sa nouvelle tentative. Les requêtes 4 à 6 n’ont pas du tout appelé le fournisseur. Elles ont échoué en environ 13 ms plutôt qu’en 200 à 470 ms. Le compteur du fournisseur confirme : "answer":{"503":5}, cinq appels pour six requêtes. La réponse indique à l’appelant quand revenir :
HTTP/1.1 503 Service Unavailableretry-after: 30
{"error":{"code":"ai_unavailable","message":"The AI provider is failing; the API stopped calling it for now. Try again in 30 seconds.", ...}}Ces durées viennent de l’exécution de l’auteur sur un ordinateur occupé; vos durées seront différentes. Les nombres d’appels sont les mêmes sur tous les ordinateurs.
Ce que cela nous apprend. Un disjoncteur ouvert transforme un échec lent en échec rapide. Le client reçoit un 503 dans les deux cas. Mais maintenant, il arrive en 13 ms avec un Retry-After clair, et le fournisseur ne reçoit aucune charge supplémentaire.
Larkfield : le processus pendant une panne
Section intitulée « Larkfield : le processus pendant une panne »Le processus utilise le même disjoncteur, avec une règle supplémentaire. Quand le disjoncteur est ouvert, le processus remet la tâche dans la file jusqu’à ce que le disjoncteur puisse se refermer. La tentative ne compte pas. La tâche n’a rien fait de mal, donc elle attend.
Le script scripts/outage_demo.py teste ce comportement. Il place 30 nouveaux billets dans la file et démarre un processus. Il met le fournisseur simulé en mode panne pendant 20 secondes, puis revient à la normale et attend que la file soit vide. Le quota est activé. Pour raccourcir l’exécution, le script utilise des attentes entre tentatives plus courtes que les valeurs par défaut : 1 à 8 secondes plutôt que 2 à 60. L’exécution mesurée, avec le disjoncteur activé, a donné le même résultat lors des 3 essais :
Outage over after 20 s (simulated).Circuit breaker: on (opened 1 time(s))Calls that reached the provider during the outage: 8 (answered {'200': 0, '429': 0, '503': 8})Jobs at the end (65 s): succeeded 30Huit appels ont atteint le fournisseur en 20 secondes. Cinq échecs consécutifs ont ouvert le disjoncteur; les autres appels avaient déjà commencé. Le processus a ensuite cessé d’appeler et a remis chaque tâche dans la file. Après 30 secondes, l’appel d’essai a réussi, car la panne était terminée, et le processus a exécuté les 30 tâches.
Avec --breaker off, la même panne a donné ceci, également lors des 3 essais :
Outage over after 20 s (simulated).Circuit breaker: offCalls that reached the provider during the outage: 150 (answered {'200': 0, '429': 0, '503': 150})Jobs at the end (65 s): dead_letter 30Description textuelle du graphique
Un graphique à deux colonnes. Avec le disjoncteur activé, 8 appels ont atteint le fournisseur pendant la panne de 20 secondes. Avec le disjoncteur désactivé, 150 appels l’ont atteint : 30 tâches multipliées par 5 tentatives. Tous ces appels ont échoué. Chaque essai de mesure a donné exactement les mêmes nombres.
- Disjoncteur activé
- Disjoncteur désactivé
Description textuelle du graphique
Un graphique à quatre colonnes, sur un axe de 0 à 30 tâches. Avec le disjoncteur activé, 30 tâches ont réussi et 0 sont des messages non livrables. Avec le disjoncteur désactivé, 0 tâche a réussi et 30 sont des messages non livrables. Le fournisseur était revenu après 20 secondes dans les deux exécutions. Mais sans disjoncteur, il ne restait aucune tâche pour l’utiliser.
Ce que cela nous apprend. Le disjoncteur a changé deux nombres, et le second compte davantage pour les clients. Moins d’appels protègent le fournisseur et le quota du compte. Mais le disjoncteur a aussi permis le travail d’IA pour les 30 billets, avec environ une minute de retard, plutôt qu’aucun. Omar demande ce que voient les clients. Avec le disjoncteur, le service de soutien voit chaque brouillon de réponse arriver après la panne. Sans lui, 30 billets n’ont aucun brouillon. Quelqu’un doit trouver les messages non livrables et relancer chacun avec POST /v1/jobs/{id}/retry.
Quand utiliser chaque outil, et à quel coût
Section intitulée « Quand utiliser chaque outil, et à quel coût »| Outil | Quand l’utiliser | Son coût |
|---|---|---|
| Délai d’expiration | Pour chaque appel réseau | Trop court : des appels normaux échouent. Trop long : un blocage paralyse le processus |
| Nouvelle tentative rapide avec budget | Quand une personne attend, pour les appels qu’on peut répéter sans danger | Un peu de charge supplémentaire; une attente plus longue pour la personne lors d’une vraie panne |
| Nouvelle tentative en file avec délai d’attente croissant | Pour le travail en arrière-plan | Le travail arrive plus tard |
| Disjoncteur | Devant une dépendance qui peut tomber entièrement en panne | 30 s sans travail d’IA après un bref problème; des seuils à choisir |
Sam demande : « Pourquoi chaque processus a son propre disjoncteur? Quatre processus doivent chacun voir cinq échecs. » C’est vrai, et c’est un choix. Un disjoncteur par processus n’a pas besoin d’état partagé et continue de fonctionner quand Valkey est en panne. Le coût est quelques appels échoués de plus au début d’une panne : jusqu’à 5 par processus. Un disjoncteur partagé dans Valkey détecterait la panne plus vite. Mais il ajoute une dépendance au code qui vous protège des dépendances. Le projet garde donc une approche simple.
Deux autres limites. Le disjoncteur ne distingue pas une panne du fournisseur d’un problème de votre réseau, car les deux ressemblent à des délais d’expiration. Et un disjoncteur protège l’utilisateur seulement quand le travail peut attendre. Le 503 ai_unavailable (IA indisponible) de l’API est honnête : il indique ce qui a échoué et quand revenir.
Exercice guidé : une panne, avec et sans le disjoncteur
Section intitulée « Exercice guidé : une panne, avec et sans le disjoncteur »-
Dans
~/projects/ticket-api, avec l’environnement virtuel actif, copiez les fichiers de cette leçon depuis l’instantanéend-of-m05.worker.pycomprend aussi l’arrêt en douceur de la leçon Arrêt en douceur, qui vient plus tard dans ce module.Fenêtre de terminal S=../nextia-learning-labs/C21/snapshots/end-of-m05for f in README.md ticket_api/resilience.py ticket_api/provider.py ticket_api/config.py ticket_api/errors.py ticket_api/main.py ticket_api/worker.py scripts/outage_demo.py tests/test_resilience.py; do cp "$S/$f" "$f"; doneFenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m05"foreach ($f in 'README.md', 'ticket_api\resilience.py', 'ticket_api\provider.py', 'ticket_api\config.py', 'ticket_api\errors.py', 'ticket_api\main.py', 'ticket_api\worker.py', 'scripts\outage_demo.py', 'tests\test_resilience.py') { Copy-Item "$S\$f" $f } -
Exécutez les tests :
python -m pytest. Le résultat attendu est172 passed, 1 deselected(172 tests réussis, 1 non sélectionné). -
Exécutez seulement les nouveaux tests, avec leurs noms :
python -m pytest tests/test_resilience.py -v. Le résultat attendu est9 passed(9 tests réussis). -
Arrêtez tout processus du module 4 encore actif, car la démonstration lance le sien. Dans le terminal 1, lancez le fournisseur simulé :
python -m simulator. -
Dans le terminal 2, rechargez les données pour que la démonstration compte seulement ses propres tâches :
python -m scripts.load --reset. -
Exécutez la panne avec le disjoncteur. Cela prend environ 65 secondes.
LOG_LEVEL=WARNINGmasque les lignes du journal du processus.Fenêtre de terminal LOG_LEVEL=WARNING python -m scripts.outage_demo --breaker onFenêtre de terminal $env:LOG_LEVEL = "WARNING"; python -m scripts.outage_demo --breaker on -
Exécutez de nouveau
python -m scripts.load --reset. Puis exécutez l’étape 6 avec--breaker off. -
Observez maintenant le disjoncteur dans l’API. Arrêtez le simulateur avec Ctrl+C, puis lancez-le en mode panne :
python -m simulator --mode outage. Dans le terminal 2, lancez l’API :fastapi dev. -
Dans le terminal 3, envoyez six questions, l’une après l’autre. Sur Windows, tapez
curl.exeet envoyez la requête six fois à la main (rédigé, mais non testé) :Fenêtre de terminal for i in 1 2 3 4 5 6; do curl -s -o /dev/null -w "request $i: %{http_code} in %{time_total} s\n" -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 number $i?\"}"; done -
Envoyez une autre question avec
-ià la place de-s -o /dev/null -w …. Lisez son en-têteretry-after(délai avant une nouvelle tentative) et son code d’erreur.
Afficher le résultat attendu
Les étapes 6 et 7 affichent les deux résultats de cette leçon : 8 appels et succeeded 30 (30 réussites) avec le disjoncteur; 150 appels et dead_letter 30 (30 tâches en échec définitif) sans lui. Le nombre d’appels est identique sur tous les ordinateurs. Le temps entre parenthèses, (65 s), peut être un peu plus long sur un ordinateur occupé. Si l’étape 7 compte plus de 30 tâches, vous avez oublié --reset. Le script compte chaque billet dont l’objet commence par Outage test (test de panne).
L’étape 9 affiche six lignes 503. Les trois premières prennent quelques centaines de millisecondes. Les trois dernières prennent environ 10 à 20 ms, car le disjoncteur est ouvert. L’étape 10 affiche 503, un en-tête retry-after: avec un nombre de secondes allant jusqu’à 30, et "code":"ai_unavailable" (IA indisponible). Si les premières requêtes répondent déjà rapidement, le disjoncteur était ouvert avant le début : attendez 30 secondes et réessayez. Quand vous avez terminé, arrêtez l’API et relancez le simulateur sans --mode outage.
À vous de jouer : un fournisseur lent
Section intitulée « À vous de jouer : un fournisseur lent »Une panne est facile à voir. Un fournisseur lent est plus difficile à repérer. Changez une condition : lancez le simulateur avec python -m simulator --mode slow. Chaque réponse prend maintenant 8 fois plus de temps. Une classification prend donc environ 7,3 secondes, et un brouillon de réponse environ 8,8 secondes. Ce sont des médianes, donc certains appels prennent plus de 10 secondes.
Faites d’abord une prédiction. Avec PROVIDER_TIMEOUT=10, les tâches vont-elles échouer? Le disjoncteur va-t-il s’ouvrir? Lancez ensuite un processus (python -m ticket_api.worker) et l’API (fastapi dev). Envoyez 8 billets avec python -m scripts.send_tickets --rate 1 --seconds 8, puis observez avec python -m scripts.queue_watch --every 5.
Afficher la réponse
Lors de l’exécution de l’auteur, les 8 tâches ont réussi. Trois brouillons de réponse ont pris plus de 10 secondes. Ces trois tâches ont donc fait l’objet d’une nouvelle tentative et ont réussi à la tentative 2. Le journal du processus indiquait job 2: retried (attempt 1) (tâche 2 : nouvelle tentative, tentative 1), puis job 2: succeeded (attempt 2) (tâche 2 : réussie, tentative 2). Le disjoncteur ne s’est pas ouvert : les délais expirés et les réussites alternaient, sans jamais atteindre 5 échecs consécutifs. L’âge de la plus vieille tâche de la file a atteint environ 31 secondes.
Le compteur du simulateur montre deux coûts d’un délai expiré. Il a répondu à 8 classifications, mais à 11 demandes de brouillon de réponse. Le fournisseur a terminé les 3 appels lents que le processus avait cessé d’attendre. Avec un vrai fournisseur, vous payez ces réponses. Les classifications n’ont pas été répétées, car leurs résultats étaient enregistrés avec l’identifiant de la tâche (module 4).
Avec l’ancien PROVIDER_TIMEOUT=30, ces tâches réussiraient à la tentative 1. Mais chaque appel lent occuperait une place dans le processus pendant un maximum de 30 secondes. Aucune des deux valeurs ne convient pour toujours. Un fournisseur lent justifie de mesurer à nouveau, comme dans Trouver le goulot d’étranglement.
Erreur courante
Réessayer jusqu'à ce que le fournisseur réponde
Symptôme : pendant la panne, Tomás dit : « Le fournisseur va revenir. Désactivez le disjoncteur, augmentez JOB_MAX_ATTEMPTS à 50 et continuez de réessayer. » Avec le disjoncteur désactivé et 5 tentatives, la démonstration affiche Calls that reached the provider during the outage: 150 (appels ayant atteint le fournisseur pendant la panne : 150) et Jobs at the end (65 s): dead_letter 30 (tâches à la fin, après 65 secondes : 30 en échec définitif). Le fournisseur était revenu après 20 secondes, mais il ne restait aucune tâche pour l’utiliser.
Cause : chaque appel échoué consomme une tentative. Les délais entre les tentatives sont plus courts que bien des pannes. Ils vont de 1 à 8 secondes dans la démonstration, et jusqu’à 60 secondes par défaut. Les tentatives s’épuisent donc pendant la panne. Augmenter leur nombre ne fait que déplacer le problème. Avec 50 tentatives, les tâches survivent à une panne plus longue. Mais le fournisseur reçoit jusqu’à 50 appels par tâche pendant qu’il est indisponible. Avec 300 tâches dans la file, cela représente jusqu’à 15 000 appels échoués, et chacun compte dans le quota. Une véritable tempête de nouvelles tentatives peut aussi empêcher un fournisseur en rétablissement de reprendre son service.
Diagnostic : examinez la tendance des échecs, pas une seule tâche. python -m scripts.queue_watch montre que dead (en échec définitif) augmente pour plusieurs tâches à la fois. Le journal du processus montre ProviderUnavailable (fournisseur indisponible) ou ProviderTimeout (délai du fournisseur expiré) pour chaque tâche, pas seulement certaines. Le point /admin/stats du simulateur, ou la page d’état d’un vrai fournisseur, montre seulement des réponses 503. Quand chaque appel échoue, la dépendance est indisponible, et davantage d’appels ne peuvent pas aider.
Correction :
- Gardez le disjoncteur activé (
BREAKER_FAILURES=5). Pendant qu’il est ouvert, les tâches attendent sans consommer de tentatives. - Limitez le nombre de tentatives (
JOB_MAX_ATTEMPTS=5). Cette limite vous protège contre une tâche qui ne peut jamais réussir. - Après la panne, relancez volontairement les tâches en échec définitif :
POST /v1/jobs/{id}/retry.
Pour un service d’IA : un fournisseur d’IA compte chaque appel dans le quota, et certains facturent aussi les appels échoués. Des tentatives illimitées transforment une panne en facture et en problème de quota qui persiste après la panne.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Le fournisseur réel observé a produit un brouillon de réponse en au plus 2 172 ms. Amira fixe PROVIDER_TIMEOUT=2. Que verra-t-elle un jour normal, et quelle valeur serait meilleure?
Afficher la réponse
Un jour normal, certains appels échoueront. Les 100 brouillons de réponse observés avaient un p95 de 1 514 ms et un maximum de 2 172 ms. Les appels normaux les plus lents dépassent donc 2 secondes. Chacun dépasse le délai, la tâche est relancée et le fournisseur fait le travail deux fois : deux réponses à payer. Un bon délai maximal dépasse largement l’appel normal le plus lent, sans approcher le point où « le processus est bloqué ». Les 10 secondes du projet représentent plus de quatre fois la durée de l’appel observé le plus lent. Elle devrait vérifier cette valeur à nouveau quand la requête ou le modèle change.
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 : le disjoncteur d'un processus est ouvert, et 12 tâches sont prêtes. Que leur arrive-t-il, et consomment-elles des tentatives?
Afficher la réponse
Le processus les prend, mais aucun appel n’est envoyé : le disjoncteur lève immédiatement BreakerOpen (disjoncteur ouvert). Le processus remet chaque tâche dans la file jusqu’à ce que le disjoncteur puisse se fermer, sans compter la tentative. Les tâches attendent donc sans perdre de tentatives. Après 30 secondes, un appel d’essai passe. Si le fournisseur est revenu, le disjoncteur se ferme et les tâches s’exécutent normalement. C’est pourquoi les 30 tâches de la démonstration de panne ont réussi.
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
Lesquels peuvent être relancés automatiquement, et pourquoi : un appel de classification au fournisseur; POST /v1/tickets sans Idempotency-Key; POST /v1/tickets avec cette clé?
Afficher la réponse
L’appel de classification : oui, quelques fois. L’exécuter deux fois coûte une deuxième réponse et ne change rien d’autre. POST /v1/tickets sans clé : non. Si la première requête a été enregistrée et que seule sa réponse a été perdue, une nouvelle tentative crée un deuxième billet et une deuxième tâche. Avec une Idempotency-Key (clé d’idempotence) : oui. L’API retourne le même billet et la même tâche, avec Idempotent-Replayed: true (requête idempotente rejouée). La règle est celle du module 4 : ne répétez que les opérations sans danger, et sécurisez les écritures avec une clé d’idempotence.
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
- Un délai maximal limite un appel. Fixez-le au-delà des appels normaux les plus lents, avec une marge (au plus 2 172 ms dans les observations). Le projet utilise 10 secondes plutôt que 30.
- Ne répétez que les opérations sans danger. Les appels au fournisseur sont sûrs; les écritures le sont seulement avec une clé d’idempotence. Le processus relance les tâches par la file d’attente. L’API fait une seule nouvelle tentative rapide, dans un budget de nouvelles tentatives de 10 % d’appels supplémentaires.
- Un disjoncteur s’ouvre après 5 échecs consécutifs (délais expirés ou réponses 5xx, pas 429). Il refuse immédiatement les appels pendant 30 secondes, puis laisse un appel d’essai décider. Dans l’API, un disjoncteur ouvert répondait
503 ai_unavailableavecRetry-Afteren environ 13 ms plutôt qu’en plusieurs centaines. - Lors d’une panne simulée de 20 secondes avec 30 tâches, le disjoncteur a réduit les appels au fournisseur de 150 à 8. Les 30 tâches ont ensuite réussi, au lieu de devenir 30 tâches en échec définitif.
- Réessayer jusqu’à ce que le fournisseur réponde transforme une panne en tempête d’appels et en accumulation de tâches en échec définitif.
Ensuite, vous décidez combien de processus exécuter et laissez la file vous indiquer quand en ajouter ou en retirer.
Leçon suivante : Signaux de mise à l'échelle