Aller au contenu
Engineer
Menu
Design
Français

Engineer / Glossaire

File d’attente

travail mis en ordre pour être repris par un autre programme

Ce que c’est

Une file d’attente est un espace de stockage intermédiaire entre deux programmes : l’un y dépose des messages ou des tâches, l’autre les retire lorsqu’il est prêt, généralement en commençant par les plus anciens. La plupart des systèmes utilisent plusieurs files, une par type de travail. Le programme qui ajoute du travail est le producteur, celui qui le prend est le consommateur, et ce qui conserve les messages entre les deux est le courtier de messages, qui peut être un serveur dédié ou une table dans une base que le système possède déjà.

Cette organisation évite aux deux côtés de s’attendre. Une requête web qui doit déclencher un courriel ajoute un message et répond aussitôt à l’utilisateur ; un processus de traitement récupère le message quelques instants plus tard et, si cent messages arrivent ensemble, les traite à son propre rythme. Une pointe de trafic devient du travail en attente, et une dépendance devient un délai.

Deux notions décrivent les garanties de livraison d’une file. La première est l’acquittement : un consommateur indique au courtier qu’il a fini de traiter un message, et le message n’est supprimé qu’à ce moment-là. Dans le modèle AMQP 0-9-1, que RabbitMQ implémente, un message dont le consommateur meurt avant de l’acquitter est transmis à un autre consommateur. La deuxième est la durabilité : une file durable contenant des messages persistants survit au redémarrage du courtier, contrairement à une file conservée uniquement en mémoire.

Trois notions voisines méritent d’être distinguées. Une file de messages transporte des données entre services. Une file de tâches transporte des unités de travail destinées à des processus d’arrière-plan, chacune avec ses arguments, un état et un nombre de tentatives. Un journal, le modèle d’Apache Kafka, ressemble de l’extérieur à une file, mais conserve les événements après leur lecture pendant une durée de rétention choisie par sujet, ce qui permet à plusieurs lecteurs de rejouer le même historique. Lire dans une file supprime le message ; lire dans un journal ne fait qu’avancer la position du lecteur.

Une file ne nécessite pas forcément un produit distinct. PostgreSQL peut jouer ce rôle avec une table de tâches et une requête qui s’attribue la ligne suivante tout en sautant celles qu’un autre processus a déjà verrouillées. Le manuel cite les tables servant de files d’attente pour expliquer l’existence de la clause SKIP LOCKED :

WITH next AS (
  SELECT id
    FROM jobs
   WHERE state = 'available'
   ORDER BY id
   LIMIT 1
     FOR UPDATE SKIP LOCKED
)
UPDATE jobs
   SET state = 'running',
       attempt = attempt + 1
  FROM next
 WHERE jobs.id = next.id
RETURNING jobs.id, jobs.args;

Pourquoi c’est important

Une file décide ce qui fait attendre l’utilisateur. Le travail qui y est déposé se déroule après l’envoi de la réponse : une page qui déclenche un courriel, un PDF, une réindexation de recherche et un recalcul peut donc répondre dans le temps nécessaire pour écrire quatre lignes, les quatre tâches lentes se terminant ensuite. Pour un acheteur, c’est la différence entre une validation de commande qui répond en quelques centaines de millisecondes et une autre qui répond lorsque le serveur de messagerie est prêt.

Elle décide aussi de ce qui survit à une panne. Un travail lancé dans un thread d’arrière-plan vit dans la mémoire de ce processus, et un déploiement qui redémarre ce processus fait disparaître le travail, sans laisser de trace du fait qu’il devait être exécuté. Un travail dans une file durable constitue au contraire un enregistrement : il peut être réessayé, examiné et compté.

Elle sépare également deux rythmes. Les producteurs avancent au rythme du trafic entrant ; les consommateurs à celui du service le plus lent qu’ils appellent. Une file entre les deux absorbe l’écart, et sa profondeur devient l’un des indicateurs les plus fidèles d’un système. Une file qui grossit depuis une heure indique que les consommateurs prennent du retard, quoi que suggère le graphique du processeur.

Les avantages ont un coût. Le travail reste désormais invisible entre son envoi et son exécution. La livraison se fait presque toujours au moins une fois : un consommateur doit donc tolérer de voir deux fois le même message. L’ordre est moins garanti qu’il n’y paraît. Et un courtier dédié est un serveur supplémentaire à exploiter, sécuriser, surveiller et mettre à niveau.

À quoi cela ressemble en pratique

Sur une plateforme, l’envoi de courriels, la reconstruction d’un index de recherche, la génération de documents et le recalcul des classements ont tous été retirés du chemin des requêtes. Le travail confié à une goroutine disparaît lorsque le processus redémarre au milieu d’un déploiement : il a donc été placé dans une file de tâches River conservée dans PostgreSQL. La base était déjà la source de référence du système, ce qui permet d’ajouter une tâche dans la même transaction que les données concernées. La plateforme y a gagné la possibilité de réessayer et un historique consultable ; la limite annoncée est qu’une file intégrée à la base ne pourra pas monter en charge indéfiniment.

