Aller au contenu
English

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.

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 mainEnviron 50 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet après Signaux de mise à l’échelle : python -m pytest affiche 172 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.

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 | 1

Quatre 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 :

  1. Il ne prend aucune nouvelle tâche et affiche le nombre de tâches encore en cours.
  2. Il attend jusqu’à WORKER_DRAIN_SECONDS (20) pour les tâches en cours.
  3. 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.
  4. 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.

Deux rangées de cinq cases. Arrêt en douceur avec SIGTERM : un processus traite 4 tâches à la fois, avec 12 tâches en file d'attente; SIGTERM à 3 s, aucune nouvelle tâche prise; les tâches en cours terminent, délai permis de 20 s, le processus termine 2,2 à 3,4 s plus tard; 8 réussites et 4 tâches jamais commencées, encore en file d'attente; un nouveau processus les termine en environ 3 s, toutes à la tentative 1. Arrêt forcé avec SIGKILL, cas construit : même départ; SIGKILL à 3 s, le processus termine immédiatement; 4 tâches restent en cours sans être traitées; leur bail expire, 10 s dans cette démonstration, et elles peuvent être reprises; un nouveau processus termine la file en 12,7 à 13,2 s, 4 tâches à la tentative 2, avec 3 résultats d'IA chacune.
Le même processus arrêté de deux façons. Un arrêt en douceur termine les tâches en cours; un arrêt forcé les laisse verrouillées jusqu'à l'expiration du bail.
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.

Médiane de 3 exécutions : après un arrêt en douceur, un nouveau processus a terminé les tâches restantes en 3,1 s; après un arrêt forcé, il lui a fallu 12,7 s, car 4 tâches sont restées verrouillées jusqu'à l'expiration de leur bail de 10 secondes.
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 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 down
INFO: Waiting for connections to close. (CTRL+C to force quit)
INFO ticket_api: POST /v1/answers 200 7539ms queries=4 id=3b174f14eca5
INFO: 127.0.0.1:54613 - "POST /v1/answers HTTP/1.1" 200 OK
INFO: 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.

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 SIGKILL de 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.

  1. 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/
  2. 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.

  3. Exécutez la démonstration. Elle prend environ 30 secondes et démarre ses propres processus. Sous Windows, Python ne peut pas envoyer SIGTERM ou SIGKILL à un autre processus. Les deux scénarios arrêtent immédiatement le processus avec terminate(). 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
  4. 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 avec AI results per job [3].

  5. 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 :

Fenêtre de terminal
WORKER_DRAIN_SECONDS=2 python -m ticket_api.worker

Faites 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 :

  1. Arrêtez volontairement un processus avec SIGTERM (Ctrl+C ou kill -TERM <pid> sous macOS et Linux). Un processus qui effectue un vidage affiche Stopping: no new jobs … (arrêt : aucune nouvelle tâche…) et termine avec le code de sortie 0.
  2. Cherchez les tâches running dont locked_by désigne un processus qui ne fonctionne plus.
  3. Comparez WORKER_DRAIN_SECONDS avec le délai de grâce de la plateforme : 30 secondes sur Azure Container Apps, 10 secondes pour docker 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é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.

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.

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.

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, puis SIGKILL aprè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 pour docker 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’état running.
  • Mesure avec 12 tâches : après SIGTERM, un nouveau processus a terminé le reste en environ 3 secondes. Après un SIGKILL (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 son 200, 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, 503 ou 429 avec Retry-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