Traitement en arrière-plan
- Leçon 12
- 55 min
- Module 4 : États d'interaction propres à l'IA
Où nous en sommes
Dans la leçon précédente, le bureau a affiché un brouillon en flux continu et nommé chaque façon dont il peut finir. Mais le travail d'IA d'un nouveau billet n'arrive pas en flux : il s'exécute en arrière-plan pendant quelques secondes, et le bureau reçoit seulement « queued », puis plus rien. Dans cette leçon, nous suivons la tâche et nous disons chaque état en mots simples, d'abord en interrogeant le serveur chaque seconde, puis en le laissant nous prévenir. Un café qui donne un téléavertisseur montre les deux façons.
Leçon 12 sur 19 · Architecture frontend et performance des applications d'IATraitement en arrière-plan
1. Premiers pas avec le Web
2. Composants et structure de l'application
3. Récupération des données et gestion de l'état
4. États d'interaction propres à l'IA
5. Performance et capacité de croissance
6. Sécurité, accessibilité et remise du travail
Ce que vous saurez faire
Permettez à l’agent de suivre le travail d’IA d’un nouveau billet de soutien pendant son exécution en arrière-plan. Présentez les états simplement : en attente, en cours, terminé ou échoué. Interrogez d’abord le serveur chaque seconde, puis laissez-le envoyer chaque changement.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- La machine à états d’un brouillon et les raisons des mots et boutons propres à chaque fin, dans Interfaces en flux continu.
- Les requêtes,
staleTimeet les nouvelles tentatives dans TanStack Query, dans Cycle de vie d’une requête. - Le formulaire de nouveau billet et sa réponse
202 Accepted(accepté), dans Pagination et formulaires.
Ce qu’il vous faut sur votre ordinateur
- Votre projet
ticket-deskaprès Interfaces en flux continu :npm testse termine parTests 35 passed (35)(35 tests réussis). - L’instantané
end-of-m04dans~/projects/nextia-learning-labs/C22/snapshots/, pour copier les fichiers de cette leçon.
Testé avec Node.js 24.18 sur macOS (Apple silicon), dans Chromium. Les commandes Windows (PowerShell) et Linux sont fournies, mais non testées.
Un téléavertisseur dans un café achalandé
Section intitulée « Un téléavertisseur dans un café achalandé »Vous commandez un repas dans un café achalandé. Le cuisinier a besoin de quelques minutes. La personne à la caisse vous donne donc un reçu numéroté, et vous vous asseyez. Vous avez alors deux façons de savoir quand votre repas est prêt.
Vous pouvez aller au comptoir chaque minute et demander : « Le numéro 42 est-il prêt? » Cela fonctionne sans équipement particulier. Mais la plupart des déplacements sont inutiles. Vous apprenez la nouvelle seulement à votre prochaine visite au comptoir. Ou le café vous donne un petit téléavertisseur. Il vibre dès que votre repas est prêt, sans que vous ayez à demander. Certains cafés offrent une troisième option : un serveur qui discute avec vous à table, dans les deux sens, aussi souvent que nécessaire.
Le bureau des billets fait face au même choix. Cette leçon construit la première solution, puis la compare aux deux autres.
Le problème : « en attente », puis le silence
Section intitulée « Le problème : « en attente », puis le silence »Quand un agent enregistre un nouveau billet, l’API des billets ne fait pas le travail d’IA immédiatement. Elle enregistre le billet, place le travail d’IA dans une file d’attente et répond 202 Accepted. Mettre à l’échelle les API et les charges de travail d’IA a déplacé ce travail dans une file, car il prend plusieurs secondes. Dans les appels enregistrés, la classification, la rédaction d’une réponse et le plongement prenaient respectivement 913, 1 097 et 198 ms. Cela représente environ 2,2 s au total. Un processus fait ensuite le travail en arrière-plan.
À la fin du module 3, le formulaire de nouveau billet affichait la réponse 202, puis s’arrêtait :
Saved as T-500001. The AI work is queued (job 1).Cette phrase reste à l’écran indéfiniment. L’agent ne découvre jamais l’équipe choisie par l’IA, ni si le travail a échoué. « En attente » n’est que le premier état d’une tâche. C’est un travail qu’un serveur exécute plus tard, avec un état qui change. L’agent doit voir ces changements d’état.
Examinez la tâche avec curl. L’API simulée simule la file : 1,5 s d’attente, plus 2 s pour chaque tâche qui précède. Elle utilise ensuite les durées enregistrées des tâches. Envoyez un billet, puis demandez l’état de sa tâche chaque seconde :
curl -X POST http://127.0.0.1:8100/v1/tickets -H "Content-Type: application/json" \ -d '{"customer_id": "C-0022", "subject": "Parcel lost", "body": "It did not arrive."}'curl http://127.0.0.1:8100/v1/jobs/1$body = '{"customer_id": "C-0022", "subject": "Parcel lost", "body": "It did not arrive."}'Invoke-RestMethod -Method Post -Uri http://127.0.0.1:8100/v1/tickets -ContentType 'application/json' -Body $bodycurl.exe http://127.0.0.1:8100/v1/jobs/1La réponse au POST arrive immédiatement, puis celle de la tâche demandée chaque seconde. Voici les sorties réelles de l’équipe du cours, avec les longues lignes raccourcies. Les lignes --- after … (après…) marquent les secondes :
{"ticket_id":"T-500001","job_id":1,"state":"queued","status_url":"/v1/jobs/1","queued_ahead":0,"estimated_wait_seconds":3.7}--- after 1 s{"job_id":1,"ticket_id":"T-500001","state":"queued","attempts":0,…,"started_at":null,"finished_at":null,…}--- after 2 s{"job_id":1,"ticket_id":"T-500001","state":"running","attempts":1,…,"started_at":"…",…}--- after 3 s{"job_id":1,"ticket_id":"T-500001","state":"running","attempts":1,…}--- after 4 s{"job_id":1,"ticket_id":"T-500001","state":"succeeded","attempts":1,…,"finished_at":"…","last_error":null,"result":{"team":"shipping","priority":2,"draft_reply":"Thank you for your message. A member of our team will look at your ticket and reply soon.","embedding_version":"embed-small-384-v1"}}Toutes les valeurs nécessaires à l’écran sont là. state (état) est passé de queued (en attente) à running (en cours), puis à succeeded (réussi). attempts (tentatives) compte les essais, et result (résultat) contient l’équipe et la priorité. Le bureau doit seulement demander, puis afficher la réponse en mots.
L’idée : suivre la tâche et décrire chaque état en mots
Section intitulée « L’idée : suivre la tâche et décrire chaque état en mots »Une tâche peut avoir six états. Le contrat de l’API les définit. La leçon Cycle de vie d’une tâche du cours sur la mise à l’échelle les a construits côté serveur. Trois sont des étapes normales. Les trois autres sont des fins qui demandent l’attention de l’agent :
| État | Ce qui s’est passé | Ce que dit le bureau | Ce que l’agent peut faire |
|---|---|---|---|
queued |
La tâche attend un processus. | Le travail d’IA attend dans la file. Environ 4 secondes. | Annuler le travail d’IA |
running |
Un processus fait le travail d’IA. | L’IA travaille sur le billet : équipe, priorité et premier brouillon. | rien : attendre |
succeeded |
Le travail est terminé. | Le travail d’IA est terminé. Équipe : expédition, priorité 2. | rien à faire |
failed |
La réponse de l’IA était incorrecte, et un nouvel essai donne la même réponse. | Réessayer n’aidera pas; une personne doit trier le billet. | trier le billet manuellement |
dead_letter |
Le fournisseur n’a pas répondu, cinq fois. La tâche a cessé ses tentatives. | Le travail d’IA a échoué plusieurs fois et s’est arrêté. Vous pouvez réessayer plus tard. | Réessayer |
cancelled |
L’agent a annulé la tâche pendant qu’elle attendait. | Le billet est enregistré sans ce travail. | rien à faire |
Examinez les deux échecs. failed (échoué) et dead_letter (mis de côté) signifient tous deux « aucun résultat ». Mais les conseils sont opposés. Une tâche failed a reçu une mauvaise réponse, et un nouvel essai donne la même mauvaise réponse. Le bureau n’offre donc pas de bouton Réessayer. Une tâche dead_letter a échoué parce que le fournisseur était indisponible. Elle pourrait réussir plus tard, donc le bureau offre Réessayer. Une tâche mise de côté est une tâche que la file cesse de réessayer et réserve à une personne. Le terme anglais dead letter vient des lettres que la poste ne peut pas livrer.
Description textuelle du diagramme
Une nouvelle tâche commence dans queued. L’écran indique « En attente », estime l’attente et offre Annuler le travail d’IA. Depuis queued, la tâche passe à running (« En cours », aucun bouton), ou à cancelled (annulé) si l’agent l’annule. Depuis running, elle se termine dans l’un de trois états. succeeded affiche « Terminé » avec l’équipe et la priorité. failed indique que réessayer n’aidera pas, et une personne trie le billet. dead_letter indique que le travail a échoué plusieurs fois. Il offre Réessayer, ce qui remet la tâche dans queued.
Interrogation périodique : demander chaque seconde
Section intitulée « Interrogation périodique : demander chaque seconde »La façon la plus simple de suivre une tâche est l’interrogation périodique (polling). Le bureau envoie la même requête GET à intervalle fixe, jusqu’à ce que la tâche atteigne un état final. C’est la visite au comptoir du café chaque minute. TanStack Query le fait pour vous avec une option, refetchInterval. Voici useJobPolling dans src/features/jobs/useJob.ts :
/** Polling: ask for the job every second until it is final. Simple, and it works everywhere. */export function useJobPolling(id: number, intervalMs = 1000) { return useQuery({ queryKey: jobKey(id), queryFn: ({ signal }) => getJob(id, signal), refetchInterval: (query) => (query.state.data && isFinal(query.state.data.state) ? false : intervalMs), staleTime: 0, });}Ici, refetchInterval est une fonction, pas un nombre. Après chaque réponse, TanStack Query lui demande : « Quand dois-je demander à nouveau? » Tant que la tâche s’exécute, la réponse est 1 000 ms. Quand la tâche atteint un état final, la réponse est false, et l’interrogation périodique s’arrête. isFinal() dans src/api/jobs.ts liste les quatre états finaux : succeeded, failed, cancelled et dead_letter.
JobStatus.tsx affiche la réponse : une rangée de trois étapes (En attente, En cours, Terminé), la phrase du tableau et le bouton adapté. Le formulaire de nouveau billet affiche maintenant JobStatus sous « Saved as T-500001. » (enregistré sous T-500001), au lieu de l’ancienne phrase.
Suivre la tâche dans le bureau des billets
Section intitulée « Suivre la tâche dans le bureau des billets »-
Dans
~/projects/ticket-desk, copiez les fichiers de cette leçon depuis l’instantané. Cinq fichiers sont nouveaux; le formulaire de nouveau billet, son test et la page des laboratoires changent.Fenêtre de terminal S=../nextia-learning-labs/C22/snapshots/end-of-m04for f in src/api/jobs.ts src/features/jobs/useJob.ts src/features/jobs/JobStatus.tsx \src/features/jobs/JobStatus.test.tsx src/labs/JobLab.tsx \src/features/jobs/NewTicketForm.tsx src/features/jobs/NewTicketForm.test.tsx src/labs/LabsPage.tsx; docp "$S/$f" "$f"doneFenêtre de terminal $S = "..\nextia-learning-labs\C22\snapshots\end-of-m04"$files = 'src\api\jobs.ts', 'src\features\jobs\useJob.ts', 'src\features\jobs\JobStatus.tsx','src\features\jobs\JobStatus.test.tsx', 'src\labs\JobLab.tsx','src\features\jobs\NewTicketForm.tsx', 'src\features\jobs\NewTicketForm.test.tsx', 'src\labs\LabsPage.tsx'foreach ($f in $files) { Copy-Item "$S\$f" $f } -
Exécutez les tests :
Fenêtre de terminal npm testLa sortie se termine par :
Test Files 14 passed (14)Tests 38 passed (38)Les trois nouvelles vérifications sont dans
JobStatus.test.tsx. La première, « polls until the job is done, then stops asking » (interroge jusqu’à la fin, puis s’arrête), prend environ 3 secondes. Elle répondqueued,runningetsucceeded, puis attend encore 1,2 s et vérifie qu’aucune requête n’est arrivée. -
Démarrez l’API simulée (
npm run api) et le bureau (npm run dev) dans deux terminaux. Ouvrez http://localhost:5173/#/new. -
Remplissez le formulaire : client
C-0022, objetParcel lost(colis perdu), messageMy parcel did not arrive.(mon colis n’est pas arrivé). Cliquez ensuite sur Send ticket (envoyer le billet). « Saved as … » (enregistré sous…) apparaît, et les étapes de la tâche commencent à Waiting (en attente).
queued : la première réponse de l'API, maintenant suivie de l'état de la tâche et de la seule action utile. L’image est en anglais. -
Observez les étapes pendant environ 4 secondes. Working (en cours) passe en gras, puis Done (terminé), et l’équipe apparaît.

