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.
Leçon 5 sur 19 · Mettre à l'échelle les API et les charges de travail d'IATravail d'E/S et travail de calcul
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
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 main
Ce que vous devez savoir
- Où passe le temps d’un billet : environ 2,2 secondes, presque toutes chez le fournisseur d’IA, dans Trouver le goulot d’étranglement.
- Le débit, le p95 et une exécution de Locust, dans Latence et capacité.
- Les trois terminaux (simulateur, API, commandes), dans Exécuter la charge de travail d’IA sur votre ordinateur.
Ce qu’il vous faut sur votre ordinateur
- Votre projet à la fin du module 1 :
python -m pytestaffiche128 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 pulldansnextia-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 cuisinier et une casserole d’eau
Section intitulée « Un cuisinier et une casserole d’eau »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.
Le problème : un serveur qui regarde la casserole
Section intitulée « Le problème : un serveur qui regarde la casserole »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 msUn 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.
L’idée : travail d’E/S et travail de calcul
Section intitulée « L’idée : travail d’E/S et travail de calcul »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.
- 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/healths’exécute dans un cinquième. - E/S asynchrones : un cuisinier, plusieurs casseroles. Un point de terminaison
async defs’exécute sur la boucle d’événements du serveur : un fil avec une liste de tâches. Quand une tâche atteintawait, 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. - 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.
Un petit exemple : quatre billets, deux façons
Section intitulée « Un petit exemple : quatre billets, deux façons »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.
/healthattend 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.
/healthrépond en quelques millisecondes à chaque appel.
La différence est d’un facteur quatre pour les billets, et de plusieurs milliers pour /health :
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=bb7f214414eaINFO ticket_api: POST /v1/tickets 201 8479ms queries=7 id=c5b2dd1547abINFO ticket_api: POST /v1/tickets 201 8480ms queries=7 id=cc7f8d112c36INFO ticket_api: POST /v1/tickets 201 8480ms queries=7 id=6db109487a91Mesure : le blocage en chiffres
Section intitulée « Mesure : le blocage en chiffres »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 :
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.
Larkfield : INTAKE_MODE dans ticket_api/intake.py
Section intitulée « Larkfield : INTAKE_MODE dans ticket_api/intake.py »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 :
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_threadpoolfait ce que FastAPI faisait pour vous quand le point de terminaison était undef.blockingappelledo_ai_work, qui utiliseprovider.call(). Il s’agit dehttpx.Client.post: un appel normal qui attend. Rien n’y indiqueawait; la boucle d’événements reste donc bloquée jusqu’à la réponse du fournisseur.asyncappelledo_ai_work_async, qui utiliseawait provider.acall(...). Il s’agit dehttpx.AsyncClient.post. À chaqueawait, 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 :
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 »-
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-m02for 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"; doneFenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m02"foreach ($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') { Copy-Item "$S\$f" $f } -
Exécutez les tests :
python -m pytest. Attendez-vous à137 passed(137 tests réussis). Le nouveau fichiertests/test_concurrency.pyenvoie 4 billets à la fois à chaque mode. Il utilise un faux fournisseur qui prend 0,2 s par appel. -
Dans le premier terminal, démarrez le fournisseur simulé :
python -m simulator. -
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.envreste donc inchangé :Fenêtre de terminal INTAKE_MODE=blocking fastapi devFenêtre de terminal $env:INTAKE_MODE = "blocking"; fastapi dev -
Dans le troisième terminal, lancez le test de blocage. Il prend environ 20 secondes :
python -m scripts.stall. -
Regardez le journal de l’API dans le deuxième terminal. Repérez les appels au fournisseur et les lignes
GET /healthavec leurs durées. -
Arrêtez l’API avec Ctrl+C. Redémarrez-la dans le mode par défaut :
fastapi devsur macOS et Linux. Sur Windows, supprimez d’abord la variable :Remove-Item Env:INTAKE_MODE; fastapi dev. -
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 msVos 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.
À vous de jouer : la version du module 1
Section intitulée « À vous de jouer : la version du module 1 »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 msChaque 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).
Quand utiliser chaque option, et à quel coût
Section intitulée « Quand utiliser chaque option, et à quel coût »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 :
- Exécutez
python -m scripts.stallpour tester l’API. Une médiane de plusieurs secondes pour/healthindique que la boucle d’événements est bloquée. - Lisez le journal. Des appels qui ne se chevauchent jamais, malgré plusieurs requêtes en cours, indiquent la même cause.
- Examinez chaque
async defsur le parcours de la requête lente. Chaque appel qui attend doit être précédé deawaitou passer parrun_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érification des connaissances
Section intitulée « Vérification des connaissances »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.
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
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.
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
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.
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.
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
awaitdans unasync def) arrête toute la boucle d’événements. Mesures :/healtha 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_MODEconserve trois conceptions dans une seule base de code :thread(fils d’exécution, module 1),blocking(bloquant, l’erreur) etasync(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