Mise à l'échelle horizontale
- Leçon 6
- 50 min
- Module 2 : Concurrence et limites des services
Où nous en sommes
Dans la leçon précédente, un seul processus d'API a appris à attendre plusieurs billets à la fois avec les E/S asynchrones. Mais un seul processus a ses limites quand beaucoup d'utilisateurs arrivent en même temps. Dans cette leçon, nous exécutons plusieurs copies de l'API derrière une seule adresse, nous gardons l'état partagé à l'extérieur de ces copies, et nous comparons deux configurations avec le même test de charge. Un supermarché qui ouvre d'autres caisses montre la règle.
Leçon 6 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAMise à l'échelle horizontale
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
Traitez plus de billets de soutien à la fois en exécutant plusieurs copies de l’API derrière une seule adresse. Gardez tout ce que les requêtes partagent à l’extérieur de ces copies. Comparez deux configurations avec le même test de charge.
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, les processus et la boucle d’événements, vus dans Travail d’E/S et travail de calcul.
- Les utilisateurs Locust,
SAMPLES_CSVetscripts.percentiles, vus dans Latence et capacité. - Le pool de connexions (pool), vu dans Gestion des connexions. Il permet au plus 10 connexions et 5 secondes d’attente, puis renvoie
503 database_busy(base de données occupée).
Ce qu’il vous faut sur votre ordinateur
- Votre projet après Travail d’E/S et travail de calcul :
python -m pytestaffiche137 passed(137 tests réussis). - PostgreSQL en cours d’exécution, avec les petites données chargées. Cette leçon n’ajoute aucun fichier.
Le fournisseur d’IA est celui simulé. Cette leçon l’exécute avec son quota désactivé, comme si le compte de Larkfield permettait beaucoup plus d’appels par minute. Avec le quota activé, celui-ci serait la limite. Vous ne pourriez pas voir la limite de l’API. L’équipe du cours a mesuré les résultats sur un Apple M4 (10 cœurs, 16 Go), sans autre programme occupé. Vos temps seront différents, mais la tendance restera la même. Tests effectués sur macOS (Apple silicon); les commandes Windows n’ont pas été testées.
Quatre caisses et une file
Section intitulée « Quatre caisses et une file »Un supermarché a une seule caisse. Un samedi achalandé, la file atteint le fond du magasin. La gérante n’achète pas une caisse plus rapide. Elle ouvre trois autres caisses. Un employé se place au début de la file et dirige chaque client vers la prochaine caisse libre.
Cela fonctionne pour une raison : n’importe quelle caissière peut servir n’importe quel client. Les prix, les stocks et les points de fidélité se trouvent dans le système central du magasin. Ils ne sont pas dans la tête d’une seule caissière. Si la caissière 2 notait les points dans son propre cahier, un client passant à la caisse 3 la semaine suivante les perdrait.
Les quatre caisses sont quatre copies de l’API. L’employé au début de la file est l’adresse qui distribue le travail. Le système central est la base de données.
Le problème : un processus et 32 utilisateurs
Section intitulée « Le problème : un processus et 32 utilisateurs »Dans Travail d’E/S et travail de calcul, servir 8 utilisateurs était facile. Le Vendredi fou en amène davantage. L’équipe du cours a lancé 32 utilisateurs Locust sur la conception du module 1 (INTAKE_MODE=thread), dans un seul processus d’API :
| Un processus, 32 utilisateurs | Valeur (médiane de 5 essais) |
|---|---|
| Billets traités avec succès par seconde | 3.37 (3.3–3.41) |
| p50 | 6,831 ms |
| p95 | 7,480 ms |
503 database_busy |
10 à 14 par essai |
Quatre fois plus d’utilisateurs que dans la dernière leçon ont donné presque le même débit qu’avec 8 utilisateurs (3,22 billets par seconde). Les utilisateurs supplémentaires n’ont fait qu’attendre. La moitié des réponses ont pris plus de 6,8 secondes, et certaines requêtes ont reçu 503. L’utilisation du processeur par l’API est restée près de 1 %. L’ordinateur n’était donc pas occupé. Qu’est-ce qui l’était?
L’auteur a examiné la base de données pendant un tel essai. Il s’agit de son essai; pg_stat_activity liste chaque connexion à PostgreSQL :
state | count---------------------+------- idle in transaction | 10Dix connexions, soit tout le pool, et les dix sont idle in transaction (inactives dans une transaction). Chacune appartient à un billet qui a commencé sa transaction et attend maintenant le fournisseur d’IA. Les 22 autres billets attendent une connexion dans la file. Après 5 secondes, certains abandonnent avec 503. Un processus a un seul pool, et ce pool est plein.
L’idée : plus de copies, une seule adresse
Section intitulée « L’idée : plus de copies, une seule adresse »La mise à l’échelle horizontale consiste à exécuter plus de copies du même service et à répartir les requêtes entre elles. Chaque copie est une instance. L’autre méthode, la mise à l’échelle verticale, donne un ordinateur plus puissant à une seule instance. Elle n’aiderait pas ici : l’ordinateur est presque inactif.
Deux éléments permettent à la mise à l’échelle horizontale de fonctionner :
- Une seule adresse à l’entrée. Les clients ne choisissent pas d’instance. Ils envoient chaque requête à une seule adresse. Un mécanisme y transmet chaque requête ou connexion à une instance. Dans le nuage, c’est un répartiteur de charge. Sur votre ordinateur, c’est le programme serveur lui-même.
fastapi run --workers 4démarre un processus parent qui ouvre le port 8000 et démarre quatre processus. Le système d’exploitation donne chaque nouvelle connexion à l’un d’eux. - Des instances sans état. Une instance sans état ne conserve rien entre les requêtes dont une requête ultérieure aurait besoin. Toute instance peut servir toute requête, comme toute caissière. Tout ce qui est partagé reste à l’extérieur, dans un service que toutes les instances utilisent : ici, PostgreSQL.
Pourquoi des processus, et non plus de fils d’exécution? En Python, un seul fil d’un processus exécute du code Python à la fois. Des processus distincts s’exécutent en parallèle sur des cœurs de processeur distincts. Ici, la raison est encore différente : chaque processus a son propre pool de connexions. Quatre processus ont quatre pools de 10 connexions.
Un petit exemple : ce que quatre processus devraient donner
Section intitulée « Un petit exemple : ce que quatre processus devraient donner »Utilisons des nombres arrondis. Dans la conception du module 1, un billet garde sa connexion pendant environ 2,2 secondes.
- Un processus : au plus 10 billets en cours, un par connexion. Cela donne au plus 10 ÷ 2,2 s ≈ 4,5 billets par seconde. Les 22 autres utilisateurs attendent. Mesure : 3.37.
- Quatre processus : au plus 40 billets en cours. Seulement 32 utilisateurs envoient des requêtes, donc au plus 32 billets sont en cours. Si chaque processus reçoit 8 utilisateurs, cela donne 32 ÷ 2,2 s ≈ 14,5 billets par seconde.
Quatre processus devraient donc donner environ trois fois le débit, et l’attente devrait presque disparaître. Voici la configuration, avec les nombres de chaque partie :
Description textuelle du diagramme
De gauche à droite : 32 utilisateurs Locust, une adresse sur le port 8000, quatre processus et deux services partagés. Chaque processus a un pool d’au plus 10 connexions et un client pour le fournisseur. Les quatre se connectent à un seul PostgreSQL. Il accepte 100 connexions, dont 3 pour les administrateurs, et conserve les billets et la séquence qui les numérote. Les quatre appellent un seul fournisseur simulé, dont le quota s’applique à tout le compte. Quatre processus peuvent ouvrir au plus 40 connexions au total. Rien dont une requête ultérieure a besoin ne reste dans un processus.
Mesures : un processus contre quatre
Section intitulée « Mesures : un processus contre quatre »L’équipe du cours a exécuté le même test avec --workers 4, avec cinq essais pour chaque configuration :
Description textuelle du graphique
Avec 32 utilisateurs et la conception du module 1, un processus d’API a traité 3.37 billets par seconde. Les essais allaient de 3.3 à 3.41. Quatre processus en ont traité 9.59 (de 8.96 à 10.74).
| 32 utilisateurs, conception du module 1 | 1 processus | 4 processus |
|---|---|---|
| Billets traités avec succès par seconde | 3.37 | 9.59 (8.96–10.74) |
| p50 | 6,831 ms | 2,621 ms |
| p95 | 7,480 ms | 4,410 ms |
503 database_busy par essai |
10 à 14 | aucun |
| Connexions à la base de données au maximum | 10 | 40 |
Ce que cela nous apprend. Quatre processus ont traité 9.59 billets par seconde, soit 2,8 fois plus. Le p50 est passé de 6,831 à 2,621 ms. Les erreurs 503 ont disparu. Le gain venait des pools, pas du processeur : un processus avait utilisé environ 1 % d’un cœur.
Deux nombres n’atteignent pas les prévisions du petit exemple. Le débit a atteint 9.59, et non 14,5. Le p95 est de 4,410 ms, et non d’environ 3 000 ms. Les essais ont aussi beaucoup varié : de 8.96 à 10.74. La raison probable est la répartition des utilisateurs. Chaque utilisateur Locust garde une connexion ouverte, et cette connexion reste avec le processus qui l’a acceptée. L’auteur a compté les connexions de chaque processus pendant un essai avec lsof :
Locust connections per API process: 20 6 4 2database connections per API process: 10 6 4 2Un processus a reçu 20 des 32 utilisateurs. Son pool de 10 était plein, et 10 utilisateurs attendaient dans la file. Les trois autres processus avaient des connexions libres. Le système d’exploitation ne répartit pas les connexions selon le travail en cours. Un véritable répartiteur de charge peut faire mieux. Il peut envoyer chaque requête, plutôt que chaque connexion, à l’instance la moins occupée.
Garder l’état partagé à l’extérieur des processus
Section intitulée « Garder l’état partagé à l’extérieur des processus »Quatre processus sont quatre programmes distincts. Ils ne partagent aucune variable Python. Pour chaque donnée, demandez-vous donc : une requête ultérieure en a-t-elle besoin? Si oui, elle doit rester à l’extérieur des processus.
| Élément | Où il se trouve | Partagé par tous les processus? |
|---|---|---|
| Billets, exécutions d’IA, plongements (embeddings) | PostgreSQL | oui |
| Le prochain numéro de billet (T-500001, …) | Séquence PostgreSQL ticket_number_seq |
oui |
| Le pool de connexions | chaque processus | non : 4 pools d’au plus 10 |
Le client du fournisseur et PROVIDER_MAX_CONCURRENCY |
chaque processus | non |
| Le quota du fournisseur | le fournisseur, par compte | oui : plus de processus ne l’augmente pas |
Le numéro de billet montre pourquoi. La migration 013_ai_work.sql numérote les nouveaux billets avec une séquence dans la base de données : 'T-' || nextval('ticket_number_seq'). Imaginez plutôt un compteur Python dans intake.py, next_number += 1 (un exemple construit, absent du projet). Chacun des quatre processus commencerait à 500001. Quatre billets différents recevraient donc T-500001. La séquence de la base de données donne chaque numéro exactement une fois, peu importe le nombre de processus.
Le pool et le client du fournisseur sont différents. Ce ne sont pas des données dont une requête a besoin plus tard. Ce sont des ressources : chaque processus a besoin des siennes. Mais le nombre de processus multiplie chacune de ces ressources. Quatre processus ouvrent au plus 40 connexions, et douze en ouvriraient au plus 120. Limites des dépendances en fait la somme.
Larkfield : plusieurs processus, aucun nouveau code
Section intitulée « Larkfield : plusieurs processus, aucun nouveau code »Le projet n’a besoin d’aucun changement. Seule la commande de démarrage change :
fastapi devdémarre un processus qui redémarre quand vous enregistrez un fichier. Utilisez-le pendant que vous écrivez du code.fastapi rundémarre l’API sans ces redémarrages. Avec--workers 4, il démarre un processus parent et quatre processus.uvicorn ticket_api.main:app --workers 4fait la même chose.
Le journal de fastapi run --workers 4 montre les processus (essai de l’auteur, sans les lignes d’avertissement) :
INFO: Started parent process [92211]INFO: Started server process [92223]INFO: Waiting for application startup.INFO: Application startup complete.INFO: Started server process [92225]...Chaque processus exécute lui-même le démarrage de l’application. Il ouvre son propre pool, avec 2 connexions quand il est peu occupé. L’auteur a donc vu 8 connexions idle (inactives) avant le test, soit 2 par processus. Chaque processus utilisait aussi environ 87 Mo de mémoire après le démarrage sur le Mac de l’auteur. Le parent utilisait environ 52 Mo de plus.
Exercice guidé : comparer deux configurations
Section intitulée « Exercice guidé : comparer deux configurations »Voici l’exercice du module : la même charge de travail sur deux configurations, mesurée de la même façon. Fermez d’abord les autres programmes occupés.
-
Dans le premier terminal, démarrez le fournisseur simulé avec son quota désactivé :
Fenêtre de terminal SIM_QUOTA=off python -m simulatorFenêtre de terminal $env:SIM_QUOTA = "off"; python -m simulator -
Dans le deuxième terminal, démarrez un processus de la conception du module 1 :
Fenêtre de terminal INTAKE_MODE=thread fastapi runFenêtre de terminal $env:INTAKE_MODE = "thread"; fastapi run -
Dans le troisième terminal, exécutez 32 utilisateurs pendant 40 secondes. Locust écrit chaque requête dans
one.csv:Fenêtre de terminal SAMPLES_CSV=one.csv locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 32 -r 32 -t 40sFenêtre de terminal $env:SAMPLES_CSV = "one.csv"; locust -f loadtest/locustfile.py --host http://127.0.0.1:8000 --headless -u 32 -r 32 -t 40s -
Résumez l’essai sans ses 10 premières secondes (la période de préparation) :
python -m scripts.percentiles one.csv --skip 10. -
Arrêtez l’API avec Ctrl+C. Démarrez quatre processus :
INTAKE_MODE=thread fastapi run --workers 4(Windows :fastapi run --workers 4, la variable est encore définie). -
Répétez l’étape 3 avec
four.csvau lieu deone.csv, puis l’étape 4 avecfour.csv. -
Copiez
docs/benchmark-template.mdversdocs/results-processes.md. Indiquez la machine (python -m scripts.machine), la charge de travail et les deux lignes de résultats.
Afficher le résultat attendu
Locust affiche un tableau toutes les quelques secondes et un résumé à la fin. Pour l’essai avec un processus, il termine avec le code de sortie 1. Certaines requêtes ont en effet échoué avec 503. Voici les deux essais de l’auteur sur un ordinateur partagé occupé :
106 requests in 28.3 s; status codes {'201': 95, '503': 11}Successful: 95 = 3.36 per secondLatency of the successful requests: mean 6906.5 ms | p50 6867.0 ms | p95 7629.2 ms | p99 8254.4 ms | max 8254.4 ms
302 requests in 29.8 s; status codes {'201': 302}Successful: 302 = 10.14 per secondLatency of the successful requests: mean 2840.1 ms | p50 2627.0 ms | p95 4020.6 ms | p99 4250.1 ms | max 5093.0 msVos nombres seront différents. Attendez-vous à la même tendance. Un processus traite environ 3,4 billets par seconde, avec quelques 503 et un p50 supérieur à 5 secondes. Quatre processus en traitent environ trois fois plus, sans 503. Un seul essai n’est pas un résultat. Les nombres de l’équipe du cours sont la médiane de cinq essais. Si vous avez le temps, exécutez chaque configuration au moins trois fois. Notez la valeur la plus basse et la plus haute.
À vous de jouer : un processus asynchrone
Section intitulée « À vous de jouer : un processus asynchrone »Changez une condition : gardez un seul processus, mais utilisez la conception asynchrone. Faites d’abord une prédiction. Avec 32 utilisateurs, un processus asynchrone traite-t-il plus ou moins de billets par seconde que quatre processus du module 1? Démarrez ensuite l’API avec fastapi run (avec INTAKE_MODE non définie, ou INTAKE_MODE=async). Exécutez les étapes 3 et 4 avec async.csv. Sur Windows, supprimez d’abord la variable : Remove-Item Env:INTAKE_MODE.
Afficher la réponse
Plus. L’équipe du cours a mesuré 13.39 billets par seconde pour un processus asynchrone avec 32 utilisateurs. C’est la médiane de 3 essais de 30 secondes. Son p95 était de 2,680 ms, sans 503. L’essai de l’auteur sur un ordinateur occupé : 12,72 par seconde, p95 de 2 997 ms. C’est plus que quatre processus de la conception du module 1 (9.59).
La conception asynchrone attend le fournisseur sans connexion. Le pool de 10 n’est donc plus la limite. Les 32 billets sont en cours à la fois : 32 ÷ 2,2 s ≈ 14,5 au maximum. Quatre processus ont multiplié les pools; la conception asynchrone a supprimé le besoin de les utiliser pendant l’attente. Les deux méthodes permettent d’en faire plus à la fois. Elles ne s’excluent pas. En production, vous exécuteriez plusieurs processus asynchrones, pour la sécurité et pour le travail de calcul. La prochaine leçon montre ce qui les limite alors.
Quand ajouter des instances, et à quel coût
Section intitulée « Quand ajouter des instances, et à quel coût »Ajoutez des instances quand une instance est la limite et que les services partagés ont encore de la capacité. La mise à l’échelle horizontale offre aussi une sécurité : si une instance plante, les autres continuent de servir les requêtes. Dans le nuage, c’est ainsi qu’un service passe d’un conteneur à plusieurs. Le module 5 détermine automatiquement le nombre d’instances.
N’ajoutez pas d’instances quand la limite se trouve derrière elles. Plus de processus n’augmente pas le quota du fournisseur et n’accélère pas une base de données lente. Ils lui envoient plus de travail. Pour un travail exigeant en calcul, avoir plus de processus que de cœurs les fait simplement alterner sur les mêmes cœurs.
Ce que cela coûte :
- Mémoire : chaque processus charge sa propre copie de Python, des bibliothèques et de l’application. Ici, environ 87 Mo chacun.
- Connexions : chaque processus a son propre pool. Quatre processus peuvent ouvrir 40 connexions; la limite de la base de données s’applique à leur total.
- Travail inégal : la répartition entre les instances n’est pas parfaite, comme l’a montré la répartition 20–6–4–2.
- Aucune mémoire partagée : tout ce que les requêtes partagent doit passer dans un service partagé. Le module 3 déplace le cache vers Valkey. Le module 4 y déplace la limite de débit pour cette même raison.
État à l’intérieur d’un processus
Section intitulée « État à l’intérieur d’un processus »Erreur courante
Une limite conservée dans un dictionnaire Python
Symptôme (construit, absent du projet) : un développeur limite chaque client à 30 nouveaux billets de soutien par minute. Le test réussit avec fastapi dev. En production, avec quatre processus, un client envoie 100 billets en une minute et l’API en accepte environ 100. Le journal ne montre aucun 429 pour ce client.
Cause : le compteur est un dictionnaire dans le module, par exemple sent = defaultdict(int), avec sent[customer_id] += 1 pour chaque billet. Chaque processus a son propre dictionnaire. Quatre processus permettent 4 × 30 = 120 billets par minute, et un redémarrage remet chaque compteur à 0.
Diagnostic :
- Cherchez les variables au niveau du module qui changent pendant l’exécution de l’API : dictionnaires, listes, compteurs et instructions
global. Un paramètre lu une seule fois au démarrage ne pose pas de problème. - Exécutez le test avec
fastapi run --workers 2, pas seulement avecfastapi dev. Une limite ou un compte correct avec un processus, mais incorrect avec deux, se trouve à l’intérieur du processus.
Correction : conservez le compteur dans un service partagé que chaque processus utilise. Le module 4 fait exactement cela : RATE_LIMIT_PER_MINUTE compte dans Valkey, pour que tous les processus voient un seul compte. Gardez dans un processus seulement des ressources (un pool, un client) et des données qui ne changent jamais pendant l’exécution de l’API.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Avec la conception du module 1 et 32 utilisateurs, quatre processus traitaient 9,59 billets par seconde, contre 3,37 pour un processus. L'API utilisait environ 1 % d'un cœur de processeur. Qu'ont ajouté les processus supplémentaires, sinon de la puissance de calcul?
Afficher la réponse
Des pools de connexions (pools). Dans la conception du module 1, chaque billet garde une connexion à la base de données pendant environ 2,2 secondes. Pendant ce temps, il attend le fournisseur. Un processus a un pool de 10 connexions, donc au plus 10 billets sont en cours : environ 4,5 par seconde au maximum. Les 22 autres utilisateurs attendaient une connexion, et certains ont reçu 503. Quatre processus ont quatre pools, soit jusqu’à 40 connexions. Les 32 utilisateurs pouvaient donc tous avoir un billet en cours.
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
Quels éléments peuvent rester dans un seul processus d'API quand vous en exécutez quatre : (a) le pool de connexions, (b) le prochain numéro de billet, (c) un dictionnaire qui compte les billets de chaque client durant cette minute, (d) la clé d'API lue dans un fichier au démarrage? Expliquez.
Afficher la réponse
(a) et (d) peuvent rester. Le pool est une ressource dont chaque processus a besoin pour lui-même. La clé d’API ne change pas pendant l’exécution de l’API. (b) et (c) ne peuvent pas rester. Une requête ultérieure en a besoin, et chaque processus doit voir la même valeur. Le numéro de billet vient de la séquence ticket_number_seq de la base de données. Le compteur doit se trouver dans un service partagé comme Valkey. Si ces éléments restaient dans le processus, quatre processus attribueraient T-500001 quatre fois et permettraient quatre fois la limite.
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
Omar demande : « Si 4 processus ont donné presque 3 fois le débit, est-ce que 40 processus donneront 30 fois le débit? » Que répondez-vous?
Afficher la réponse
Non. Le test n’avait que 32 utilisateurs, et la version asynchrone a montré leur plafond : environ 32 ÷ 2,2 s ≈ 14,5 billets par seconde. Ajouter des processus multiplie aussi les ressources des services partagés que chaque processus utilise. Avec des pools de 10, 40 processus pourraient ouvrir 400 connexions, alors que PostgreSQL en permet 100. De plus, le quota du fournisseur s’applique par compte. Quand il est activé, il permet environ 50 billets par minute, peu importe le nombre de processus. La prochaine leçon additionne ces limites.
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
- La mise à l’échelle horizontale exécute plus d’instances du même service derrière une seule adresse. La mise à l’échelle verticale utilise un ordinateur plus puissant.
- Une instance doit être sans état : ce dont une requête ultérieure a besoin se trouve dans un service partagé (ici PostgreSQL), jamais dans une variable Python.
fastapi run --workers 4démarre quatre processus, chacun avec son propre pool d’au plus 10 connexions.- Mesures avec 32 utilisateurs et la conception du module 1 : un processus 3.37 billets par seconde (p50 6,831 ms, quelques
503); quatre processus 9.59 (p50 2,621 ms, aucun503). Un processus asynchrone : 13.39. - Les connexions ne sont pas réparties également : 20, 6, 4 et 2 utilisateurs lors de l’exécution de l’auteur.
- Chaque processus multiplie ses ressources : mémoire, connexions. Le quota du fournisseur n’augmente pas.
Leçon suivante : Limites des dépendances