Aller au contenu
English

Travail d'E/S et travail de calcul

  • Leçon 5
  • 55 min
  • Module 2 : Concurrence et limites des services

Où nous en sommes

Dans le module 1, nous avons vu qu'un billet passe environ 98 % de son temps à attendre le fournisseur d'IA. Pendant cette attente, il occupe un fil d'exécution, et le serveur fait peu de vrai travail. Dans cette leçon, nous permettons à un seul processus d'API de traiter plusieurs billets pendant cette attente, et nous voyons comment un seul appel mal choisi fait attendre tout le serveur. Un cuisinier et sa casserole d'eau montrent l'idée.

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

Ce que vous saurez faire

Permettez à un seul processus d’API de traiter plusieurs billets de soutien à la fois. Chaque billet attend plusieurs secondes la réponse du fournisseur d’IA. Apprenez la différence entre le travail d’attente et le travail de calcul. Voyez comment un seul appel mal choisi fait attendre tout le serveur.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet à la fin du module 1 : python -m pytest affiche 128 passed (128 tests réussis). PostgreSQL fonctionne, avec le petit jeu de données chargé.
  • Votre copie du dépôt des exercices, à côté du projet, à jour (git pull dans nextia-learning-labs).

Après cette leçon, votre projet correspond à l’instantané end-of-m02, sauf pour un script de la dernière leçon de ce module. Le fournisseur d’IA est celui simulé sur votre ordinateur : ses durées proviennent d’appels réels enregistrés. Le mode blocking (bloquant) de cette leçon est une erreur faite volontairement. L’équipe du cours a mesuré les résultats sur un Apple M4 (10 cœurs, 16 Go), sans autre activité. Vos durées seront différentes, mais le profil restera le même. Les commandes ont été testées sur macOS (Apple silicon); celles pour Windows ne l’ont pas été.

Un petit restaurant a un seul cuisinier. Une commande de pâtes arrive. Le cuisinier met une casserole d’eau sur la cuisinière. L’eau prend huit minutes à bouillir.

Un bon cuisinier ne reste pas à regarder la casserole pendant huit minutes. Il commence la commande suivante, coupe des légumes et prépare une assiette de salade. Quand l’eau bout, il revient aux pâtes. Un seul cuisinier sert plusieurs commandes, car une commande demande surtout de l’attente : l’eau, le four, le refroidissement au réfrigérateur.

Imaginez maintenant un cuisinier qui reste devant la casserole jusqu’à ce que l’eau bouille. L’eau bout aussi vite. Mais pendant huit minutes, personne ne prend de commande et personne ne prépare de salade. Un client qui veut seulement un verre d’eau attend aussi huit minutes.

Votre API est le cuisinier, et le fournisseur d’IA est la casserole d’eau.

Dans Trouver le goulot d’étranglement, un billet prenait environ 2 147 ms. La base de données prenait 9,5 ms, et le reste du code, 7,6 ms. Les trois appels au fournisseur d’IA prenaient environ 98 % du temps. Lors des essais de référence de base avec 1 à 4 utilisateurs, le processus d’API utilisait 0,6 à 2,2 % d’un cœur. L’API ne calcule pas. Elle attend.

L’attente coûte peu, mais seulement si le serveur peut faire autre chose pendant ce temps. Le projet de cette leçon possède un réglage qui montre ce qui arrive quand il ne le peut pas. INTAKE_MODE=blocking est une erreur volontaire : le point de terminaison attend le fournisseur d’une façon qui immobilise tout le serveur. Le script scripts.stall envoie 8 billets, 4 à la fois. En même temps, il appelle GET /health toutes les 0,1 secondes. /health ne fait aucun travail et devrait donc répondre en quelques millisecondes. Voici l’essai de l’équipe du cours, avec le fournisseur simulé :

8 tickets, 4 at a time: 18.8 s, status codes [201]
GET /health during that time: 3 answers, median 8737.2 ms, slowest 9824.7 ms