succeeded : le résultat que l'ancien formulaire ne montrait jamais. L’image est en anglais. -
Arrêtez l’API simulée, puis démarrez-la avec
node mock-api/server.mjs --jobs fail. Envoyez un autre billet. Cet échec est simulé : chaque tâche se termine dansfailed.
failed : le bureau explique pourquoi réessayer est inutile et ne le propose pas. L’image est en anglais. -
Arrêtez l’API simulée, puis démarrez-la avec
--jobs dead_letter. Envoyez un autre billet. Cette tâche s’exécute environ trois fois plus longtemps, puis s’arrête après cinq tentatives.
dead_letter : le fournisseur était indisponible, donc réessayer plus tard peut fonctionner. Seul cet état offre Réessayer. L’image est en anglais. -
Cliquez sur Try again (réessayer). L’API simulée remet la tâche dans la file. Cette fois, elle réussit : En attente, En cours, Terminé.
-
Arrêtez l’API simulée, puis démarrez-la avec
npm run api. Envoyez un dernier billet et cliquez immédiatement sur Cancel the AI work (annuler le travail d’IA), pendant que la tâche attend. Le panneau indique : « Vous avez annulé le travail d’IA. Le billet est enregistré sans ce travail. »
Le serveur pourrait plutôt nous informer
Section intitulée « Le serveur pourrait plutôt nous informer »L’interrogation périodique a deux coûts, et l’équipe du cours a mesuré les deux dans le navigateur. Pour un nouveau billet, le bureau a envoyé 5 requêtes avant de voir la fin de la tâche. La plupart disaient seulement « toujours en attente » ou « toujours en cours ». Et le bureau a vu la fin en retard. La tâche s’est terminée entre deux requêtes. L’écran a donc affiché « terminé » avec un délai médian de 403 ms après le finished_at de la tâche.
Le téléavertisseur du café représente l’autre solution. Les événements envoyés par le serveur (server-sent events) fonctionnent aussi pour les tâches. Le bureau ouvre une requête GET. Le serveur la garde ouverte et écrit un événement à chaque changement d’état. Ici, EventSource est le bon outil : la requête est un GET et n’a besoin d’aucun en-tête. Avec curl, vous voyez les événements arriver pendant que la requête reste ouverte :
curl -N http://127.0.0.1:8100/v1/jobs/1/eventsevent: statedata: {"job_id":1,"ticket_id":"T-500001","state":"queued","attempts":0,…}
event: statedata: {"job_id":1,"ticket_id":"T-500001","state":"running","attempts":1,…}
event: statedata: {"job_id":1,"ticket_id":"T-500001","state":"succeeded","attempts":1,…,"result":{"team":"shipping",…}}Lors de l’essai de l’équipe du cours, les trois événements sont arrivés 0, 1,5 et 3,6 secondes après la requête. Le serveur a ensuite fermé la connexion. Dans le bureau, useJobEvents dans src/features/jobs/useJob.ts ouvre la connexion et la ferme quand la tâche atteint un état final :
/** Server-sent events: the server sends each new state; no repeated requests. */export function useJobEvents(id: number): Job | null { const [job, setJob] = useState<Job | null>(null); useEffect(() => { const source = new EventSource(jobEventsUrl(id)); source.addEventListener('state', (e) => { const next = JSON.parse((e as MessageEvent).data) as Job; setJob(next); if (isFinal(next.state)) source.close(); }); return () => source.close(); }, [id]); return job;}Deux appels à close(), pour deux raisons. Le nettoyage ferme la connexion quand le composant quitte l’écran, comme doit le faire tout effet qui utilise une connexion. Le close() après un état final est important : EventSource se reconnecte automatiquement quand une connexion se termine. C’est utile pour un flux qui ne doit jamais s’arrêter. Pour une tâche terminée, cela ouvrirait le flux à nouveau.
Description textuelle du diagramme
La tâche d’un nouveau billet attend environ 1,5 s et s’exécute pendant environ 2 s. Le bureau avec interrogation périodique demande à 0, 1, 2, 3 et 4 secondes. Il reçoit queued, queued, running, running et succeeded : cinq requêtes. Le bureau avec événements ouvre une requête, et le serveur y envoie trois événements. queued arrive immédiatement, running au début du travail, et succeeded à sa fin. Dans les essais mesurés, le bureau avec événements affichait la fin 29 ms après la fin de la tâche. Le bureau avec interrogation périodique l’affichait 403 ms après, à sa prochaine requête.
Le laboratoire des tâches du bureau exécute les deux méthodes côte à côte, sur la même tâche. Il se trouve à http://localhost:5173/#/labs/job. Cliquez sur Send a test ticket (envoyer un billet de test) et observez les deux colonnes :

