Aller au contenu
English

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.

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 mainEnviron 45 minutes

Ce que vous devez savoir

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.

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.

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 :

  1. Classer : déterminer quelle équipe reçoit le billet et son degré d’urgence.
  2. Rédiger une réponse : une première réponse qu’une personne du service de soutien vérifie avant l’envoi.
  3. 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.

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.

Un flux de gauche à droite. L'équipe du cours a enregistré une seule fois 763 appels réels à un modèle hébergé. Ces données vont dans calibration.json : 100 durées par tâche, le quota de 100 requêtes de conversation par minute et les nombres de jetons. calibration.json alimente python -m simulator sur votre ordinateur, au port 8300. ticket-api, au port 8000, envoie des requêtes classify (classer), draft (rédiger) et embed (créer un plongement) au simulateur. Celui-ci répond après une durée enregistrée, ou avec 429 si le quota est dépassé. Une note en pointillé sur le simulateur : il ne simule pas les réponses plus lentes sous charge, les vraies pannes ni les vraies réponses du modèle.
D'où vient le comportement du fournisseur simulé. Les durées et le quota sont réels; les réponses ne le sont pas.
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) et outage (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.

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.

Un diagramme de séquence avec quatre participants : l'outil du service de soutien ou le générateur de charge, ticket-api POST /v1/tickets, PostgreSQL et le fournisseur d'IA simulé. Le client envoie un nouveau billet. L'API commence une transaction et emprunte une connexion, insère le billet T-500001, puis appelle le fournisseur trois fois : classify (équipe et priorité, environ 0,9 s), draft (texte de réponse, environ 1,1 s) et embed (384 nombres, environ 0,2 s). Ensuite, elle enregistre 3 exécutions d'IA, l'équipe et le vecteur, valide la transaction et rend la connexion. Elle répond avec 201 Created (créé) et un en-tête Server-Timing. Une note : la connexion reste empruntée pendant toute la durée, environ 2,2 s.
Un nouveau billet selon la conception de ce module : une transaction englobe tout, avec trois appels au fournisseur l'un après l'autre.
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.

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).

  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ôt git -C nextia-learning-labs pull.

    Fenêtre de terminal
    cd ~/projects
    git clone https://github.com/Nextia-Intelligence/nextia-learning-labs.git

    Sans Git, téléchargez le fichier ZIP du dépôt et décompressez-le dans ~/projects. Son dossier s’appelle alors nextia-learning-labs-main. Utilisez ce nom dans les étapes suivantes.

  2. Si un dossier ticket-api existe, renommez-le d’abord. Ensuite, copiez l’instantané start et créez votre .env :

    Fenêtre de terminal
    mv ticket-api ticket-api-databases # only if the folder exists
    cp -R nextia-learning-labs/C21/snapshots/start ticket-api
    cd ticket-api
    cp .env.example .env
  3. Ouvrez le dossier dans VS Code. Dans .env, remplacez change-me-local-only par votre propre mot de passe, aux trois endroits.

  4. 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
  5. Créez l’environnement virtuel, installez les paquets, chargez les données et exécutez les tests :

    Fenêtre de terminal
    python3 -m venv .venv
    source .venv/bin/activate
    python -m pip install -r requirements.txt
    python -m scripts.load
    python -m pytest

    Le 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.

  6. 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-m01
    cp -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; do
    cp "$S/$f" "$f"
    done
  7. Installez le nouveau paquet, le générateur de charge Locust :

    Fenêtre de terminal
    python -m pip install -r requirements.txt
  8. 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 --reset
    applied 013_ai_work
    Database is up to date (13 migrations).
    Loaded the small data in 1.0 s:
    customers 40
    tickets 200
    messages 331
    attachments 43
    documents 36
    ai_runs 294
    ticket_embeddings 200
    43 files uploaded to the object storage.
    3 messages have no ticket: they are in orphaned_messages.
  9. 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.

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.

Vous exécutez maintenant deux services et envoyez des requêtes depuis un troisième terminal. Activez l’environnement virtuel dans chaque terminal.

  1. Terminal 1, le fournisseur simulé. Laissez-le fonctionner.

    Fenêtre de terminal
    python -m simulator
    Simulated 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.
  2. Terminal 2, l’API. Laissez-la fonctionner aussi.

    Fenêtre de terminal
    fastapi dev
  3. Terminal 3, un billet. Sous Windows, tapez curl.exe plutôt que curl et 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 Created
date: Sat, 10 Oct 2026 13:21:44 GMT
server: uvicorn
content-length: 758
content-type: application/json
server-timing: db;dur=10.3, classify;dur=787.0, draft_reply;dur=1167.7, embed;dur=222.6
x-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.

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.

Fenêtre de terminal
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 24

Ce 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é :

Fenêtre de terminal
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é.

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.

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 Unavailable
date: Sat, 10 Oct 2026 13:22:09 GMT
server: uvicorn
content-length: 138
content-type: application/json
x-request-id: 2c21e9863825
server-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 refused

Cause : 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é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.

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.

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.

É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.

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 pytest affiche 123 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