Un point de terminaison qui ne fait rien a attendu 8,7 secondes. En 18,8 secondes, la vérification de santé a reçu 3 réponses. En mode asynchrone, elle reçoit environ 50 réponses en 5 secondes. Pensez à un répartiteur de charge qui vérifie /health avec un délai maximal de quelques secondes. Il conclurait que ce serveur est hors service et cesserait de lui envoyer du trafic.

Chaque requête fait deux sortes de travail.

  • Le travail de calcul consiste à calculer : analyser du JSON, construire une requête (prompt), hacher un mot de passe, exécuter un modèle sur votre ordinateur. Le processeur est occupé. Dans la cuisine, c’est couper des légumes.
  • Le travail d’E/S consiste à attendre quelque chose d’extérieur au programme : une réponse du réseau, d’un disque, d’une base de données ou d’un fournisseur d’IA. E/S signifie entrées-sorties. Le processeur n’a rien à faire avant l’arrivée de la réponse. Dans la cuisine, c’est la casserole d’eau.

Dans ce cours, un billet demande presque uniquement du travail d’E/S. Il attend environ 2,1 secondes le fournisseur et calcule pendant quelques millisecondes. Calculer plus vite n’aiderait donc pas. La question importante est ce que fait le serveur pendant l’attente. Il y a trois réponses.

  1. Fils d’exécution : plusieurs cuisiniers dans une cuisine. Un fil d’exécution est une suite de travail dans un processus. Chaque fil peut attendre indépendamment. Le point de terminaison du module 1 était une fonction normale (def). FastAPI exécute cette fonction dans un pool de fils d’exécution, avec au plus 40 fils simultanés par défaut. Quatre billets attendent dans quatre fils, et /health s’exécute dans un cinquième.
  2. E/S asynchrones : un cuisinier, plusieurs casseroles. Un point de terminaison async def s’exécute sur la boucle d’événements du serveur : un fil avec une liste de tâches. Quand une tâche atteint await, le cuisinier pose la casserole sur la cuisinière, et la boucle exécute une autre tâche. Quand la réponse arrive, la boucle reprend la première tâche. Un seul fil peut attendre des centaines de réponses à la fois.
  3. Processus : plusieurs cuisines. Un processus est un programme complet en cours d’exécution, avec sa propre mémoire. Plusieurs processus de l’API peuvent traiter des requêtes en parallèle. C’est le sujet de la prochaine leçon, Mise à l’échelle horizontale.

L’erreur de cette leçon concerne la deuxième réponse. Dans un point de terminaison async def, un appel normal qui attend n’utilise pas await. La boucle d’événements ne reprend donc jamais le contrôle, et toutes les autres tâches attendent. C’est un appel bloquant : le cuisinier qui fixe la casserole.

Prenez quatre billets qui arrivent en même temps. Utilisez les médianes des appels réels enregistrés : classifier, 0,91 s; rédiger une réponse, 1,10 s; produire un plongement, 0,20 s. Le travail d’IA d’un billet prend 0,91 + 1,10 + 0,20 = 2,21 s. Un appel GET /health arrive 0,1 s plus tard.

  • Bloquant. La boucle d’événements exécute les trois appels du billet 1 sans interruption, de 0 à 2,21 secondes. Elle traite ensuite le billet 2, de 2,21 à 4,42 secondes. Le billet 3 se termine à 6,63 secondes, et le billet 4, à 8,84 secondes. /health attend donc tout ce temps. Il répond vers 8,8 secondes, après 8,7 secondes d’attente : les 8 737 ms de la mesure.
  • Asynchrone. Les quatre billets envoient leur appel de classification en même temps et attendent ensemble. Ils se terminent vers 2,21 s. /health répond en quelques millisecondes à chaque appel.

La différence est d’un facteur quatre pour les billets, et de plusieurs milliers pour /health :