L’équipe du cours a mesuré le laboratoire avec un script de navigateur, en trois essais. Le graphique montre les médianes et l’étendue des trois essais :
Description textuelle du graphique
Deux panneaux. Requêtes pour une tâche : l’interrogation chaque seconde a envoyé 5 requêtes dans chacun des 3 essais; les événements envoyés par le serveur ont utilisé 1 requête. Temps entre la fin de la tâche et l’affichage : l’interrogation périodique affichait la fin après un délai médian de 403 ms, entre 198 et 477 ms. Les événements envoyés par le serveur l’affichaient après un délai médian de 29 ms, entre 4 et 30 ms. La tâche elle-même prenait un temps médian de 3,621 ms entre sa création et sa fin.
Le délai de l’interrogation périodique n’est pas fixe. Il dépend du moment où la tâche se termine entre deux requêtes. Il va de 0 à un intervalle complet, soit environ la moitié en moyenne. Dans ces essais, il allait de 198 à 477 ms.
Et les WebSockets?
Section intitulée « Et les WebSockets? »Un WebSocket est le serveur qui discute avec vous à table. C’est une connexion qui reste ouverte, où les deux côtés peuvent envoyer des messages à tout moment. Le navigateur commence par une requête HTTP normale, puis les deux côtés passent au protocole WebSocket. C’est le bon outil quand le navigateur envoie aussi beaucoup de messages. Par exemple : un clavardage où plusieurs personnes écrivent, un document partagé ou un jeu.
Pour l’état d’une tâche, le navigateur n’envoie rien après la première requête. Les messages vont dans un seul sens, du serveur au navigateur. Un WebSocket ajoute donc du travail sans avantage ici. Il faut un serveur qui utilise le protocole WebSocket, des messages que vous concevez et votre propre mécanisme de reconnexion. Il faut aussi des serveurs mandataires qui le laissent passer. Le bureau des billets n’en utilise pas, et ce cours n’en construit pas. Le tableau compare les trois méthodes :
| Interrogation périodique | Événements envoyés par le serveur | WebSocket | |
|---|---|---|---|
| Qui parle | le navigateur demande, encore et encore | le serveur, sur un seul GET ouvert |
les deux, sur une connexion ouverte |
| Requêtes pour une tâche (mesurées) | 5 | 1 | 1 connexion |
| Délai après un changement | jusqu’à un intervalle (médiane mesurée de 403 ms) | presque nul (médiane mesurée de 29 ms) | presque nul |
| Ce qu’il faut au serveur | un point de terminaison GET normal |
un point de terminaison qui garde une réponse ouverte et écrit des événements | le protocole WebSocket |
| Si la connexion coupe | la prochaine requête fonctionne | EventSource se reconnecte automatiquement |
votre code rétablit la connexion |
| Utile pour | une courte attente, peu d’écrans, le code le plus simple | l’état et la progression venant du serveur | des messages fréquents dans les deux sens |
Quand utiliser chaque méthode, et à quel coût
Section intitulée « Quand utiliser chaque méthode, et à quel coût »Commencez par l’interrogation périodique. Elle fonctionne avec tous les serveurs et à travers tous les serveurs mandataires. Elle ne nécessite aucune connexion ouverte, et TanStack Query l’arrête pour vous. Son coût vient des requêtes : 5 pour chaque nouveau billet de soutien, à raison d’une requête par seconde. Le bureau de Grace compte quelques agents, chacun avec au plus une tâche à l’écran. Ce coût reste donc faible.
Utilisez les événements envoyés par le serveur quand le délai compte, ou quand de nombreux écrans attendent en même temps. Avec 200 agents qui interrogent chacun le serveur chaque seconde, l’API répond à 200 requêtes par seconde. La plupart disent « rien n’a changé ». Les événements ont leur propre coût : chaque écran ouvert garde une connexion au serveur pendant toute l’attente. Les navigateurs limitent aussi à environ six les connexions ouvertes vers un même hôte en HTTP/1.1. Un EventSource qui ne se ferme jamais peut donc bloquer les autres requêtes du bureau.
Kwame demande si le bureau pourrait plutôt attendre le travail de l’IA dans le POST, sans créer de tâche. Le cours Mettre à l’échelle les API et les charges de travail d’IA a mesuré pourquoi cette approche ne convient pas. L’API gardait une connexion à la base de données pendant les 2,2 secondes de traitement de chaque billet. Le quota du fournisseur bloquait des appels sous charge. Le 202 et la tâche gardent l’API rapide, et cette leçon rend la tâche visible.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
L'interrogation périodique ne s'arrête jamais
Symptôme (construit) : la tâche affiche Done (terminée), mais le panneau Network (réseau) du navigateur affiche un nouveau GET /v1/jobs/1 chaque seconde. Cela continue tant que le formulaire reste ouvert. Les compteurs de l’API simulée à http://127.0.0.1:8100/admin/stats montrent que le compteur de la route des tâches augmente.
Cause : refetchInterval: 1000, un nombre fixe. TanStack Query interroge alors le serveur indéfiniment, même après que la tâche a atteint un état final.
Solution : donnez à refetchInterval une fonction qui retourne false pour un état final, comme le fait useJobPolling. Le test « interroge jusqu’à la fin de la tâche, puis arrête de demander » compte les requêtes après la fin. Il échoue quand ce nombre augmente.
Conséquence pour le travail d’IA : chaque écran oublié envoie une requête par seconde. Avec beaucoup d’agents, l’API passe son temps à donner des réponses qui ne changent jamais.
Erreur courante
Réessayer une tâche en échec
Symptôme (construit) : le bureau propose Try again (réessayer) pour chaque tâche en échec. Un agent voit une tâche failed (en échec) et clique à répétition. Le billet reste en attente, sans équipe.
Cause : le bureau traitait failed et dead_letter (arrêt après plusieurs échecs) comme un seul état. L’API accepte de relancer une tâche failed, donc rien n’arrête l’agent. Un modèle qui a donné une mauvaise réponse à un billet en donne généralement une mauvaise à nouveau. Chaque nouvelle tentative coûte donc un autre appel et prolonge l’attente. L’API simulée ne peut pas montrer cet aspect : dans la simulation, chaque tâche relancée réussit. Ce résultat est simulé pour rendre visible le parcours de nouvelle tentative.
Solution : affichez le bouton seulement quand une nouvelle tentative peut aider. Dans JobStatus.tsx, Try again apparaît seulement pour dead_letter. Le texte pour failed indique qu’une personne doit trier le billet. Le test « failed et dead letter ont des affichages différents, et seul dead letter propose Try again » le vérifie.
À vous de jouer : interroger toutes les deux secondes
Section intitulée « À vous de jouer : interroger toutes les deux secondes »Changez une seule condition : l’intervalle. Dans JobStatus.tsx, remplacez useJobPolling(jobId) par useJobPolling(jobId, 2000). Avant d’envoyer un billet, faites une prédiction : combien de requêtes le bureau enverra-t-il pour une tâche? La fin apparaîtra-t-elle plus tard? Envoyez ensuite un billet et comptez les requêtes jobs dans le panneau Network du navigateur.
Afficher la réponse
Le bureau interroge le serveur à 0, 2 et 4 secondes : 3 requêtes au lieu de 5. L’équipe du cours a mesuré les deux intervalles avec un petit script, sans navigateur. Elle a utilisé poll_interval.mjs, avec 5 passages par intervalle et la même tâche simulée de 3 547 ms :
every 1000 ms: requests 5, 5, 5, 5, 5 (median 5); late 471, 466, 468, 465, 467 ms (median 467); job 3547, 3547, 3547, 3547, 3547 msevery 2000 ms: requests 3, 3, 3, 3, 3 (median 3); late 460, 460, 461, 461, 464 ms (median 461); job 3547, 3547, 3547, 3547, 3547 msLe délai n’a pas augmenté ici, et cette surprise mérite une explication. La tâche s’est terminée à 3,55 secondes. Les deux intervalles prévoient une requête à 4 secondes. Ils ont donc tous deux détecté la fin avec environ 0,45 seconde de retard. Prenez plutôt une tâche qui se termine à 2,1 secondes. Sa fin s’affiche avec 0,9 seconde de retard pour un intervalle d’une seconde. Avec un intervalle de deux secondes, le retard atteint 1,9 seconde. Un intervalle plus long réduit les requêtes, mais augmente le délai dans le pire cas. Rétablissez l’intervalle par défaut avant de continuer.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
La tâche d'un nouveau billet se termine dans l'état failed pour un agent et dead_letter pour un autre. Qu'affiche le bureau pour chacun, et pourquoi ces deux états diffèrent-ils?
Afficher la réponse
Pour failed, le bureau indique « Le travail de l’IA a échoué. Réessayer n’aidera pas; une personne doit trier le billet. ». Il affiche le détail ai_bad_answer, sans bouton. L’IA a répondu, mais sa réponse était fausse, et une nouvelle tentative donne la même mauvaise réponse. Pour dead_letter, il indique « Le travail de l’IA a échoué plusieurs fois et s’est arrêté. Vous pouvez réessayer plus tard. ». Il affiche ai_unavailable, 5 tentatives et un bouton Try again. Le fournisseur n’a pas répondu, ce qui peut changer plus tard. Chaque échec reçoit l’action qui peut aider.
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
Faites une prédiction : 200 agents ont chacun un nouveau billet à l'écran, et chaque tâche dure environ 4 secondes. Comparez l'interrogation chaque seconde aux événements envoyés par le serveur : requêtes, connexions ouvertes et délai.
Afficher la réponse
Avec l’interrogation périodique, chaque écran envoie environ 5 requêtes par tâche, soit environ 1 000 requêtes au total. Cela représente environ 200 requêtes par seconde pendant l’exécution des tâches. La plupart répondent « aucun changement ». Aucune connexion ne reste ouverte. Chaque écran affiche la fin avec jusqu’à une seconde de retard (médiane mesurée de 403 ms). Avec les événements envoyés par le serveur, chaque écran ouvre 1 requête qui reste ouverte pendant environ 4 secondes. Cela représente 200 connexions ouvertes en même temps. La fin s’affiche presque aussitôt (médiane mesurée de 29 ms). L’interrogation périodique coûte des requêtes; les événements coûtent des connexions ouvertes.
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
Tomás veut un WebSocket pour l'état de la tâche, « parce que c'est la méthode moderne ». Que lui répondez-vous?
Afficher la réponse
L’état de la tâche circule dans un seul sens, du serveur vers le navigateur. Le canal bidirectionnel d’un WebSocket n’apporte donc aucun avantage. Il coûte davantage : un serveur qui utilise le protocole WebSocket, des messages conçus par l’équipe et son propre mécanisme de reconnexion. Les serveurs mandataires doivent aussi le laisser passer. Les événements envoyés par le serveur offrent les mêmes mises à jour rapides avec un GET HTTP normal. La reconnexion est intégrée à EventSource. L’interrogation périodique est encore plus simple et suffit pour quelques agents. Choisissez un WebSocket quand le navigateur envoie aussi des messages fréquents, comme dans un clavardage à plusieurs.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Une tâche est un travail que le serveur effectue plus tard. La réponse
202n’est que son premier état. Le bureau la suit jusqu’àsucceeded(réussie),failed,dead_letteroucancelled(annulée), et décrit chaque état en mots. - Chaque état reçoit la seule action qui peut aider : Cancel (annuler) pendant l’état
queued(en attente), Try again seulement pourdead_letter, et une personne pourfailed. - L’interrogation périodique demande à nouveau à intervalle fixe.
refetchIntervalretournefalsepour un état final, ce qui l’arrête. Mesures : 5 requêtes pour une tâche, fin affichée avec 403 ms de retard (médiane). - Les événements envoyés par le serveur gardent un
GETouvert, et le serveur écrit chaque changement. Mesures : 1 requête, 29 ms. Fermez leEventSourceà la fin, car il se reconnecte tout seul. - Un WebSocket sert aux messages fréquents dans les deux sens. L’état d’une tâche circule dans un seul sens, donc le bureau n’en a pas besoin.
Ensuite, le brouillon et la tâche sont terminés. L’agent peut-il leur faire confiance? Le bureau montre les sources du brouillon, son incertitude et les situations où une personne doit décider. Il décrit aussi les erreurs avec des mots qui indiquent quoi faire.
Leçon suivante : Une rétroaction digne de confiance