Aller au contenu
English

Concevoir un test de charge

  • Leçon 17
  • 50 min
  • Module 6 : Valider et justifier les changements

Où nous en sommes

Dans les modules 2 à 5, nous avons changé le service de nombreuses fois : E/S asynchrones, plus de processus, un cache, une file d'attente, des limites et un arrêt en douceur. Chaque changement semblait aider. Mais un test de charge mal planifié peut cacher une longue attente derrière une réponse rapide. Dans cette leçon, nous planifions un test de charge comme une expérience qui répond à une question, comme les ingénieurs qui testent un nouveau pont avant son ouverture.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Planifiez un test de charge pour répondre à une question sur le Vendredi fou. Définissez sa charge de travail et son évolution dans le temps. Exécutez-le dans un environnement jetable sur votre propre ordinateur, peu sollicité.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet après Arrêt en douceur : python -m pytest affiche 172 passed, 1 deselected (172 tests réussis, 1 exclu).
  • PostgreSQL, Azurite et Valkey en cours d’exécution : docker compose up -d db azurite cache.

Après cette leçon, votre projet correspond à l’instantané end-of-m06, sauf pour les fichiers des deux prochaines leçons. Testé sur macOS (Apple silicon); les commandes Windows ne sont pas testées. Le fournisseur d’IA est celui qui est simulé. Les chiffres de ce module proviennent d’un ordinateur Apple M4 (10 cœurs, 16 Go). Les mesures du cours ont été prises sans autre activité. Les essais de l’auteur, identifiés chaque fois, utilisaient le même ordinateur avec d’autres activités. Chacun indique sa charge moyenne. Vos chiffres seront différents.

Avant l’ouverture d’un nouveau pont, les ingénieurs le testent avec des camions lourds. Ils ferment d’abord le pont à la circulation. Ils y font passer un camion, puis deux, puis quatre. À chaque étape, ils mesurent la flexion du pont. Ils stationnent une file de camions pendant une heure. Ils envoient un convoi soudain. Certains camions restent toute la nuit, pour voir si quelque chose cède lentement.

Les ingénieurs ne testent jamais un pont ouvert au public. Ils notent chaque charge et chaque mesure. Leur rapport dit « avec 12 camions de 40 tonnes, le tablier a fléchi de 18 mm ». Il ne dit pas « le pont est solide ».

Un test de charge applique la même idée à un service. Vous appliquez une charge planifiée à un service qui vous appartient et que vous pouvez mettre hors service. Vous notez chaque mesure. Cette leçon planifie des tests de charge pour le Vendredi fou de Larkfield.

Le problème : une réponse rapide qui cachait une longue attente

Section intitulée « Le problème : une réponse rapide qui cachait une longue attente »

Tomás voulait prouver que la conception avec file d’attente était prête. Il a exécuté le profil de pointe de cette leçon avec son réglage le plus intense. Il envoie 2 billets de soutien par seconde, puis 20 par seconde pendant 15 secondes, puis à nouveau 2 par seconde. scripts.percentiles a affiché ceci (essai de l’auteur, vos chiffres seront différents) :

518 requests in 80.0 s; status codes {'202': 474, '429': 44}
Successful: 474 = 5.92 per second
Latency of the successful requests: mean 16.2 ms | p50 14.9 ms | p95 31.2 ms | p99 37.9 ms | max 38.6 ms

« Chaque billet enregistré a reçu une réponse en moins de 39 ms », a dit Tomás. « Les 44 refus viennent de la limite de débit par client, dans Contre-pression. Ça fonctionne. Nous sommes prêts pour le Vendredi fou. » Puis Omar a posé la question que le test ne mesurait pas : quand les clients ont-ils reçu leur réponse d’IA?

La réponse 202 dit seulement « votre billet est enregistré, et son traitement d’IA attend dans la file ». Le quota du fournisseur limite le traitement d’IA lui-même : 100 appels de clavardage par minute, donc au maximum 50 billets par minute. La file a atteint 377 tâches. La dernière tâche s’est terminée plus de 7 minutes après l’arrêt des envois du test. La moitié des clients ont attendu plus de 4 minutes leur réponse. L’attente la plus longue a duré 8 minutes.

  • envoyés (enregistrés, 202)
  • traitement d'IA terminé