Deux chronologies de 0 à 9 secondes. En haut, INTAKE_MODE=blocking : les billets 1 à 4 exécutent chacun classify, draft_reply et embed, un billet après l'autre. Ils terminent à 2,2, 4,4, 6,6 et 8,8 s. Les quatre répondent vers 8,8 s, et GET /health, appelé à 0,1 s, attend jusque-là. En bas, INTAKE_MODE=async : les quatre billets exécutent leurs appels en même temps et répondent vers 2,2 s; GET /health répond à chaque appel.
Quatre billets et une vérification de santé sur un seul serveur, dessinés à l'échelle selon les médianes des appels enregistrés au fournisseur. Cette chronologie est construite. Le mode bloquant attend un billet à la fois; le mode asynchrone attend les quatre ensemble.
Description textuelle du diagramme

En haut, en mode bloquant : les barres des billets se suivent. Les barres hachurées représentent le temps passé à attendre le serveur, et non le fournisseur. Les quatre billets répondent ensemble vers 8,8 secondes. La dernière étape de chaque billet, l’enregistrement, permet au serveur de commencer le travail bloquant du billet suivant. GET /health attend tout ce temps. En bas, en mode asynchrone : les barres des quatre billets se superposent, les quatre répondent à 2,2 secondes. GET /health répond en quelques millisecondes à chaque appel.

Le journal de l’API de l’auteur montre le même ordre lors d’un essai bloquant. Les douze appels au fournisseur se suivent strictement, un billet après l’autre, et les réponses partent ensemble. Voici l’essai de l’auteur sur un ordinateur occupé, avec le nom d’hôte abrégé en …; vos durées seront différentes :

INFO httpx: HTTP Request: POST …/v1/chat/completions "HTTP/1.1 200 OK"
INFO httpx: HTTP Request: POST …/v1/chat/completions "HTTP/1.1 200 OK"
INFO httpx: HTTP Request: POST …/v1/embeddings "HTTP/1.1 200 OK"
... the same three lines for tickets 2, 3 and 4 ...
INFO ticket_api: GET /health 200 4143ms queries=0 id=bb7f214414ea
INFO ticket_api: POST /v1/tickets 201 8479ms queries=7 id=c5b2dd1547ab
INFO ticket_api: POST /v1/tickets 201 8480ms queries=7 id=cc7f8d112c36
INFO ticket_api: POST /v1/tickets 201 8480ms queries=7 id=6db109487a91

L’équipe du cours a exécuté scripts.stall cinq fois par mode, sur un ordinateur sans autre activité, avec le quota désactivé. Le simulateur agit alors comme si le compte de Larkfield permettait beaucoup plus d’appels par minute. Le quota ne peut donc pas masquer le blocage. La prochaine leçon montre comment le désactiver. Le graphique montre la durée médiane de /health :

Durée médiane de GET /health pendant scripts.stall (8 billets, 4 à la fois), médiane de 5 essais par mode. Fournisseur simulé, quota désactivé. Les barres des modes asynchrone et fils d'exécution sont présentes : 3,4 ms est trop petit pour être visible à côté de 8,7 secondes.
Description textuelle du graphique

Durée médiane de GET /health pendant que l’API traitait 8 nouveaux billets, 4 à la fois, sur 5 essais : bloquant 8,737.2 ms (réponse la plus lente d’un essai typique 9,824.7 ms), asynchrone 3.4 ms, fil d’exécution (version du module 1) 3.4 ms. Les 8 billets ont pris 18.8 s, 5.4 s et 4.8 s.

Ce que cela nous apprend. Un appel bloquant ne ralentit pas seulement sa propre requête. Il ralentit toutes les requêtes du processus, y compris celles qui ne font aucun travail. Les billets en souffrent aussi : 8 billets ont pris 18.8 s au lieu d’environ 5.4 s.

Voici les trois mêmes modes sous une charge constante de 8 utilisateurs Locust pendant 40 secondes, sur 5 essais :

