Contre-pression
- Leçon 13
- 50 min
- Module 4 : Files d'attente et travailleurs en arrière-plan
Où nous en sommes
Dans les deux dernières leçons, nous avons placé le travail d'IA dans une file d'attente et rendu chaque tâche sûre à exécuter deux fois. Mais une file d'attente sans limite déplace seulement l'attente : lors d'une pointe du Vendredi fou, elle accepte tout, et le dernier travail d'IA arrive avec des minutes de retard. Dans cette leçon, nous décidons combien de travail en attente accepter, et nous refusons le reste tout de suite avec un délai honnête, comme l'hôtesse d'un restaurant achalandé.
Leçon 13 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAContre-pression
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
Décidez combien de tâches en attente l’API accepte. Refusez immédiatement le reste, avec un délai réaliste avant une nouvelle tentative. Indiquez à chaque appelant accepté combien de temps le travail prendra.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- La file d’attente, le processus et
GET /v1/queue, vus dans Cycle de vie d’une tâche. - Pourquoi une tâche attend sans utiliser de tentative quand le fournisseur répond 429, vu dans Livraison et nouvelles tentatives.
- Un flux ouvert : des billets arrivent à leur propre rythme, peu importe ce que fait le service. Voir Modèle de charge de travail.
scripts/send_tickets.pyen envoie un.
Ce qu’il vous faut sur votre ordinateur
- Le projet à
end-of-m04:python -m pytestaffiche163 passed, 1 deselected. - PostgreSQL et Valkey en cours d’exécution, et le fournisseur simulé (
python -m simulator) dans son propre terminal.
Cette leçon n’ajoute aucun code. L’essai de surcharge est un court test de charge. Exécutez-le seulement sur les services de votre ordinateur. Fermez d’abord les autres programmes occupés. Le fournisseur est simulé; le quota est celui enregistré (100 requêtes de clavardage par minute). Les mesures viennent d’un ordinateur Apple M4 sans autre activité; vos résultats seront différents. Testé sur macOS (Apple silicon); les commandes Windows ne sont pas testées.
La liste d’attente d’un restaurant achalandé
Section intitulée « La liste d’attente d’un restaurant achalandé »Un samedi soir, un restaurant populaire n’a aucune table libre. L’hôtesse inscrit les noms des nouveaux clients sur une liste d’attente. Une table se libère environ toutes les cinq minutes. Quand la liste compte 12 noms, un nouveau client attendrait une heure.
Une bonne hôtesse fait deux choses. Quand la liste est trop longue, elle dit : « Nous sommes complets ce soir. Réessayez à 21 h. » Le client peut aller ailleurs ou revenir plus tard. Elle ne laisse pas non plus une personne inscrire 30 noms sur la liste. La liste a une limite globale et une limite plus petite par client.
Une mauvaise hôtesse inscrit tous les noms et sourit. À minuit, quarante personnes attendent encore, et chacune a reçu un « oui ».
Le problème : une file sans limite ne fait que déplacer l’attente
Section intitulée « Le problème : une file sans limite ne fait que déplacer l’attente »Les deux leçons précédentes ont rendu la file sûre : chaque billet accepté est enregistré, et chaque tâche s’exécute effectivement une seule fois. Regardons maintenant la même rafale que dans la première leçon : 10 billets par seconde pendant 30 secondes. Le quota enregistré et deux processus sont actifs.
Sans limite de file, l’API a accepté les 300 billets, et chaque réponse a pris environ 13 millisecondes. Cela semble parfait. Mais le quota ne laisse passer qu’environ 50 tâches par minute. Quand l’envoi a cessé, 225–230 tâches attendaient, et la plus ancienne attendait depuis 23.4 secondes. À 50 par minute, la dernière a reçu son brouillon de réponse environ cinq minutes plus tard.
Une rafale de trente secondes a créé cinq minutes de travail en attente. Le Vendredi fou d’Omar dure plusieurs heures. Sans limite, un client accepté à midi pourrait recevoir un brouillon de réponse le soir. L’API a dit « oui » à du travail qu’elle ne pouvait pas accomplir dans un délai utile. Cette promesse rompue était invisible : aucune erreur, aucune ligne de journal, seulement un nombre qui augmentait.
Il y a un deuxième problème. Un appelant dont le script fonctionne mal pourrait envoyer des milliers de billets et remplir la file. Tous les autres clients attendraient alors derrière lui.
L’idée : refuser tôt
Section intitulée « L’idée : refuser tôt »La contre-pression signifie qu’une partie pleine d’un système résiste à la partie qui l’alimente. Le travail ne s’accumule donc pas sans fin. Le nom vient des tuyaux : quand l’eau ne sort pas assez vite, la pression remonte vers la source. Dans une API, exercer une contre-pression signifie répondre « pas maintenant » tôt, à faible coût et honnêtement.
Le projet utilise deux limites :
- Une limite de file. Quand la file contient
QUEUE_MAXtâches, l’API répond503 queue_full(file pleine) et n’enregistre rien. Cette limite protège la promesse faite à tous les clients. - Une limite de débit par appelant. Un appelant peut envoyer au plus
RATE_LIMIT_PER_MINUTEnouveaux billets par minute (30). Le 31e reçoit429 rate_limited(débit limité). Cette limite empêche un appelant de remplir la file pour tout le monde.
Les deux codes ont des sens différents. 429 Too Many Requests (trop de requêtes) signifie : vous en avez envoyé trop. 503 Service Unavailable (service indisponible) signifie : le service est actuellement trop occupé pour tout le monde. Les deux réponses contiennent Retry-After (délai avant une nouvelle tentative). C’est le nombre de secondes après lequel une nouvelle tentative est raisonnable. Un bon client attend ce délai et ne réessaie pas immédiatement.
Voici un petit exemple où tous les nombres sont visibles. La limite est de 100. La file contient 100 tâches, et 50 tâches ont terminé dans la dernière minute. Le rythme est donc de 50 ÷ 60 = 0,83 tâche par seconde. Un nouveau billet arrive :
- La réponse :
503 queue_full; le billet n’est pas enregistré. - Retry-After : 100 tâches ÷ 0,83 tâche par seconde = 120 secondes. Le projet garde la valeur entre 1 et 300 secondes.
- La limite de débit : un client envoie son 31e billet 2 secondes après le début d’une minute. La réponse est
429, avec Retry-After 60 − 2 = 58 secondes, au début de la minute suivante.
Chaque vérification se fait avant que l’API enregistre quoi que ce soit, dans cet ordre :
Description textuelle du diagramme
Lisez à partir du haut. Les deux premières vérifications concernent l’appelant : trop de billets cette minute, ou une requête que l’API a déjà vue. La troisième concerne tout le monde : la file. Seule une requête qui passe les trois vérifications est enregistrée. Le billet et sa tâche sont alors enregistrés ensemble. Un refus n’enregistre rien. Un client refusé peut donc renvoyer le même billet plus tard sans créer de copie.
Larkfield : la limite de file et la limite de débit dans le code
Section intitulée « Larkfield : la limite de file et la limite de débit dans le code »La limite occupe trois lignes dans accept, à l’intérieur de la transaction qui enregistrerait le billet :
stats = jobs.stats(conn)if stats["queued"] >= settings.queue_max: wait = wait_estimate(stats, stats["queued"]) raise QueueFull(stats["queued"], min(300, max(1, math.ceil(wait or 30))))wait_estimate divise le nombre de tâches en attente par le nombre de tâches terminées dans la dernière minute. Si aucune tâche n’a terminé dans la dernière minute, aucun rythme ne permet la division. L’API indique alors 30 secondes.
La limite de débit se trouve dans ticket_api/ratelimit.py. Elle garde un compteur par appelant et par minute dans Valkey, le cache partagé du module 3. Tous les processus de l’API comptent donc ensemble. Si le cache ne répond pas, la limite est désactivée : le cache autorise les requêtes en cas de panne. Un problème de cache ne doit pas empêcher les clients d’envoyer des billets.
Ce que chaque conception a fait avec la même rafale
Section intitulée « Ce que chaque conception a fait avec la même rafale »Le cours a exécuté la rafale trois fois pour chaque conception : 300 billets, 10 par seconde, deux processus, le quota enregistré.
- enregistrés (202 ou 201)
- refusés tout de suite (503 queue_full, Retry-After)
- perdus (503 ai_busy après le refus du fournisseur)
Description textuelle du graphique
Trois barres horizontales de 300 billets chacune. Sans file, avec le travail d’IA pendant la requête : 55 enregistrés et 245 perdus, avec une réponse 503 ai_busy après le refus du fournisseur; leurs billets n’ont pas été enregistrés. Une file sans limite : les 300 billets enregistrés, aucun refusé, aucun perdu; mais 225–230 tâches attendaient quand l’envoi a cessé. Une file limitée à 100 : 172 enregistrés et 128 refusés immédiatement avec 503 queue_full et un Retry-After de 88–128 secondes; aucun perdu.
Ce que cela nous apprend. Aucune conception ne peut faire plus de travail d’IA que le quota le permet. Elles diffèrent par qui attend et qui reçoit une réponse honnête :
- Sans file : environ 245 clients ont perdu leurs billets. Le délai médian de réponse était d’environ 150 millisecondes, avec un p95 d’environ 2,5 secondes. Les réponses indiquaient
Retry-After: 1. Ce délai était beaucoup trop court pour un quota calculé sur une minute. - File sans limite : personne n’a été refusé. Mais le travail d’IA des derniers billets est arrivé environ cinq minutes plus tard, sans avertissement.
- File limitée à 100 : 172 clients ont été acceptés, et leur travail a commencé en environ deux minutes. 128 ont été refusés en environ 12 millisecondes, avec un Retry-After de 88–128 secondes. C’était un message honnête : « revenez dans environ deux minutes ». La file a atteint 107, et non 100; l’erreur courante ci-dessous explique pourquoi.
Explorer la file
Section intitulée « Explorer la file »L’explorateur rejoue la rafale avec d’autres nombres. Il est calculé à partir de rythmes mesurés, et non mesuré. Un processus exécute 4 tâches à la fois, et une tâche prend 2,2 secondes. Le quota enregistré permet de commencer 50 tâches à la fois, puis 50 par minute. Pour les deux configurations mesurées dans le cours, l’explorateur affiche les essais mesurés à côté de ses propres nombres.
Explorer
Une file sous une rafale de billets
Prédisez d’abord : Les billets arrivent à 10 par seconde pendant 30 secondes, et deux processus pourraient commencer 3,6 tâches par seconde. Après les 50 premières tâches, le quota permet de commencer seulement environ 0,83 tâche par seconde. Sans limite, combien de tâches attendent quand l'envoi cesse, et depuis combien de temps la plus ancienne attend-elle?
- Acceptés (202)
- 300 sur 300
- Refusés (503)
- 0
- File la plus longue
- 226 tâches
- Plus longue attente à 30 s
- 22,6 s
- File vide
- après 5 minutes
300 billets en 30 s. 2 travailleurs peuvent lancer environ 3,6 tâches/s; après les 50 premières tâches, le quota laisse démarrer seulement 0,83 tâches/s. Quand l’envoi s’arrête, 226 tâches attendent, la plus ancienne depuis 22,6 s. La dernière tâche est terminée après 5 minutes.
- tâches en attente
- attente de la plus ancienne tâche
- fin de l’envoi (30 s)
| Calculé | Mesuré | |
|---|---|---|
| Acceptés (202) | 300 | 300 |
| Refusés (503) | 0 | 0 |
| File la plus longue | 226 | 225–230 |
| Attente de la plus ancienne tâche quand l’envoi s’arrête | 22,6 s | 23,4 s |
| Retry-After | – | – |
Description textuelle de l’explorateur
La commande principale est le débit d’arrivée : de 2 à 12 billets par seconde, pendant 30 secondes. Trois autres commandes règlent les processus (1 à 4), la limite de file (aucune ou 100) et le quota du fournisseur (actif ou inactif). Deux graphiques linéaires montrent les tâches en attente et l’attente de la plus ancienne, de 0 à 120 secondes. Une ligne pointillée indique la fin de l’envoi. L’affichage indique les billets acceptés et refusés, la file la plus longue et l’attente la plus ancienne à 30 secondes. Il indique aussi quand la file redevient vide.
Au départ : 10 billets par seconde, 2 processus, aucune limite, quota actif. Les 50 premières tâches commencent rapidement; ensuite, seulement 0,83 par seconde peut commencer. Quand l’envoi cesse, 226 tâches attendent, et la plus ancienne attend depuis 22,6 secondes. La file se vide après environ 5 minutes. Les essais mesurés avaient de 225 à 230 tâches en attente et une attente maximale de 23,4 secondes.
Avec la limite active, 174 billets sont acceptés et 126 refusés, avec un Retry-After de 83 à 108 secondes. La file reste à 100 et se vide après environ 2,5 minutes. Les essais mesurés ont accepté de 172 à 173 billets et en ont refusé de 127 à 128. La file a atteint 107, et le Retry-After envoyé allait de 88 à 128 secondes.
Avec le quota actif, plus de processus ne changent presque rien : 4 processus donnent les mêmes 174 et 126. Sans quota, les processus comptent : à 10 billets par seconde, 2 processus laissent 188 tâches en attente à 30 secondes. Avec 4 processus, il en reste 77. À 2 billets par seconde, un processus suit le rythme, et au plus 6 tâches attendent.
Ce que cela nous apprend. Une file absorbe une rafale, mais elle ne peut pas accélérer le fournisseur. Quand le quota est la limite, les processus supplémentaires ne font que l’attendre. La limite de file détermine la durée maximale de l’attente. Avec 100 tâches à 50 par minute, un billet accepté attend au plus environ deux minutes. Choisissez la limite selon l’attente que vous pouvez promettre, pas selon l’espace dans la base de données.
Indiquer aux appelants combien de temps le travail prendra
Section intitulée « Indiquer aux appelants combien de temps le travail prendra »Une réponse 202 contient deux champs supplémentaires : queued_ahead, le nombre de tâches devant celle-ci, et estimated_wait_seconds, le délai avant son démarrage. Ce délai utilise le rythme de la dernière minute. L’écran du service de soutien peut indiquer « environ une minute » plutôt que seulement « accepté ».
Une estimation dépend de la qualité du rythme utilisé. Dans l’essai de l’auteur, un processus avait traité une rafale de 80 billets pendant 20 secondes. Un autre billet est alors arrivé :
{"ticket_id":"T-500081","job_id":81,"state":"queued","status_url":"/v1/jobs/81","queued_ahead":43,"estimated_wait_seconds":80.0}job 81 succeeded attempts 1 started after 23.6 s, finished after 25.6 sL’estimation indiquait 80 secondes. En fait, la tâche a commencé après 23,6 secondes. La « dernière minute » ne contenait que 20 secondes de travail. Le rythme semblait donc trois fois plus lent qu’il ne l’était. L’API a calculé (43 + 1) ÷ 33 tâches par minute = 80 secondes. Cela vient de la formule, pas de l’ordinateur. Le phénomène se produit donc sur tous les ordinateurs au début d’une rafale. L’estimation est trop élevée au début d’une rafale et plus juste ensuite. Une estimation trop élevée est l’erreur la plus sûre. Mais affichez-la comme une approximation, jamais comme une promesse.
Un autre choix : enregistrer le billet, sans travail d’IA
Section intitulée « Un autre choix : enregistrer le billet, sans travail d’IA »L’API de Larkfield refuse le billet entier quand la file est pleine. Omar n’aime pas cela : « Au Vendredi fou, le message d’un client compte plus que son brouillon de réponse. » Il a raison : une autre conception existe. Le cours la décrit, mais ne la construit pas.
Quand la file est pleine, l’API enregistre le billet sans tâche et répond 201. Une note indique qu’aucun travail d’IA n’est prévu. Le service de soutien voit tous les billets. Les gens les classent à la main, comme avant le travail d’IA. Plus tard, une petite tâche peut chercher les billets sans résultats d’IA. Elle peut les ajouter à la file quand celle-ci est de nouveau courte.
Le coût : le service de soutien perd son aide d’IA précisément quand il est le plus occupé. L’API a besoin d’une troisième réponse, en plus de « en file » et « refusé ». L’écran du service de soutien doit l’afficher. La tâche de rattrapage ajoute aussi du code à tester. Les deux conceptions sont honnêtes; elles protègent des choses différentes. Le cours garde le 503 pour que la limite reste facile à voir et à mesurer.
Exercice guidé : la rafale avec une limite
Section intitulée « Exercice guidé : la rafale avec une limite »Exécutez la rafale mesurée sur votre ordinateur, avec une limite de 100 et deux processus.
-
Arrêtez l’API (Ctrl+C) et tout processus en cours. Rechargez les données :
python -m scripts.load --reset. -
Redémarrez le fournisseur simulé (Ctrl+C, puis
python -m simulator) pour rétablir son quota complet. -
Démarrez l’API avec une limite de 100. Désactivez la limite de débit, comme dans les essais mesurés. Ainsi, seule la limite de file refuse des billets :
Fenêtre de terminal QUEUE_MAX=100 RATE_LIMIT_PER_MINUTE=0 fastapi runFenêtre de terminal $env:QUEUE_MAX = "100"; $env:RATE_LIMIT_PER_MINUTE = "0"; fastapi run -
Démarrez deux processus, chacun dans son terminal :
python -m ticket_api.worker --name worker-1etpython -m ticket_api.worker --name worker-2. -
Dans un autre terminal, commencez à surveiller la file :
python -m scripts.queue_watch --seconds 40 --every 5. -
Dans le dernier terminal, envoyez la rafale :
python -m scripts.send_tickets --rate 10 --seconds 30. -
Quand la surveillance cesse, arrêtez les processus et l’API avec Ctrl+C. Dans PowerShell, exécutez aussi
Remove-Item Env:QUEUE_MAX, Env:RATE_LIMIT_PER_MINUTE.
Afficher le résultat attendu
L’essai de l’auteur, sur un ordinateur occupé (vos nombres seront différents) :
Sent 300 tickets at 10 per second in 29.9 s: status codes {202: 172, 503: 128}Retry-After values: {'87': 2, '89': 7, '90': 6, '91': 16, '92': 5, '93': 8, '94': 20, '95': 1, '96': 21, '97': 9, '98': 9, '99': 2, '100': 6, '106': 6, '108': 4, '110': 4, '112': 1, '123': 1}Answer time: median 14 ms, p95 24 ms
time queued ready running oldest s done/min dead 0 0 0 0 0.0 0 0 5 24 24 8 2.4 8 0 10 56 56 8 5.6 26 0 15 87 87 8 8.6 46 0 20 100 74 8 12.6 63 0 25 105 0 2 17.6 65 0 30 102 0 2 22.6 68 0 35 96 0 2 27.6 74 0Les essais mesurés sur un ordinateur sans autre activité ont donné 172–173 acceptés, 127–128 refusés et Retry-After 88–128 secondes. Regardez la colonne ready (prêt). À partir de 25 secondes, presque aucune tâche en file n’est prête. Elles attendent toutes le quota, comme l’expliquait la leçon précédente. dead (abandonné) reste à 0.
Essayez ensuite la limite de débit avec les réglages normaux. Relancez fastapi dev et envoyez 31 billets d’un même client dans la même minute. La boucle affiche seulement les codes d’état; la dernière commande montre la réponse complète :
for i in $(seq 1 30); do curl -s -o /dev/null -w "%{http_code} " -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" -d "{\"customer_id\": \"C-0022\", \"subject\": \"Test $i\", \"body\": \"Rate limit test.\"}"; donecurl -s -i -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" -d '{"customer_id": "C-0022", "subject": "One more", "body": "Rate limit test."}'Dans PowerShell, écrivez curl.exe et envoyez les requêtes une par une (commandes rédigées, mais non testées). La boucle affiche 202 30 fois, ou moins si C-0022 a envoyé des billets plus tôt dans cette minute. Le 31e reçoit :
HTTP/1.1 429 Too Many Requestsretry-after: 58{"error":{"code":"rate_limited","message":"More than 30 new tickets in one minute. Try again in 58 seconds.",…}}Votre retry-after dépend de la seconde de la minute où vous l’envoyez.
À vous de jouer : deux fois plus de processus
Section intitulée « À vous de jouer : deux fois plus de processus »Faites d’abord une prédiction. Exécutez la même rafale avec quatre processus au lieu de deux. Est-ce que plus de billets sont acceptés? Essayez d’abord dans l’explorateur, puis sur votre ordinateur : démarrez deux processus supplémentaires à l’étape 4.
Afficher la réponse
Presque rien ne change. L’essai de l’auteur avec quatre processus : {202: 168, 503: 132}, Retry-After de 96 à 117 secondes. La file est encore à environ 100 à partir de 20 secondes. L’explorateur calcule 174 et 126 pour deux comme pour quatre processus. Le quota, et non les processus, fixe le rythme. Quatre processus commencent les 50 premières tâches un peu plus tôt, puis tous attendent le quota. C’est l’idée de Tomás, « ajouter plus de processus », au mauvais moment. Plus de processus aident seulement quand ils sont le goulot d’étranglement, comme le montre l’explorateur sans quota.
Une limite qui n’est pas exacte
Section intitulée « Une limite qui n’est pas exacte »Erreur courante
QUEUE_MAX vaut 100, mais la file contient 107 tâches
Symptôme (mesuré) : avec QUEUE_MAX=100, la file a atteint un maximum de 107 tâches dans les trois essais mesurés. Dans l’essai de l’auteur, elle en contenait 105.
Cause : la vérification et l’insertion sont deux étapes. La requête A compte 99 tâches en attente, donc elle peut en insérer une. Au même moment, la requête B en compte aussi 99. Les deux insèrent une tâche, et la file en contient 101. FastAPI traite plusieurs requêtes à la fois. Avec plusieurs processus d’API, encore plus de requêtes peuvent passer la vérification ensemble. C’est une condition de concurrence : le résultat dépend de la requête qui s’exécute en premier.
Diagnostic : comparez le maximum dans scripts.queue_watch avec QUEUE_MAX. Quelques tâches au-delà de la limite sous charge indiquent une condition de concurrence. Une file largement au-delà de la limite indique que celle-ci n’est pas définie : vérifiez QUEUE_MAX dans l’environnement de l’API.
Corrigez le problème, ou acceptez-le :
- Si la limite protège une promesse (« au plus environ deux minutes »), 7 tâches supplémentaires ne changent rien. Traitez
QUEUE_MAXcomme une limite souple, et documentez ce choix. - Si la limite doit être exacte, faites de la vérification et de l’insertion une seule étape pour tout le monde. Par exemple, prenez un verrou consultatif PostgreSQL (
pg_advisory_xact_lock) dansacceptavant le comptage. En contrepartie, le système enregistre alors les nouveaux billets un à la fois.
Quand utiliser la contre-pression, et ce qu’elle coûte
Section intitulée « Quand utiliser la contre-pression, et ce qu’elle coûte »Limitez chaque file qu’une requête client remplit. Choisissez la limite selon l’attente maximale que vous pouvez promettre. Ajoutez une limite de débit par appelant quand plusieurs appelants partagent une file, pour empêcher un seul de la remplir. Joignez un Retry-After (délai avant une nouvelle tentative) à chaque refus. Ce délai doit être honnête : le projet le calcule à partir du rythme réel.
Ne fixez pas une limite si basse qu’elle entraîne des refus de billets pendant les journées normales. L’heure normale la plus chargée de Larkfield compte 101 billets : moins de deux par minute, bien en dessous du quota. Et ne remplacez pas la limite de la file par une limite de débit. Même en respectant leurs limites, 40 clients peuvent remplir la file ensemble.
Ces coûts sont réels. Le service refuse certains clients, et le client logiciel doit gérer 429 et 503, puis réessayer plus tard. Quelqu’un doit choisir ces limites, les mesurer et les modifier quand le quota change. De plus, un billet refusé est un message que le service de soutien n’a pas encore vu. C’est pourquoi Omar a prévu une autre conception.
Vérification du module
Section intitulée « Vérification du module »Ce module a déplacé le travail d’IA de la requête vers une file d’attente. Vous pouvez maintenant :
- Enregistrer un billet et sa tâche dans une seule transaction, répondre
202et suivre les états de la tâche (Cycle de vie d’une tâche). - Faire en sorte qu’une requête répétée et une livraison répétée produisent un seul effet prévu. Réessayer avec un délai d’attente croissant, de la gigue et un message non distribuable (Livraison et nouvelles tentatives, avec la vérification de fin de module).
- Limiter la file, refuser tôt avec
503ou429etRetry-After, et indiquer aux appelants leur temps d’attente (cette leçon).
Avant de continuer, vérifiez que python -m pytest affiche toujours 163 passed, 1 deselected (163 tests réussis, 1 désélectionné). Puis redémarrez l’API sans QUEUE_MAX ni RATE_LIMIT_PER_MINUTE pour appliquer les valeurs par défaut (500 et 30).
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
La file sans limite a accepté les 300 billets en environ 13 ms chacun. Pourquoi n'est-ce pas un bon résultat?
Afficher la réponse
L’acceptation était rapide, mais pas le travail. Le quota laisse passer environ 50 tâches par minute. Après 30 secondes, environ 225 à 230 tâches attendaient. La dernière a reçu son traitement d’IA environ cinq minutes plus tard. Chaque client a reçu la réponse « accepté », sans aucune indication de l’attente. Avec une rafale plus longue, l’attente augmente sans fin. Une limite maintient l’attente dans ce que le service de soutien peut promettre. Elle indique honnêtement aux autres de revenir plus tard.
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 script d'un client envoie 200 billets en une minute. Quelle réponse reçoit-il, 429 ou 503, et pourquoi cette différence compte-t-elle pour les autres clients?
Afficher la réponse
Après 30 billets pendant cette minute, il reçoit 429 rate_limited (débit limité), avec Retry-After jusqu’à la minute suivante. Un code 429 indique que cet appelant a trop envoyé de requêtes. Les autres clients ne sont pas touchés et reçoivent toujours 202. Sans limite par appelant, les billets du script rempliraient la file. Tous les clients recevraient alors 503 queue_full (file pleine), qui indique que le service est trop occupé pour tout le monde. La limite de débit empêche le problème d’un appelant de devenir celui de tous.
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 avec les chiffres : la limite est de 100, la file est pleine et 25 tâches ont terminé dans la dernière minute. Quel Retry-After un nouveau billet reçoit-il? Sans quota et avec quatre processus, attendriez-vous un nombre plus grand ou plus petit?
Afficher la réponse
Le rythme est de 25 ÷ 60 = 0,42 tâche par seconde. Donc, 100 ÷ 0,42 = 240 secondes, dans la limite de 1 à 300 : Retry-After: 240. Sans quota, quatre processus terminent environ 7 tâches par seconde. La dernière minute montrerait beaucoup plus de tâches terminées et un Retry-After beaucoup plus court. 100 ÷ 7,3 donne environ 14 secondes. Retry-After suit le rythme réel : il indique donc un délai plus long aux appelants quand le service est lent.
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 file sans limite ne fait que déplacer l’attente : 300 billets acceptés, 225–230 en attente après 30 secondes, le dernier traitement d’IA environ cinq minutes plus tard.
- La contre-pression refuse tôt :
503 queue_fullquand la file contientQUEUE_MAXtâches,429 rate_limitedquand un appelant dépasse 30 envois par minute. Dans les deux cas, le service n’enregistre rien et envoieRetry-After. - Retry-After = tâches en attente ÷ rythme de la dernière minute (1 à 300 s). Avec une limite de 100 : 172–173 acceptés, 127–128 refusés avec 88–128 secondes, aucun perdu; sans file, environ 245 billets ont été perdus.
- Quand le quota impose la limite, ajouter des processus n’aide pas. L’explorateur calcule 174 acceptations avec 2 ou 4 processus, et l’essai de l’auteur avec 4 processus en a donné 168.
- La réponse
202contientqueued_ahead(tâches devant la vôtre) etestimated_wait_seconds(attente estimée en secondes). Au début d’une rafale, l’estimation est trop élevée (80 s annoncées, 23,6 s réelles). Présentez-la avec « environ ». - Une autre conception enregistre le billet sans traitement d’IA quand la file est pleine. Elle conserve chaque message, mais perd l’aide de l’IA au moment où elle est le plus nécessaire.
Leçon suivante : Contenir les défaillances