Aller au contenu
English

Modèle de charge de travail

  • Leçon 2
  • 50 min
  • Module 1 : Mesurer avant de mettre à l'échelle

Où nous en sommes

Dans la leçon précédente, nous avons exécuté le travail d'IA avec un fournisseur simulé et lancé notre premier test de charge. Mais les « dix fois plus de billets que d'habitude » d'Omar ne sont pas encore utilisables dans un test. À quelle vitesse les billets arrivent-ils, et quelle est la taille des pointes? Dans cette leçon, nous transformons cette phrase en modèle de charge de travail chiffré, comme une boulangère qui prépare le festival de la ville.

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

Ce que vous saurez faire

Transformez les « dix fois plus de billets que d’habitude » d’Omar en chiffres utilisables dans un test. À quelle vitesse les billets arrivent-ils? Quelle est la taille des pointes? Combien de temps chaque billet prend-il, quelle est sa taille et qu’attendent les clients?

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

  • Votre projet ~/projects/ticket-api de la dernière leçon : python -m pytest affiche 123 passed (123 tests réussis). PostgreSQL et Azurite fonctionnent (docker compose up -d db azurite).
  • Environ 1 Go d’espace disque libre pour les grandes données. Le premier chargement télécharge leurs vecteurs (15 Mo).

Une boulangère apprend que le festival de la ville attirera « dix fois plus de clients » samedi. Combien de pains doit-elle préparer? Combien de personnes doivent travailler?

« Dix fois » ne suffit pas pour planifier. Elle doit en savoir plus :

  • Quand viennent-ils? Sur dix heures, ou tous ensemble à la fin du défilé, à midi?
  • Que commandent-ils? Vendre un pain prend dix secondes. Un gâteau de mariage prend vingt minutes.
  • Combien de temps prend chaque commande, au comptoir et dans le four?
  • Combien de temps un client attendra-t-il avant de quitter la file?

Avec ces réponses, elle peut planifier. Elle peut même s’exercer : demander à des amis d’arriver tous ensemble à midi et chronométrer la file.

Omar dit que le service de soutien recevra environ dix fois plus de billets que d’habitude au Vendredi fou. Tomás a un plan rapide : « Envoyons 1 000 billets à l’API pour voir ce qui se passe. »

Mais 1 000 billets sur combien de temps? Comparons deux interprétations de « dix fois », tirées des mêmes données. Chaque billet nécessite deux appels de clavardage (classer et rédiger une réponse). Le quota est de 100 appels de clavardage par minute :

  • L’heure la plus chargée, multipliée par dix : 1 010 billets en une heure. Cela donne 17 billets par minute, donc 34 appels de clavardage par minute. Le quota suffit largement.
  • La minute la plus chargée, multipliée par dix : 90 billets en une minute, donc 180 appels de clavardage. C’est presque le double du quota.

Les deux représentent « dix fois ». L’une indique que le service fonctionne bien; l’autre, qu’environ la moitié des billets échouent. Sans échelle de temps, un test ne donne aucune réponse. Et si Tomás choisit l’échelle au hasard, personne ne peut répéter son test la semaine prochaine.

Un modèle de charge de travail décrit brièvement, par écrit, les requêtes qu’un service doit traiter. Il comprend cinq parties :

  1. Taux d’arrivée : le nombre moyen de requêtes qui arrivent par seconde, pendant la période que vous planifiez.
  2. Taille des pointes : le nombre maximal de requêtes sur une courte période, comme une minute. Le trafic réel n’est jamais régulier.
  3. Durée des tâches : le temps nécessaire pour une requête, quand rien d’autre n’attend.
  4. Taille des données transmises : la taille de chaque requête. Un texte plus long coûte plus de jetons (tokens) et de temps.
  5. Attentes des utilisateurs : le temps d’attente que les utilisateurs acceptent, dans leurs mots.

On parle de modèle parce qu’il représente le trafic réel de façon simplifiée. Il garde ce qui compte pour le test et laisse le reste de côté. Chaque partie contient un nombre ou une hypothèse écrite que quelqu’un pourra vérifier plus tard.

Un petit exemple : l’heure la plus chargée, multipliée par dix

Section intitulée « Un petit exemple : l’heure la plus chargée, multipliée par dix »

Les grandes données d’exercice contiennent 300 000 billets fictifs répartis sur une année. L’heure la plus chargée de l’année comptait 101 billets. Appliquez le « dix fois » d’Omar à cette heure, une étape à la fois :