INTAKE_MODE Billets traités avec succès par seconde p50 p95
thread (module 1) 3.22 2,237.3 ms 3,030.2 ms
blocking (l’erreur) 0.33 18,288.2 ms 18,292.6 ms
async 3.47 2,146.6 ms 2,734.2 ms

Avec 8 utilisateurs, les modes fils d’exécution et asynchrone traitent chacun environ 3,3 billets par seconde. Il y a 8 billets en cours, à environ 2,3 s chacun. Le mode bloquant traite un seul billet à la fois; les 8 utilisateurs se le partagent donc. Chacun attend environ 8 × 2,2 s de travail sur les autres billets, et la réponse médiane a pris 18,3 secondes.

Amira garde les trois conceptions dans une seule base de code, comme le cours sur les bases de données gardait DB_POOL=false. Un seul réglage choisit la conception. Chaque mesure compare donc le même code avec un seul changement. La valeur par défaut est async (asynchrone). Le point de terminaison est maintenant async def, et les trois modes diffèrent en quelques lignes :

ticket_api/intake.py (create_ticket, the part that waits)
mode = request.app.state.settings.intake_mode
if mode == "thread":
ticket, work = await run_in_threadpool(create_in_one_transaction, db, provider, new, timer)
else:
with timer("db"):
await run_in_threadpool(check_customer, db, new.customer_id)
if mode == "blocking":
# A mistake, on purpose: the waiting client inside an async endpoint.
work = do_ai_work(provider, new.subject, new.body, timer)
else:
work = await do_ai_work_async(provider, new.subject, new.body, timer)
with timer("db"):
ticket = await run_in_threadpool(save_new_ticket, db, new, work)

Lisez le code ligne par ligne :

  • thread (fil d’exécution) exécute le code du module 1, inchangé, dans le pool de fils d’exécution. run_in_threadpool fait ce que FastAPI faisait pour vous quand le point de terminaison était un def.
  • blocking appelle do_ai_work, qui utilise provider.call(). Il s’agit de httpx.Client.post : un appel normal qui attend. Rien n’y indique await; la boucle d’événements reste donc bloquée jusqu’à la réponse du fournisseur.
  • async appelle do_ai_work_async, qui utilise await provider.acall(...). Il s’agit de httpx.AsyncClient.post. À chaque await, la boucle traite d’autres requêtes.

Les appels à la base de données sont aussi des fonctions normales. Le projet utilise en effet le pool normal (synchrone) de psycopg. Le point de terminaison asynchrone les envoie donc à un fil avec run_in_threadpool. Ils prennent quelques millisecondes, et la boucle d’événements reste libre.

Le mode asynchrone change aussi quand le billet est enregistré. Le module 1 ouvrait une transaction, insérait le billet, attendait 2,2 s le travail d’IA, puis enregistrait les résultats. La connexion restait empruntée tout ce temps. Le mode asynchrone vérifie d’abord que le client existe. Il fait ensuite le travail d’IA sans connexion. À la fin, il enregistre le billet et ses résultats dans une courte transaction. C’est la règle de Gestion des connexions : aucun travail lent dans une transaction. Limites des dépendances mesure la valeur de cette règle.

La nouvelle méthode du fournisseur est courte :

ticket_api/provider.py (acall)
async def acall(self, path: str, body: dict) -> tuple[dict, float]:
"""The same as call(), awaited. The time includes any wait for a free slot."""
started = time.perf_counter()
if self._slots is None:
response = await self._apost(path, body)
else:
async with self._slots:
response = await self._apost(path, body)
return _check(response), (time.perf_counter() - started) * 1000

_slots est une limite facultative du nombre d’appels en cours, PROVIDER_MAX_CONCURRENCY. Limites des dépendances l’explique; pour l’instant, elle est désactivée.

Exercice guidé : bloquer le serveur, puis le corriger

