Signaux de mise à l'échelle
- Leçon 15
- 55 min
- Module 5 : Résilience et mise à l'échelle automatique
Où nous en sommes
Dans la leçon précédente, les délais d'expiration, les limites de nouvelles tentatives et un disjoncteur ont empêché une panne du fournisseur de faire tomber le service. Mais le nombre de processus est encore fixe : trop peu lors d'une pointe, trop quand le travail a disparu. Dans cette leçon, nous laissons la file d'attente décider quand ajouter ou retirer des processus, et nous fixons les limites qui rendent cela sûr. Une gérante de supermarché qui ouvre d'autres caisses surveille la file, pas les mains de la caissière.
Leçon 15 sur 19 · Mettre à l'échelle les API et les charges de travail d'IASignaux de mise à l'échelle
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
Exécutez plus de processus quand le travail s’accumule, et moins quand il disparaît, sans surveillance humaine. Choisissez la valeur qui guide cette décision et fixez les limites qui la rendent sûre.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les délais d’expiration et le disjoncteur, présentés dans Contenir les défaillances.
- Les valeurs de la file (
queued[en attente],ready[prêtes],running[en cours], âge de la plus ancienne tâche), présentées dans Cycle de vie d’une tâche. - Les limites par processus qui s’additionnent (pool de connexions, quota du fournisseur), présentées dans Limites des dépendances.
Ce qu’il vous faut sur votre ordinateur
- Le projet après Contenir les défaillances :
python -m pytestaffiche172 passed, 1 deselected(172 tests réussis, 1 non sélectionné). - PostgreSQL et Valkey en cours d’exécution. Aucun processus de traitement en cours : le gestionnaire de mise à l’échelle automatique démarre les siens.
Tout ce qui est mis à l’échelle dans cette leçon est une simulation sur votre ordinateur. scripts/autoscale.py démarre et arrête de vrais processus de traitement selon les valeurs de la file. Un gestionnaire de mise à l’échelle automatique fait de même avec des conteneurs sur une plateforme. Le cours n’a pas exécuté de gestionnaire de mise à l’échelle automatique dans le nuage. Les renseignements sur Azure Container Apps viennent de sa documentation, et non d’une exécution. Nous le précisons chaque fois.
Ouvrir plus de caisses
Section intitulée « Ouvrir plus de caisses »Un samedi matin, un supermarché a une seule caisse ouverte. Puis une foule arrive. Une bonne gestionnaire ouvre d’autres caisses, mais que surveille-t-elle pour décider? Elle ne surveille pas la vitesse des mains de la caissière. La caissière travaille à la même vitesse avec 2 ou 20 personnes qui attendent. Elle surveille la file : le nombre de personnes et le temps d’attente de celle qui est au bout.
Ouvrir une caisse n’est pas instantané. Une caissière doit s’y rendre et se connecter : une minute de délai. Quand la file disparaît, la gestionnaire ne ferme pas les caisses supplémentaires immédiatement. Une autre vague de clients pourrait arriver sous peu. Rappeler la caissière coûterait une autre minute. Elle attend donc quelques minutes. Elle garde toujours au moins une caisse ouverte, sans jamais dépasser le nombre de caisses du magasin.
Voilà les éléments de cette leçon : un signal à surveiller, un délai de démarrage, une attente avant l’arrêt et deux limites.
Le problème : un nombre fixe de processus
Section intitulée « Le problème : un nombre fixe de processus »Le Vendredi fou apporte environ dix fois plus de billets de soutien que d’habitude, pendant quelques heures. Dans Modèle de charge de travail, l’heure la plus chargée, multipliée par dix, donnait 1 010 billets. Avec un nombre fixe de processus, Amira doit choisir entre deux mauvaises options :
- Peu de processus (un seul, comme un jour normal). Lors d’une pointe, la file s’allonge. Chaque client attend plus longtemps son brouillon de réponse.
- Beaucoup de processus toute la journée (six, pour répondre à la minute la plus chargée). La majeure partie de l’année, cinq ne font rien. Chacun garde tout de même des connexions à la base de données et coûte de l’argent là où il s’exécute.
Voici un petit exemple, sans quota. Un processus traite 4 tâches à la fois, et une tâche prend environ 2,2 secondes. Un processus traite donc environ 1,8 billet par seconde. Une pointe apporte 6 billets par seconde pendant 30 secondes : 180 billets. Un processus a besoin d’environ 180 ÷ 1,8 = 100 secondes pour les traiter. Le dernier billet attend environ 70 secondes après son arrivée. Quatre processus traitent environ 7 billets par seconde, plus vite que la pointe. La file s’allonge donc à peine.
La mise à l’échelle automatique est la réponse. Un programme ajuste le nombre de processus, ou de réplicas de l’API, selon un signal mesuré et dans certaines limites. La question est de choisir le signal.
Quatre signaux et ce que chacun voit
Section intitulée « Quatre signaux et ce que chacun voit »| Signal | Ce qu’il mesure | Pour le traitement des billets par l’IA |
|---|---|---|
| Processeur (CPU) | Le taux d’utilisation des processeurs | Un processus attend le fournisseur; il ne fait pas de calcul. Dans le module 1, l’API utilisait de 0,6 à 2,2 % du processeur pendant l’attente. L’utilisation reste faible pendant que la file s’allonge : un mauvais signal ici |
| Concurrence (requêtes en cours) | Le nombre de requêtes qu’un réplica traite à la fois | Bon pour l’API : Azure Container Apps l’utilise par défaut pour la mise à l’échelle (selon la documentation). Mais l’API répond maintenant à un nouveau billet en environ 12 ms. Le travail n’est donc pas là |
| Longueur de la file (travail accumulé) | Les tâches qui peuvent s’exécuter maintenant, plus celles en cours : ready + running |
Augmente précisément quand les processus sont trop peu nombreux : un bon signal pour les processus |
| Âge de la file | Le temps d’attente de la plus ancienne tâche en attente | Ce que ressentent les clients. Ce signal réagit tard : l’âge doit d’abord augmenter |
Le processeur est un bon signal pour le travail de calcul, comme le redimensionnement d’images ou un modèle exécuté localement. Pour le travail qui attend un autre service, il ne vous dit rien. C’est la même leçon que dans Travail d’E/S et travail de calcul. Sachez à quoi votre processus consacre son temps avant de choisir ce que vous surveillez.
Le signal du travail accumulé, avec toutes les valeurs
Section intitulée « Le signal du travail accumulé, avec toutes les valeurs »Le gestionnaire de mise à l’échelle automatique du projet (scripts/autoscale.py) lit la file toutes les 2 secondes. Avec le signal du travail accumulé, il calcule :
processus souhaités = ceil(travail accumulé ÷ cible par processus)
ceil arrondit à l’entier supérieur. La cible est de 8 tâches par processus : 4 qu’il exécute et 4 qui l’attendent. Ensuite, le gestionnaire ramène le résultat entre un minimum et un maximum. À 18,1 secondes dans l’exécution mesurée, la file contenait 15 tâches prêtes et 12 en cours :
Description textuelle du diagramme
La boucle comporte six étapes. De nouveaux billets arrivent dans la file. À cet instant, elle contient 15 tâches prêtes et 12 en cours, soit un travail accumulé de 27. Le gestionnaire de mise à l’échelle automatique lit ce signal toutes les 2 secondes. Il calcule le nombre de processus souhaités : 27 divisé par 8 par processus donne 3,4, arrondi à 4. Il ramène 4 entre le minimum de 1 et le maximum de 6. Le résultat reste donc 4. Ensuite, il ajuste les processus. Il démarre les nouveaux immédiatement. Un nouveau processus attend environ 0,28 seconde avant de pouvoir prendre des tâches : c’est son démarrage à froid. Il en arrête un seulement après 20 secondes de demande pour moins de processus : c’est le délai de stabilisation. Les processus prennent des tâches et la file diminue. Cela ferme la boucle : la prochaine lecture voit moins de travail accumulé.
On parle de boucle de rétroaction parce que sa propre action change la prochaine lecture. Plus de processus vident la file, le travail accumulé diminue, et le gestionnaire veut de nouveau moins de processus. Une telle boucle a besoin de deux freins, sinon elle oscille :
- Un démarrage à froid est le temps entre « démarrer un processus » et « il prend sa première tâche ». Localement, un nouveau processus avait besoin de 0,28 seconde (médiane). Dans le nuage, il faut aussi placer le nouveau réplica, télécharger son image et ouvrir ses connexions. Le cours n’a pas mesuré ce temps et n’en cite aucun.
- Un délai de stabilisation indique combien de temps la demande pour moins de processus doit durer avant d’en arrêter un. Localement, il est de 20 secondes, et le gestionnaire arrête un seul processus à la fois. Le démarrage est immédiat; l’arrêt est volontairement lent. Un processus arrêté trop tôt pourrait redevenir nécessaire un instant plus tard. Il faudrait alors subir de nouveau son démarrage à froid.
Le minimum garde un processus prêt. Le premier billet du matin n’attend donc pas un démarrage à froid. Le maximum protège ce que les processus partagent. Chacun a son propre pool de connexions (pool), avec jusqu’à 5 connexions. Six processus peuvent donc en garder 30. Ajoutez le pool de l’API. Le total doit rester bien sous la limite de 100 de PostgreSQL, comme dans Limites des dépendances. Le quota du fournisseur est aussi partagé, comme le montrent les prochaines sections.
Larkfield : le gestionnaire local pendant une pointe
Section intitulée « Larkfield : le gestionnaire local pendant une pointe »Le cours a exécuté le gestionnaire avec un minimum de 1, un maximum de 6 et 8 tâches par processus. Le délai de stabilisation était de 20 secondes. Dix secondes plus tard, scripts/send_tickets.py a envoyé 6 billets par seconde pendant 30 secondes : 180 billets. L’expéditeur n’attend pas les réponses, comme les vrais clients. L’API a répondu à chaque billet avec 202 en environ 12 ms (médiane). Le quota était désactivé : le fournisseur simulé se comportait comme si le compte avait un quota beaucoup plus élevé.
- Signal du travail accumulé
- Signal de l'âge
Description textuelle du graphique
Un graphique linéaire du nombre de processus, de 0 à 150 secondes. Les billets arrivent entre environ 10 et 40 secondes. Avec le signal du travail accumulé, les processus passent de 1 à 2 à 12 secondes. Ils passent à 3 à 14 secondes, puis à 4 à 18 secondes. La dernière tâche s’est terminée vers 44 secondes. Les processus diminuent ensuite un à la fois : 3 à 44 secondes, 2 à 64 et 1 à 84. Avec le signal de l’âge, le premier processus supplémentaire démarre plus tard, à 18 secondes. Le nombre atteint 5 à 24 secondes. Il commence à diminuer à 64 secondes et atteint 1 à 124 secondes.
- Signal du travail accumulé
- Signal de l'âge
Description textuelle du graphique
Un graphique linéaire des tâches prêtes ou en cours, de 0 à 60 secondes. Avec le signal du travail accumulé, le nombre passe de 0 à 10 secondes à un maximum de 28 vers 20 secondes. Il redescend à 0 vers 44 secondes. La plus ancienne tâche n’a jamais attendu plus de 2.3 secondes. Avec le signal de l’âge, le nombre atteint un maximum de 51 vers 22 secondes. Le premier processus supplémentaire n’a démarré que lorsque la plus ancienne tâche avait plus de 5 secondes. La plus ancienne tâche a attendu jusqu’à 6.4 secondes. Le nombre redescend aussi à 0 vers 44 secondes.
Ce que cela nous apprend. Les deux signaux ont fonctionné, de façons différentes. Le signal du travail accumulé a réagi à la quantité de travail. Il a ajouté un processus dès que 8 tâches supplémentaires attendaient. La file n’a donc jamais contenu plus de 28 tâches, et aucune n’a attendu plus de 2,3 secondes. Le signal de l’âge a réagi à l’attente. Rien ne s’est passé avant que la plus ancienne tâche ait 5 secondes. À ce moment, plus de travail s’était accumulé. Il fallait donc 5 processus, et les tâches ont attendu jusqu’à 6,4 secondes. Dans les deux exécutions, toutes les tâches étaient terminées vers 44 secondes. Dans les deux cas, les processus supplémentaires sont restés un moment après : c’est le prix du délai de stabilisation.
Le démarrage à froid d’un processus prenait 0,28 seconde (médiane, le plus lent : 0,31). Comparé aux tâches de 2,2 secondes, il avait peu d’effet ici. Il compte lorsque le démarrage à froid est long par rapport au travail, ou lorsque le minimum est de 0.
Le quota change la réponse
Section intitulée « Le quota change la réponse »Voici maintenant la même exécution avec le quota activé : 100 requêtes de clavardage par minute, comme pour le compte réel. Le quota permet environ 50 billets par minute, soit 0,83 par seconde, quel que soit le nombre de processus.
- Toutes les tâches en attente
- Prêtes + en cours (le signal du travail accumulé)
- Processus × 10
Description textuelle du graphique
Un graphique linéaire de 0 à 150 secondes. Le nombre de processus est multiplié par dix dans le graphique : 4 processus apparaissent donc comme 40. Jusqu’à 22 secondes, l’exécution ressemble à celle sans quota. Les processus atteignent 4, et les tâches prêtes et en cours atteignent un maximum de 28. Ensuite, le fournisseur refuse les appels avec 429, et les tâches attendent le quota. La courbe de toutes les tâches en attente monte à 116 à 40 secondes. Elle diminue lentement, jusqu’à 25 à la fin. La courbe des tâches prêtes et en cours descend entre 1 et 8, car une tâche qui attend n’est pas prête. Le signal du travail accumulé demande donc 1 processus. Les processus diminuent d’un par délai de stabilisation : 3 à 44 secondes, 2 à 64 et 1 à 84. La plus ancienne tâche avait attendu plus de deux minutes (126.8 secondes) à la fin de l’exécution.
Ce que cela nous apprend. Le gestionnaire a retiré des processus alors que jusqu’à 116 tâches attendaient. Est-ce un bogue? Non. Les tâches attendaient le quota. Un cinquième ou sixième processus aurait seulement reçu plus de réponses 429. Le signal du travail accumulé compte seulement les tâches qui peuvent s’exécuter maintenant. Il a donc fait le bon choix, presque par accident. Les clients attendaient toujours : le plus ancien billet a attendu plus de deux minutes pour son brouillon. Plus de processus ne peuvent pas régler cela. Un quota plus élevé, ou moins de travail d’IA par billet, le peut. Avant la correction du module 4, une réponse 429 consommait encore une tentative. La même pointe envoyait alors 99 des 180 tâches dans les messages non traitables.
Choisissez donc un signal qui mesure ce que plus de processus peuvent régler. Surveillez l’âge séparément, comme une alarme. Il indique ce que ressentent les clients, même quand la mise à l’échelle ne peut pas aider.
Ce que fait une plateforme : Azure Container Apps
Section intitulée « Ce que fait une plateforme : Azure Container Apps »Cette partie vient de la documentation, sans exécution dans ce cours. Azure Container Apps met les conteneurs à l’échelle avec KEDA (Kubernetes Event-driven Autoscaling), un gestionnaire de mise à l’échelle automatique à code source ouvert. Ses règles correspondent aux éléments de la simulation locale :
| Élément | Simulation locale | Azure Container Apps (documentation) |
|---|---|---|
| Limites | --min 1 --max 6 |
minReplicas (0 par défaut) et maxReplicas (10 par défaut, au plus 1 000) |
| Signal HTTP | non utilisé | règle HTTP concurrentRequests (requêtes simultanées; 10 par défaut), comptées toutes les 15 s |
| Signal de la file | travail accumulé dans la table jobs |
une règle personnalisée avec un composant de mise à l’échelle KEDA, par exemple postgresql, une requête et un targetQueryValue |
| Fréquence de lecture | toutes les 2 s | intervalle d’interrogation : 30 s (sauf pour les règles HTTP) |
| Nombre souhaité | ceil(backlog ÷ 8) |
desiredReplicas = ceil(currentMetricValue / targetMetricValue) |
| Augmentation | immédiatement, autant que nécessaire | fenêtre de stabilisation de 0 s; paliers de 1, 4, 8, 16, 32… jusqu’au maximum |
| Diminution | un processus par délai de stabilisation de 20 s | après 300 s de demande réduite (la fenêtre de stabilisation); le délai de stabilisation de 300 s s’applique seulement au passage du dernier réplica à 0 |
Une règle de mise à l’échelle pour le processus pourrait ressembler à ceci. C’est une ébauche à lire, fondée sur les paramètres documentés du composant PostgreSQL de KEDA, et non testée :
# From the documentation, not run in this course.scale: minReplicas: 1 maxReplicas: 6 rules: - name: ticket-jobs custom: type: postgresql metadata: query: "SELECT count(*) FROM jobs WHERE state = 'running' OR (state = 'queued' AND run_after <= now())" targetQueryValue: "8" auth: - secretRef: database-url triggerParameter: connectionLa requête donne le travail accumulé du gestionnaire : les tâches prêtes plus celles en cours. targetQueryValue est la cible de 8 tâches par processus. Deux différences avec l’exécution locale comptent. La plateforme lit toutes les 30 secondes, et non toutes les 2 secondes. Elle réagit donc plus lentement à une pointe de 30 secondes. Avec minReplicas: 0, la première tâche après une période calme attend aussi un démarrage à froid complet. Mesurez les deux avant de vous y fier. Le cours n’a aucune mesure dans le nuage pour ces deux délais.
Sources : Mise à l’échelle dans Azure Container Apps (Microsoft Learn) et le composant de mise à l’échelle PostgreSQL de KEDA (documentation de KEDA).
Exercice guidé : exécuter l’outil local de mise à l’échelle automatique
Section intitulée « Exercice guidé : exécuter l’outil local de mise à l’échelle automatique »Vous avez besoin de quatre terminaux, chacun dans ~/projects/ticket-api, avec l’environnement virtuel actif.
-
Copiez le script de cette leçon depuis l’instantané
end-of-m05. Le script d’envoi,scripts/send_tickets.py, est déjà dans votre projet depuis Contre-pression.Fenêtre de terminal S=../nextia-learning-labs/C21/snapshots/end-of-m05cp "$S/scripts/autoscale.py" scripts/Fenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m05"Copy-Item "$S\scripts\autoscale.py" scripts\ -
Arrêtez tous les processus en cours. Rechargez ensuite les données :
python -m scripts.load --reset. -
Dans le terminal 1, arrêtez le fournisseur simulé s’il est en cours d’exécution (Ctrl+C). Redémarrez-le sans quota :
SIM_QUOTA=off python -m simulator. Dans PowerShell :$env:SIM_QUOTA = "off"; python -m simulator. -
Dans le terminal 2, démarrez l’API sans limite de débit par appelant :
RATE_LIMIT_PER_MINUTE=0 fastapi dev. Dans PowerShell :$env:RATE_LIMIT_PER_MINUTE = "0"; fastapi dev. L’essai mesuré désactivait aussi cette limite, pour que seuls les processus influencent la file d’attente. -
Dans le terminal 3, démarrez l’outil de mise à l’échelle automatique. Il fonctionne pendant 150 secondes et affiche une ligne toutes les 2 secondes :
Fenêtre de terminal python -m scripts.autoscale --min 1 --max 6 --per-worker 8 --cooldown 20 --seconds 150 --log autoscale.csv -
Dans les 10 secondes environ, envoyez la rafale depuis le terminal 4 :
Fenêtre de terminal python -m scripts.send_tickets --rate 6 --seconds 30 -
Observez le terminal 3. À la fin, lisez sa dernière ligne : le démarrage à froid d’un processus.
Afficher le résultat attendu
L’étape 6 affiche Sent 180 tickets at 6 per second in 29.9 s: status codes {202: 180} (180 billets envoyés à 6 par seconde en 29,9 secondes, tous avec le code 202). Dans le terminal 3, la vérification de l’auteur, sur un ordinateur occupé, ressemblait à l’essai mesuré :
time ready running oldest workers wanted 10 0 0 0.0 1 1 12 8 4 1.3 2 2 +1 14 13 8 2.0 3 3 +1 16 13 11 2.0 3 3 18 15 12 2.3 4 4 +1 20 11 16 1.7 4 4 22 8 16 1.2 4 3 ... 42 0 0 0.0 3 1 -1 ... 62 0 0 0.0 2 1 -1...Cold start of a worker (process start until it can take jobs): median 0.32 s, slowest 0.34 s (4 starts)+1 indique un processus démarré et -1 un processus arrêté. wanted (nombre souhaité) baisse dès que le nombre de tâches à traiter diminue. Mais workers (nombre de processus) ne suit qu’après 20 secondes. Vos temps et vos nombres exacts varieront un peu; la forme restera la même. autoscale.csv contient une ligne par vérification, ainsi que la colonne queued (tâches en attente), que l’écran n’affiche pas.
À vous : le signal d’âge avec le quota activé
Section intitulée « À vous : le signal d’âge avec le quota activé »Changez volontairement deux paramètres à la fois, car la question porte sur les deux : le quota activé et le signal d’âge. Démarrez le simulateur sans SIM_QUOTA=off, puis exécutez l’outil de mise à l’échelle automatique avec --signal age --target-age 5. Faites d’abord une prédiction : combien de processus démarrera-t-il, et quand les retirera-t-il?
Afficher la réponse
Dans l’essai de l’auteur, le signal d’âge a atteint le maximum de 6 processus après environ 26 secondes. Il a gardé les 6 jusqu’à la fin de l’essai. La tâche la plus ancienne de la file continuait de vieillir, car les tâches attendaient le quota. L’âge dépassait donc toujours 5 secondes. Mais seulement 1 à 6 tâches s’exécutaient à tout moment, car le quota n’en permettait pas plus. Six processus peuvent exécuter 24 tâches à la fois. La plupart restaient donc inactifs, chacun avec ses propres connexions à la base de données.
Le signal d’âge mesure ce que ressentent les clients. C’est pourquoi il constitue ici un mauvais signal de mise à l’échelle : les processus ne peuvent pas changer un quota. Avec le signal du nombre de tâches à traiter, la même rafale ramenait le nombre de processus à 1. Gardez l’âge pour une alarme (« les billets attendent plus de 2 minutes »). Envoyez-la à une personne qui peut augmenter le quota ou désactiver une partie du travail d’IA.
Erreur courante
Mise à l'échelle selon l'utilisation du processeur
Symptôme : Kwame propose la règle habituelle : « Ajoutez un processus quand l’utilisation du processeur dépasse 70 %. » Pendant la rafale, la file atteint des dizaines de tâches, et la plus ancienne attend de plus en plus longtemps. Pourtant, l’outil de mise à l’échelle automatique n’ajoute jamais de processus.
Cause : le processus passe son temps à attendre le fournisseur, pas à calculer. Dans le module 1, l’API utilisait de 0,6 à 2,2 % du processeur pendant qu’elle attendait le fournisseur. Un processus est le même genre de programme. L’utilisation du processeur reste faible, peu importe la longueur de la file. Une règle fondée sur cette utilisation ne détecte donc jamais le problème.
Diagnostic : comparez le signal au symptôme. python -m scripts.queue_watch montre que ready (tâches prêtes) et oldest s (âge de la plus ancienne, en secondes) augmentent. Un moniteur de processus montre que les processus sont presque inactifs. Quand la file s’allonge sans hausse d’utilisation du processeur, le travail attend autre chose.
Solution : ajustez le nombre de processus selon les tâches à traiter (ready + running), avec une cible par processus issue d’une mesure. Gardez les règles fondées sur l’utilisation du processeur pour le travail de calcul. Gardez l’âge comme alarme.
Pour un service d’IA : presque chaque appel à un modèle hébergé passe son temps à attendre, pas à calculer. Un modèle local qui s’exécute sur la même machine représente le cas inverse. L’utilisation du processeur ou du processeur graphique est alors un signal pertinent.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
La file contient 21 tâches prêtes et 16 en cours. La cible est de 8 tâches par processus, le minimum de 1 et le maximum de 4. Combien de processus la règle des tâches à traiter demande-t-elle, et combien s'exécutent?
Afficher la réponse
Il y a 21 + 16 = 37 tâches à traiter. 37 ÷ 8 = 4,6, arrondi au supérieur à 5 processus. Le maximum est de 4, donc l’application des bornes donne 4 processus. La file se videra plus lentement que ce que la règle demandait. C’est le rôle du maximum : protéger les connexions à la base de données et le quota du fournisseur que tous les processus partagent.
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
Expliquez pourquoi le nombre de processus est passé de 4 à 1 alors que jusqu'à 116 tâches attendaient, avec le quota activé. Était-ce une erreur?
Afficher la réponse
Les tâches attendaient le quota du fournisseur. Leur run_after (moment à partir duquel elles peuvent s’exécuter) était donc dans le futur, et elles n’étaient pas prêtes. Le signal des tâches à traiter compte seulement les tâches prêtes et en cours, soit 1 à 8 à la fois. Il demandait donc 1 processus. Ce n’était pas une erreur. Le quota permet environ 0,83 billet par seconde, peu importe le nombre de processus. Plus de processus recevraient seulement plus de réponses 429. Les clients attendaient quand même plus de deux minutes. Pour corriger cela, il faut un quota plus élevé ou moins de travail d’IA par billet, pas plus de processus. Surveillez l’âge comme alarme.
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 sont les coûts d'un démarrage à froid et d'un délai de stabilisation? Pourquoi démarrer vite, mais arrêter lentement, est-il un bon choix par défaut?
Afficher la réponse
Le démarrage à froid est le délai avant qu’un nouveau processus puisse prendre des tâches. Il était de 0,28 seconde pour un processus local. Une réplique dans le nuage prend plus de temps (non mesuré dans ce cours). Un délai de stabilisation garde des processus supplémentaires après la fin du travail. Dans l’essai local, le dernier processus supplémentaire s’est arrêté environ 40 secondes après que la file s’est vidée. Démarrer vite évite de faire attendre les clients quand une rafale commence. Arrêter lentement évite de payer un autre démarrage à froid si la prochaine vague arrive peu après. Le coût est de garder quelques processus inactifs après chaque rafale.
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 automatique change le nombre de processus ou de répliques selon un signal mesuré, entre un minimum et un maximum.
- L’utilisation du processeur est un mauvais signal pour le travail d’IA qui attend un fournisseur. La concurrence convient à l’API. Le nombre de tâches à traiter (prêtes + en cours) convient aux processus : nombre souhaité = plafond(tâches à traiter ÷ cible par processus). L’âge représente ce que ressentent les clients, mais il réagit tard.
- Dans la simulation locale (quota désactivé, 180 billets en 30 secondes), le signal des tâches à traiter a atteint 4 processus. Aucune tâche n’a attendu plus de 2,3 secondes. Le signal d’âge a atteint 5 processus, et les tâches ont attendu jusqu’à 6,4 secondes.
- Avec le quota activé, le nombre de processus est revenu à 1 alors que jusqu’à 116 tâches attendaient le quota. Plus de processus ne peuvent pas dépasser un quota.
- Démarrage à froid : 0,28 seconde pour un processus local. Délai de stabilisation : retirer les processus lentement. Azure Container Apps documente un intervalle de vérification de 30 secondes et une fenêtre de réduction de 300 secondes. Aucune valeur dans le nuage n’a été mesurée dans ce cours.
Ensuite, vous vérifierez qu’arrêter un processus, ce que fait chaque réduction de capacité, ne perd aucun travail.
Leçon suivante : Arrêt en douceur