Latence et capacité
- Leçon 3
- 55 min
- Module 1 : Mesurer avant de mettre à l'échelle
Où nous en sommes
Dans les deux dernières leçons, nous avons exécuté le service et décrit le Vendredi fou comme une charge de travail chiffrée. Nous devons maintenant mesurer le service sous cette charge. Mais le temps moyen d'une requête peut sembler correct pendant que certains clients attendent beaucoup trop. Dans cette leçon, nous lisons les temps d'un test de charge avec des centiles, et nous notons une première référence de base. Un autobus qui a « en moyenne 3 minutes de retard » montre le problème.
Leçon 3 sur 19 · Mettre à l'échelle les API et les charges de travail d'IALatence et capacité
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
Apprenez à lire les temps d’un test de charge avec les bons nombres : moyennes, centiles, concurrence et files d’attente. Notez ensuite la première référence de base de Larkfield : le débit et la latence p95 pour une charge de travail précisée. Chaque changement ultérieur aura ainsi un résultat à dépasser.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- La latence, le débit et votre première exécution de Locust, vus dans Exécuter la charge de travail d’IA sur votre ordinateur.
- Le modèle de charge de travail et la boucle fermée, vus dans Modèle de charge de travail.
Ce qu’il vous faut sur votre ordinateur
- Votre projet de la dernière leçon, avec les petites données chargées (
python -m scripts.load --reset).python -m pytestaffiche123 passed(123 tests réussis). - PostgreSQL et Azurite en marche. Vous démarrez le simulateur et l’API dans l’exercice guidé.
Quel est le retard de l’autobus?
Section intitulée « Quel est le retard de l’autobus? »Une société de transport affirme que ses autobus ont « en moyenne 3 minutes de retard ». La plupart des jours, votre autobus a 1 minute de retard. Mais une ou deux fois par mois, il tombe en panne et arrive avec 40 minutes de retard.
La moyenne est vraie, mais elle n’est pas utile. Un jour normal, elle vous fait attendre pour rien. Et elle ne dit rien sur le jour de votre entrevue d’embauche, où vous ne pouvez pas avoir 40 minutes de retard. Pour ce jour-là, vous voulez un autre nombre : « Sur 19 jours sur 20, l’autobus a au plus 4 minutes de retard. »
Les temps des requêtes fonctionnent de la même façon. La plupart sont proches, et quelques requêtes sont très lentes. Ce sont ces quelques requêtes lentes que les clients retiennent.
Le problème : la moyenne cache les requêtes lentes
Section intitulée « Le problème : la moyenne cache les requêtes lentes »Votre premier tableau Locust indiquait Avg 2388 (moyenne de 2 388). Omar le lit et demande : « Donc chaque client attend environ 2,4 secondes? » Non. Voici un petit exemple qui montre pourquoi. Il est construit pour que chaque valeur soit visible.
Vingt requêtes : dix-neuf prennent 100 ms et une prend 5 000 ms.
| Requête | 1 à 19 | 20 |
|---|---|---|
| Temps | 100 ms chacune | 5 000 ms |
La moyenne est (19 × 100 + 5 000) ÷ 20 = 6 900 ÷ 20 = 345 ms. Personne n’a attendu 345 ms. Dix-neuf clients ont attendu 100 ms et un a attendu 5 secondes. La requête lente tire la moyenne vers le haut, et celle-ci ne décrit aucune requête réelle. Un des tests du projet, test_the_average_hides_the_slow_requests, vérifie ce même profil avec 100 requêtes.
L’idée : les centiles
Section intitulée « L’idée : les centiles »Triez les temps du plus rapide au plus lent. Un centile est le temps à une position fixe dans cette liste triée :
- p50, la médiane : la moitié des requêtes ont pris ce temps ou moins.
- p95 : 95 requêtes sur 100 ont pris ce temps ou moins. Une requête sur vingt était plus lente.
- p99 : 99 requêtes sur 100 ont pris ce temps ou moins.
Le nom vient de « pour cent » : p95 est la 95e valeur sur 100. L’extrémité lente de la liste est la queue. On appelle donc p95 et p99 des latences de queue.
Pour trouver p95 dans une liste de n temps, triez-les, calculez 0,95 × n, puis arrondissez vers le haut. Prenez le temps à cette position. C’est la méthode du rang le plus proche, utilisée par scripts.percentiles. Dans le petit exemple, n vaut 20 :
| Nombre | Position | Valeur |
|---|---|---|
| p50 | 0,50 × 20 = 10 → la 10e | 100 ms |
| p95 | 0,95 × 20 = 19 → la 19e | 100 ms |
| p99 | 0,99 × 20 = 19,8 → la 20e | 5 000 ms |
| max | la 20e | 5 000 ms |
Ce tableau contient deux leçons. D’abord, p50 et p95 indiquent « 100 ms », ce qui est vrai pour 19 clients sur 20. Ensuite, avec seulement 20 requêtes, p99 est la requête la plus lente. Il faut beaucoup de requêtes pour qu’un centile de queue ait vraiment du sens.
Quel nombre promettriez-vous? Essayez avec des temps réels.
Explorer
Quel nombre décrit un temps lent et irrégulier?
Prédisez d’abord : Omar doit promettre aux clients un délai pour un nouveau billet. Quel nombre promettriez-vous : la moyenne, p50, p95, p99 ou le maximum?
- classement
- 958 ms (35 sur 100 plus lents)
- rédaction d’une réponse
- 1 140 ms (37 sur 100 plus lents)
- plongement
- 200 ms (47 sur 100 plus lents)
classement, moyenne : 958 ms; 35 des 100 appels enregistrés ont pris plus de temps. La moyenne additionne tous les temps et divise par leur nombre. Quelques requêtes lentes la tirent vers le haut, donc elle est au-dessus de la médiane, et elle n’appartient à aucune vraie requête. Pour le classement, la moyenne de 958 ms est 45 ms au-dessus de la médiane de 913 ms.
| Tâche | moyenne | p50 (médiane) | p95 | p99 | maximum |
|---|---|---|---|---|---|
| classement | 958 ms | 913 ms | 1 397 ms | 1 985 ms | 2 143 ms |
| rédaction d’une réponse | 1 140 ms | 1 097 ms | 1 514 ms | 2 141 ms | 2 172 ms |
| plongement | 200 ms | 198 ms | 300 ms | 333 ms | 341 ms |
Description textuelle de l’explorateur
L’explorateur montre des bandes de points représentant les temps mesurés, avec un point par appel. Dans la première vue, trois bandes montrent les 100 appels réels enregistrés pour chaque tâche d’IA, exécutés un à la fois. Classer : moyenne 958 ms, p50 913 ms, p95 1 397 ms, p99 1 985 ms, max 2 143 ms. Rédiger une réponse : moyenne 1 140 ms, p50 1 097 ms, p95 1 514 ms, p99 2 141 ms, max 2 172 ms. Produire un plongement : moyenne 200 ms, p50 198 ms, p95 300 ms, p99 333 ms, max 341 ms. Dans la deuxième vue, une bande montre 106 billets complets d’un test de charge à 1 utilisateur avec le fournisseur simulé (exécution de l’auteur) : moyenne 2,265 ms, p50 2,230 ms, p95 2,796 ms, p99 3,088 ms, max 3,358 ms. Choisir une statistique déplace un repère sur chaque bande. L’affichage indique combien de temps mesurés dépassent cette valeur.
Ce que cela nous apprend. Les temps ont une longue queue à droite : la plupart des appels sont proches, et quelques-uns sont beaucoup plus lents. La moyenne dépasse donc la médiane : 958 ms contre 913 ms pour le classement. Le maximum est réel, mais il représente un seul événement, et le prochain test en aura un autre. p95 est le choix habituel pour une promesse. Elle est tenue pour 19 clients sur 20 et varie peu entre les exécutions. Passez aux billets complets : la queue est toujours là, car chaque billet ajoute trois appels irréguliers.
Omar formule maintenant mieux sa promesse : « 95 % des nouveaux billets sont enregistrés en 5 secondes ou moins. » Elle combine un centile et une limite. On appelle souvent ce type de cible un objectif de niveau de service.
Concurrence et débit
Section intitulée « Concurrence et débit »La concurrence est le nombre de requêtes en cours en même temps. Dans un test en boucle fermée sans pause, elle correspond au nombre d’utilisateurs Locust.
Une règle simple relie les trois termes :
débit = concurrence ÷ latence
Vérifiez avec un utilisateur. Un billet est en cours et prend environ 2,3 secondes. Le débit est donc 1 ÷ 2,3 = 0,43 billet par seconde. Avec deux utilisateurs, deux billets attendent en même temps : 2 ÷ 2,3 = 0,87 par seconde. Cette règle est la loi de Little, du nom de John Little, qui l’a démontrée en 1961. Elle s’applique à tout système stable dans le temps.
Le cours a mesuré le même test avec 1, 2 et 4 utilisateurs sur un ordinateur peu occupé. Chaque configuration a eu cinq passages de 60 secondes :
Description textuelle du graphique
Billets réussis par seconde, médianes de 5 passages : 1 utilisateur 0,43 (0,41 à 0,45), 2 utilisateurs 0,85 (0,83 à 0,88), 4 utilisateurs 1,54 (1,46 à 1,57). À chaque passage avec 4 utilisateurs, le fournisseur a refusé entre 41 et 115 appels. Ces billets ont reçu une erreur.
Un et deux utilisateurs suivent la règle : 0,43, puis 0,85. Quatre utilisateurs devraient donner environ 1,7, mais ils ont donné 1,54. Quelque chose a refusé du travail. Trouver le goulot d’étranglement permet de découvrir quoi.
Files d’attente : pourquoi l’attente augmente
Section intitulée « Files d’attente : pourquoi l’attente augmente »Une boucle fermée garde la concurrence fixe. Les vrais clients ne le font pas, comme l’a montré la dernière leçon. Quand les requêtes arrivent plus vite que le service les termine, elles attendent dans une file d’attente. C’est une liste de travaux arrivés, mais pas encore commencés.
Voici un petit exemple. Un commis a besoin de 2 secondes par client. Quatre clients arrivent à une seconde d’intervalle :
| Client | Arrivée à | Début à | Fin à | Attente dans la file | Temps total |
|---|---|---|---|---|---|
| 1 | 0 s | 0 s | 2 s | 0 s | 2 s |
| 2 | 1 s | 2 s | 4 s | 1 s | 3 s |
| 3 | 2 s | 4 s | 6 s | 2 s | 4 s |
| 4 | 3 s | 6 s | 8 s | 3 s | 5 s |
Le travail par client ne change jamais : 2 secondes. Mais le temps total augmente d’une seconde pour chaque nouveau client. Les clients arrivent chaque seconde, et le commis en a besoin de deux. S’ils continuent d’arriver, la file grandit sans fin. Le taux d’arrivée dépasse maintenant le débit que le commis peut fournir. Cette file ne se vide jamais.
Cela mène à la capacité : le plus haut taux d’arrivée qu’un service peut traiter tout en tenant sa promesse. Au-delà, une file d’attente grandit, et la latence aussi.
Pour Larkfield, les nombres montrent déjà une limite de capacité. Le quota permet 100 appels de clavardage par minute, et chaque billet en exige deux. Le fournisseur peut donc accepter au plus 50 billets par minute : 0,83 billet par seconde. La minute la plus occupée du Vendredi fou en apporte 1,5 par seconde. Quoi que fasse l’API, les billets supplémentaires doivent attendre ou échouer.
Exercice guidé : noter la référence de base
Section intitulée « Exercice guidé : noter la référence de base »Une référence de base mesure la conception actuelle avec une charge de travail précisée. Vous la conservez et y comparez chaque changement ultérieur. Sans référence de base, « c’est plus rapide maintenant » ne veut rien dire.
Il vous faut deux scripts et un modèle de document. scripts.percentiles calcule les centiles exacts à partir de chaque requête. scripts.machine affiche les caractéristiques de l’ordinateur. docs/benchmark-template.md est le formulaire pour le résultat.
-
Dans
~/projects/ticket-api, avec l’environnement virtuel activé, copiez les quatre fichiers de cette leçon depuis l’instantanéend-of-m01:Fenêtre de terminal S=../nextia-learning-labs/C21/snapshots/end-of-m01for f in scripts/percentiles.py scripts/machine.py docs/benchmark-template.md tests/test_measure_tools.py; docp "$S/$f" "$f"doneFenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m01"foreach ($f in 'scripts\percentiles.py', 'scripts\machine.py', 'docs\benchmark-template.md', 'tests\test_measure_tools.py') { Copy-Item "$S\$f" $f } -
Exécutez les tests :
python -m pytest. Le résultat attendu est128 passed, 1 deselected(128 tests réussis, 1 non sélectionné). -
Fermez les autres programmes exigeants : appel vidéo, compilation, téléchargement volumineux. Ils prennent du temps de processeur à votre test. Affichez ensuite les caractéristiques de votre ordinateur :
Fenêtre de terminal python -m scripts.machineComputer: Apple M4, 10 cores, 16.0 GB memory; Darwin 25.6.0 (arm64)Python 3.12.13; Docker: Engine 29.6.1, 10 CPUs, 7.8 GBLoad average (1 minute): 5.04 (other programs that use the CPU make the numbers worse)C’est l’ordinateur de l’auteur, qui effectuait aussi d’autres travaux à ce moment-là. La charge moyenne compte les programmes qui demandent le processeur. Les mesures du cours ont attendu qu’elle soit inférieure à 3. Sur Windows, le script n’affiche pas de charge moyenne.
-
Démarrez le simulateur dans le terminal 1 (
python -m simulator), comme avant. Dans le terminal 2, démarrez l’API avecfastapi runplutôt quefastapi dev. Le mode développement surveille les changements dans vos fichiers. C’est du travail supplémentaire dont une mesure n’a pas besoin.Fenêtre de terminal fastapi run -
Dans le terminal 3, exécutez la charge de travail à 1 utilisateur pendant 60 secondes. Enregistrez chaque requête dans
run.csv:Fenêtre de terminal SAMPLES_CSV=run.csv locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 1 -r 1 -t 60sFenêtre de terminal $env:SAMPLES_CSV = "run.csv"locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 1 -r 1 -t 60sRemove-Item Env:SAMPLES_CSV -
Calculez les centiles exacts deux fois : avec toutes les requêtes, puis sans les 10 premières secondes :
Fenêtre de terminal python -m scripts.percentiles run.csvpython -m scripts.percentiles run.csv --skip 10
L’exécution de l’auteur a affiché ceci. Vos nombres seront différents :
24 requests in 58.0 s; status codes {'201': 24}Successful: 24 = 0.41 per secondLatency of the successful requests: mean 2414.9 ms | p50 2298.6 ms | p95 3231.2 ms | p99 3306.4 ms | max 3306.4 ms19 requests in 46.0 s; status codes {'201': 19}Successful: 19 = 0.41 per secondLatency of the successful requests: mean 2423.4 ms | p50 2352.8 ms | p95 3306.4 ms | p99 3306.4 ms | max 3306.4 msLe tableau de Locust pour la même exécution indiquait Med 2400 (médiane de 2 400) et 95%: 3200 (centile 95 de 3 200). Locust arrondit chaque temps avant de compter, et son tableau indique « approximated » (approximatif). scripts.percentiles utilise chaque temps exact : p50 de 2 298,6 ms et p95 de 3 231,2 ms.
--skip 10 exclut le préchauffage : les premières secondes, où les connexions s’ouvrent et le code se charge pour la première fois. Ici, cela a peu changé les résultats. Dans la deuxième ligne, p95, p99 et le maximum correspondent à la même requête. Avec 19 requêtes, la position du centile 95 est déjà la dernière. Une courte exécution donne un profil, pas un p95 stable.
C’est pourquoi le cours a mesuré cinq passages et utilisé la médiane de chaque nombre. Sur un ordinateur peu occupé, avec la même charge de travail, le résultat était :
| 1 utilisateur (médiane de 5 passages) | passage le plus bas et le plus haut | |
|---|---|---|
| Débit | 0,43 billet par seconde | 0,41 à 0,45 |
| p50 | 2 200 ms | 2 168 à 2 318 |
| p95 | 2 995 ms | 2 676 à 3 340 |
| p99 | 3 098 ms | 2 772 à 3 616 |
| Processeur de l’API | 0,6 % | 0,4 à 0,6 % |
Description textuelle du graphique
Le p95 de chacun des cinq passages avec 1 utilisateur : 3 340, 3 138, 2 676, 2 817 et 2 995 ms. La médiane des cinq est de 2 995 ms.
Ce que cela nous apprend. Rien n’a changé entre les passages : même code, même charge de travail, même ordinateur. Pourtant, p95 a varié de 664 ms, soit environ 22 %. Avec environ 20 requêtes par passage, un appel lent au fournisseur change p95. Une différence de quelques centaines de millisecondes entre deux exécutions uniques ne prouve donc rien. Répétez, indiquez la médiane et montrez le passage le plus bas et le plus haut.
Écrivez le résultat. Copiez docs/benchmark-template.md dans docs/baseline.md et remplissez-le pour votre propre exécution. Inscrivez la question, la sortie de scripts.machine, le tableau de charge de travail et vos nombres. Décrivez la charge de travail assez précisément pour qu’une autre personne puisse la reproduire.
Afficher un exemple rempli
| La question | Combien de nouveaux billets par seconde la conception du module 1 termine-t-elle avec un utilisateur, et combien de temps prennent-ils? |
| La machine | Apple M4, 10 cœurs, 16 Go, macOS; Docker 10 processeurs, 7,8 Go; Python 3.12.13; charge moyenne inférieure à 3, aucun autre programme exigeant en marche |
| Point de terminaison et requête | POST /v1/tickets, les 200 billets d’exercice, choisis avec la graine fixe 21 |
| Générateur de charge et commande | SAMPLES_CSV=run.csv locust -f loadtest/locustfile.py --headless -u 1 -r 1 -t 60s |
| Profil | constant, boucle fermée, 1 utilisateur, sans pause; 60 s, les 10 premières secondes exclues |
| Dépendances | PostgreSQL 18.6, petites données; fournisseur d’IA simulé (mode normal, quota enregistré de 100 requêtes de clavardage par minute) |
| Configuration | fastapi run, un processus, valeurs par défaut de .env.example |
| Passages | 5; médiane de chaque nombre, avec le passage le plus bas et le plus haut |
| Résultats | 0,43 billet par seconde (0,41 à 0,45); p50 2 200 ms; p95 2 995 ms (2 676 à 3 340); p99 3 098 ms; aucune erreur; processeur de l’API 0,6 % |
Quand utiliser chaque nombre
Section intitulée « Quand utiliser chaque nombre »Utilisez p95 pour les promesses et les comparaisons entre conceptions. Utilisez p99 seulement quand vous avez des milliers de requêtes. Le centile 99 repose alors sur beaucoup de requêtes, pas une ou deux. Utilisez la médiane pour décrire la requête typique. Indiquez le maximum pour montrer qu’il existe, mais ne comparez pas les conceptions avec lui.
N’utilisez pas la moyenne des latences pour une promesse. La moyenne reste utile pour une chose : les totaux. Le temps moyen multiplié par le nombre de requêtes donne le temps d’attente total, par exemple pour estimer une facture.
Indiquez le débit en requêtes réussies par seconde. Une requête qui échoue en 5 ms n’est pas du travail utile. Pour cette raison, scripts.percentiles compte seulement les réponses 2xx.
Les centiles ont un coût. Vous devez conserver le temps de chaque requête, comme le fait SAMPLES_CSV. Vous pouvez aussi utiliser un outil qui les estime, comme Locust. Il faut également assez de requêtes. Environ 20 par passage, comme ici, donnent un p95 approximatif et aucun véritable p99.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
Un ordinateur occupé dégrade les nombres
Symptôme : python -m scripts.machine affiche une charge élevée, par exemple Load average (1 minute): 19.8 (charge moyenne sur 1 minute : 19,8). Votre p95 dépasse celui de la dernière exécution.
Cause : d’autres programmes se disputent le processeur et le disque. La mesure les mesure alors aussi. L’ordinateur de l’auteur affichait 19,8 pendant qu’il effectuait d’autres travaux exigeants.
Solution : fermez les autres programmes, attendez une ou deux minutes, puis exécutez encore scripts.machine. Mesurez quand la charge moyenne est faible et inscrivez-la dans votre résultat. Si vous ne pouvez pas réduire l’activité de l’ordinateur, dites-le à côté des nombres.
Erreur courante
Comparer une exécution à une autre
Symptôme : vous ne changez rien, relancez le test, et p95 varie de plusieurs centaines de millisecondes. Ou vous changez un paramètre, et une seule exécution semble 10 % plus rapide.
Cause : les courtes exécutions ont peu de requêtes. La queue repose donc sur un ou deux appels lents. Les cinq passages de référence ont fait varier p95 entre 2 676 et 3 340 ms.
Solution : effectuez au moins trois passages, de préférence cinq, pour chaque configuration. Comparez les médianes et montrez l’étendue. Si les étendues se chevauchent, le test n’a pas montré de différence.
À vous de jouer : deux utilisateurs
Section intitulée « À vous de jouer : deux utilisateurs »Changez une chose : exécutez le même test avec 2 utilisateurs (-u 2 -r 2), avec SAMPLES_CSV. Avant de l’exécuter, prédisez le débit et p95 avec la loi de Little. Comparez ensuite avec votre résultat à 1 utilisateur et ajoutez une ligne à docs/baseline.md.
Afficher la réponse
La loi de Little prédit le double du débit : 2 ÷ 2,3 s = environ 0,87 billet par seconde. La latence devrait rester à peu près la même, car chaque billet attend encore ses trois propres appels. Sur cinq passages avec 2 utilisateurs, le cours a mesuré 0,85 billet par seconde (0,83 à 0,88). Le p95 était de 2 988 ms (2 652 à 3 139). Il n’y a pas de changement de p95 : les étendues de 1 et 2 utilisateurs se chevauchent. Votre exécution unique sera différente, mais elle devrait montrer environ le double du débit.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Un test de 20 requêtes donne : moyenne de 900 ms, p50 de 400 ms, p95 de 3 800 ms, maximum de 4 000 ms. Omar veut écrire « 95 % des billets en moins de 1 seconde ». Est-ce vrai? Quel nombre vous le dit?
Afficher la réponse
Non. Le p95 est de 3 800 ms : 95 % des requêtes ont pris au plus 3,8 secondes. Une requête sur vingt a pris plus de temps. La moyenne (900 ms) est inférieure à 1 seconde seulement parce que beaucoup de requêtes étaient rapides. Elle cache les requêtes lentes. Omar pourrait écrire « la moitié des billets en moins de 0,4 seconde » (p50) ou « 95 % en moins de 4 secondes » (p95). Avec seulement 20 requêtes, le p95 correspond au 19e temps. Il devrait donc exécuter plus de requêtes avant de promettre quoi que ce soit.
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 la loi de Little : 8 utilisateurs Locust, aucune pause, et environ 2,3 secondes par billet. Quel débit prévoyez-vous? Nommez une chose qui pourrait réduire le résultat réel.
Afficher la réponse
8 ÷ 2,3 = environ 3,5 billets par seconde. Cela demande environ 7 appels de clavardage par seconde, soit 420 par minute, pour un quota de 100 par minute. Le fournisseur refuserait donc la plupart des appels après la première rafale, et le débit de réussite serait beaucoup plus faible. D’autres limites pourraient aussi le freiner, comme le pool de connexions (pool) à la base de données, limité à 10. La prochaine leçon et le module 2 mesurent ces limites.
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 pratique : donnez votre référence de base en une phrase, avec la charge de travail et l'ordinateur. Une autre personne doit pouvoir la reproduire.
Afficher la réponse
Par exemple : « Sur un Apple M4 avec 16 Go (charge moyenne inférieure à 3), la conception du module 1 avec le fournisseur simulé (quota enregistré) a traité 0,43 billet par seconde, avec un p95 de 2 995 ms (de 2 676 à 3 340 sur 5 essais). La charge de travail était loadtest/locustfile.py : 1 utilisateur, aucune pause, 60 secondes, les 10 premières secondes exclues, les billets d’exercice avec une graine de 21, peu de données. » Vos nombres diffèrent; tous les éléments doivent être présents : le résultat, l’étendue, la charge de travail et l’ordinateur.
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
- La moyenne des latences cache les requêtes lentes. Les centiles ne les cachent pas : le p50 représente la requête typique, le p95 sert habituellement aux promesses, et le p99 représente les temps les plus longs.
- La concurrence est le nombre de requêtes en cours. Loi de Little : débit = concurrence ÷ latence. Un utilisateur a donné 0,43 billet par seconde, deux ont donné 0,85.
- Une file d’attente s’allonge quand le travail arrive plus vite qu’il ne se termine. La capacité est le débit maximal qui respecte la promesse. Le quota limite Larkfield à 0,83 billet par seconde.
- La référence de base de la conception du module 1, avec 1 utilisateur et un ordinateur peu sollicité : 0,43 billet par seconde, p95 de 2 995 ms (de 2 676 à 3 340 sur 5 essais).
- Chaque résultat précise sa charge de travail et son ordinateur. Les essais courts varient : répétez-les, utilisez la médiane et montrez l’étendue.
Ensuite, vous décomposez les 2,2 secondes d’un billet. Vous trouvez ce qui a empêché quatre utilisateurs de doubler encore le débit.
Leçon suivante : Trouver le goulot d'étranglement