Section intitulée « Exercice guidé : bloquer le serveur, puis le corriger »
  1. Dans le dossier de votre projet, avec l’environnement virtuel actif, copiez les fichiers de cette leçon depuis l’instantané end-of-m02 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C21/snapshots/end-of-m02
    for f in ticket_api/config.py ticket_api/intake.py ticket_api/main.py ticket_api/provider.py ticket_api/repository.py tests/fakes.py tests/test_concurrency.py scripts/stall.py README.md; do cp "$S/$f" "$f"; done
  2. Exécutez les tests : python -m pytest. Attendez-vous à 137 passed (137 tests réussis). Le nouveau fichier tests/test_concurrency.py envoie 4 billets à la fois à chaque mode. Il utilise un faux fournisseur qui prend 0,2 s par appel.

  3. Dans le premier terminal, démarrez le fournisseur simulé : python -m simulator.

  4. Dans le deuxième terminal, démarrez l’API en mode bloquant. Une variable définie dans le terminal a priorité sur .env; le fichier .env reste donc inchangé :

    Fenêtre de terminal
    INTAKE_MODE=blocking fastapi dev
  5. Dans le troisième terminal, lancez le test de blocage. Il prend environ 20 secondes : python -m scripts.stall.

  6. Regardez le journal de l’API dans le deuxième terminal. Repérez les appels au fournisseur et les lignes GET /health avec leurs durées.

  7. Arrêtez l’API avec Ctrl+C. Redémarrez-la dans le mode par défaut : fastapi dev sur macOS et Linux. Sur Windows, supprimez d’abord la variable : Remove-Item Env:INTAKE_MODE; fastapi dev.

  8. Exécutez de nouveau python -m scripts.stall.

Afficher le résultat attendu

L’étape 2 se termine par 137 passed. L’étape 5 affiche deux lignes comme celles au début de cette leçon. Attendez-vous à environ 18 à 20 secondes, aux codes d’état [201], et à 3 ou 4 réponses de /health. Leur médiane sera de plusieurs secondes. L’étape 8, dans le mode asynchrone par défaut, affiche environ ceci (essai médian de l’équipe, sur un ordinateur sans autre activité) :

8 tickets, 4 at a time: 5.4 s, status codes [201]
GET /health during that time: 51 answers, median 3.4 ms, slowest 6.0 ms

Vos durées seront différentes. Sur un ordinateur occupé, l’auteur a observé une médiane de 1,7 ms pour /health et de 6,1 s pour les billets. Ce qui compte, c’est le profil : des dizaines de réponses en quelques millisecondes chacune, plutôt que trois réponses en plusieurs secondes.

Le fournisseur simulé a un quota de 100 requêtes de clavardage par minute, et chaque exécution de scripts.stall en utilise 16. Si vous l’exécutez plus d’environ cinq fois en une minute, certains billets reçoivent 503 avec ai_busy (IA occupée). Attendez une minute, puis relancez-le.

Le point de terminaison du module 1 était une fonction normale, et personne ne se plaignait de /health. Faites d’abord une prédiction : avec INTAKE_MODE=thread, combien de temps prend /health pendant que les 8 billets attendent? Et combien de temps prennent les 8 billets? Démarrez ensuite l’API avec INTAKE_MODE=thread fastapi dev (Windows : $env:INTAKE_MODE = "thread"; fastapi dev) et exécutez python -m scripts.stall.

Afficher la réponse

/health reste rapide, et les billets prennent à peu près autant de temps qu’en mode asynchrone. Voici l’essai médian de l’équipe du cours :

8 tickets, 4 at a time: 4.8 s, status codes [201]
GET /health during that time: 45 answers, median 3.4 ms, slowest 5.4 ms