La pointe intense (essai de l'auteur, vos chiffres seront différents) : billets envoyés par Locust et billets dont le traitement d'IA était terminé, comptés depuis le début. L'écart vertical représente la file; l'écart horizontal représente le temps d'attente d'un billet.
Description textuelle du graphique

Deux lignes qui comptent les billets. La ligne « envoyés » monte lentement pendant 20 secondes, puis rapidement pendant 15 secondes, puis lentement à nouveau. Elle s’arrête à 476 billets enregistrés après 80 secondes. (Locust en a compté 474 : son compte s’arrête à la fin du test, et 2 requêtes étaient encore en cours.) La ligne « traitement d’IA terminé » monte beaucoup plus lentement, au rythme du fournisseur. Elle atteint 476 seulement après environ 525 secondes. L’écart entre les deux lignes représente la file.

Le test de Tomás mesurait correctement le temps de réponse de l’API. Mais il répondait à une question que personne n’avait posée, avec une charge bien supérieure à celle du Vendredi fou.

L’idée : un test de charge est une expérience planifiée

Section intitulée « L’idée : un test de charge est une expérience planifiée »

Un test de charge utile comprend quatre parties. Notez-les toutes avant de commencer, comme les ingénieurs du pont :

  1. La question. Une phrase sur quelque chose qui compte pour une personne. « Chaque billet du Vendredi fou reçoit-il sa réponse d’IA en moins de 5 minutes? » est une question. « Quelle est la vitesse de l’API? » n’en est pas une.
  2. La charge de travail. Ce qui arrive, à quelle fréquence et avec quelles données. Elle vient du modèle de charge de travail du module 1, et non d’une supposition.
  3. Le profil. L’évolution de la charge dans le temps : un niveau constant, des paliers, une pointe ou une longue exécution.
  4. L’environnement et les mesures. Où le test s’exécute, comment il démarre dans le même état chaque fois et ce que vous notez. Les mesures peuvent porter sur les temps des requêtes, les erreurs, la file, les refus du fournisseur et l’ordinateur.

Concevoir un test de charge, c’est choisir ces quatre parties. Chaque choix découle de la question. La question d’Omar portait sur la réponse d’IA. Les mesures importantes sont donc l’âge de la plus ancienne tâche et le temps entre l’envoi et le résultat. Ce n’est pas le temps de réponse 202.

Les tests du module 1 formaient une boucle fermée : chaque utilisateur Locust attend la réponse avant d’envoyer à nouveau. Avec la conception avec file d’attente, une réponse prend environ 20 ms. Un utilisateur en boucle fermée envoie donc environ 50 billets par seconde. Aucun client ne fait cela.

Les vrais clients forment un flux ouvert : ils arrivent à leur propre rythme. Le fichier Locust propose un réglage pour cela, PACE_SECONDS. Avec PACE_SECONDS=10, chaque utilisateur envoie un billet toutes les 10 secondes, si la réponse arrive à temps. Le taux d’arrivée est donc le nombre d’utilisateurs divisé par l’intervalle d’envoi :

Utilisateurs PACE_SECONDS Taux d’arrivée Comparaison avec la charge de travail
2 10 2 ÷ 10 = 0,2 billet par seconde Heure la plus occupée du Vendredi fou : 0,28 par seconde
20 10 20 ÷ 10 = 2 billets par seconde Minute la plus occupée du Vendredi fou : 90 billets, 1,5 par seconde
20 1 20 ÷ 1 = 20 billets par seconde 13 fois la minute la plus occupée

La dernière ligne correspond au test de Tomás. Le fichier de pointe est le même pour toutes les lignes; seul l’intervalle d’envoi change le taux. Un profil décrit donc une évolution, et l’intervalle d’envoi le relie à votre charge de travail. Les lignes intermédiaires sont proches du Vendredi fou d’Omar. L’exercice de cette leçon utilise donc PACE_SECONDS=10.

Chaque profil répond à une question différente. Le projet contient un fichier pour chacun, dans loadtest/. Chaque fichier est un fichier Locust avec les mêmes clients et un profil de charge. Un profil de charge est une liste d’étapes, chacune avec un temps de fin et un nombre d’utilisateurs.

Quatre petits graphiques en escalier montrant les utilisateurs dans le temps, tous sur une échelle de 0 à 20 utilisateurs. Montée en charge, loadtest/ramp.py : 2, 4, 8, 12 et 16 utilisateurs, pendant 20 secondes chacun, jusqu'à 100 secondes. Sa question : où p95 commence-t-il à augmenter? Charge constante, loadtest/steady.py : 4 utilisateurs pendant 70 secondes, les 10 premières secondes ombrées représentent le préchauffage. Sa question : quelle est la référence de base pour comparer? Pointe, loadtest/burst.py : 2 utilisateurs jusqu'à 20 secondes, 20 utilisateurs de 20 à 35 secondes, en rouge, puis 2 utilisateurs jusqu'à 80 secondes. Sa question : que voient les utilisateurs, et combien de temps faut-il pour que la file se vide à nouveau? Endurance (courte), loadtest/soak.py : 3 utilisateurs pendant 600 secondes. Sa question : quelque chose augmente-t-il alors qu'il ne devrait pas, comme la mémoire, les connexions ou l'âge des tâches dans la file?
Les quatre profils de charge du projet, tracés à partir de leurs fichiers. Avec PACE_SECONDS=1, le nombre d'utilisateurs égale le nombre de billets par seconde; un intervalle plus grand ralentit le même profil.
Description textuelle du diagramme

Chaque panneau montre le nombre d’utilisateurs dans le temps pour un fichier. La montée en charge progresse en cinq paliers de 20 secondes. Le profil constant maintient 4 utilisateurs pendant 70 secondes. Les 10 premières secondes servent au préchauffage et sont exclues. La pointe maintient 2 utilisateurs, passe à 20 pendant 15 secondes, puis revient à 2. Le profil d’endurance maintient 3 utilisateurs pendant 10 minutes. Sous chaque panneau se trouve la question à laquelle le profil répond.

  • La montée en charge augmente la charge par paliers. Vous cherchez le palier où p95 ou les erreurs commencent à augmenter : le coude de la courbe. Au-delà du coude, augmenter la charge augmente l’attente, pas le travail accompli. Utilisez ce profil pour trouver une limite encore inconnue. La montée du projet dépasse 10 utilisateurs. C’est là que la conception du module 1 atteignait son coude dans Limites des dépendances : le pool de 10 connexions à la base de données.
  • La charge constante maintient une charge assez longtemps pour bien la mesurer. C’est le profil pour une référence de base et pour comparer deux configurations, comme dans la prochaine leçon. Excluez le préchauffage.
  • La pointe dépasse largement la charge normale pendant un court moment, puis redescend. Elle répond à deux questions. Que voient les utilisateurs pendant la pointe? Et combien de temps faut-il au service pour récupérer, par exemple pour vider sa file?
  • L’endurance maintient une charge normale pendant longtemps. Elle détecte des problèmes lents qu’un test court ne révèle jamais. Par exemple, la mémoire augmente, des connexions ne reviennent jamais au pool, ou la file augmente d’une tâche par minute. Le test d’endurance du projet dure 10 minutes, pour convenir à un portable. Un vrai test d’endurance dure des heures.

Voici le fichier de pointe :

loadtest/burst.py
"""Burst: 2 users, then 20 users for 15 s (ten times more), then 2 users again for 45 s.
What do users see during the burst, and how long until the queue is empty again?"""
from locustfile import Customer # noqa: F401 (the user)
from shapes import Stages
class Burst(Stages):
stages = [(20, 2), (35, 20), (80, 2)]

Stages dans loadtest/shapes.py lit la liste une fois par seconde. Jusqu’à la seconde 20, il demande 2 utilisateurs; jusqu’à la seconde 35, 20; jusqu’à la seconde 80, 2. Puis le test s’arrête. Vous exécutez un profil sans -u ni -t, car le profil décide des deux.

Où l’exécuter : chez vous, dans un environnement jetable et peu sollicité

Section intitulée « Où l’exécuter : chez vous, dans un environnement jetable et peu sollicité »

Vos propres services seulement. Un test de charge envoie volontairement beaucoup de trafic. Contre le service d’une autre entreprise, il peut nuire à ses vrais utilisateurs et enfreindre ses conditions d’utilisation. Contre un vrai fournisseur d’IA, il coûte de l’argent et consomme un quota dont vos collègues ont besoin. Chaque test de ce cours s’exécute donc sur votre ordinateur. Il utilise votre propre API, base de données et cache, ainsi que le fournisseur simulé.

Jetable. Avant chaque test, remettez tout dans le même état. Rechargez le petit jeu de données, videz le cache et redémarrez le fournisseur simulé, ce qui remplit son quota. Ainsi, chaque test commence au même point, et vous pouvez tout mettre hors service.

Peu sollicité. Le générateur de charge, l’API, le processus, PostgreSQL et Valkey partagent votre ordinateur avec tous les autres programmes. Un appel vidéo ou une compilation prend du temps processeur à votre test. Exécutez python -m scripts.machine avant et après le test, et notez la charge moyenne dans le résultat. Les mesures du cours commençaient seulement quand la charge sur 1 minute était inférieure à 3.

Le générateur de charge fait partie de l’ordinateur. Le cours a choisi Locust (licence MIT) pour trois raisons. Il s’installe avec pip sur tous les systèmes, ses charges et profils sont du code Python, et il écrit des fichiers CSV. L’équipe du cours l’a comparé à oha (licence MIT, écrit en Rust). Les deux s’exécutaient dans Docker contre /health avec 64 connexions. oha envoyait 12 201 requêtes par seconde; Locust en envoyait 9 067 et utilisait un cœur de processeur entier. Locust est plus lent, mais ce cours nécessite moins de 30 requêtes par seconde. k6, un autre outil populaire, n’a pas été retenu : sa licence AGPL-3.0 ne respecte pas les règles du cours concernant les outils.

Vous exécutez la pointe au taux du Vendredi fou et surveillez les réponses ainsi que la file. Il vous faut cinq terminaux, chacun dans ~/projects/ticket-api avec l’environnement virtuel activé.

  1. Copiez les fichiers de test de charge depuis l’instantané. locustfile.py reçoit le réglage PACE_SECONDS :

    Fenêtre de terminal
    S=../nextia-learning-labs/C21/snapshots/end-of-m06
    for f in locustfile.py shapes.py ramp.py steady.py burst.py soak.py; do
    cp "$S/loadtest/$f" "loadtest/$f"
    done
    cp "$S/README.md" README.md
  2. Fermez les autres programmes exigeants. Affichez ensuite les mesures de l’ordinateur : python -m scripts.machine. Si la charge moyenne est élevée, attendez une minute et affichez-les à nouveau.

  3. Remettez les données et le cache dans le même état :

    Fenêtre de terminal
    python -m scripts.load --reset
    python -m scripts.cache flush
  4. Dans le terminal 1, démarrez le fournisseur simulé : python -m simulator. S’il tourne encore depuis un test précédent, arrêtez-le avec Ctrl+C et redémarrez-le pour remplir son quota.

  5. Dans le terminal 2, démarrez l’API sans la surveillance des fichiers : fastapi run.

  6. Dans le terminal 3, démarrez un processus : python -m ticket_api.worker.

  7. Dans le terminal 4, surveillez la file pendant 3 minutes : python -m scripts.queue_watch --seconds 180.

  8. Dans le terminal 5, lancez immédiatement la pointe avec un intervalle d’envoi de 10 secondes :

    Fenêtre de terminal
    PACE_SECONDS=10 SAMPLES_CSV=burst.csv locust -f loadtest/burst.py --host http://127.0.0.1:8000 --headless
  9. Quand Locust s’arrête après 80 secondes, calculez les centiles exacts : python -m scripts.percentiles burst.csv.

  10. Attendez que le terminal 4 affiche 0 tâche en attente et 0 en cours. Affichez ensuite les mesures de l’ordinateur à nouveau : python -m scripts.machine.

  11. Demandez à la base de données combien de temps chaque billet a attendu son traitement d’IA, de l’envoi (created_at) au résultat (finished_at) :

    Fenêtre de terminal
    docker compose exec db psql -U tickets -d tickets -c "SELECT count(*) AS jobs, round(percentile_disc(0.5) WITHIN GROUP (ORDER BY s)::numeric, 1) AS p50_s, round(percentile_disc(0.95) WITHIN GROUP (ORDER BY s)::numeric, 1) AS p95_s, round(max(s)::numeric, 1) AS max_s FROM (SELECT extract(epoch FROM finished_at - created_at) AS s FROM jobs WHERE state = 'succeeded') AS t;"
Afficher le résultat attendu

Essai de l’auteur, sur un ordinateur avec une charge sur 1 minute de 3,69 avant et de 2,8 après. Vos chiffres seront différents. Étape 9 :

62 requests in 80.1 s; status codes {'202': 62}
Successful: 62 = 0.77 per second
Latency of the successful requests: mean 18.1 ms | p50 19.7 ms | p95 26.0 ms | p99 26.2 ms | max 26.2 ms

Terminal 4, une ligne sur cinq (time représente les secondes depuis le début de la surveillance) :

time queued ready running oldest s done/min dead
0 0 0 0 0.0 0 0
5 0 0 0 0.0 2 0
10 0 0 0 0.0 2 0
15 0 0 0 0.0 4 0
20 0 0 0 0.0 4 0
25 10 10 4 4.9 10 0
30 1 1 4 9.9 19 0
35 13 13 4 5.0 27 0
40 6 6 3 10.0 36 0
45 5 5 4 5.0 45 0
50 2 2 0 0.0 54 0
55 0 0 0 0.0 56 0
60 2 2 0 0.1 56 0

La pointe a commencé à la seconde 20. Dans la sortie complète, la file a atteint un maximum de 20 tâches à la seconde 31. La plus ancienne tâche n’a jamais attendu plus de 11 secondes. La file était à nouveau vide environ 20 secondes après la fin de la pointe. L’étape 11 a donné le temps entre l’envoi et le résultat pour les 62 tâches : p50 de 6,5 s, p95 de 12,7 s et un maximum de 14,1 s.

Pourquoi la file est-elle restée courte, alors que la pointe de Tomás avait créé une file de 377 tâches? Le fournisseur simulé commence avec un quota plein, comme le vrai : une minute d’appels, soit 100. La pointe du Vendredi fou a envoyé environ 30 billets en 15 secondes, donc environ 60 appels de clavardage. Le quota plein les a acceptés presque immédiatement. La pointe de Tomás a envoyé environ 300 billets pendant les mêmes 15 secondes : 600 appels de clavardage, six fois le quota.

  • envoyés (enregistrés, 202)
  • traitement d'IA terminé
La pointe avec PACE_SECONDS=10 (essai de l'auteur, vos chiffres seront différents). Le traitement d'IA suit les billets envoyés avec quelques secondes de retard : la file est restée courte.
Description textuelle du graphique

Deux lignes qui comptent les billets sur environ 83 secondes. Les deux montent lentement pendant 20 secondes, puis plus vite pendant 15 secondes, puis lentement à nouveau. La ligne « traitement d’IA terminé » reste toujours quelques secondes à droite de la ligne « envoyés ». Les deux se terminent à 62 billets.

Ce que cela nous apprend. Au taux du Vendredi fou, avec un quota plein au départ, chaque billet a reçu sa réponse d’IA en moins de 14,1 secondes grâce à la file d’attente. Cette réponse concerne cet ordinateur, le fournisseur simulé et un test de 80 secondes. Un vrai Vendredi fou dure des heures. Le quota pourrait donc ne pas être plein lorsque la minute la plus occupée arrive. Le test d’endurance dans « À vous de jouer » examine une exécution plus longue.

À vous de jouer : un court test d’endurance juste sous le quota

Section intitulée « À vous de jouer : un court test d’endurance juste sous le quota »

Changez une seule chose : le profil de charge. Exécutez loadtest/soak.py (3 utilisateurs pendant 10 minutes) avec PACE_SECONDS=4. Avant de l’exécuter, notez le taux d’arrivée et comparez-le aux 50 billets par minute que le quota permet. Faites une prédiction : la file reste-t-elle courte ou s’allonge-t-elle? Quoi d’autre pourrait augmenter en 10 minutes?

Remettez d’abord l’environnement dans le même état (étapes 3 et 4). Pendant le test d’endurance, surveillez la file avec python -m scripts.queue_watch --seconds 660 --every 10.

Afficher la réponse

3 utilisateurs ÷ 4 secondes = 0,75 billet par seconde, soit 45 par minute. Le quota permet 50 billets par minute. Le fournisseur peut donc suivre le rythme, mais de justesse : 90 % du quota.

L’exécution de l’auteur (la charge moyenne sur 1 minute était de 11,9 au début et de 4,2 à la fin; vos chiffres seront différents). scripts.percentiles a affiché :

453 requests in 600.0 s; status codes {'202': 453}
Successful: 453 = 0.75 per second
Latency of the successful requests: mean 10.9 ms | p50 9.2 ms | p95 19.6 ms | p99 22.9 ms | max 25.1 ms

La surveillance de la file, une ligne sur 60 :

time queued ready running oldest s done/min dead
0 0 0 0 0.0 0 0
60 3 3 0 0.2 45 0
121 0 0 3 0.0 45 0
242 0 0 3 0.0 45 0
362 0 0 3 0.0 45 0
483 0 0 2 0.0 45 0
604 0 0 0 0.0 45 0

La file n’a jamais contenu plus de 3 tâches, et done/min (tâches terminées par minute) est resté à 45, le taux d’arrivée. Le fournisseur n’a refusé aucun appel. Les 453 tâches ont toutes réussi. Leur délai entre la soumission et le résultat était de 2,4 s au p50, de 3,2 s au p95 et d’au plus 3,7 s. L’auteur a aussi relevé la mémoire de l’API et du processus toutes les 30 secondes avec ps. Il a relevé les connexions à la base de données avec pg_stat_activity. De la deuxième minute à la fin, l’API utilisait environ 46 Mo et le processus, de 37 à 43 Mo. La base de données avait 9 connexions. Rien n’a augmenté.

Ce que cela nous dit. Dix minutes à 90 % du quota ont été stables sur cet ordinateur. Un vrai test d’endurance dure des heures, car une fuite de 1 Mo par heure reste invisible en 10 minutes.

Erreur courante

Le test du profil de charge s'arrête immédiatement

Symptôme : vous exécutez un fichier de profil de charge, et Locust s’arrête après une fraction de seconde, sans requêtes :

INFO/locust.runners: Shape test starting.
INFO/locust.runners: Shape worker starting
INFO/locust.runners: Shape test stopping
INFO/locust.main: Shape test completed, shutting down

Le tableau récapitulatif indique 0 requêtes.

Cause : Locust a exécuté le mauvais profil de charge. Un fichier de profil importe la classe de base Stages. Le fichier contient donc deux classes de profil : Stages et, par exemple, Burst. Locust prend la première qu’il trouve. Stages n’a aucune étape, donc sa première réponse est « stop » (arrêter). La première version de shapes.py du cours avait exactement ce défaut.

Diagnostic : lisez loadtest/shapes.py et cherchez la ligne abstract = True dans la classe Stages. Sans elle, Locust traite Stages comme un profil à part entière.

Correction : marquez la classe de base comme abstraite : une classe qu’on n’utilise pas seule. Locust l’ignore alors :

loadtest/shapes.py (the fix)
class Stages(LoadTestShape):
"""A list of (until second, users). The test stops after the last stage."""
abstract = True
stages: list[tuple[int, int]] = []

L’instantané end-of-m06 contient cette correction, et tests/test_load_tests.py vérifie que Locust prend le profil propre à chaque fichier. Tester les outils de test vaut le temps investi : un test de charge défectueux ne signale rien, et « rien » semble correct.

Quand utiliser chaque profil de charge et ce qu’il coûte

Section intitulée « Quand utiliser chaque profil de charge et ce qu’il coûte »

Utilisez une montée progressive quand vous ne savez pas où se trouve la limite. Utilisez un régime constant pour chaque chiffre que vous comparerez ou promettrez. Utilisez une pointe lorsque la charge de travail présente des pics, comme la minute la plus achalandée du Vendredi fou. Mesurez le rétablissement ainsi que les réponses. Utilisez un test d’endurance avant un événement prolongé, et après tout changement à un élément qui conserve des ressources : pools, caches, processus.

N’exécutez pas de test d’endurance sur un ordinateur pendant que vous y travaillez. Dix minutes d’activité de vos autres programmes feront partie du résultat.

Chaque test coûte du temps. Une pointe prend 80 secondes, plus le temps nécessaire pour vider la file, plus la remise à zéro. Un chiffre que vous comparez demande plusieurs exécutions. Notez d’abord les quatre parties, pour exécuter seulement les tests qui répondent à une question.

Vérifiez votre compréhension

Le test en boucle fermée de Tomás, avec 50 utilisateurs, affiche un p95 de 30 ms et aucune erreur avec l'architecture à file d'attente. Pourquoi cela ne montre-t-il pas que le service est prêt pour le Vendredi fou?

Afficher la réponse

Le test a mesuré seulement la réponse 202, qui signifie « enregistré et mis en file d’attente ». Le travail d’IA attend dans la file et s’exécute au rythme du fournisseur, au plus 50 billets par minute. Une boucle fermée avec 50 utilisateurs envoie aussi beaucoup plus de requêtes que le Vendredi fou. La file s’allonge donc sans limite. La question d’Omar demande d’autres mesures : la tâche la plus ancienne de la file et le délai entre la soumission et le résultat. Elle demande aussi une charge de travail tirée du modèle de charge de travail.

Vérifiez votre compréhension

Faites une prédiction : vous exécutez burst.py avec PACE_SECONDS=5. Quel est le taux d'arrivée avant et pendant la pointe? Vous attendez-vous à une longue file?

Afficher la réponse

Avant la pointe : 2 ÷ 5 = 0,4 billet par seconde. Pendant la pointe : 20 ÷ 5 = 4 billets par seconde pendant 15 secondes, soit environ 60 billets et 120 appels de clavardage. Un quota plein contient 100 appels, donc environ 50 billets passent d’un coup. Les autres attendent pendant que le quota se renouvelle à 100 appels par minute. Attendez-vous à une courte file de quelques dizaines de tâches, qui se vide une ou deux minutes après la pointe.

Vérifiez votre compréhension

Vérification pratique : écrivez les quatre parties de votre test de pointe du Vendredi fou, comme vous les présenteriez en tête d'un résultat.

Afficher la réponse

Par exemple. Question : chaque billet de la minute la plus achalandée du Vendredi fou reçoit-il sa réponse d’IA en moins de 5 minutes? Charge de travail : nouveaux billets des données d’exercice (graine 21), petit volume de données. Le taux est de 0,2 billet par seconde, avec une pointe de 2 par seconde pendant 15 secondes (burst.py, PACE_SECONDS=10). Environnement : un processus d’API (fastapi run), un processus en arrière-plan, PostgreSQL et Valkey dans Docker, et le fournisseur simulé avec le quota consigné. Données et cache remis à zéro, simulateur redémarré. L’ordinateur et sa charge moyenne, obtenus avec scripts.machine. Mesures : le délai de réponse 202 (p50, p95) et les erreurs. La longueur de la file et sa tâche la plus ancienne, chaque seconde. Le délai entre la soumission et le résultat.

Récapitulatif

  • Un test de charge est une expérience planifiée : une question, une charge issue du modèle de charge de travail, un profil et un environnement avec des mesures. Écrivez d’abord les quatre parties.
  • PACE_SECONDS convertit le nombre d’utilisateurs en taux d’arrivée : utilisateurs ÷ intervalle. Le même profil peut représenter le Vendredi fou, ou treize fois le Vendredi fou.
  • La montée progressive trouve le point d’inflexion, le régime constant donne une référence de base, la pointe montre le pic et le rétablissement, le test d’endurance trouve ce qui augmente lentement.
  • Testez seulement vos propres services, remettez-les à zéro avant chaque test et consignez la charge de la machine. Locust est plus lent qu’oha, mais assez rapide pour les dizaines de requêtes par seconde de ce cours.
  • Une réponse 202 rapide peut cacher une longue attente : mesurez la file et le délai entre la soumission et le résultat.

Leçon suivante : Comparer les configurations