Étape Calcul Résultat
Billets dans l’heure la plus chargée d’après les données 101
Dix fois (estimation d’Omar) 101 × 10 1 010 billets
Taux d’arrivée par seconde 1 010 ÷ 3 600 s 0,28 billet par seconde
Appels de clavardage par minute 1 010 × 2 ÷ 60 34 par minute
Comparaison avec le quota 34 ÷ 100 34 % du quota

Passons à la pointe. La minute la plus chargée de l’année comptait 9 billets :

Étape Calcul Résultat
Dix fois 9 × 10 90 billets en une minute
Taux d’arrivée par seconde 90 ÷ 60 s 1,5 billet par seconde
Appels de clavardage dans cette minute 90 × 2 180
Comparaison avec le quota 180 ÷ 100 180 % du quota

La moyenne horaire ne pose pas de risque. La pointe, oui. Un modèle de charge de travail doit inclure les deux chiffres, car ils mènent à des décisions différentes.

Appels de clavardage par minute nécessaires au service de soutien, d'après les grandes données d'exercice. L'heure la plus chargée respecte le quota, même multipliée par dix. La minute la plus chargée, multipliée par dix, nécessite presque le double du quota.
Description textuelle du graphique

Quatre colonnes, en appels de clavardage par minute. L’heure la plus chargée d’une année normale : 3,4. L’heure la plus chargée, multipliée par dix : 34. La minute la plus chargée, multipliée par dix : 180. Le quota du fournisseur : 100. Seule la pointe dépasse le quota.

Pourquoi des pointes surviennent même pendant une heure calme

Section intitulée « Pourquoi des pointes surviennent même pendant une heure calme »

Un taux de 101 billets par heure semble régulier : environ 1,7 par minute. Il ne l’est pas. Les clients agissent chacun de leur côté. Certaines minutes ne reçoivent donc aucun billet, et d’autres en reçoivent plusieurs. Le graphique répartit les 60 minutes de l’heure la plus chargée selon le nombre de billets reçus.

L'heure la plus chargée des grandes données (16 septembre 2026, de 19 h à 20 h UTC) : 101 billets, mais pas 1,7 chaque minute. Dix minutes n'en comptaient aucun, et quatre minutes en comptaient quatre.
Description textuelle du graphique

Pour chaque nombre de billets par minute, de 0 à 4, voici le nombre de minutes dans l’heure la plus chargée : 0 billet pendant 10 minutes, 1 pendant 17, 2 pendant 19, 3 pendant 10 et 4 pendant 4 minutes. La moyenne est de 1,7 billet par minute.

La minute la plus chargée de cette heure comptait quatre billets, soit plus du double de la moyenne. Sur l’année entière, la minute la plus chargée en comptait neuf. Voilà pourquoi la pointe constitue une partie distincte du modèle. Un test qui envoie une moyenne régulière ne rencontre jamais la minute qui dépasse le quota.

La journée elle-même n’est pas régulière non plus. Le 16 septembre, jour de l’heure la plus chargée, les billets sont arrivés de 7 h à 20 h 59 UTC. Les heures étaient très différentes :

Billets par heure le 16 septembre 2026, jour de l'heure la plus chargée des grandes données (heures en UTC). L'heure de 19 h comptait 101 billets; les heures calmes en comptaient environ 31.
Description textuelle du graphique

Billets par heure le 16 septembre 2026, de 7 h à 20 h UTC : 67, 72, 69, 33, 76, 75, 31, 74, 68, 72, 37, 73, 101 et 35. L’heure de 19 h est la plus chargée de toute l’année.

Durée des tâches. Vous l’avez mesurée dans la dernière leçon : un billet seul prend environ 2,2 secondes. Presque tout ce temps sert à attendre le fournisseur. Notez la source du chiffre : les temps enregistrés du fournisseur, un appel à la fois.

Taille des données transmises. scripts.workload mesure les textes des billets : la médiane est de 125 caractères, soit environ 31 jetons. Le plus long compte 196 caractères. Les textes courts font que la taille des requêtes ne pose pas de problème ici. Dans un autre service, par exemple pour résumer de longs documents, la taille des données transmises pourrait dominer le modèle.

