Limites des dépendances
- Leçon 7
- 55 min
- Module 2 : Concurrence et limites des services
Où nous en sommes
Dans les deux dernières leçons, nous avons utilisé les E/S asynchrones et plusieurs processus pour traiter plus de billets à la fois. Mais chaque processus apporte son propre pool de connexions, et derrière l'API se trouvent la base de données et le quota du fournisseur. À un moment, davantage de requêtes simultanées produisent moins de travail utile, et non plus. Dans cette leçon, nous comptons chaque limite et nous mesurons cette chute. Un ascenseur de dix places montre comment cela arrive.
Leçon 7 sur 19 · Mettre à l'échelle les API et les charges de travail d'IALimites des dépendances
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
Repérez chaque limite derrière l’API : le pool de connexions, la base de données, le quota du fournisseur et les réglages de chaque processus. Additionnez-les. Mesurez pourquoi davantage de requêtes simultanées finit par produire moins de travail utile, et non plus.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les fils d’exécution, les E/S asynchrones et le réglage
INTAKE_MODE, vus dans Travail d’E/S et travail de calcul. - Plusieurs processus derrière une seule adresse et la comparaison de deux configurations, vus dans Mise à l’échelle horizontale.
- Le goulot d’étranglement et le quota du fournisseur (100 requêtes de clavardage par minute), vus dans Trouver le goulot d’étranglement.
Ce qu’il vous faut sur votre ordinateur
- Votre projet après Mise à l’échelle horizontale :
python -m pytestaffiche137 passed(137 tests réussis). - PostgreSQL en cours d’exécution, avec le petit jeu de données chargé.
Après cette leçon, votre projet correspond à l’instantané end-of-m02. Le fournisseur d’IA est celui simulé, avec son quota désactivé pendant les tests de charge, comme dans la dernière leçon. Le cas avec 12 processus est construit : un mauvais réglage choisi volontairement. L’équipe du cours a mesuré les valeurs sur un Apple M4 (10 cœurs, 16 Go), sans autre activité. Vos temps seront différents, mais la tendance restera la même. Testé sur macOS (Apple silicon); les commandes Windows n’ont pas été testées.
Un ascenseur de dix places
Section intitulée « Un ascenseur de dix places »Un immeuble de bureaux possède un seul ascenseur. Il transporte 10 personnes, et un aller-retour prend une minute. Tout le monde a une réunion au dernier étage, et les réunions commencent dans cinq minutes.
Avec 10 personnes devant l’ascenseur, tout le monde arrive à l’heure : un seul trajet. Avec 30 personnes, les dernières attendent trois trajets, et elles arrivent encore à l’heure. Maintenant, 60 personnes arrivent. L’ascenseur transporte toujours 10 personnes par minute : il travaille autant qu’avant. Mais la file dure six minutes, donc les personnes à la fin arrivent en retard. Si les gens arrivent aussi vite que l’ascenseur les transporte, la file ne raccourcit jamais. Bientôt, tout le monde arrive en retard au dernier étage. L’ascenseur fonctionne sans arrêt, mais aucun trajet n’aide personne. Certaines personnes abandonnent et prennent l’escalier.
Plus de personnes devant la porte n’ont pas augmenté la capacité de l’ascenseur. Elles ont seulement allongé la file. L’API de billets de soutien a aussi son ascenseur.
Le problème : plus d’utilisateurs, moins de travail utile
Section intitulée « Le problème : plus d’utilisateurs, moins de travail utile »Dans Mise à l’échelle horizontale, un processus de la conception du module 1 traitait environ 3,4 billets par seconde avec 32 utilisateurs. L’équipe du cours a ensuite mesuré cette même conception avec 2 à 64 utilisateurs. Chaque point est la médiane de 3 essais de 30 secondes.
D’abord, précisons ce qui compte. Dans ce module, une réponse est utile si elle indique un succès (201) en moins de 5 secondes. Une personne attend dans le formulaire du service de soutien pendant que l’API enregistre le billet. Après quelques secondes, les gens abandonnent ou renvoient le billet. Le débit utile est le nombre de réponses utiles par seconde : le débit que vous pouvez promettre. La question donnée en exemple dans le modèle de banc d’essai utilise les mêmes 5 secondes.
| Utilisateurs (requêtes en cours) | Billets utiles par seconde | p50 | 503 par essai |
|---|---|---|---|
| 2 | 0.85 | 2,310 ms | aucun |
| 8 | 3.12 | 2,299 ms | aucun |
| 10 | 3.86 | 2,233 ms | aucun |
| 12 | 3.88 | 2,687 ms | aucun |
| 16 | 3.68 | 3,608 ms | aucun |
| 32 | 0 (3.25 terminés) | 6,820 ms | 9 à 11 |
| 64 | 0 (2.53 terminés) | 10,842 ms | 32 à 34 |
Jusqu’à 10 utilisateurs, ajouter des utilisateurs produisait plus de travail utile. De 10 à 16, rien ne changeait : environ 3,9 billets par seconde. À 32 utilisateurs, l’API terminait encore 3.25 billets par seconde, mais aucun en moins de 5 secondes. Le débit utile tombait à 0. À 64 utilisateurs, la réponse médiane prenait 10.8 secondes.
L’idée : une dépendance à capacité limitée
Section intitulée « L’idée : une dépendance à capacité limitée »Une dépendance est un service dont votre API a besoin pour répondre : la base de données, le fournisseur d’IA, puis le cache. Chacune a ses limites. Si une dépendance ne peut traiter que quelques requêtes à la fois, c’est une dépendance à capacité limitée. Les requêtes font la file devant elle, comme les gens devant l’ascenseur.
Ici, la contrainte est le pool de connexions (pool) : au plus 10 connexions, une attente maximale de 5 secondes, puis 503 database_busy (base de données occupée). Le cours sur les bases de données a fixé ces règles dans Gestion des connexions. La conception du module 1 garde une connexion pendant les 2,2 secondes du travail d’IA. Ainsi, 10 connexions permettent au plus 10 billets en cours.
La loi de Little, vue dans Latence et capacité, explique les valeurs. Inversez-la : temps dans le système = requêtes en cours ÷ débit. Utilisez le débit mesuré d’environ 3,9 billets par seconde :
- 16 utilisateurs : 16 ÷ 3,9 ≈ 4,1 secondes par billet. Sous le délai promis de 5 secondes, donc encore utile. p50 mesuré : 3.6 s.
- 32 utilisateurs : 32 ÷ 3,9 ≈ 8,2 secondes. Au-delà du délai promis. p50 mesuré : 6.8 s; les réponses
503après 5 secondes raccourcissent un peu la file. - 64 utilisateurs : 64 ÷ 3,9 ≈ 16 secondes, avec davantage de requêtes refusées. p50 mesuré : 10.8 s.
Le débit ne peut pas dépasser la capacité du pool, donc chaque utilisateur supplémentaire ajoute seulement de l’attente. À partir d’un certain point, chaque billet attend plus longtemps que le délai promis. Le travail se fait encore, mais rien de ce travail n’est utile. Voilà pourquoi une concurrence accrue finit par réduire le débit utile. Le nombre de billets terminés par seconde a aussi baissé un peu, de 3.85 à 3.25 et 2.53. Le cours n’a pas mesuré pourquoi; les requêtes en attente consomment aussi des ressources du serveur.
La conception asynchrone attend le fournisseur sans connexion. Elle en emprunte une seulement pour l’enregistrement final, pendant quelques millisecondes. Voici les deux conceptions avec 32 requêtes en cours :
Description textuelle du diagramme
La grille du haut représente la conception du module 1 avec 32 requêtes en cours. 10 requêtes gardent les 10 connexions du pool pendant qu’elles attendent le fournisseur. Les 22 autres attendent une connexion, et après 5 secondes, l’API leur répond avec 503 database_busy. PostgreSQL voit 10 connexions qui ne font presque rien. Au plus 10 billets sont en cours, donc au plus environ 4,5 billets par seconde. L’équipe du cours a mesuré 3,86 à 10 utilisateurs.
La grille du bas représente la conception asynchrone avec les mêmes 32 requêtes. Aucune ne garde de connexion pendant l’attente. Les 32 appels au fournisseur sont en cours ensemble, et chaque billet emprunte une connexion seulement pour son enregistrement. Au plus environ 14,5 billets par seconde; l’équipe du cours a mesuré 13,39.
Explorer : de 2 à 64 utilisateurs
Section intitulée « Explorer : de 2 à 64 utilisateurs »Changez le nombre d’utilisateurs et observez les deux courbes. L’explorateur montre les médianes mesurées, pas un modèle :
Explorer
Plus de requêtes en cours que de connexions dans le pool
Prédisez d’abord : À 10 utilisateurs, la conception du module 1 traite 3,86 billets utiles par seconde. Prédisez son débit utile à 32 utilisateurs : plus élevé, semblable ou plus faible? Et celui de la conception asynchrone?
- Utilisateurs
- 10
- Conception du module 1 : utile
- 3,86/s
- Conception du module 1 : terminé
- 3,85/s
- Conception du module 1 : p95
- 3,2 s
- Conception du module 1 : 503
- aucune
- async : utile
- 4,05/s
- async : p95
- 2,9 s
10 requêtes en cours. Chaque requête obtient tout de suite une des 10 connexions, donc les deux conceptions servent à peu près autant : 3,86/s et 4,05/s, avec un p95 sous 3,2 s. À 10 utilisateurs, la conception du module 1 utilise tout le pool. C’est son meilleur résultat.
- Conception du module 1 (garde une connexion)
- async (une connexion seulement pour enregistrer)
La ligne pointillée : ce que la conception du module 1 a terminé par seconde, y compris les réponses arrivées trop tard.
Description textuelle de l’explorateur
L’explorateur a une commande, un curseur pour le nombre d’utilisateurs : 2, 4, 8, 10, 12, 16, 32 ou 64. Il commence à 10. Au-dessus des deux graphiques, il montre quatre valeurs de la conception du module 1 : débit utile, billets terminés par seconde, p95 et nombre de 503. Il montre aussi le débit utile et le p95 de la conception asynchrone.
Le premier graphique montre les billets utiles par seconde selon le nombre d’utilisateurs. Sur son échelle, 2, 4, 8, 16, 32 et 64 sont espacés également. Une ligne pointillée marque la taille du pool, 10. La conception du module 1 passe de 0.85 à 2 utilisateurs à 3.86 à 10 et 3.88 à 12. Elle reste à 3.68 à 16, puis tombe à 0 à 32 et 64. Une ligne pointillée montre les billets terminés, même trop tard : 3.25 à 32 utilisateurs et 2.53 à 64. La conception asynchrone augmente tout au long : 4.05 à 10, 6.69 à 16, 13.39 à 32 et 27.18 à 64.
Le deuxième graphique montre le temps p95 des réponses 201, avec une ligne pointillée au délai promis de 5 secondes. La conception du module 1 reste près de 3 secondes jusqu’à 10 utilisateurs, puis augmente : 4.2 s à 16, 7.5 s à 32 et 11.8 s à 64. La conception asynchrone reste sous 3,2 secondes à chaque point.
Ce que cela nous apprend. Le pool fixe le maximum de la conception du module 1 : environ 3,9 billets par seconde, atteint avec 10 à 12 utilisateurs. Au-delà, les utilisateurs supplémentaires ajoutent seulement de l’attente. À partir de 32 utilisateurs, aucune réponse n’arrive à temps. La conception asynchrone n’a pas cette file devant le pool. À 64 utilisateurs, elle traitait 27.18 billets par seconde avec un p95 de 2.8 s. Cette courbe finit aussi quelque part, à la prochaine limite. Avec le quota désactivé, le cours ne l’a pas atteinte.
Larkfield : compter chaque limite
Section intitulée « Larkfield : compter chaque limite »Tomás a une solution rapide pour la conception du module 1 : « Ajoutons des processus. » Mise à l’échelle horizontale a montré que quatre processus aident. Mais chaque réglage numérique s’applique par processus, et les limites derrière eux s’appliquent à tout le monde. Mei, responsable de la base de données, demande à Amira de les additionner d’abord.
| Limite | Réglée où | S’applique à | Valeur ici |
|---|---|---|---|
Connexions dans le pool (DB_POOL_MAX) |
le .env de l’API |
chaque processus | 10 |
Attente d’une connexion (DB_POOL_TIMEOUT) |
le .env de l’API |
chaque requête | 5 s, puis 503 |
| Fils d’exécution pour les fonctions normales | FastAPI (anyio) | chaque processus | 40 |
Appels au fournisseur en cours (PROVIDER_MAX_CONCURRENCY) |
le .env de l’API |
chaque processus | 0 = aucune limite |
Connexions à PostgreSQL (max_connections) |
la base de données | tous les processus ensemble | 100, dont 3 réservées aux administrateurs |
| Quota du fournisseur | le fournisseur | tout le compte | 100 requêtes de clavardage par minute |
Le script scripts.limits lit les réglages et la limite de la base de données, puis multiplie :
Database: max_connections 100 (3 kept for administrators); 1 in use nowAPI: 12 process(es) x DB_POOL_MAX 10 = up to 120 connections <- more than the database allowsProvider: PROVIDER_MAX_CONCURRENCY no limit per process; the quota is 100 chat requests per minute for the whole account, whatever the number of processesDouze processus pourraient demander 120 connexions, mais la base de données en accepte 97 pour l’application. Le quota n’augmente pas du tout. Avec deux appels de clavardage par billet, il permet 50 billets par minute pour tout le compte. Cela donne 0,83 billet par seconde. Avec le quota activé, les deux conceptions s’arrêtent là, avec un processus ou douze. L’heure du Vendredi fou d’Omar exige 0,28 billet par seconde en moyenne, donc le quota suffit pour la moyenne. Une minute chargée exige 1,5 billet par seconde : presque le double du quota. Le module 4 gère ces pointes avec une file d’attente.
Deux autres faits doivent entrer dans le calcul. D’abord, le vrai fournisseur ralentissait avec la charge. Dans les enregistrements, une réponse prenait environ 7 % plus de temps avec 16 appels en cours, et 30 % avec 40. Le fournisseur simulé ne modélise pas cela. La courbe asynchrone ci-dessus est donc meilleure que celle d’un vrai fournisseur. Ensuite, une limite peut protéger une dépendance : PROVIDER_MAX_CONCURRENCY plafonne les appels en cours d’un processus. Les autres attendent une place libre dans l’API, pas chez le fournisseur. Un petit exemple tiré de tests/test_concurrency.py : 6 appels, 2 places, 0,1 seconde par appel. Les appels passent en 3 groupes de 2, donc les 6 prennent environ 0,3 seconde. Comme pour le pool, la valeur s’applique par processus : quatre processus limités à 8 envoient jusqu’à 32 appels simultanés.
Exercice guidé : mesurer la chute
Section intitulée « Exercice guidé : mesurer la chute »Voici la vérification de fin du module : mesurez le débit utile de la conception du module 1 sous et au-dessus de la capacité du pool. Expliquez la différence.
-
Copiez le dernier script de ce module depuis l’instantané
end-of-m02:Fenêtre de terminal cp ../nextia-learning-labs/C21/snapshots/end-of-m02/scripts/limits.py scripts/limits.pyFenêtre de terminal Copy-Item ..\nextia-learning-labs\C21\snapshots\end-of-m02\scripts\limits.py scripts\limits.py -
Exécutez
python -m scripts.limits --processes 12, puispython -m scripts.limits --processes 4. Comparez la deuxième ligne de chaque résultat. -
Démarrez le fournisseur simulé avec son quota désactivé dans le premier terminal, comme dans la dernière leçon (
SIM_QUOTA=off python -m simulator). -
Démarrez un processus de la conception du module 1 dans le deuxième terminal :
INTAKE_MODE=thread fastapi run(Windows :$env:INTAKE_MODE = "thread"; fastapi run). -
Dans le troisième terminal, lancez 16 utilisateurs pendant 40 secondes, puis résumez :
Fenêtre de terminal SAMPLES_CSV=t16.csv locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 16 -r 16 -t 40spython -m scripts.percentiles t16.csv --skip 10Fenêtre de terminal $env:SAMPLES_CSV = "t16.csv"; locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 16 -r 16 -t 40spython -m scripts.percentiles t16.csv --skip 10 -
Comptez les réponses utiles : les réponses
201en moins de 5 secondes, en excluant les 10 premières secondes. Une ligne de Python le fait; elle fonctionne dans les deux interpréteurs de commandes :Fenêtre de terminal python -c "import csv; r=list(csv.DictReader(open('t16.csv'))); t0=float(r[0]['start']); r=[x for x in r if float(x['start'])-t0>=10]; print(sum(x['status']=='201' and float(x['ms'])<=5000 for x in r), 'of', len(r), 'requests: 201 within 5 s')" -
Répétez les étapes 5 et 6 avec 32 utilisateurs et le fichier
t32.csv. -
Arrêtez l’API. Démarrez-la en mode asynchrone (
fastapi runavecINTAKE_MODEnon définie; sur Windows, exécutez d’abordRemove-Item Env:INTAKE_MODE). Répétez les étapes 5 et 6 avec 32 utilisateurs eta32.csv.
Afficher le résultat attendu
L’étape 2 affiche les trois lignes ci-dessus pour 12 processus. Pour 4 processus, la deuxième ligne est API: 4 process(es) x DB_POOL_MAX 10 = up to 40 connections (jusqu’à 40 connexions), sans avertissement. Voici les essais de l’auteur pour les étapes 5 à 8, sur un ordinateur partagé et occupé :
16 users, Module 1 design112 requests in 29.8 s; status codes {'201': 112}Successful: 112 = 3.76 per secondLatency of the successful requests: mean 3735.0 ms | p50 3766.0 ms | p95 4448.1 ms | p99 4816.2 ms | max 5031.4 ms111 of 112 requests: 201 within 5 s
32 users, Module 1 design110 requests in 29.9 s; status codes {'201': 101, '503': 9}Successful: 101 = 3.38 per secondLatency of the successful requests: mean 6874.9 ms | p50 6878.2 ms | p95 7399.9 ms | p99 7493.9 ms | max 8042.7 ms0 of 110 requests: 201 within 5 s
32 users, async384 requests in 29.8 s; status codes {'201': 384}Successful: 384 = 12.9 per secondLatency of the successful requests: mean 2299.2 ms | p50 2248.4 ms | p95 3031.2 ms | p99 3347.6 ms | max 3862.7 ms384 of 384 requests: 201 within 5 sCette page ajoute les titres au-dessus de chaque bloc; les commandes affichent seulement les lignes en dessous. Vos valeurs seront différentes. Attendez-vous à la même tendance. À 16 utilisateurs, presque chaque réponse est utile. À 32 utilisateurs, la conception du module 1 termine encore environ 3,4 billets par seconde. Mais presque aucun ne termine en moins de 5 secondes, et certaines requêtes reçoivent 503. La conception asynchrone répond à toutes les requêtes à temps avec 32 utilisateurs.
Répondez maintenant à la vérification de fin dans vos propres mots. Écrivez dans docs/results-processes.md de la dernière leçon, ou dans une nouvelle copie du modèle. Pourquoi doubler les utilisateurs de 16 à 32 a-t-il fait passer le débit utile d’environ 3,7 à environ 0?
À vous : limiter les appels au fournisseur
Section intitulée « À vous : limiter les appels au fournisseur »Changez un réglage. Gardez la conception asynchrone et 32 utilisateurs, mais limitez chaque processus à 8 appels au fournisseur en cours : PROVIDER_MAX_CONCURRENCY=8 fastapi run (Windows : $env:PROVIDER_MAX_CONCURRENCY = "8"; fastapi run). Faites d’abord une prédiction : quel nombre maximal de billets par seconde pouvez-vous obtenir? Voyez les places comme le pool d’un nouvel ascenseur. Exécutez ensuite les étapes 5 et 6 avec max8.csv.
Afficher la réponse
La limite crée un nouvel ascenseur. Un billet utilise une place trois fois : pendant environ 0,91, 1,10 et 0,20 seconde. Cela représente environ 2,2 secondes d’occupation des places par billet. 8 places donnent au plus 8 ÷ 2,2 ≈ 3,6 billets par seconde, comme le pool de 10 donnait environ 4,5. Les 24 autres billets attendent dans l’API, et le temps de chaque appel comprend maintenant cette attente. L’essai de l’auteur, sur un ordinateur occupé, donnait un résultat encore plus bas :
62 requests in 29.2 s; status codes {'201': 62}Successful: 62 = 2.12 per secondLatency of the successful requests: mean 9474.6 ms | p50 9383.7 ms | p95 10463.5 ms | p99 11077.6 ms | max 11077.6 msUne limite a donc un coût : elle déplace la file du fournisseur vers votre API. Elle reste utile quand la dépendance se dégrade avec la charge, comme le vrai fournisseur avec 40 appels en cours. Fixez-la selon le comportement mesuré de la dépendance et multipliez-la par le nombre de processus. Supprimez la variable quand vous avez terminé (Remove-Item Env:PROVIDER_MAX_CONCURRENCY sur Windows).
Quand fixer une limite, et ce qu’elle coûte
Section intitulée « Quand fixer une limite, et ce qu’elle coûte »Comptez d’abord. Avant d’ajouter des processus, multipliez chaque réglage par processus par le nombre de processus. Comparez ensuite le total à la limite partagée : python -m scripts.limits --processes N. Faites de même pour chaque service utilisé par plusieurs programmes. Un processus du module 4, une deuxième API ou un script de rapport partagent tous la même limite de 100 connexions.
Gardez une ressource limitée seulement pendant son utilisation. La meilleure solution de cette leçon n’était pas un plus grand pool de connexions (pool). C’était la conception asynchrone, qui ne garde pas de connexion pendant l’attente. Un plus grand pool déplace seulement la file vers PostgreSQL. Chaque connexion y correspond à un processus serveur avec sa propre mémoire.
Limitez le travail à l’entrée, pas seulement à la sortie. Une file dans l’API retarde quand même chaque réponse. Le module 4 refuse le travail en surplus dès l’entrée, avec une réponse claire et un en-tête Retry-After (réessayer après). Ainsi, le travail accepté reste utile.
Ce qu’elle coûte. Chaque limite impose volontairement une attente ou une erreur à certaines requêtes. Un 503 après 5 secondes vaut mieux qu’une réponse après 11 secondes. Fixez des attentes plus courtes que le délai promis. Une requête qui ne peut pas arriver à temps échoue alors rapidement, au lieu d’utiliser des ressources pour rien.
Plus de processus que la base de données n’en permet
Section intitulée « Plus de processus que la base de données n’en permet »Erreur courante
Douze processus, une base de données : trop de clients
Symptôme (construit) : Amira démarre douze processus avec un pool minimum élevé, DB_POOL_MIN=10 fastapi run --workers 12. /health répond encore 200. Mais le journal se remplit d’avertissements, et même psql ne peut pas se connecter pour examiner la situation. Voici l’exécution de l’auteur, avec les avertissements comptés et le port abrégé en … :
100 WARNING psycopg.pool: error connecting in 'ticket-api': connection failed: connection to server at "127.0.0.1", port … failed: FATAL: sorry, too many clients alreadypsql: error: connection to server on socket "/var/run/postgresql/.s.PGSQL.5432" failed: FATAL: sorry, too many clients alreadyCause : chaque processus ouvre son propre pool, et douze pools de 10 font 120 connexions. PostgreSQL en accepte 100 au total. Les premiers pools remplissent la base de données, et les autres continuent d’essayer. Les processus sans connexion répondent 503 database_busy (base de données occupée) à chaque billet de soutien. Un processus en arrière-plan, une migration ou un administrateur ne peut pas non plus se connecter. Avec la valeur par défaut de 2 pour DB_POOL_MIN, la même erreur apparaît plus tard, sous charge, quand les pools grandissent.
Diagnostic :
- Exécutez
python -m scripts.limits --processes 12. L’avertissement<- more than the database allows(plus que la base de données ne permet) montre le problème avant tout test. - Cherchez
too many clients(trop de clients) dans le journal. - Comptez les connexions quand vous pouvez encore vous connecter :
SELECT count(*) FROM pg_stat_activity WHERE backend_type = 'client backend';.
Solution : arrêtez l’API. Ajustez ensuite le total à la limite. Utilisez moins de processus, ou un DB_POOL_MAX plus petit par processus. Le total processus × pool, plus tous les autres programmes, doit rester sous max_connections, avec une marge pour les administrateurs. Mieux encore, gardez les connexions moins longtemps, comme le fait la conception asynchrone. Augmenter max_connections est le dernier choix : chaque connexion consomme de la mémoire dans la base de données.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Expliquez pourquoi augmenter la concurrence finit par réduire le débit utile. Utilisez les chiffres de la conception du module 1 à 10, 16 et 32 utilisateurs.
Afficher la réponse
La conception du module 1 garde une connexion à la base de données pendant les 2,2 secondes du travail d’IA. Le pool de 10 permet donc au plus 10 billets en cours. Son débit plafonne à environ 3,9 billets par seconde : 3,86 à 10 utilisateurs, 3,68 à 16. Ajouter des utilisateurs ne peut pas l’augmenter; ils attendent simplement une connexion dans la file. Selon la loi de Little, temps = utilisateurs ÷ débit. Cela donne environ 4,1 secondes à 16 utilisateurs, dans le délai promis de 5 secondes. À 32 utilisateurs, cela donne environ 8,2 secondes, au-delà du délai promis. À 32 utilisateurs, l’API terminait donc encore 3,25 billets par seconde, mais aucun en moins de 5 secondes : débit utile de 0. Certaines requêtes ont attendu une connexion plus de 5 secondes et ont reçu un 503. La concurrence supplémentaire n’a ajouté que de l’attente, qui a rendu chaque réponse trop tardive.
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
Six processus d'API avec DB_POOL_MAX à 10 et deux processus en arrière-plan (module 4) avec des pools de 10 partagent un PostgreSQL avec max_connections à 100. Le total est-il sûr? Et avec le quota activé : combien de billets par seconde peuvent-ils traiter ensemble?
Afficher la réponse
Six processus d’API peuvent ouvrir 60 connexions, et deux processus en arrière-plan, 20 : 80 au total. C’est moins que les 97 connexions permises pour l’application, avec une marge pour une migration ou psql. Avec le quota activé, les connexions ne sont pas la limite. Le quota permet 100 requêtes de conversation par minute pour tout le compte, deux par billet. Cela donne 50 billets par minute, environ 0,83 par seconde, quel que soit le nombre de processus.
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 conception asynchrone a traité 27,18 billets par seconde à 64 utilisateurs, avec le fournisseur simulé et son quota désactivé. Kwame demande si un processus peut traiter 27 billets par seconde lors du Vendredi fou. Que lui dites-vous?
Afficher la réponse
Ce test ne permet pas de le dire. Le quota était désactivé, et le quota réel permet environ 0,83 billet par seconde pour tout le compte. Le fournisseur simulé ne ralentit pas sous charge, mais le vrai fournisseur ralentissait : environ 30 % avec 40 appels en cours. De plus, le test utilisait un seul portable et le petit jeu de données. Les 27 billets par seconde montrent seulement que l’API et le pool ne sont plus la limite. La prochaine limite est le fournisseur, et un test de charge sur vos propres services ne peut pas mesurer sa capacité. Le module 6 transforme de tels résultats en une recommandation prudente.
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
- Une dépendance limitée ne traite que quelques requêtes à la fois; les autres attendent dans une file. Ici, c’était le pool de 10, car la conception du module 1 gardait une connexion pendant 2,2 secondes.
- Le débit utile compte les réussites dans le délai promis (201 en moins de 5 secondes). Conception du module 1 : 3.86 à 10 utilisateurs, 3.68 à 16, 0 à 32 et 64, même si elle terminait encore 3.25 et 2.53 par seconde.
- Loi de Little : temps dans le système = requêtes en cours ÷ débit. Quand quelque chose plafonne le débit, plus de concurrence ajoute seulement de l’attente, jusqu’à ce que chaque réponse arrive trop tard.
- La conception asynchrone ne garde aucune connexion pendant l’attente : 13.39 par seconde à 32 utilisateurs, 27.18 à 64 (quota désactivé, fournisseur simulé).
- Les réglages par processus s’additionnent : 12 processus × 10 = 120 connexions, plus que les 100 de PostgreSQL. Le quota s’applique au compte : 0,83 billet par seconde pour tout le monde.
- Votre projet correspond à
end-of-m02:137 passed(137 tests réussis).
Leçon suivante : Choisir ce qui peut être mis en cache