Arrêt en douceur
- Leçon 16
- 50 min
- Module 5 : Résilience et mise à l'échelle automatique
Où nous en sommes
Dans la leçon précédente, la mise à l'échelle automatique a ajouté des processus lors d'une pointe et les a retirés quand le travail a disparu. Mais chaque réduction arrête un processus, comme chaque déploiement. Un processus qui s'arrête au milieu d'une tâche peut laisser du travail à moitié fait. Dans cette leçon, nous arrêtons les processus pour qu'ils terminent ou remettent leur travail, et nous récupérons quand l'un d'eux s'arrête sans avertissement, comme un café à la fermeture, ou pendant une panne de courant.
Leçon 16 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAArrêt en douceur
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
Remplacez un processus de traitement ou d’API sans perdre le travail d’IA d’un billet de soutien. Lors d’un arrêt volontaire, terminez ou remettez le travail en attente. Récupérez aussi lorsqu’un processus s’arrête sans avertissement.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Le bail de la tâche (
locked_until), les tentatives et pourquoi chaque résultat d’étape est enregistré avec l’identifiant de la tâche, dans Livraison et nouvelles tentatives. - Le disjoncteur et comment un processus remet une tâche en attente sans utiliser une tentative, dans Contenir les défaillances.
- Pourquoi un système de mise à l’échelle automatique arrête des processus, dans Signaux de mise à l’échelle.
Ce qu’il vous faut sur votre ordinateur
- Le projet après Signaux de mise à l’échelle :
python -m pytestaffiche172 passed, 1 deselected. - PostgreSQL et Valkey en marche, ainsi que le fournisseur simulé (
python -m simulator) en mode normal. Aucun processus de traitement en marche.
L’arrêt forcé de cette leçon est un cas construit : le cours arrête volontairement un processus avec SIGKILL. Le fournisseur est celui du simulateur.
L’heure de fermeture et une panne de courant
Section intitulée « L’heure de fermeture et une panne de courant »Un café ferme à 18 h. À 17 h 50, le personnel verrouille la porte : aucun nouveau client n’entre. Les clients à l’intérieur terminent leur café, paient et partent. Un client qui a commandé un gâteau à 17 h 55 le reçoit quand même. À 18 h, la salle est vide, toutes les factures sont payées et personne n’a perdu sa commande.
Imaginez maintenant une panne de courant à 17 h 55. Les lumières s’éteignent, la machine à café s’arrête et le personnel fait sortir tout le monde. Certains clients ont payé, d’autres non; un gâteau est à moitié préparé. Le lendemain matin, le responsable doit consulter le registre des commandes pour savoir lesquelles ont été terminées.
Le premier cas est un arrêt en douceur : ne plus accepter de travail, terminer le travail en cours, puis s’arrêter. Le deuxième est un arrêt brusque. Le registre des commandes permet alors de récupérer.
Le problème : chaque réduction de capacité arrête un processus
Section intitulée « Le problème : chaque réduction de capacité arrête un processus »Dans la dernière leçon, le système de mise à l’échelle automatique arrêtait des processus après chaque pointe de trafic. Une plateforme arrête des processus pour bien d’autres raisons : déploiement d’une nouvelle version, remplacement d’une machine, déplacement d’une réplique. Azure Container Apps, par exemple, le documente. Lors d’une réduction de capacité, ou de la suppression d’une révision ou de l’application, la plateforme envoie le signal SIGTERM. Si le conteneur ne s’est pas arrêté après 30 secondes, SIGKILL le termine. Cela vient de la documentation; le cours ne l’a pas exécuté.
Un signal est un court message que le système d’exploitation envoie à un processus. SIGTERM signifie « veuillez arrêter » : le processus peut le capter et libérer ses ressources. SIGKILL signifie « arrêtez maintenant » : le processus ne peut pas le capter et se termine immédiatement. Ctrl+C dans un terminal envoie SIGINT, que la plupart des programmes traitent comme SIGTERM.
Que faisait le processus du module 4 avec SIGTERM? L’auteur a mis 12 billets en file d’attente, démarré ce processus et envoyé SIGTERM après 3 secondes. Le processus s’est terminé immédiatement avec le code de sortie 143 (SIGTERM termine un programme qui ne le capte pas). Voici les tâches juste après :
state | count | min | max-----------+-------+-----+----- queued | 4 | 0 | 0 running | 4 | 1 | 1 succeeded | 4 | 1 | 1Quatre tâches étaient running (en cours), mais aucun processus ne les traitait plus. Leur bail les gardait verrouillées pendant 30 secondes (JOB_LEASE_SECONDS), empêchant tout autre processus de les prendre. Le processus du module 4 traitait un SIGTERM poli comme une panne de courant. Chaque réduction de capacité et chaque déploiement retarderaient jusqu’à 4 tâches par processus d’une demi-minute, en utilisant une tentative.
L’idée : terminer le travail en cours, puis arrêter
Section intitulée « L’idée : terminer le travail en cours, puis arrêter »Le vidage consiste à ne plus accepter de travail, à laisser un temps limité au travail en cours pour terminer, puis à remettre le reste en attente. Le processus du module 5 le fait quand il reçoit SIGTERM ou Ctrl+C :
- Il ne prend aucune nouvelle tâche et affiche le nombre de tâches encore en cours.
- Il attend jusqu’à
WORKER_DRAIN_SECONDS(20) pour les tâches en cours. - Si une tâche est encore en cours après ce délai, il la remet en file d’attente (
jobs.release). La tentative ne compte pas. Ses étapes enregistrées restent enregistrées. - Il ferme son pool de connexions à la base de données (pool) et son client du fournisseur. Il termine avec le code de sortie 0.
Le temps de vidage doit être inférieur au délai de grâce de la plateforme. Sinon, la plateforme termine le processus pendant son vidage. Azure Container Apps attend 30 secondes, donc 20 convient. Par défaut, docker stop attend seulement 10 secondes sous Linux. Un processus dans Docker Compose a donc besoin d’un stop_grace_period plus long. Le fichier compose.yaml du projet accorde 30 secondes au processus. Le cours n’a pas exécuté le processus Compose.
Et l’arrêt brusque, la panne de courant? Un processus qui reçoit SIGKILL, plante ou perd sa machine ne peut pas effectuer de vidage. Pour ce cas, le registre des commandes est déjà en place depuis le module 4 :
- Le bail : une tâche est verrouillée seulement jusqu’à
locked_until. Quand le bail expire, un autre processus peut reprendre la tâche. - Les étapes enregistrées : chaque résultat d’étape est enregistré immédiatement avec l’identifiant de la tâche,
UNIQUE (job_id, task). Le processus suivant n’appelle pas de nouveau une étape terminée.
L’arrêt en douceur rend donc le cas normal rapide, et le bail rend le cas rare sûr.
Description textuelle du diagramme
La rangée du haut montre l’arrêt en douceur. Un processus traite 4 tâches à la fois, avec 12 tâches en file d’attente. Après 3 secondes, il reçoit SIGTERM et ne prend aucune nouvelle tâche. Ses tâches en cours terminent; il peut attendre jusqu’à 20 secondes, mais le processus a terminé 2,2 à 3,4 secondes plus tard. À ce moment, 8 tâches avaient réussi et 4 n’avaient jamais commencé, donc elles restaient en file d’attente. Un nouveau processus les a terminées en environ 3 secondes, toutes à la tentative 1. La rangée du bas montre l’arrêt forcé, un cas construit. Le même processus reçoit SIGKILL après 3 secondes et termine immédiatement. Quatre tâches restent running, mais personne ne les traite. Quand leur bail expire (10 secondes dans cette démonstration, 30 par défaut), un autre processus peut les prendre. Un nouveau processus a terminé la file en 12,7 à 13,2 secondes. Les 4 tâches ont terminé à la tentative 2, avec 3 résultats d’IA chacune : aucun doublon.
Larkfield : remplacer un processus pendant son travail
Section intitulée « Larkfield : remplacer un processus pendant son travail »scripts/shutdown_demo.py exécute les deux scénarios du diagramme. Il met 12 billets en file d’attente et démarre un processus qui traite 4 tâches à la fois. Après 3 secondes, il arrête le processus. Il démarre ensuite un nouveau processus et mesure le temps nécessaire pour terminer la file. Le bail dure 10 secondes dans la démonstration, et non 30, pour raccourcir le scénario d’arrêt forcé. Voici une exécution mesurée :
Round 'graceful': stopped after 3 s with SIGTERM; the process ended 3.0 s later (exit code 0) worker said: Stopping: no new jobs; 4 running job(s) get up to 20 s to finish. worker said: Done in 5.7 s: 8 taken, 8 succeeded, 0 waiting for the quota, 0 to retry later, 0 failed, 0 dead letters, 0 given back to the queue. right after: states {'queued': 4, 'succeeded': 8}; attempts per job [0, 1]; AI results per job [0, 3] a new worker finished the queue in 3.6 s: states {'succeeded': 12}; attempts per job [1]; AI results per job [3]Round 'killed': stopped after 3 s with SIGKILL; the process ended 0.0 s later (exit code -9) right after: states {'queued': 5, 'running': 4, 'succeeded': 3}; attempts per job [0, 1]; AI results per job [0, 2, 3] a new worker finished the queue in 12.7 s: states {'succeeded': 12}; attempts per job [1, 2]; AI results per job [3]Lisez la sortie ligne par ligne. Dans le scénario en douceur, le processus a annoncé ce qu’il faisait, terminé ses 4 tâches en cours et retourné le code de sortie 0. Il ne restait aucune tâche running. Les 4 tâches jamais commencées restaient en file d’attente, à la tentative 0. Le nouveau processus les a terminées en environ 3,5 secondes. La dernière ligne du processus compte aussi les tâches qui attendaient le quota : aucune ici.
Dans le scénario d’arrêt forcé, le code de sortie -9 signifie SIGKILL. Quatre tâches sont restées running. Le nouveau processus ne pouvait pas les prendre avant l’expiration de leur bail, environ 10 secondes après leur prise initiale. Il les a ensuite traitées à la tentative 2. Chaque tâche a toujours exactement 3 résultats d’IA : classification, rédaction et plongement, une fois chacun. Juste après l’arrêt forcé, une tâche avait 2 résultats d’IA (AI results per job [0, 2, 3], résultats d’IA par tâche). Elle avait enregistré sa classification et son brouillon avant l’arrêt du processus. Le nouveau processus n’a pas refait ces deux étapes, car le premier avait enregistré chaque étape avec l’identifiant de la tâche.
Description textuelle du graphique
Un graphique à colonnes avec deux colonnes. Après l’arrêt en douceur (SIGTERM), un nouveau processus a terminé les tâches restantes en une médiane de 3.1 secondes (3,1 à 3,6 sur 3 exécutions). Après l’arrêt forcé (SIGKILL), il lui a fallu une médiane de 12.7 secondes (12,7 à 13,2). La différence vient du bail : 4 tâches sont restées verrouillées jusqu’à son expiration. Dans les deux scénarios, les 12 tâches ont réussi, et aucune n’a reçu deux fois son travail d’IA.
Ce que cela nous apprend. Aucun des deux arrêts n’a perdu de travail ni créé de doublon. La différence, c’est le temps. Avec un arrêt en douceur, le remplacement est presque invisible : le brouillon du client arrive quelques secondes en retard, au plus. Avec un arrêt forcé, jusqu’à 4 brouillons par processus attendent l’expiration du bail. Avec le bail par défaut de 30 secondes, ils attendent jusqu’à une demi-minute et utilisent chacun une tentative.
L’API effectue aussi un vidage
Section intitulée « L’API effectue aussi un vidage »L’API est aussi un processus, et chaque déploiement la remplace. fastapi run utilise le serveur Uvicorn, qui effectue déjà un vidage sur SIGTERM. Il cesse d’accepter de nouvelles connexions et attend les requêtes en cours. Ensuite, il exécute le code d’arrêt de l’application, qui ferme le pool de connexions à la base de données. L’auteur l’a testé avec le fournisseur simulé en mode lent. Une question a été envoyée, puis l’API a reçu SIGTERM une seconde plus tard :
INFO: Shutting downINFO: Waiting for connections to close. (CTRL+C to force quit)INFO ticket_api: POST /v1/answers 200 7539ms queries=4 id=3b174f14eca5INFO: 127.0.0.1:54613 - "POST /v1/answers HTTP/1.1" 200 OKINFO: Waiting for application shutdown.INFO: Application shutdown complete.La question lente a quand même reçu son 200 après 7,5 secondes. Une nouvelle requête envoyée après le signal a été refusée : la connexion a échoué. Un répartiteur de charge l’enverrait donc à une autre réplique. Par défaut, Uvicorn attend les requêtes ouvertes sans limite; uvicorn --timeout-graceful-shutdown 20 en fixe une. Dans la conception avec file d’attente, un nouveau billet prend environ 12 ms. L’API effectue donc son vidage presque immédiatement. Le travail lent se fait dans le processus de traitement, qui a donc besoin de son propre vidage.
Quand l’utiliser et ce qu’il coûte
Section intitulée « Quand l’utiliser et ce qu’il coûte »L’arrêt en douceur vaut toujours la peine. Les plateformes arrêtent constamment des processus, et le vidage rend la plupart de ces arrêts imperceptibles pour le client. Ses coûts sont faibles, mais réels :
- Un arrêt prend plus de temps. Un déploiement ou une réduction de capacité attend jusqu’au temps de vidage par processus.
- Le temps de vidage est une estimation. Trop court, il remet les longues tâches en attente, puis elles reprennent à leur dernière étape enregistrée. Trop long, le
SIGKILLde la plateforme arrive avant la fin. - Il n’aide pas lors d’un plantage. Seuls le bail et les étapes enregistrées le permettent.
Le bail impose son propre compromis. Un bail court accélère la récupération après un arrêt forcé. Mais si une tâche dépasse son bail, un deuxième processus la prend pendant que le premier la traite encore. Une tâche normale prend environ 2,2 secondes, bien moins que 30. Avec le délai d’expiration de 10 secondes, la tâche la plus lente possible représente environ trois appels de 10 secondes. Cela fait 30 secondes, exactement la durée du bail. Une tâche qui peut dépasser son bail a besoin d’un signal de vie : le processus renouvelle locked_until régulièrement pendant son travail. Le projet n’a pas de signal de vie, car ses tâches sont courtes.
Exercice guidé : remplacer un processus
Section intitulée « Exercice guidé : remplacer un processus »-
Copiez le script de cette leçon depuis l’instantané
end-of-m05:Fenêtre de terminal cp ../nextia-learning-labs/C21/snapshots/end-of-m05/scripts/shutdown_demo.py scripts/Fenêtre de terminal Copy-Item ..\nextia-learning-labs\C21\snapshots\end-of-m05\scripts\shutdown_demo.py scripts\ -
Vérifiez qu’aucun processus de traitement ne fonctionne et que le simulateur fonctionne en mode normal. Rechargez les données :
python -m scripts.load --reset. -
Exécutez la démonstration. Elle prend environ 30 secondes et démarre ses propres processus. Sous Windows, Python ne peut pas envoyer
SIGTERMouSIGKILLà un autre processus. Les deux scénarios arrêtent immédiatement le processus avecterminate(). Le scénario en douceur ressemble donc à l’arrêt forcé (code écrit, non testé). Sous Windows, observez le vidage avec Ctrl+C dans le terminal du processus, comme dans À vous de jouer ci-dessous.Fenêtre de terminal python -m scripts.shutdown_demo -
Comparez votre sortie avec l’exécution ci-dessus. Vérifiez trois points : le scénario en douceur termine avec le code de sortie 0; l’arrêt forcé laisse 4 tâches
running; les deux scénarios terminent avecAI results per job [3]. -
Exécutez les tests du module pour cette leçon :
python -m pytest tests/test_resilience.py -k "graceful or cannot_finish" -v. Exécutez ensuite tous les tests :python -m pytest. Attendez-vous à172 passed, 1 deselected.
Afficher le résultat attendu
La vérification de l’auteur, sur un ordinateur occupé :
Round 'graceful': stopped after 3 s with SIGTERM; the process ended 1.8 s later (exit code 0) worker said: Stopping: no new jobs; 4 running job(s) get up to 20 s to finish. worker said: Done in 4.4 s: 6 taken, 6 succeeded, 0 waiting for the quota, 0 to retry later, 0 failed, 0 dead letters, 0 given back to the queue. right after: states {'queued': 6, 'succeeded': 6}; attempts per job [0, 1]; AI results per job [0, 3] a new worker finished the queue in 5.7 s: states {'succeeded': 12}; attempts per job [1]; AI results per job [3]Round 'killed': stopped after 3 s with SIGKILL; the process ended 0.0 s later (exit code -9) right after: states {'queued': 5, 'running': 4, 'succeeded': 3}; attempts per job [0, 1]; AI results per job [0, 2, 3] a new worker finished the queue in 12.8 s: states {'succeeded': 12}; attempts per job [1, 2]; AI results per job [3]Sur un ordinateur plus lent, le premier processus prend moins de tâches pendant ses 3 secondes. Les nombres changent donc : ici, 6 réussites plutôt que 8. Certains éléments ne changent pas. Le scénario en douceur ne laisse aucune tâche running, et l’arrêt forcé en laisse 4, une par place. Après un arrêt forcé, le nouveau processus prend environ la durée du bail plus celle d’une tâche. Chaque tâche termine avec 3 résultats d’IA. L’étape 5 exécute 2 tests : test_graceful_shutdown_finishes_the_running_jobs et test_jobs_that_cannot_finish_in_time_go_back_to_the_queue.
À vous de jouer : un fournisseur lent et un vidage court
Section intitulée « À vous de jouer : un fournisseur lent et un vidage court »Changez deux paramètres pour créer le cas où un vidage ne peut pas terminer le travail. Démarrez le simulateur avec python -m simulator --mode slow : une tâche prend maintenant environ 18 secondes. Rechargez les données (python -m scripts.load --reset), pour que les nouvelles tâches portent les identifiants 1 à 4. Envoyez 4 billets (fastapi dev doit fonctionner) : python -m scripts.send_tickets --rate 4 --seconds 1. Démarrez ensuite un processus avec un temps de vidage de 2 secondes. Arrêtez-le avec Ctrl+C après environ 4 secondes :
WORKER_DRAIN_SECONDS=2 python -m ticket_api.worker$env:WORKER_DRAIN_SECONDS = "2"; python -m ticket_api.workerFaites d’abord une prédiction : quel état et quel nombre de tentatives auront ensuite les 4 tâches? Vérifiez avec GET /v1/jobs/1 ou python -m scripts.queue_watch --seconds 1.
Afficher la réponse
L’exécution de l’auteur :
Stopping: no new jobs; 4 running job(s) get up to 2 s to finish.... job 1: given back to the queue (the worker is stopping)... job 2: given back to the queue (the worker is stopping)... job 4: given back to the queue (the worker is stopping)... job 3: given back to the queue (the worker is stopping)Done in 5.7 s: 4 taken, 0 succeeded, 0 waiting for the quota, 0 to retry later, 0 failed, 0 dead letters, 4 given back to the queue.Les 4 tâches étaient de nouveau queued (en file d’attente), avec 0 tentative. Aucune n’a été perdue, et aucune n’a utilisé une tentative à cause de l’arrêt. Le processus suivant les prend immédiatement, sans attendre un bail. Le coût : leurs appels lents en cours ont été abandonnés, mais le fournisseur les a quand même terminés. Avec un vrai fournisseur, vous payez pour ce travail. Le temps de vidage doit donc couvrir une tâche normale avec une marge. Un délai de 20 secondes couvre facilement des tâches de 2,2 secondes, mais pas celles-ci, de 18 secondes. Redémarrez le simulateur en mode normal quand vous avez terminé.
Erreur courante
Un processus qui ignore SIGTERM
Symptôme : après chaque déploiement ou réduction de capacité, quelques billets reçoivent leur brouillon de réponse environ une demi-minute en retard. Leurs tâches affichent une tentative supplémentaire. python -m scripts.queue_watch montre des tâches running pendant 30 secondes sans qu’aucun processus les traite. Sur une plateforme de conteneurs, le journal indique que le conteneur a été terminé après son délai de grâce.
Cause : le processus ne gère pas SIGTERM. Il n’a peut-être aucun gestionnaire, comme celui du module 4 (code de sortie 143 immédiatement). Ou son vidage dépasse le délai de grâce de la plateforme, et SIGKILL arrive pendant le vidage. Ses tâches en cours restent verrouillées jusqu’à l’expiration de leur bail.
Diagnostic :
- Arrêtez volontairement un processus avec
SIGTERM(Ctrl+C oukill -TERM <pid>sous macOS et Linux). Un processus qui effectue un vidage afficheStopping: no new jobs …(arrêt : aucune nouvelle tâche…) et termine avec le code de sortie 0. - Cherchez les tâches
runningdontlocked_bydésigne un processus qui ne fonctionne plus. - Comparez
WORKER_DRAIN_SECONDSavec le délai de grâce de la plateforme : 30 secondes sur Azure Container Apps, 10 secondes pourdocker stop(selon leur documentation).
Correction : gérez SIGTERM et SIGINT comme le fait le processus du module 5. Gardez le vidage plus court que le délai de grâce, ou augmentez ce délai (Compose : stop_grace_period). Conservez le bail et les étapes enregistrées pour les plantages qu’aucun gestionnaire ne peut capter.
Pour un service d’IA : les tâches d’IA sont lentes, et chaque appel est facturé. Une tâche arrêtée de force répète ses appels inachevés. Une tâche remise en attente trop tôt fait la même chose. Un bon vidage et des étapes enregistrées limitent la facture à une réponse par étape.
Vérification du module : la surcharge reste limitée
Section intitulée « Vérification du module : la surcharge reste limitée »La vérification de fin de module vous demande de limiter la surcharge et d’expliquer ce que les utilisateurs observent. Vous avez maintenant tous les éléments nécessaires. Rappelez-vous le test de surcharge de Contre-pression. La file avait une limite de 100. Elle recevait 10 billets par seconde pendant 30 secondes, avec 2 processus et le quota activé. De 172 à 173 billets ont été acceptés. De 127 à 128 ont reçu 503 queue_full (file pleine), avec un Retry-After (délai avant une nouvelle tentative) de 88 à 128 secondes. La file a atteint 107, car la vérification de la limite n’est pas atomique. Chaque limite du service produit un effet différent pour l’utilisateur :
| Ce qui se passe | Ce que fait le service | Ce que l’utilisateur observe |
|---|---|---|
| Un pic dépasse ce que les processus peuvent traiter | La file grandit; la mise à l’échelle automatique ajoute des processus jusqu’au maximum | 202 immédiatement; le brouillon de réponse arrive plus tard |
La file est pleine (QUEUE_MAX) |
Refuse les nouveaux billets; le billet n’est pas enregistré | 503 queue_full avec Retry-After : renvoyez-le plus tard |
| Un appelant envoie trop de requêtes | La limite de débit refuse les requêtes | 429 rate_limited (débit limité) avec Retry-After |
| Le fournisseur est en panne | Le disjoncteur s’ouvre; les tâches attendent sans utiliser de tentatives | Les brouillons arrivent en retard; POST /v1/answers donne 503 ai_unavailable (IA indisponible) avec Retry-After |
| Le quota du fournisseur est épuisé | Les tâches attendent le quota; ajouter des processus ne sert à rien | Les brouillons arrivent en retard; l’âge de la tâche la plus ancienne augmente |
| Un processus est remplacé | Il termine ses tâches en cours, ou ses tâches attendent la fin du bail | Rien, ou quelques brouillons retardés d’au plus la durée d’un bail |
Rien dans ce tableau ne grandit sans limite. La file a une limite et les processus ont un maximum. Les nouvelles tentatives ont un budget, et les tâches ont des tentatives et un bail.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Un processus reçoit SIGTERM pendant l'exécution de 4 tâches. Décrivez, étape par étape, ce que fait le processus du module 5. Que devient une tâche encore en cours après 20 secondes?
Afficher la réponse
Il ne prend aucune nouvelle tâche et affiche combien de tâches sont encore en cours. Il attend jusqu’à WORKER_DRAIN_SECONDS (20) pour qu’elles se terminent. Une tâche terminée est enregistrée comme d’habitude. Le processus annule une tâche encore en cours après 20 secondes et la rend disponible avec jobs.release. Son état redevient queued (en file d’attente), sa tentative ne compte pas et ses étapes enregistrées restent enregistrées. Ensuite, le processus ferme son pool de connexions (pool) et son client fournisseur, puis se termine avec le code de sortie 0. Le processus suivant prend immédiatement la tâche rendue disponible, sans attendre la fin d’un bail.
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
Après un SIGKILL, un nouveau processus a eu besoin de 12,7 à 13,2 secondes plutôt que d'environ 3 secondes. Expliquez la différence et pourquoi aucune tâche n'a effectué son travail d'IA deux fois.
Afficher la réponse
SIGKILL ne peut pas être intercepté. Le processus tué a donc laissé 4 tâches dans l’état running (en cours d’exécution). Leur bail (10 secondes dans la démonstration) les gardait verrouillées. Le nouveau processus a dû attendre sa fin, puis les a prises pour leur deuxième tentative. Cette attente, plus environ la durée d’une tâche, donne les 12,7 à 13,2 secondes. Aucune tâche n’a effectué son travail d’IA deux fois, car le résultat de chaque étape est enregistré immédiatement. Il est associé à l’identifiant de la tâche, sous UNIQUE (job_id, task). Le nouveau processus saute les étapes déjà enregistrées. Chaque tâche s’est donc terminée avec exactement 3 résultats d’IA.
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
Fin du module : pendant le Vendredi fou, 10 billets par seconde arrivent et la file a une limite de 100. Le fournisseur subit une panne de 20 secondes. Expliquez ce qu'observent un client et le service de soutien, et pourquoi rien ne grandit sans limite.
Afficher la réponse
Tant que la file a de la place, les clients reçoivent 202 immédiatement. Quand elle est pleine, les nouveaux billets reçoivent 503 queue_full avec un Retry-After. Ce délai était de 88 à 128 secondes pendant la surcharge mesurée. L’API n’enregistre pas ces billets. Le site Web doit donc afficher « réessayez plus tard ». Pendant la panne, le disjoncteur s’ouvre : les tâches attendent sans utiliser de tentatives. Le service de soutien voit les brouillons de réponse arriver en retard, plutôt que des tâches dans la file des lettres mortes. Les questions envoyées à POST /v1/answers reçoivent 503 ai_unavailable avec Retry-After. Les limites sont celles de la file (environ 100), le maximum de processus et le budget de nouvelles tentatives. Il y a aussi les 5 tentatives par tâche et le bail. Chaque limite transforme la charge supplémentaire en refus clair ou en attente, plutôt qu’en croissance illimitée.
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
- Les plateformes arrêtent régulièrement des processus : à chaque réduction de capacité, déploiement et changement de machine. Elles envoient d’abord
SIGTERM, puisSIGKILLaprès un délai de grâce. Selon leur documentation, ce délai est de 30 secondes sur Azure Container Apps et de 10 secondes pourdocker stop. - Un arrêt en douceur termine les tâches en cours : aucune nouvelle tâche, jusqu’à
WORKER_DRAIN_SECONDS(20) pour celles en cours. Les autres sont rendues disponibles sans utiliser de tentative. Le processus du module 4 n’avait pas ce mécanisme : il mourait immédiatement et laissait 4 tâches dans l’étatrunning. - Mesure avec 12 tâches : après
SIGTERM, un nouveau processus a terminé le reste en environ 3 secondes. Après unSIGKILL(construit), il lui fallait de 12,7 à 13,2 secondes à cause du bail de 10 secondes. Toutes les tâches ont réussi, chacune avec exactement 3 résultats d’IA. - L’API termine aussi ses requêtes en cours lors d’un
SIGTERM. Une requête lente a quand même reçu son200, et les nouvelles connexions ont été refusées. - Le bail doit dépasser la durée de la tâche la plus longue; une longue tâche a besoin d’un signal de présence.
- La surcharge reste limitée : limite de file, maximum de processus, budget de nouvelles tentatives, limite de tentatives et bail. Les utilisateurs voient
202,503ou429avecRetry-After, ou un brouillon en retard. Jamais un billet perdu sans réponse.
Ensuite, dans le module 6, vous concevez des tests de charge pour vérifier si ces changements aident vraiment. Vous évitez les affirmations que le test ne peut pas appuyer.
Leçon suivante : Concevoir un test de charge