Attentes des utilisateurs. Cette partie vient des personnes, pas des données. Amira pose la question à Omar. Il réfléchit un instant : « Le client doit voir en moins de 5 secondes que son billet a été enregistré. Le service de soutien peut attendre quelques minutes pour le brouillon de réponse. » Notez ses mots tels quels dans le modèle. Ils définissent la promesse de ce cours : un nouveau billet est enregistré en moins de 5 secondes. Une réponse qui arrive plus tard n’est pas un travail utile. Les leçons suivantes testent cette promesse, et le module 4 modifie la conception pour la respecter.

Effectuez maintenant la mesure vous-même.

  1. Dans ~/projects/ticket-api, avec l’environnement virtuel actif, copiez les deux fichiers de cette leçon depuis l’instantané end-of-m01 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C21/snapshots/end-of-m01
    cp "$S/scripts/workload.py" scripts/
    cp "$S/docs/workload.md" docs/
  2. Exécutez le script sur les petites données, actuellement chargées :

    Fenêtre de terminal
    python -m scripts.workload
    Tickets: 200 from 2026-09-25 to 2026-10-08 (14 days)
    Per day: 14 on average, 23 on the busiest day
    Per hour with tickets: 1.7 on average, 5 in the busiest hour
    Busiest minute: 2 tickets
    Ticket text (subject + body): median 126 characters (about 32 tokens), p95 164, longest 183
    Busiest hour: 5 tickets = 0.00 per second on average
    Chat calls to the AI provider in that hour: 0 per minute (the quota is 100 per minute)

    Deux semaines comptant 200 billets ne peuvent pas décrire le Vendredi fou. Il vous faut une année de données.

  3. Chargez les grandes données. Cela prend environ une demi-minute, plus le téléchargement des vecteurs la première fois :

    Fenêtre de terminal
    python -m scripts.load --size large --reset

    Les dernières lignes indiquent les nombres, en commençant par customers 20,000 (20 000 clients) et tickets 300,000 (300 000 billets).

  4. Décrivez les grandes données, d’abord telles quelles, puis multipliées par dix :

    Fenêtre de terminal
    python -m scripts.workload
    python -m scripts.workload --factor 10
    Tickets: 300,000 from 2025-10-09 to 2026-10-08 (365 days)
    Per day: 822 on average, 899 on the busiest day
    Per hour with tickets: 58.7 on average, 101 in the busiest hour
    Busiest minute: 9 tickets
    Ticket text (subject + body): median 125 characters (about 31 tokens), p95 169, longest 196
    Busiest hour x 10: 1,010 tickets = 0.28 per second on average
    Chat calls to the AI provider in that hour: 34 per minute (the quota is 100 per minute)

    La sortie ci-dessus correspond à --factor 10. Sans cette option, les deux dernières lignes indiquent 101 tickets = 0.03 per second (101 billets, soit 0,03 par seconde) et 3 per minute (3 par minute).

  5. Ouvrez docs/workload.md. Ce fichier présente l’exemple détaillé de cette leçon sous forme de tableau. Chaque ligne contient une valeur pour un jour normal, une valeur pour le Vendredi fou et sa source. Trouvez la ligne « What users expect » (attentes des utilisateurs). Elle contient les mots d’Omar et la promesse de 5 secondes. Comparez-la avec votre propre modèle.

  6. Rechargez les petites données. Les tests de charge de ce module les utilisent :

    Fenêtre de terminal
    python -m scripts.load --reset

Le script compte seulement les billets d’exercice. Les billets de vos tests de charge commencent à T-500001, et le script les exclut. Ainsi, un test ne change jamais le modèle.

Un modèle sur papier n’est pas encore un test. Une charge de travail reproductible est un script qui envoie les mêmes requêtes, de la même façon, à chaque exécution. Ainsi, deux exécutions diffèrent seulement par ce que vous avez changé.

loadtest/locustfile.py, que vous avez exécuté dans la dernière leçon, fixe ces parties du test :

Partie Comment le fichier locustfile la fixe
La requête POST /v1/tickets avec un sujet et un corps
Les données transmises les sujets et les corps des 200 billets d’exercice, choisis avec la graine fixe 21
Les expéditeurs -u utilisateurs; chacun envoie, attend la réponse, puis envoie de nouveau
La durée -t 60s, en excluant les premières secondes comme période d’échauffement (prochaine leçon)

Le fichier locustfile ne fixe pas une partie : le taux d’arrivée. Chaque utilisateur Locust attend sa réponse avant d’envoyer le billet suivant. Avec 4 utilisateurs, au plus 4 billets sont donc en cours à la fois. Ce type de test est une boucle fermée : les réponses déterminent quand les prochaines requêtes arrivent.