Dans une application macOS construite sur une bibliothèque C, la file servait à préserver l’ordre. La boucle d’événements bloquante de la bibliothèque émet des événements dans un ordre important, car une modification doit arriver après le message qu’elle modifie. Lancer une tâche par événement laisse l’environnement d’exécution les ordonnancer librement : une modification peut donc dépasser le message auquel elle se rapporte. La conception livrée comporte un thread producteur, un consommateur et une file entre les deux, puis un unique passage sur l’acteur principal. L’ordre tient parce qu’il n’existe qu’un seul chemin. La contrepartie concerne le parallélisme : chaque événement passe par cet unique consommateur.

Une file peut aussi nuire. Dans une application macOS, une rafale d’événements de journalisation du noyau applicatif était conservée dans un flux principal non borné et copiée vers des abonnés dont les consommateurs n’utilisaient pas ces événements. Les rapports de diagnostic ont relevé 111 Go de pages compressées sur une machine de 36 Go ; un échantillon distinct de l’empreinte mémoire a relevé une croissance d’environ 41 Mo par seconde pendant une boucle de tentatives de connexion. Le chemin des événements a reçu des limites explicites, avec des abonnements filtrés par type d’événement et une politique explicite de débordement. Les événements de diagnostic répétitifs peuvent être abandonnés et l’état concerné actualisé plutôt que de conserver un nombre illimité d’événements. Des contrôles d’architecture et des tests de respect des budgets de ressources de l’application défendent cette conception, mais le dossier ne fournit ni mesure de mémoire après correction ni benchmark de production.

Où les problèmes surviennent

Les problèmes de file apparaissent tard et ailleurs, car le travail est invisible par conception.

Le travail en attente augmente jusqu’à épuiser la mémoire ou le disque. Une file sans limite accepte du travail plus vite qu’il n’est exécuté et conserve la différence. Donnez à chaque file une longueur maximale et décidez à l’avance de la conduite à tenir à cette limite : ralentir le producteur, refuser le nouveau travail ou abandonner le plus ancien. Surveillez ensuite deux nombres, la profondeur et l’âge du message le plus ancien, car une file courte de messages très anciens est aussi problématique qu’une longue file.

Le même message est traité deux fois. Un consommateur termine le travail et meurt avant de l’acquitter ; le courtier livre de nouveau le message, comme il le doit. La documentation de RabbitMQ demande aux consommateurs de prévoir ces nouvelles livraisons et d’être conçus pour l’idempotence. Donnez un identifiant à chaque message et enregistrez ceux déjà traités dans la même transaction que le travail lui-même. Une note du site sur la vente de stocks limités sans survente construit son mécanisme d’écriture autour de cette même hypothèse.

Les messages arrivent dans un ordre différent de leur envoi. Les consommateurs parallèles, la prélecture et les nouvelles tentatives qui replacent un message en échec derrière les plus récents réordonnent tous le travail. Lorsque l’ordre compte, faites passer tout ce qui concerne un compte ou une commande par la même partition ou le même consommateur. Kafka le fait par clé, au prix d’une limite : une clé très sollicitée ne peut avancer plus vite qu’un seul consommateur.

Un message défectueux bloque le traitement ou boucle indéfiniment. Un message dont la charge utile fait planter le consommateur à chaque fois est remis en file, livré de nouveau et provoque un nouveau plantage. Limitez les tentatives et déplacez les messages qui les ont toutes épuisées dans un endroit distinct où une personne pourra les examiner. RabbitMQ appelle cela dead-lettering et l’applique aux messages rejetés, expirés ou qui dépasseraient la limite de longueur.

Le travail disparaît au redémarrage. Un canal, une liste en mémoire ou un thread d’arrière-plan est une file qui ne conserve rien après un redémarrage. En AMQP, une file durable ne suffit pas non plus : les messages doivent également être publiés comme persistants. Décidez pour chaque type de travail si sa perte est acceptable.

La base et la file divergent. Un service écrit une ligne, publie ensuite un message et plante entre les deux : l’un existe alors sans l’autre. Conservez la file dans la même base pour qu’une tâche ne devienne visible des processus de traitement qu’au commit de sa transaction, comme le fait River, ou écrivez le message dans une table d’envoi au cours de cette transaction et publiez-le à partir de là.

Pour aller plus loin

Contact

Vous cherchez encore à préciser vos besoins ?

Dites-nous ce qui ne fonctionne pas ou ce que vous essayez de construire. Nous vous dirons ce que cela demanderait, son coût approximatif et si nous sommes les bonnes personnes pour le réaliser.

À partir de 1 400 DKK de l'heure, hors TVA — et un tarif horaire réduit pour une réservation plus longue.

welcome@engineer.company +45 50 10 61 84 Copenhague, Danemark