Chaque billet attend dans son propre fil du pool de fils d’exécution. /health s’exécute sur la boucle d’événements, qui reste libre. Les fils résolvent donc aussi le problème d’attente. Ils ont deux coûts. D’abord, le pool a 40 fils par défaut, et chaque fil a besoin de mémoire. Une boucle d’événements attend des centaines de réponses dans un seul fil. Ensuite, et c’est plus important ici : le code du module 1 garde une connexion à la base de données pendant toute l’attente. Avec 4 billets, cela n’a pas d’importance. Limites des dépendances montre ce qui arrive avec 32. Supprimez de nouveau la variable avant de continuer (Remove-Item Env:INTAKE_MODE sur Windows).

Utilisez le mode asynchrone pour les points de terminaison qui attendent surtout des E/S, si chaque bibliothèque utilisée permet await. Par exemple : httpx.AsyncClient pour HTTP, un pilote de base de données asynchrone et le client de cache asynchrone du module 3. Un seul processus attend alors plusieurs appels lents à la fois. Le coût : dans un async def, chaque appel qui attend doit utiliser await ou être envoyé à un fil. Un seul appel normal oublié bloque toutes les requêtes du processus, même si le code semble correct. Par exemple : time.sleep(1), requests.get(...) ou une requête normale à la base de données.

Utilisez les fils d’exécution (un point de terminaison def normal, ou run_in_threadpool) lorsqu’une bibliothèque n’a pas de version asynchrone. C’est le cas du pool psycopg de ce projet. Le coût : un nombre fixe de fils (40 par défaut dans FastAPI), et de la mémoire pour chaque fil.

Utilisez les processus pour le travail de calcul. En Python, un seul fil d’un processus exécute du code Python à la fois. Les fils ne rendent donc pas le calcul plus rapide. La prochaine leçon exécute plusieurs processus. Le travail de calcul dans un async def bloque la boucle d’événements exactement comme un appel qui attend. Si un point de terminaison doit calculer longtemps, exécutez cette partie dans un autre processus ou un processus en arrière-plan. C’est ce que fait le module 4.

Ne convertissez pas le code en mode asynchrone seulement parce que c’est plus récent. La version à fils du module 1 traitait déjà 3,22 billets par seconde avec 8 utilisateurs, contre 3,47 en mode asynchrone. Convertissez quand une mesure montre que les fils en attente ou les connexions retenues constituent la limite.

Un appel qui attend dans un point de terminaison asynchrone

Section intitulée « Un appel qui attend dans un point de terminaison asynchrone »

Erreur courante

Un appel ordinaire dans un async def bloque toutes les requêtes

Symptôme : sous charge, /health et les autres points de terminaison rapides prennent plusieurs secondes. Le processeur de l’API est utilisé à près de 0 %. Dans le journal, les appels au fournisseur pour différents billets ne se chevauchent jamais. Trois appels pour un billet, puis trois pour le suivant. Tous les billets reçoivent une réponse à peu près au même moment.

Cause : un point de terminaison async def appelle une fonction qui attend sans await. Dans ce projet, c’est do_ai_work, qui utilise le client ordinaire httpx.Client. D’autres exemples courants sont time.sleep(), requests.get(), un pilote de base de données ordinaire et la lecture d’un gros fichier.

Diagnostic :

  1. Exécutez python -m scripts.stall pour tester l’API. Une médiane de plusieurs secondes pour /health indique que la boucle d’événements est bloquée.
  2. Lisez le journal. Des appels qui ne se chevauchent jamais, malgré plusieurs requêtes en cours, indiquent la même cause.
  3. Examinez chaque async def sur le parcours de la requête lente. Chaque appel qui attend doit être précédé de await ou passer par run_in_threadpool.

Correction : utilisez le client asynchrone avec await (provider.acall). Si une bibliothèque n’a pas de version asynchrone, enveloppez l’appel : await run_in_threadpool(function, arguments). Ou définissez le point de terminaison avec un def ordinaire. FastAPI l’exécute alors dans un fil d’exécution. Ajoutez ensuite un test comme test_a_blocking_call_stalls_the_whole_server. Quatre billets simultanés doivent prendre environ le temps d’un seul billet, pas de quatre.