Les vrais clients forment un flux ouvert. Ils ne s’attendent pas les uns les autres. Au Vendredi fou, 90 clients en une minute envoient 90 billets, même si l’API n’a pas répondu aux premiers.

Deux boîtes côte à côte. À gauche, une boucle fermée : Locust avec 4 utilisateurs, sans pause. Les utilisateurs envoient le billet suivant seulement après la réponse; ticket-api répond après environ 2,2 s, et la flèche revient aux utilisateurs. À droite, un flux ouvert : les clients du Vendredi fou arrivent à leur propre rythme, 90 pendant la minute la plus chargée. Un nouveau billet va donc à ticket-api toutes les 0,7 s, avec ou sans réponse.
Une boucle fermée attend les réponses; un flux ouvert ne les attend pas. Les tests du module 1 sont des boucles fermées.
Description textuelle du diagramme

Dans la boucle fermée à gauche, chacun des quatre utilisateurs attend sa réponse, environ 2,2 secondes, avant d’envoyer de nouveau. Une API lente ralentit les expéditeurs. Le test n’envoie donc jamais plus de quatre billets à la fois. Dans le flux ouvert à droite, les clients arrivent à leur propre rythme : 90 pendant la minute la plus chargée, soit un toutes les 0,7 secondes. Ils continuent d’arriver, que l’API ait répondu ou non.

Sam demande : « Alors, la boucle fermée, c’est une erreur? » Non. Une boucle fermée convient pour mesurer la vitesse du service avec un nombre fixe de requêtes en cours. C’est le rôle des deux prochaines leçons. Mais une boucle fermée masque un danger : quand l’API ralentit, le test ralentit aussi, donc la file ne grandit jamais. Le module 4 envoie un flux ouvert à taux fixe, et vous y verrez ce qui se passe.

Rédigez un modèle de charge de travail avant chaque test de charge et chaque décision de capacité. Cela prend une heure et évite l’erreur la plus courante dans le travail sur la performance : un test qui répond à une question que personne n’a posée.

Gardez chaque modèle petit. Cinq chiffres et leurs sources suffisent. Un modèle de cinquante chiffres semble précis, mais personne ne le vérifie.

Connaissez ses limites. Le ×10 est une estimation d’Omar, pas une donnée. Le modèle l’indique dans la colonne « where it comes from » (source). Après le Vendredi fou, comparez la journée réelle au modèle et corrigez le prochain. Un modèle jamais vérifié n’est qu’une supposition dans un tableau.

Erreur courante

La charge de travail indique 0,00 par seconde

Symptôme : python -m scripts.workload affiche Busiest hour: 5 tickets = 0.00 per second on average (heure la plus chargée : 5 billets, soit 0,00 par seconde en moyenne) et 0 per minute (0 par minute).

Cause : les petites données sont chargées : 200 billets sur 14 jours. Les chiffres sont corrects pour ces données, mais trop petits pour décrire un vrai service de soutien.

Diagnostic : lisez la première ligne de la sortie. Elle indique Tickets: 200 from 2026-09-25 to 2026-10-08 (14 days) (200 billets du 25 septembre au 8 octobre 2026, soit 14 jours).

Correction : chargez les grandes données avec python -m scripts.load --size large --reset, puis exécutez le script de nouveau. Ensuite, rechargez les petites données avec python -m scripts.load --reset.

Erreur courante

Un modèle fondé seulement sur la moyenne horaire

Symptôme : le modèle indique « 0,28 billet par seconde, 34 % du quota : aucun problème ». Puis, le jour réel, de nombreux billets échouent avec des erreurs.

Cause : le modèle contient le taux d’arrivée, mais pas la taille des pointes. La minute la plus chargée, multipliée par dix, nécessite 180 appels de clavardage, presque le double du quota.

Correction : placez toujours la pointe à côté du taux. Dans ces données, une pointe correspond à la minute la plus chargée. Pour un service dont la limite compte par seconde, examinez aussi la seconde la plus chargée.

Omar rappelle : l’équipe marketing prévoit maintenant une campagne plus grande, et il attend quinze fois plus de billets que d’habitude. Prédisez le taux d’arrivée pendant l’heure la plus chargée et les appels de clavardage par minute. Puis, prédisez les appels de clavardage pendant la minute la plus chargée. Vérifiez l’heure avec python -m scripts.workload --factor 15 sur les grandes données.

