Trouver le goulot d'étranglement
- Leçon 4
- 50 min
- Module 1 : Mesurer avant de mettre à l'échelle
Où nous en sommes
Dans la leçon précédente, nous avons noté une référence de base : un utilisateur donnait 0,43 billet par seconde, et deux utilisateurs l'ont presque doublé. Mais quatre utilisateurs ne l'ont pas doublé de nouveau, et nous ne savons pas encore pourquoi. Changer la mauvaise partie n'aide en rien. Dans cette leçon, nous décomposons les 2,2 secondes d'un billet et nous vérifions chaque ressource, pour trouver la partie qui limite tout le reste, comme le goulot d'une bouteille.
Leçon 4 sur 19 · Mettre à l'échelle les API et les charges de travail d'IATrouver le goulot d'étranglement
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écomposez les 2,2 secondes d’un billet de soutien et vérifiez chaque ressource qui pourrait limiter le service. Trouvez ce qui a empêché quatre utilisateurs de doubler le débit. Vous saurez alors quel changement peut aider avant le Vendredi fou, et lequel ne le peut pas.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les percentiles, la loi de Little, les files d’attente et la référence de base, dans Latence et capacité.
- Les transactions et le pool de connexions (pool), dans Gestion des connexions.
Ce qu’il vous faut sur votre ordinateur
- Votre projet de la dernière leçon :
python -m pytestaffiche128 passed(128 tests réussis). Le petit jeu de données est chargé. - PostgreSQL et Azurite en cours d’exécution. Vous démarrez le simulateur et l’API dans l’exercice guidé.
Le goulot étroit d’une bouteille
Section intitulée « Le goulot étroit d’une bouteille »Retournez une bouteille pleine. L’eau ne sort pas à un débit proportionnel à la largeur de la bouteille. Son débit dépend du goulot. Une bouteille plus large avec le même goulot ne se vide pas plus vite.
Une autoroute fonctionne de la même façon. Quatre voies se réduisent à une seule dans une zone de travaux. Toute la circulation avance maintenant à la vitesse de cette seule voie. Ajouter une cinquième voie avant les travaux ne change rien.
La partie étroite est le goulot d’étranglement : la seule partie qui limite tout le système. Tout travail sur une autre partie est inutile tant que le goulot d’étranglement ne change pas.
Le problème : corriger la mauvaise partie
Section intitulée « Le problème : corriger la mauvaise partie »Dans la dernière leçon, quatre utilisateurs n’ont pas doublé le débit de deux utilisateurs. Tomás propose déjà une solution : « L’API est trop lente. Donnons-lui un ordinateur plus puissant avec plus de processeurs. »
Amira vérifie d’abord un chiffre. Pendant la mesure de référence avec quatre utilisateurs, le processus de l’API utilisait 2,2 % d’un processeur. Avec un utilisateur, il en utilisait 0,6 %. L’API ne fait pas de calculs : elle attend. Un ordinateur avec deux fois plus de processeurs attendrait aussi longtemps et coûterait deux fois plus cher.
C’est l’erreur la plus courante dans la mise à l’échelle : modifier une partie qui n’est pas le goulot d’étranglement. Cela coûte de l’argent et du temps, et la mesure suivante ne montre aucun changement. Trouvez d’abord le goulot d’étranglement, avec deux questions :
- Où une requête passe-t-elle son temps? Cela révèle ce qui ralentit chaque requête.
- Quelle ressource atteint sa limite quand beaucoup de requêtes arrivent? Cela révèle ce qui limite le débit.
Les deux réponses peuvent être différentes. Une partie peut être lente sans être saturée, et une partie peut être rapide mais avoir une limite stricte.
L’idée : décomposer le temps, puis vérifier les ressources
Section intitulée « L’idée : décomposer le temps, puis vérifier les ressources »Pour répondre à la première question, l’API se mesure elle-même. ticket_api/timing.py contient un petit chronomètre. Le code l’utilise autour de chaque partie de la requête. L’API renvoie ensuite les durées dans un en-tête de réponse standard, Server-Timing :
server-timing: db;dur=10.3, classify;dur=787.0, draft_reply;dur=1167.7, embed;dur=222.6Vous avez vu cet en-tête dans la leçon de mise en place. Les navigateurs l’affichent dans leurs outils de développement. scripts.breakdown envoie des billets, lit l’en-tête de chaque réponse et calcule la médiane de chaque partie. Tout ce que l’en-tête ne couvre pas va dans « other » (autre) : le cadriciel web, le JSON et le réseau entre le script et l’API.
Pour répondre à la deuxième question, vérifiez chaque ressource utilisée par une requête : processeur, mémoire, réseau, base de données et fournisseur. Pour chacune, demandez-vous si elle approche d’une limite.
Un petit exemple : un billet en cinq parties
Section intitulée « Un petit exemple : un billet en cinq parties »L’équipe du cours a envoyé 10 billets, un à la fois, sur un ordinateur peu sollicité, avec le fournisseur simulé. Voici les médianes des parties :
| Partie | Médiane en ms | Part du total |
|---|---|---|
| db | 9,5 | 0 % |
| classify | 914,5 | 43 % |
| draft_reply | 946,9 | 44 % |
| embed | 249,9 | 12 % |
| other | 7,6 | 0 % |
| total | 2 146,6 |
Les trois appels au fournisseur prennent ensemble 2 111 ms sur les 2 147 ms. Le travail de la base de données, environ 10 ms, représente moins d’un demi pour cent. La somme des médianes des parties ne correspond pas exactement à la médiane totale. Chaque médiane provient d’un billet différent. Elles sont assez proches pour montrer où passe le temps.
Description textuelle du graphique
Médiane en millisecondes par partie d’un nouveau billet : db 9,5, classify 914,5, rédaction d’une réponse 946,9, plongement 249,9, autre 7,6. La médiane totale est de 2 146,6 ms. Les trois appels au fournisseur en prennent environ 98 %.
Ce que cela nous apprend. Pour accélérer le traitement d’un billet, seuls les appels au fournisseur comptent. Une base de données plus rapide pourrait économiser au plus 10 ms par billet. Un code Python plus rapide en économiserait moins. Seules trois options pourraient accélérer les appels : un fournisseur plus rapide, moins d’appels ou des appels simultanés plutôt que successifs.
Les ressources de Larkfield, une à une
Section intitulée « Les ressources de Larkfield, une à une »La décomposition répond à la première question. Maintenant, la deuxième : qu’est-ce qui atteint sa limite quand beaucoup de billets arrivent? Passez les ressources en revue dans l’ordre. Pour chacune, les preuves viennent d’une mesure, pas d’une supposition.
- Processeur. L’API utilisait 0,6 % d’un processeur avec un utilisateur et 2,2 % avec quatre, pendant les essais de référence. Ce n’est pas la limite. Pour un autre service, comme celui qui exécute un modèle sur son propre processeur, cela pourrait être la première limite.
- Mémoire. Lors de l’essai de l’auteur, le processus de l’API utilisait environ 51 Mo après un premier test de charge. Il utilisait encore 51 Mo après un deuxième test. L’utilisation n’augmentait pas d’un test à l’autre. Ce n’est pas la limite.
- Réseau. La partie « other », de 7,6 ms, comprend le réseau entre le script et l’API sur le même ordinateur. Ce n’est pas la limite ici. Entre de vrais centres de données, le réseau ajoute des dizaines de millisecondes.
- Travail de la base de données. Environ 10 ms par billet. Ce n’est pas la limite pour le temps. Mais regardez encore le schéma de requête de la leçon de mise en place. La transaction garde sa connexion pendant les 2,1 secondes, en attendant le fournisseur. Le pool compte 10 connexions. Le module 2 mesure ce qui arrive avec plus de 10 billets à la fois.
- Temps du fournisseur. 98 % du temps de chaque billet. C’est la limite pour la latence d’un billet.
- Quota du fournisseur. 100 appels de clavardage par minute pour tout le compte. Chaque billet en nécessite 2. Le compte peut donc terminer au plus 0,83 billet par seconde. Quatre utilisateurs en demandent davantage, comme le montre la prochaine section.
Description textuelle du diagramme
Un billet prend 2 147 ms à la médiane. Six ressources pourraient le limiter. Le processeur de l’API (de 0,6 à 2,2 %), sa mémoire (environ 51 Mo, stable) et le réseau (7,6 ms) sont loin de toute limite. Le travail de la base de données est court, 9,5 ms. Mais chaque billet garde une connexion pendant les 2,1 secondes. Le temps du fournisseur représente 98 % du temps d’un billet : il limite la latence. Le quota du fournisseur, 100 appels de clavardage par minute, limite le débit. Avec quatre utilisateurs, le fournisseur a refusé entre 41 et 115 appels par essai. Le pool de la base de données et le quota limitent la prochaine conception.
Le quota sous charge
Section intitulée « Le quota sous charge »Observez maintenant vous-même le deuxième goulot d’étranglement.
-
Dans
~/projects/ticket-api, avec l’environnement virtuel actif, copiez le script de cette leçon depuis l’instantanéend-of-m01. Votre projet correspond alors à l’instantané.Fenêtre de terminal cp ../nextia-learning-labs/C21/snapshots/end-of-m01/scripts/breakdown.py scripts/Fenêtre de terminal Copy-Item ..\nextia-learning-labs\C21\snapshots\end-of-m01\scripts\breakdown.py scripts\ -
Démarrez un nouveau simulateur dans le terminal 1 (
python -m simulator) et l’API dans le terminal 2 (fastapi run). Un nouveau simulateur a un quota complet et compte à partir de zéro. -
Dans le terminal 3, décomposez 10 billets, un à la fois :
Fenêtre de terminal python -m scripts.breakdown --tickets 10L’essai du cours sur un ordinateur peu sollicité a affiché le tableau du petit exemple, puis cette ligne. Vos temps seront différents :
Provider (simulated): 30 calls, 0 refused with 429, at most 1 at the same time -
Décomposez de nouveau 10 billets, quatre à la fois :
Fenêtre de terminal python -m scripts.breakdown --tickets 10 --concurrency 4Les parties restent à peu près identiques, car le simulateur ne ralentit pas quand les appels se chevauchent. L’essai de l’auteur avec ces 10 billets, quatre à la fois, a donné une médiane totale de 2 260 ms. Il a aussi affiché
at most 4 at the same time(au plus 4 en même temps). Le vrai fournisseur serait un peu plus lent ici. -
Envoyez maintenant une charge avec quatre utilisateurs pendant 60 secondes :
Fenêtre de terminal locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 4 -r 4 -t 60s -
Quand Locust s’arrête, demandez au simulateur ce qu’il a compté :
curl http://127.0.0.1:8300/admin/stats.
L’essai de l’auteur aux étapes 5 et 6 a affiché ceci, limité au tableau final et au rapport d’erreurs. Vos chiffres seront différents :
Type Name # reqs # fails | Avg Min Max Med | req/s failures/s--------|---------------------|-------|-------------|-------|-------|-------|-------|--------|-----------POST POST /v1/tickets 158 62(39.24%) | 1511 139 3080 2100 | 2.64 1.03
Error report# occurrences Error------------------|-----------------------------------62 POST POST /v1/tickets: 503{"mode":"normal","in_flight":1,"max_in_flight":4,"calls":{"classify":{"200":102,"429":58},"draft_reply":{"200":96,"429":6},"embed":{"200":96}},"tokens":41314,"simulated":true}62 des 158 billets ont échoué avec le statut 503. Locust indique req/s 2.64 (2,64 requêtes par seconde), mais ce chiffre comprend les échecs. Seuls 96 billets ont été enregistrés : 96 appels de plongement, un par billet enregistré. Le temps Min 139 ms (minimum de 139 ms) correspond à une requête échouée : un refus revient vite. L’équipe du cours a mesuré le même test cinq fois sur un ordinateur peu sollicité. Le fournisseur a refusé entre 41 et 115 appels par essai. Entre 41 et 115 clients par essai ont reçu un statut 503.
Regardez les six réponses rédigées qui ont été refusées. Chacun de ces billets avait déjà payé un appel de classification, mais a quand même échoué. Un refus peut gaspiller du travail déjà fait.
À quoi ressemble un refus
Section intitulée « À quoi ressemble un refus »Quand le quota est épuisé, le simulateur répond comme le vrai fournisseur. L’essai de l’auteur a capté cette réponse après une rafale de 110 appels simultanés :
HTTP/1.1 429 Too Many Requestsretry-after: 30retry-after-ms: 266x-simulated: true
{"error":{"code":"rate_limit_exceeded","type":"too_many_requests","message":"Your requests to chat-small have exceeded the request rate limit (simulated)."}}Le statut 429 Too Many Requests signifie « limite dépassée, réessayez plus tard ». Une limite de ce type, un nombre de requêtes par fenêtre de temps, est une limite de débit. La réponse donne deux indications sur le moment où réessayer, mais elles se contredisent. Retry-After: 30 indique 30 secondes. retry-after-ms: 266 indique 266 millisecondes. Le vrai fournisseur a aussi envoyé les deux : Retry-After était toujours 30, et retry-after-ms variait de 12 à quelques centaines. Le client du projet lit retry-after-ms en premier, comme la bibliothèque Python du fournisseur, car cette valeur est plus précise.
L’API transforme le refus en sa propre réponse au client :
HTTP/1.1 503 Service Unavailableretry-after: 1server-timing: db;dur=4.4, classify;dur=133.2
{"error":{"code":"ai_busy","message":"The AI provider is busy. Try again in 1 second.","request_id":"4badc55650e3","fields":[]}}La partie de classification a pris 133 ms : le refus lui-même. La transaction a été annulée, donc le billet n’a pas été enregistré. Le Vendredi fou, ce client voit une erreur et le service de soutien ne voit jamais le billet. C’est un billet perdu, pas seulement un billet lent.
Ce que le vrai fournisseur a fait
Section intitulée « Ce que le vrai fournisseur a fait »L’équipe du cours a observé le même comportement avec le vrai fournisseur. Avec 16 appels en cours, 114 appels de clavardage ont réussi en environ 8 secondes, puis le fournisseur a répondu 429. Vingt secondes plus tard, seuls 34 appels d’une rafale de 160 ont réussi. La limite compte donc les appels d’environ la dernière minute. Une rafale peut épuiser le quota d’une minute en quelques secondes, puis elle doit attendre. Voilà pourquoi le quota limite le débit, pas la vitesse : 100 appels par minute, peu importe la vitesse d’envoi.
Quatre utilisateurs ont besoin d’environ 1,7 billet par seconde. Cela représente environ 3,4 appels de clavardage par seconde, ou 206 par minute. Le quota en accorde 100. Sous charge, le goulot d’étranglement est le quota.
Quand chercher le goulot d’étranglement
Section intitulée « Quand chercher le goulot d’étranglement »Cherchez-le avant chaque changement visant à rendre le service plus rapide ou à augmenter sa capacité. Décomposez le temps et vérifiez chaque ressource avec une mesure. Modifiez ensuite seulement le goulot d’étranglement et mesurez de nouveau, car il se déplace. Quand le quota ne sera plus la limite, le pool de la base de données pourrait devenir la suivante.
Ne vous fiez pas à un seul signe. Une utilisation élevée du processeur peut venir d’un autre programme sur le même ordinateur. Une longue partie « db » peut être l’attente d’une connexion libre, pas du SQL lent. Vérifiez les preuves des deux côtés : les parties de la requête et l’utilisation de la ressource.
Les outils ont aussi un coût. Un chronomètre autour de chaque partie ajoute un peu de code à chaque requête. L’en-tête Server-Timing révèle aussi à chaque client le fonctionnement interne de votre service, par exemple les appels à un fournisseur d’IA. Dans un vrai service, envoyez-le seulement à votre personnel ou retirez-le à la frontière de votre réseau.
Tomás a une dernière idée : « Alors, exécutons quatre copies de l’API. Quatre fois le débit! » Sam pose la bonne question : « Chaque copie a son propre quota? » Non. Le quota appartient au compte. Quatre copies partageraient les mêmes 100 appels par minute et atteindraient seulement la limite plus vite. Le module 2 exécute quand même plusieurs copies et montre ce qu’elles peuvent changer ou non.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
La décomposition indique « at most 4 at the same time » pour un billet à la fois
Symptôme : vous exécutez python -m scripts.breakdown --tickets 10, un billet à la fois, et la dernière ligne indique at most 4 at the same time.
Cause : le simulateur compte le maximum d’appels en cours depuis son démarrage, pas pendant cet essai. Un test précédent avec quatre utilisateurs l’a fixé à 4. L’essai de l’auteur a montré exactement cela.
Solution : redémarrez le simulateur avant chaque mesure ou remettez ses compteurs à zéro :
curl -X POST http://127.0.0.1:8300/admin/resetSur Windows, tapez curl.exe plutôt que curl. Une remise à zéro remplit aussi le quota et rétablit le mode normal.
Erreur courante
Le nombre req/s de Locust semble bon, mais des billets sont perdus
Symptôme : avec plus d’utilisateurs, le nombre req/s de Locust augmente, par exemple à 2,64. Mais la colonne # fails (nombre d’échecs) n’est pas à zéro.
Cause : le nombre req/s de Locust compte chaque réponse, y compris les réponses 503 rapides. Une requête échouée n’est pas du travail utile.
Diagnostic : lisez # fails et le rapport d’erreurs. Comptez les billets enregistrés : un appel de plongement par billet enregistré dans /admin/stats. Vous pouvez aussi utiliser scripts.percentiles sur un fichier SAMPLES_CSV, qui compte seulement les réponses 2xx.
Solution : indiquez les requêtes réussies par seconde. Dans l’essai de l’auteur, c’était 96 billets en 60 secondes, pas 158.
À vous : un quota plus petit
Section intitulée « À vous : un quota plus petit »Changez une condition : le quota. Le simulateur a un mode quota avec un quota dix fois plus petit, soit 10 appels de clavardage par minute. Il est inventé pour l’exercice. Arrêtez le simulateur, démarrez-le avec python -m simulator --mode quota, puis prédisez ce qu’affichera python -m scripts.breakdown --tickets 10. Combien de billets réussissent, et la décomposition de ceux qui réussissent change-t-elle?
Afficher la réponse
Le quota permet environ 10 appels de clavardage. Environ 5 billets obtiennent donc leurs deux appels, et les autres reçoivent un statut 503. Les billets réussis ressemblent à ceux d’avant : le quota détermine combien réussissent, pas la vitesse de chacun. L’essai de l’auteur a affiché :
10 tickets, 1 at a time: status codes {201: 5, 503: 5}part median ms sharedb 23.7 1%classify 913.4 42%draft_reply 955.1 44%embed 223.7 10%other 7.5 0%total 2179.0Provider (simulated): 22 calls, 5 refused with 429, at most 1 at the same timeLe simulateur a compté 7 appels de classification réussis et seulement 5 billets enregistrés. Deux billets ont payé la classification, puis le quota a empêché la rédaction de leur réponse. Redémarrez le simulateur sans --mode quota quand vous avez terminé.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Tomás dit : « L'API est lente, alors il nous faut un ordinateur plus puissant. » Répondez-lui avec deux mesures de ce module.
Afficher la réponse
Les trois appels au fournisseur prennent environ 2 111 ms sur les 2 147 ms d’un billet (98 %). La base de données et le reste prennent environ 17 ms. L’utilisation du processeur de l’API était seulement de 0,6 à 2,2 % dans la référence de base. L’API attend, elle ne calcule pas. Un ordinateur plus puissant attendrait donc aussi longtemps. Sous charge, le quota du fournisseur est la limite (100 appels de clavardage par minute). Avec 4 utilisateurs, il a refusé de 41 à 115 appels par passage. Aucune de ces limites ne dépend de la puissance de l’ordinateur de l’API.
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 quota passe à 1 000 appels de clavardage par minute, sans autre changement. Que deviennent la latence d'un billet et le débit avec 4 utilisateurs?
Afficher la réponse
La latence d’un billet ne change pas : environ 2,2 secondes, car le quota ne rend pas un appel plus rapide. Le débit avec 4 utilisateurs monte à environ 4 ÷ 2,3 = 1,7 billet par seconde. Cela représente environ 206 appels de clavardage par minute, bien en dessous du nouveau quota. Il n’y a donc aucun code 503. Le quota cesse d’être le goulot d’étranglement. La limite suivante apparaît alors. Par exemple, le pool de connexions (pool) de la base de données en contient 10. Il devient une limite quand plus de 10 billets attendent en même temps.
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
Vérification de fin de module : choisissez trois nombres de ce module (par exemple, la référence avec 1 utilisateur, la répartition et l'essai avec 4 utilisateurs). Pour chacun, précisez la charge de travail et le matériel utilisés.
Afficher la réponse
Par exemple. La référence de base, 0,43 billet par seconde et un p95 de 2 995 ms : protocole du module 1, loadtest/locustfile.py, 1 utilisateur, aucune pause, 60 secondes, période de démarrage de 10 secondes exclue, 5 passages (médiane); peu de données; fournisseur simulé avec le quota consigné; Apple M4, 10 cœurs, 16 Go, charge inférieure à 3. La répartition, où les appels au fournisseur prennent 98 % des 2 147 ms : scripts.breakdown, 10 billets traités un à la fois, fournisseur simulé, même ordinateur peu sollicité. L’essai avec 4 utilisateurs, de 41 à 115 appels refusés par passage : même fichier locustfile avec 4 utilisateurs, même ordinateur, 5 passages, quota activé. Vos propres nombres doivent préciser votre ordinateur, votre charge moyenne et votre nombre de passages. Aucun de ces nombres ne représente une capacité en production.
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
- Le goulot d’étranglement est la partie qui limite tout le système. Modifier une autre partie n’améliore rien.
- Répartissez le temps avec Server-Timing et
scripts.breakdown: le fournisseur prend environ 98 % des 2,1 à 2,2 secondes d’un billet; la base de données, environ 10 ms. - Vérifiez chaque ressource avec une mesure : processeur de 0,6 à 2,2 %, mémoire stable, réseau de quelques millisecondes. Le quota du fournisseur de 100 appels de clavardage par minute limite le débit à 0,83 billet par seconde.
- Au-delà du quota, le fournisseur répond 429 avec deux indications :
Retry-After: 30(réessayer après 30 secondes) etretry-after-ms(délai avant une nouvelle tentative en millisecondes), beaucoup plus court. L’API répond 503ai_busy(IA occupée), et le billet est perdu. - Le travail de la base de données est court, mais chaque billet garde une connexion pendant toute l’attente. C’est la prochaine limite à surveiller.
Le module 1 en un paragraphe. Vous exécutez la charge de travail d’IA sur votre ordinateur. Un fournisseur simulé reproduit les durées et le quota réels. Vous décrivez le Vendredi fou comme une charge de travail : 0,28 billet par seconde pendant l’heure la plus chargée, 90 billets pendant la minute la plus chargée. Vous consignez une référence de base avec sa charge de travail et son ordinateur : 0,43 billet par seconde, p95 de 2 995 ms. Et vous connaissez les deux limites : le temps du fournisseur pour chaque billet et son quota pour plusieurs billets. Chaque nombre est accompagné de sa charge de travail et de son ordinateur.
Ensuite, le module 2 permet à l’API d’en faire plus en même temps. Vous voyez quand une concurrence accrue cesse d’aider.
Leçon suivante : Travail d'E/S et travail de calcul