Exécuter la charge de travail d'IA sur votre ordinateur
- Leçon 1
- 45 min
- Module 1 : Mesurer avant de mettre à l'échelle
Où nous en sommes
Dans Bases de données et stockage pour les applications d'IA, nous avons donné à l'API de billets une base de données qui garde ses données correctes et rapides. Maintenant, chaque nouveau billet pose aussi trois questions à un fournisseur d'IA, et le Vendredi fou peut apporter dix fois plus de billets que d'habitude. Nous ne pouvons pas tester cela avec le vrai fournisseur. Dans cette leçon, nous exécutons le travail d'IA sur notre ordinateur avec un fournisseur simulé. Pensons d'abord à un commis qui doit téléphoner aux douanes pour un colis.
Leçon 1 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAExécuter la charge de travail d'IA sur votre ordinateur
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
L’API de billets de Larkfield pose maintenant trois questions à un fournisseur d’IA pour chaque nouveau billet de soutien. Exécutez ce travail sur votre ordinateur avec un fournisseur simulé. Lancez votre premier test de charge et lisez ce qu’il vous indique.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- L’API de billets et son dossier de projet
ticket-api, du cours Bases de données et stockage pour les applications d’IA : PostgreSQL dans Docker,python -m scripts.load, les transactions et le pool de connexions (pool) de Gestion des connexions. fastapi devetcurl, du cours Créer et déployer votre première API.- Docker Compose, de Conteneurs et Docker.
Ce qu’il vous faut sur votre ordinateur
- Python 3.12 ou une version ultérieure, Docker Desktop, VS Code et un terminal.
- Environ 500 Mo d’espace disque libre pour les nouveaux paquets. Aucun compte, aucune clé et aucun paiement.
Vous partez de l’instantané start (départ) : le projet à la fin du cours sur les bases de données, sans modification. Si vous avez votre propre ticket-api de ce cours, conservez-le sous un autre nom. Ce cours commence avec une copie propre.
Un commis au téléphone
Section intitulée « Un commis au téléphone »Pensez au comptoir d’un bureau de poste. Un client apporte un colis destiné à un autre pays. Le commis le pèse en dix secondes. Ensuite, il téléphone au bureau des douanes et attend deux minutes en ligne avant d’obtenir leur accord.
Un jour normal, cela fonctionne. Les clients attendent un peu, et la file reste courte. Mais le travail du commis prend dix secondes, et l’appel dure deux minutes. Le client passe presque tout son temps à attendre quelqu’un d’autre. Et les douanes imposent une règle : au plus 100 appels par heure provenant de ce bureau de poste.
Imaginez maintenant la semaine avant un congé, avec dix fois plus de clients. La file s’allonge. Le commis ne peut pas travailler plus vite, car il passe surtout son temps à attendre. Et après 100 appels, les douanes cessent de répondre pendant un moment.
L’API de billets de Larkfield est sur le point de devenir ce commis.
Le Vendredi fou chez Larkfield
Section intitulée « Le Vendredi fou chez Larkfield »Vous connaissez le service de soutien de Larkfield grâce au cours sur les bases de données. Amira, la développeuse, est responsable de l’API de billets et vous guide dans ce cours. Mei, l’ingénieure de données, est responsable de la base de données et surveille ses connexions. Omar, le gestionnaire de produit, apporte les chiffres et demande ce que les clients verront. Kwame, l’architecte de solutions, demande combien coûte chaque changement. Tomás, un ingénieur en IA, aime les solutions rapides. Sam pose les questions des débutants, qui sont peut-être aussi les vôtres.
L’API effectue maintenant du travail d’IA pour chaque nouveau billet. Quand un client envoie un billet, l’API demande trois choses à un fournisseur d’IA :
- Classer : déterminer quelle équipe reçoit le billet et son degré d’urgence.
- Rédiger une réponse : une première réponse qu’une personne du service de soutien vérifie avant l’envoi.
- Créer un plongement (embedding) : un vecteur du texte du billet, pour que le service de soutien trouve des billets semblables.
Le Vendredi fou approche. Omar prévoit environ dix fois plus de billets que d’habitude pendant quelques heures. « Est-ce que l’API va tenir? », demande-t-il. Amira répond franchement : « Je ne sais pas encore. Personne ne le sait tant qu’on n’a pas mesuré. »
C’est toute l’idée de ce module : mesurer avant de changer quoi que ce soit. Dans cette leçon, vous construisez ce que vous allez mesurer. Vous exécutez l’API et son travail d’IA sur votre ordinateur, puis vous lui envoyez sa première charge.
Le problème : vous ne pouvez pas tester avec le vrai fournisseur
Section intitulée « Le problème : vous ne pouvez pas tester avec le vrai fournisseur »Le travail d’IA est lent, et le fournisseur impose des limites. L’équipe du cours a appelé le vrai fournisseur, un modèle de conversation hébergé et un modèle de plongement, un appel à la fois. Les durées médianes étaient de 913 ms pour classer, 1 097 ms pour rédiger une réponse et 198 ms pour créer un plongement. Le compte permet 100 requêtes de conversation par minute. Cette limite est le quota du fournisseur.
Alors, pourquoi ne pas exécuter vos tests avec le vrai fournisseur? Voici quatre raisons :
- Coût et comptes. Chaque appel coûte un peu, et il vous faut un compte et une clé. Ce cours ne demande ni l’un ni l’autre.
- Le service de quelqu’un d’autre. Un test de charge envoie volontairement de nombreuses requêtes. Ne testez jamais la charge d’un service qui ne vous appartient pas.
- Un quota partagé. Le quota appartient au compte. Votre test utiliserait le quota dont les vrais utilisateurs ont besoin.
- Des résultats instables. La vitesse du fournisseur change d’heure en heure, pour des raisons que vous ne pouvez pas voir. Vous ne pourriez pas reproduire un test.
Il vous faut quand même quelque chose qui répond comme le fournisseur : lentement, avec la même dispersion des durées et le même quota.
L’idée : un fournisseur simulé
Section intitulée « L’idée : un fournisseur simulé »Les pilotes s’entraînent dans un simulateur de vol. Ce n’est pas un avion, mais les commandes, les instruments et les délais se comportent comme dans un vrai avion. Un pilote peut s’exercer à gérer une panne de moteur sans danger.
Ce cours fait la même chose avec le fournisseur d’IA. Un fournisseur simulé est un petit programme sur votre ordinateur qui répond aux mêmes requêtes que le vrai fournisseur. Il ne réfléchit pas. Il attend pendant une durée réaliste, puis envoie une réponse simple dans le bon format.
Le fournisseur d’IA de ce cours est simulé sur votre ordinateur. Ses durées et son quota viennent d’appels réels enregistrés par l’équipe du cours; ses réponses sont simples. Tous les billets, clients et messages sont inventés pour le cours, comme dans le cours sur les bases de données.
Description textuelle du diagramme
L’équipe du cours a fait 763 appels réels au fournisseur. Un script a regroupé les durées enregistrées, le quota et les nombres de jetons dans un fichier, calibration.json. Le simulateur lit ce fichier. Quand l’API de billets l’appelle, le simulateur choisit une durée enregistrée, attend pendant cette durée, puis répond. Si le quota est dépassé, il refuse avec HTTP 429. Il ne ralentit pas sous charge, n’a aucune vraie panne et donne des réponses simples.
Ce que le simulateur reproduit à partir des enregistrements :
- Les durées. Pour chaque tâche, il tire une durée parmi les 100 durées enregistrées pour cette tâche. Sa médiane et ses appels lents sont ceux du vrai fournisseur.
- Le quota. 100 requêtes de conversation par minute. Une rafale permet environ 100 appels, puis le simulateur refuse.
- Un refus. Le statut HTTP 429 Too Many Requests (trop de requêtes), après environ 0,13 s, avec deux indications sur le moment où réessayer. Trouver le goulot d’étranglement les examine en détail.
- Les nombres de jetons (tokens). Pour que le coût de chaque billet soit réaliste.
Ce qu’il ne reproduit pas, et dont vous devez tenir compte en lisant un résultat :
- Le vrai fournisseur ralentissait quand de nombreux appels arrivaient en même temps. Rédiger une réponse prenait environ 7 % plus de temps avec 16 appels en cours, et environ 30 % avec 40. Le simulateur utilise toujours les durées mesurées avec un seul appel à la fois.
- Les vraies pannes et périodes de ralentissement. Les modes
slow(lent) etoutage(panne) du simulateur sont inventés pour le module 5. - Les réponses. Une réponse rédigée par le simulateur est une seule phrase fixe. La durée est réaliste; le texte ne l’est pas.
Un petit exemple : un billet
Section intitulée « Un petit exemple : un billet »Avant d’exécuter quoi que ce soit, additionnez le temps nécessaire pour un billet. Les trois appels d’IA s’exécutent l’un après l’autre, donc leurs durées s’additionnent :
| Étape | Qui travaille | Durée (médiane des appels réels) |
|---|---|---|
| Enregistrer le billet | PostgreSQL | quelques ms |
| Classer | le fournisseur | 913 ms |
| Rédiger une réponse | le fournisseur | 1 097 ms |
| Créer un plongement | le fournisseur | 198 ms |
| Enregistrer les résultats | PostgreSQL | quelques ms |
| Total | environ 2 208 ms |
Un billet prend donc environ 2,2 secondes. Presque tout ce temps sert à attendre le fournisseur, comme le commis au téléphone. Le diagramme montre la même requête sous forme de séquence.
Description textuelle du diagramme
L’API ouvre une transaction et enregistre le billet. Ensuite, elle appelle le fournisseur trois fois, et chaque appel attend sa réponse : environ 0,9, 1,1 et 0,2 seconde. Puis elle enregistre les résultats et valide la transaction. Le billet est enregistré seulement si tout le travail d’IA a réussi. La connexion à la base de données reste empruntée pendant les 2,2 secondes. Ce détail compte dans le module 2.
Préparer le projet
Section intitulée « Préparer le projet »Vous copiez l’instantané start, le vérifiez, puis ajoutez les fichiers de cette leçon à partir de l’instantané end-of-m01 (fin du module 1).
-
Obtenez les fichiers du cours. Si vous avez Git, clonez le dépôt des exercices une seule fois, dans
~/projects. Si vous avez déjà le clone, exécutez plutôtgit -C nextia-learning-labs pull.Fenêtre de terminal cd ~/projectsgit clone https://github.com/Nextia-Intelligence/nextia-learning-labs.gitSans Git, téléchargez le fichier ZIP du dépôt et décompressez-le dans
~/projects. Son dossier s’appelle alorsnextia-learning-labs-main. Utilisez ce nom dans les étapes suivantes. -
Si un dossier
ticket-apiexiste, renommez-le d’abord. Ensuite, copiez l’instantanéstartet créez votre.env:Fenêtre de terminal mv ticket-api ticket-api-databases # only if the folder existscp -R nextia-learning-labs/C21/snapshots/start ticket-apicd ticket-apicp .env.example .envFenêtre de terminal Rename-Item ticket-api ticket-api-databases # only if the folder existsCopy-Item -Recurse nextia-learning-labs\C21\snapshots\start ticket-apicd ticket-apiCopy-Item .env.example .env -
Ouvrez le dossier dans VS Code. Dans
.env, remplacezchange-me-local-onlypar votre propre mot de passe, aux trois endroits. -
Démarrez Docker Desktop. Ensuite, démarrez PostgreSQL et Azurite, le stockage objet du cours sur les bases de données. Le programme de chargement téléverse les fichiers du service de soutien dans Azurite.
Fenêtre de terminal docker compose up -d db azurite -
Créez l’environnement virtuel, installez les paquets, chargez les données et exécutez les tests :
Fenêtre de terminal python3 -m venv .venvsource .venv/bin/activatepython -m pip install -r requirements.txtpython -m scripts.loadpython -m pytestFenêtre de terminal python -m venv .venv.venv\Scripts\Activate.ps1python -m pip install -r requirements.txtpython -m scripts.loadpython -m pytestLe chargement applique 12 migrations et affiche les données du petit jeu : 200 billets, 43 fichiers et le reste. Les tests se terminent avec
108 passed, 1 deselected(108 réussis, 1 non sélectionné). C’est le projet du cours sur les bases de données, et il fonctionne. -
Copiez les fichiers de cette leçon à partir de l’instantané
end-of-m01. Dix fichiers et deux dossiers sont nouveaux; seize fichiers changent.Fenêtre de terminal S=../nextia-learning-labs/C21/snapshots/end-of-m01cp -R "$S/simulator" "$S/loadtest" .for f in migrations/013_ai_work.sql ticket_api/ai.py ticket_api/provider.py \ticket_api/intake.py ticket_api/prices.py ticket_api/timing.py \ticket_api/config.py ticket_api/errors.py ticket_api/main.py \ticket_api/models.py ticket_api/repository.py scripts/load.py \tests/fakes.py tests/test_ai.py tests/test_simulator.py tests/test_intake.py \tests/conftest.py contract/openapi.json requirements.txt requirements-lock.txt \pyproject.toml compose.yaml .env.example Dockerfile .dockerignore README.md; docp "$S/$f" "$f"doneFenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m01"Copy-Item -Recurse "$S\simulator", "$S\loadtest" .$files = 'migrations\013_ai_work.sql', 'ticket_api\ai.py', 'ticket_api\provider.py','ticket_api\intake.py', 'ticket_api\prices.py', 'ticket_api\timing.py','ticket_api\config.py', 'ticket_api\errors.py', 'ticket_api\main.py','ticket_api\models.py', 'ticket_api\repository.py', 'scripts\load.py','tests\fakes.py', 'tests\test_ai.py', 'tests\test_simulator.py', 'tests\test_intake.py','tests\conftest.py', 'contract\openapi.json', 'requirements.txt', 'requirements-lock.txt','pyproject.toml', 'compose.yaml', '.env.example', 'Dockerfile', '.dockerignore', 'README.md'foreach ($f in $files) { Copy-Item "$S\$f" $f } -
Installez le nouveau paquet, le générateur de charge Locust :
Fenêtre de terminal python -m pip install -r requirements.txt -
Appliquez la nouvelle migration et chargez de nouveau les données. Les tables contiennent déjà des données, donc ajoutez
--reset:Fenêtre de terminal python -m scripts.load --resetapplied 013_ai_workDatabase is up to date (13 migrations).Loaded the small data in 1.0 s:customers 40tickets 200messages 331attachments 43documents 36ai_runs 294ticket_embeddings 20043 files uploaded to the object storage.3 messages have no ticket: they are in orphaned_messages. -
Exécutez les tests :
python -m pytest. Attendez-vous à123 passed, 1 deselected(123 réussis, 1 non sélectionné), soit 15 de plus qu’avant. Les nouveaux tests utilisent un faux fournisseur qui répond immédiatement, donc ils n’attendent pas.
Le rôle des nouveaux fichiers
Section intitulée « Le rôle des nouveaux fichiers »| Fichier | Son rôle |
|---|---|
ticket_api/ai.py |
Les trois requêtes au fournisseur et le code qui vérifie chaque réponse. La classification demande du JSON dans un format fixe. |
ticket_api/provider.py |
Le client qui envoie les requêtes. Il transforme chaque défaillance en une des quatre erreurs : délai dépassé, refus pour dépassement du quota (429), fournisseur indisponible (5xx ou aucune connexion), ou requête incorrecte. |
ticket_api/intake.py |
POST /v1/tickets : une transaction englobe le billet et tout son travail d’IA, comme dans le diagramme. Elle ajoute un en-tête Server-Timing avec la durée de chaque partie. |
ticket_api/prices.py |
Des prix datés par million de jetons, pour estimer le coût de chaque appel. Les prix changent : consultez la page des tarifs du fournisseur. |
migrations/013_ai_work.sql |
Les nouveaux billets reçoivent des numéros de la base de données : T-500001, T-500002, et ainsi de suite. Ce fichier permet aussi la nouvelle tâche embed (créer un plongement). |
simulator/ |
Le fournisseur simulé. calibration.json contient les durées enregistrées et le quota. |
loadtest/locustfile.py |
La première charge de travail pour Locust. |
Le client fonctionne avec tout fournisseur qui possède la même API : définissez PROVIDER_URL et PROVIDER_API_KEY dans .env. Vous n’avez pas besoin de le faire. Sans ces paramètres, l’API appelle le simulateur à http://127.0.0.1:8300/v1.
Exécuter le projet : trois terminaux
Section intitulée « Exécuter le projet : trois terminaux »Vous exécutez maintenant deux services et envoyez des requêtes depuis un troisième terminal. Activez l’environnement virtuel dans chaque terminal.
-
Terminal 1, le fournisseur simulé. Laissez-le fonctionner.
Fenêtre de terminal python -m simulatorSimulated AI provider on http://127.0.0.1:8300/v1 (mode normal). Its times and quota come from real recorded calls; its answers are simple. Stop it with Ctrl+C. -
Terminal 2, l’API. Laissez-la fonctionner aussi.
Fenêtre de terminal fastapi dev -
Terminal 3, un billet. Sous Windows, tapez
curl.exeplutôt quecurlet mettez la commande sur une seule ligne sans le\.Fenêtre de terminal curl -i -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" \-d '{"customer_id": "C-0022", "subject": "Charged twice", "body": "Two payments for one order."}'
L’exécution de l’auteur a affiché ceci. Vos durées et vos dates seront différentes :
HTTP/1.1 201 Createddate: Sat, 10 Oct 2026 13:21:44 GMTserver: uvicorncontent-length: 758content-type: application/jsonserver-timing: db;dur=10.3, classify;dur=787.0, draft_reply;dur=1167.7, embed;dur=222.6x-request-id: ef8bf5f37ece
{"ticket_id":"T-500001","customer_id":"C-0022","subject":"Charged twice","team":"billing","priority":1,"status":"open","created_at":"2026-10-10T13:21:45.090248Z","draft_reply":"Thank you for your message about \"Charged twice\". A person on our help desk will look at it and reply to you soon. If you have an order number, please send it.","embedding_version":"embed-small-384-v1","ai_runs":[{"task":"classify","model":"chat-small (simulated)","latency_ms":787,"tokens_in":176,"tokens_out":15,"cost_usd":0.0000251},{"task":"draft_reply","model":"chat-small (simulated)","latency_ms":1168,"tokens_in":107,"tokens_out":37,"cost_usd":0.0000292},{"task":"embed","model":"embed-small (simulated)","latency_ms":223,"tokens_in":9,"tokens_out":0,"cost_usd":1.8e-7}]}Lisez à partir du haut. Le statut est 201 Created (créé), et le nouveau billet est T-500001. L’en-tête server-timing divise la requête en parties : 10 ms dans la base de données, puis 787, 1 168 et 223 ms pour les trois appels d’IA. Chaque exécution d’IA indique (simulated) (simulé) dans le nom du modèle. Ainsi, une réponse simulée ne peut jamais passer pour une vraie. Les exécutions enregistrent aussi les jetons et le coût : environ 0,00005 $ US pour ce billet. La réponse rédigée est la phrase fixe du simulateur.
Votre premier test de charge
Section intitulée « Votre premier test de charge »Un billet vous indique combien de temps prend un billet. Il ne vous indique pas ce qui arrive quand de nombreux billets arrivent. Pour cela, il faut un test de charge : un programme envoie volontairement de nombreuses requêtes selon un plan et mesure chaque réponse.
Ce programme est un générateur de charge. Ce cours utilise Locust, qui est gratuit et à code source ouvert (licence MIT). Vous décrivez les expéditeurs en Python, dans loadtest/locustfile.py. Chaque expéditeur simulé est un utilisateur. Dans cette charge de travail, un utilisateur envoie un billet, attend la réponse et envoie immédiatement le suivant. Les billets viennent des données d’exercice, choisis avec une graine fixe, pour que chaque exécution envoie le même mélange.
Deux mots décrivent le résultat :
- La latence est la durée d’une requête, de son envoi jusqu’à la fin de la réponse.
- Le débit est le nombre de requêtes qui se terminent chaque seconde.
Faites d’abord une prédiction. Un utilisateur envoie des billets pendant 60 secondes, et chaque billet prend environ 2,2 secondes. Combien de billets par seconde se termineront?
Dans le terminal 3, exécutez Locust avec votre propre API. Ne dirigez jamais un générateur de charge vers un service qui ne vous appartient pas.
locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 1 -r 1 -t 60s-u 1 correspond à un utilisateur, et -r 1 démarre un utilisateur par seconde. -t 60s arrête le test après 60 secondes. --headless affiche des tableaux au lieu d’ouvrir la page Web de Locust. Locust affiche un tableau toutes les quelques secondes. Quand il s’arrête, lisez les deux derniers tableaux. Voici l’exécution de l’auteur sur un ordinateur partagé très occupé, avec la colonne du nom raccourcie. Vos chiffres seront différents :
Type Name # reqs # fails | Avg Min Max Med | req/s failures/s--------|---------------------|-------|-------------|-------|-------|-------|-------|--------|-----------POST POST /v1/tickets 24 0(0.00%) | 2388 1796 3619 2200 | 0.42 0.00--------|---------------------|-------|-------------|-------|-------|-------|-------|--------|----------- Aggregated 24 0(0.00%) | 2388 1796 3619 2200 | 0.42 0.00
Response time percentiles (approximated)Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs--------|---------------------|--------|------|------|------|------|------|------|------|------|------|------|------POST POST /v1/tickets 2200 2400 2600 2600 3300 3400 3600 3600 3600 3600 3600 24Ce que dit le premier tableau :
- 24 requêtes, 0 échec. Chaque billet a reçu son statut 201.
- Avg (moyenne) 2 388 ms, Med (médiane) 2 200 ms. Le billet typique a pris environ 2,2 secondes, comme le prédisait le petit exemple.
- Min (minimum) 1 796 ms, Max (maximum) 3 619 ms. Certains billets étaient deux fois plus lents que d’autres. Les durées du fournisseur varient, et le simulateur reproduit cela.
- req/s (requêtes par seconde) 0,42. Débit : 0,42 billet par seconde. Un utilisateur passe environ 2,4 secondes par billet, et 1 ÷ 2,4 donne environ 0,42.
Le deuxième tableau présente les centiles, comme 95 % : 3 400 ms. Latence et capacité les explique, ainsi que la raison pour laquelle Locust les arrondit.
L’équipe du cours a mesuré le même test cinq fois sur un ordinateur peu occupé : un Apple M4 à 10 cœurs et 16 Go de mémoire, avec PostgreSQL dans Docker. Tous les chiffres de l’équipe du cours dans ce module viennent de cet ordinateur. Le résultat était de 0,43 billet par seconde (de 0,41 à 0,45). Votre résultat décrit votre ordinateur, cette charge de travail et le fournisseur simulé. Il ne dit encore rien sur le Vendredi fou.
Demandez maintenant au simulateur ce qu’il a compté :
curl http://127.0.0.1:8300/admin/stats{"mode":"normal","in_flight":1,"max_in_flight":1,"calls":{"classify":{"200":25},"draft_reply":{"200":24},"embed":{"200":24}},"tokens":10153,"simulated":true}Il y a trois appels par billet, tous avec le statut 200, et jamais plus d’un à la fois. La classification compte un appel de plus que les autres : Locust s’est arrêté pendant le traitement d’un billet. Arrêtez l’API et le simulateur avec Ctrl+C quand vous avez terminé.
Quand utiliser un fournisseur simulé
Section intitulée « Quand utiliser un fournisseur simulé »Sam demande : « Si le simulateur n’est pas le vrai fournisseur, pourquoi croire ce qu’il dit? »
Amira répond : « Faites-lui confiance pour ce qu’il reproduit. Il reproduit les vrais temps et le vrai quota. Il montre donc comment notre service se comporte quand le fournisseur est lent et limité. Il ne peut pas montrer comment le vrai fournisseur se comporte le Vendredi fou. »
Utilisez une dépendance simulée pour tester le comportement de votre propre service. Les tests de charge, délais dépassés, refus et pannes sont plus faciles à provoquer sur un simulateur. Utilisez-le pour des tests reproductibles, ou quand vous n’avez ni budget ni compte.
Ne l’utilisez pas pour juger la qualité des réponses : les réponses simulées se limitent à une seule phrase fixe. Ne l’utilisez pas pour prédire la vitesse du vrai fournisseur sous charge. Le vrai fournisseur ralentit, mais pas le simulateur.
Cela a un coût. Quelqu’un doit enregistrer de vrais appels, maintenir l’étalonnage à jour et écrire « simulé » à côté de chaque nombre. Un simulateur que personne ne compare au vrai service devient peu à peu une fiction. Chaque mesure de ce cours indique quel fournisseur a répondu.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
Le simulateur ne fonctionne pas : 503 ai_unavailable
Symptôme : la commande curl reçoit une réponse en quelques millisecondes, avec une erreur :
HTTP/1.1 503 Service Unavailabledate: Sat, 10 Oct 2026 13:22:09 GMTserver: uvicorncontent-length: 138content-type: application/jsonx-request-id: 2c21e9863825server-timing: db;dur=6.9, classify;dur=1.0
{"error":{"code":"ai_unavailable","message":"The AI provider is not available. Try again later.","request_id":"2c21e9863825","fields":[]}}Le terminal de l’API affiche AI provider: no connection to the provider: [Errno 61] Connection refused (fournisseur d’IA : aucune connexion au fournisseur, connexion refusée). Le nombre après Errno (numéro d’erreur) peut varier sous Windows et Linux.
Cause : rien ne répond sur le port 8300. Le terminal 1 est fermé, ou le simulateur s’est arrêté.
Diagnostic : curl http://127.0.0.1:8300/admin/stats échoue aussi. L’en-tête server-timing (temps de traitement du serveur) montre que la classification s’est terminée après 1 ms, sans réponse.
Solution : lancez python -m simulator dans le terminal 1, puis envoyez le billet de soutien à nouveau. Le billet qui a échoué n’a pas été enregistré, car la transaction a été annulée. Mais son numéro est déjà utilisé : le prochain billet reçoit le numéro suivant. Une séquence de base de données ne donne jamais le même numéro deux fois.
Erreur courante
Le chargement s'arrête avec Connection refused sur le port 10000
Symptôme : python -m scripts.load applique les migrations, puis s’arrête avec un long message d’erreur. Sa dernière ligne est :
azure.core.exceptions.ServiceRequestError: HTTPConnection(host='127.0.0.1', port=10000): Failed to establish a new connection: [Errno 61] Connection refusedCause : Azurite, le stockage objet, ne fonctionne pas. Le programme de chargement y téléverse les 43 fichiers du service de soutien.
Solution : exécutez docker compose up -d db azurite, puis python -m scripts.load --reset.
Réinitialisation. python -m scripts.load --reset recharge les données, et les nouveaux billets recommencent à T-500001. Le simulateur oublie ses compteurs quand vous l’arrêtez. Si votre projet ne fonctionne plus, copiez l’instantané end-of-m01 et conservez votre .env, comme l’indique le README des instantanés. Cet instantané contient aussi les fichiers des trois prochaines leçons.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Nommez deux éléments que le fournisseur simulé reproduit du vrai fournisseur, et deux qu'il ne reproduit pas. Pourquoi est-ce important quand vous lisez le résultat d'un test de charge?
Afficher la réponse
Il reproduit les temps (chacun est tiré parmi les 100 temps enregistrés pour la tâche) et le quota (100 requêtes de clavardage par minute, puis 429). Il reproduit aussi la forme d’un refus et le nombre de jetons. Il ne reproduit pas le ralentissement sous charge (le vrai fournisseur était environ 30 % plus lent avec 40 appels en cours), les vraies pannes ni le contenu des réponses. Un résultat montre donc comment notre service se comporte avec un fournisseur lent et limité. Il ne prédit pas la vitesse du vrai fournisseur le Vendredi fou et ne dit rien sur la qualité des réponses.
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
Avec un utilisateur, Locust a mesuré environ 0,42 billet par seconde. Prédisez le débit avec 2 utilisateurs, si rien d'autre ne limite le service. Expliquez votre nombre.
Afficher la réponse
Environ 0,85 billet par seconde, soit le double. Chaque utilisateur passe environ 2,4 secondes par billet, et deux utilisateurs attendent en même temps. Donc, deux fois plus de billets se terminent par seconde. Le cours a mesuré 0,85 billet par seconde avec 2 utilisateurs (5 passages, quota activé). La latence reste à peu près la même, car chaque billet attend toujours ses trois appels. Les prochaines leçons montrent où cette règle simple cesse de s’appliquer.
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 : montrez que votre installation fonctionne. Qu'affichent les tests, une commande curl et une exécution de Locust de 60 secondes?
Afficher la réponse
python -m pytest se termine par 123 passed, 1 deselected (123 tests réussis, 1 exclu). La commande curl affiche 201 Created (créé), un en-tête server-timing avec db (base de données), classify (classifier), draft_reply (rédiger une réponse) et embed (créer un plongement). Elle affiche aussi trois exécutions d’IA dont le modèle indique (simulated) (simulé). Locust avec -u 1 -t 60s affiche 0 échec, une médiane d’environ 2 200 ms et environ 0,4 requête par seconde. Vos nombres exacts seront différents.
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.
Études de cas de ce cours
À la fin du cours, vous appliquez ce que vous avez appris à un projet réaliste, des données jusqu’à la recommandation. Terminez-en au moins une pour obtenir le certificat; les autres sont facultatives.
- Plan de capacité à partir d'une trace de trafic publiqueModéliser les arrivées et les rafales à partir d'un journal public de demandes, et calculer la file d'attente que créerait un nombre donné de travailleurs.
- File d'attente et cache pour une API de données ouvertesMettre une API de données ouvertes sous charge, ajouter un cache et une tâche d'exportation en arrière-plan, et mesurer l'effet de chaque changement.
Récapitulatif
- Chaque nouveau billet reçoit maintenant trois appels d’IA : classifier, rédiger une réponse, créer un plongement. Dans la conception de ce module, ils s’exécutent l’un après l’autre, dans une seule transaction de base de données.
- Le fournisseur simulé fonctionne sur votre ordinateur. Ses temps et son quota de 100 requêtes de clavardage par minute proviennent de vrais appels enregistrés. Ses réponses sont simples, et il ne ralentit pas sous charge.
- Un billet prend environ 2,2 secondes, presque entièrement passées à attendre le fournisseur. L’en-tête
Server-Timing(temps de traitement du serveur) montre chaque partie. - Un test de charge envoie des requêtes planifiées et mesure chaque réponse. La latence est le temps d’une requête; le débit est le nombre de requêtes terminées par seconde. Un utilisateur Locust a produit environ 0,43 billet par seconde sur un ordinateur peu sollicité.
- Votre projet contient les fichiers de cette leçon :
python -m pytestaffiche123 passed(123 tests réussis).
Ensuite, vous traduirez le « dix fois plus que d’habitude » d’Omar en nombres : arrivées par seconde, pointes et attentes des clients.
Leçon suivante : Modèle de charge de travail