Afficher la réponse

L’heure la plus chargée : 101 × 15 = 1 515 billets. Cela donne 1 515 ÷ 3 600 = 0,42 billet par seconde, et 1 515 × 2 ÷ 60 = environ 50 appels de clavardage par minute. Cela reste dans le quota. L’exécution de l’auteur a affiché :

Busiest hour x 15: 1,515 tickets = 0.42 per second on average
Chat calls to the AI provider in that hour: 50 per minute (the quota is 100 per minute)

La minute la plus chargée : 9 × 15 = 135 billets, donc 270 appels de clavardage en une minute. C’est 2,7 fois le quota. Le script n’affiche pas la pointe avec le nouveau facteur, donc vous la calculez. L’heure respecte encore le quota, mais la pointe devient bien pire.

Vérifiez votre compréhension

Le modèle d'Omar prévoit 1 010 billets pendant l'heure la plus occupée. Tomás dit que cela représente seulement 34 appels de clavardage par minute. Le quota de 100 ne pose donc aucun problème. Que manque-t-il à son raisonnement? Utilisez les nombres de cette leçon.

Afficher la réponse

La pointe de trafic. Les billets n’arrivent pas à un rythme constant. La minute la plus occupée de l’année comptait 9 billets. La moyenne était de 1,7 par minute pendant l’heure la plus occupée. Avec un facteur de dix, cette minute compte 90 billets et nécessite 180 appels de clavardage. C’est presque le double du quota de 100. La moyenne horaire respecte donc le quota, mais pas la pointe. Un modèle de charge de travail doit indiquer la taille des pointes à côté du taux d’arrivée.

Vérifiez votre compréhension

Un test Locust avec 4 utilisateurs n'envoie jamais plus de 4 billets à la fois. Expliquez pourquoi. Pourquoi cela peut-il cacher un problème que de vrais clients causeraient?

Afficher la réponse

Chaque utilisateur Locust envoie un billet, attend la réponse, puis envoie le suivant. C’est une boucle fermée. Il y a donc au plus 4 billets en cours de traitement. Les vrais clients forment un flux ouvert. Ils envoient des billets à leur propre rythme, que l’API ait répondu ou non. Si l’API ralentit, une boucle fermée envoie moins de billets et la file d’attente ne grossit jamais. Un flux ouvert continue d’envoyer des billets, et la file d’attente grossit.

Vérifiez votre compréhension

Vérification pratique : écrivez les cinq éléments du modèle de charge de travail pour le Vendredi fou de Larkfield. Indiquez la valeur et la source de chaque élément.

Afficher la réponse

Taux d’arrivée : 1 010 billets pendant l’heure la plus occupée = 0,28 par seconde (scripts.workload --factor 10; le ×10 est une estimation d’Omar, donc une hypothèse). Pointe : 90 billets pendant la minute la plus occupée = 180 appels de clavardage, pour un quota de 100 (9 × 10, selon le même script). Durée de la tâche : environ 2,2 s par billet traité seul (les temps enregistrés du fournisseur). Taille des données envoyées : médiane de 125 caractères, environ 31 jetons, maximum de 196 (scripts.workload). Attentes des utilisateurs : le billet enregistré en moins de 5 secondes, la réponse préliminaire en quelques minutes (Omar). Votre fichier docs/workload.md contient les mêmes valeurs.

Récapitulatif

  • Un modèle de charge de travail comprend cinq éléments : taux d’arrivée, taille des pointes, durée des tâches, taille des données envoyées et attentes des utilisateurs. Chacun a sa source.
  • Le Vendredi fou de Larkfield, avec un facteur de dix : 0,28 billet par seconde pendant l’heure la plus occupée (34 appels de clavardage par minute). Mais la minute la plus occupée compte 90 billets (180 appels de clavardage, pour un quota de 100).
  • Le trafic n’est pas régulier. Même l’heure la plus occupée avait des minutes sans billets et des minutes avec quatre billets. La pointe détermine si le quota suffit.
  • Une charge de travail reproductible envoie les mêmes requêtes de la même façon chaque fois. Le fichier locustfile fonctionne en boucle fermée : les utilisateurs attendent les réponses. Les vrais clients forment un flux ouvert.
  • Le ×10 est une hypothèse. Notez-la et vérifiez-la après cette journée.

Ensuite, vous mesurez le service avec cette charge de travail : moyennes, centiles et première référence de base.

Leçon suivante : Latence et capacité