Vérifiez votre compréhension

En mode bloquant, GET /health a attendu 8,7 secondes même s'il ne fait aucun travail. Expliquez pourquoi avec les chiffres du petit exemple.

Afficher la réponse

Le point de terminaison et /health partagent une seule boucle d’événements. En mode bloquant, le point de terminaison appelle le fournisseur sans await. La boucle ne peut donc pas passer à une autre tâche pendant l’attente. Quatre billets sont en cours. Chacun nécessite environ 2,21 secondes d’appels au fournisseur (0,91 + 1,10 + 0,20). La boucle les traite l’un après l’autre : 4 × 2,21 = 8,84 secondes. /health est arrivé à 0,1 seconde et a dû attendre que la boucle se libère, vers 8,8 secondes.

Vérifiez votre compréhension

Un nouveau point de terminaison calcule un rapport pendant 3 secondes sur le processeur, sans E/S. Amira le définit avec async def. Prédisez ce que fait /health pendant le calcul d'un rapport et proposez une correction.

Afficher la réponse

/health attend environ 3 secondes. Le travail de calcul dans un async def n’atteint jamais de await. Il bloque donc la boucle d’événements, exactement comme un appel qui attend. async aide seulement pour l’attente, pas pour le calcul. La meilleure correction consiste à exécuter le calcul dans un autre processus, par exemple un processus en arrière-plan ou un pool de processus. Au minimum, exécutez-le dans un fil d’exécution avec run_in_threadpool pour laisser la boucle libre. En Python, il faut davantage de processus pour effectuer davantage de calculs en même temps.

Vérifiez votre compréhension

La version avec fils d'exécution du module 1 et la version asynchrone ont toutes deux maintenu /health à 3,4 ms. Avec 8 utilisateurs, leur débit était semblable (3,22 et 3,47 billets par seconde). Pourquoi le mode asynchrone devient-il alors le mode par défaut du projet?

Afficher la réponse

Les deux versions gèrent bien l’attente avec 8 billets. La différence tient aux ressources que chaque requête conserve pendant l’attente. Par défaut, chaque fil d’exécution est l’un des 40 disponibles. Le code du module 1 conserve aussi une connexion à la base de données pendant les 2,2 secondes complètes. La version asynchrone ne conserve ni l’un ni l’autre. Un seul fil d’exécution attend pour tous les billets. Elle emprunte une connexion seulement pour le bref enregistrement final. Cette différence compte quand le nombre de billets en cours dépasse le nombre de connexions du pool. La dernière leçon de ce module le mesure.

Récapitulatif

  • Le travail de calcul effectue des calculs; le travail d’E/S attend quelque chose à l’extérieur. Pour un nouveau billet, environ 98 % du temps consiste à attendre le fournisseur d’IA.
  • Les fils d’exécution attendent en parallèle, à raison d’un fil par requête. Les E/S asynchrones permettent d’attendre plusieurs requêtes dans un seul fil. À chaque await, la boucle d’événements exécute une autre tâche.
  • Un appel bloquant (un appel qui attend sans await dans un async def) arrête toute la boucle d’événements. Mesures : /health a pris 8,737.2 ms en mode bloquant et 3.4 ms en mode asynchrone; 8 billets ont pris 18.8 s au lieu de 5.4 s.
  • INTAKE_MODE conserve trois conceptions dans une seule base de code : thread (fils d’exécution, module 1), blocking (bloquant, l’erreur) et async (asynchrone, le mode par défaut désormais).
  • Le mode asynchrone effectue le travail d’IA sans connexion à la base de données, puis enregistre dans une courte transaction.
  • Le travail de calcul nécessite des processus, pas le mode asynchrone. Votre projet affiche 137 passed (137 tests réussis).

Leçon suivante : Mise à l'échelle horizontale