Aller au contenu

Pub/sub ou file de messages : diagrammes, garanties et cas d'usage

Une file remet chaque message à un consommateur, le pub/sub à chaque abonnement : comparez garanties, ordre, relecture et fonctionnement des brokers.

· Fondateur et développeur

Publié le

Deux lignes. En haut, Upload API envoie m1 à m3 à resize-jobs ; chaque worker reçoit un message. En bas, Order service publie dans order-events, qui copie les messages dans trois abonnements alimentant trois services.

Votre service e-mail envoie des reçus de commande. Vous le faites passer à trois réplicas et les clients commencent à recevoir trois reçus par commande. Chaque réplica s'est abonné avec son propre groupe de consommateurs et reçoit donc sa propre copie de chaque message. L'erreur inverse est tout aussi courante : les tâches de redimensionnement arrivent dans un topic de diffusion, un deuxième worker rejoint le système et chaque image est redimensionnée deux fois.

Ces deux erreurs confondent deux modèles de messagerie : la file de messages, où chaque message va à un consommateur, et le modèle publication-abonnement, où chaque abonné reçoit sa propre copie. Cet article les compare à l'aide d'un diagramme, puis examine les garanties de livraison, l'ordre, la relecture, la diffusion et les files de messages non distribuables, ainsi que la manière dont Kafka, RabbitMQ, SQS/SNS et Pub/Sub correspondent à ces modèles.

File ou topic : qui reçoit chaque message ?

Dans le modèle point à point, un producteur envoie un message à une file et un consommateur le reçoit. Les consommateurs d'une file sont en concurrence : le broker remet chaque message à l'un d'eux et le supprime lorsque celui-ci l'acquitte. Ce sont les réplicas d'un même service ; en ajouter permet donc de vider la file plus vite. Ce modèle de consommateurs concurrents convient aux tâches à effectuer une fois, comme le redimensionnement d'une image.

Dans le modèle publication-abonnement, un éditeur envoie un message à un topic, qui en remet une copie à chaque abonnement. Les abonnés sont des services distincts qui s'ignorent mutuellement ; en ajouter un ne change pas l'éditeur.

La plupart des systèmes combinent les deux : un topic distribue les messages aux abonnements et chaque abonnement est une file sur laquelle les réplicas d'un service sont en concurrence. La question de conception est de savoir où ont lieu la diffusion et la concurrence.

File de messages (point à point) Publication-abonnement
Consommateurs par message Un Un par abonnement
Les consommateurs sont Les réplicas d'un service Des services distincts
Passage à l'échelle Ajouter des consommateurs Ajouter des consommateurs à un abonnement
Conservation Jusqu'à l'acquittement ou à l'expiration Par abonnement ou pendant une fenêtre temporelle du journal
Relecture Non Oui, si le broker conserve un journal
Usage typique Tâches et commandes Événements et notifications

Comment Kafka, RabbitMQ, SQS/SNS et Pub/Sub représentent ces modèles

Chaque broker implémente les deux modèles :

Système Diffusion (pub/sub) Consommateurs concurrents (file) Ordre Relecture
Apache Kafka Chaque groupe de consommateurs lit chaque enregistrement Les consommateurs d'un groupe se partagent les partitions ; les groupes partagés, les enregistrements Par partition Réinitialisation des offsets du groupe
RabbitMQ Les exchanges copient les messages dans les files liées Consommateurs d'une file Par file, un consommateur Streams uniquement
Amazon SNS + SQS SNS copie dans chaque file abonnée Consommateurs d'une file SQS FIFO, par groupe de messages Topics SNS FIFO uniquement
Google Cloud Pub/Sub Chaque abonnement reçoit chaque message Clients d'un abonnement Clés d'ordre Seek

Kafka. Chaque partition est consommée par exactement un consommateur dans chaque groupe abonné (documentation de conception) ; un groupe n'a donc jamais plus de consommateurs actifs que de partitions. Kafka 4.2 (février 2026) a rendu les groupes partagés (KIP-932, Queues for Kafka) prêts pour la production : les consommateurs se partagent les enregistrements des mêmes partitions et les acquittent individuellement, sans limite liée aux partitions ni ordre.

De SNS à SQS. SNS copie chaque message dans une file SQS par service abonné, dans une enveloppe JSON sauf si vous activez la livraison brute (guide AWS sur la diffusion). Les workers de chaque service se disputent les messages de leur propre file.

RabbitMQ. Les producteurs publient dans un exchange et les liaisons déterminent quelles files reçoivent une copie : fanout copie dans chaque file liée, topic compare des motifs comme order.#, direct recherche une correspondance exacte de la clé et headers compare les en-têtes du message (types d'exchanges).

Google Pub/Sub. Un abonnement par service ; ses clients abonnés se partagent les messages.

Le problème des trois reçus vient d'un abonnement par réplica plutôt que par service. Nommez les abonnements, files et identifiants de groupe d'après le service (billing-sub, group.id=billing), jamais d'après un hôte ou un Pod.

Garanties de livraison

Les brokers relivrent les messages non acquittés ; la question est donc de savoir quand votre consommateur acquitte :

  • Au plus une fois : acquittez avant le traitement. Un plantage fait perdre le message et il n'est pas relivré.
  • Au moins une fois : acquittez après le traitement. Un plantage entraîne une nouvelle livraison ; un message peut donc être traité deux fois. Les files SQS standard et Pub/Sub livrent tous deux au moins une fois par défaut.
  • Exactement une fois : chaque message est traité une seule et unique fois, ce que les brokers ne proposent que dans certaines limites.

Les files SQS FIFO éliminent un renvoi portant le même identifiant de déduplication pendant 5 minutes. La livraison exactement une fois de Google Pub/Sub empêche une relivraison après un acquittement réussi, pour les abonnements pull d'une même région. Les transactions Kafka couvrent les lectures et écritures dans Kafka. Aucun de ces mécanismes n'empêche un consommateur de débiter deux fois une carte s'il plante entre le débit et l'acquittement.

La réponse pratique est un traitement effectivement unique : une livraison au moins une fois et un consommateur idempotent qui enregistre chaque identifiant de message dans la transaction de l'effet de bord :

BEGIN;
INSERT INTO processed_messages (consumer, message_id)
VALUES ('billing', 'm2')
ON CONFLICT DO NOTHING;
-- 0 rows: duplicate, skip the side effect
-- 1 row: apply the side effect in this transaction
COMMIT;
-- acknowledge the message only after the commit

Côté producteur, le modèle transactional outbox maintient la cohérence entre l'écriture en base et la publication.

Ordre

Les consommateurs concurrents rompent le premier entré, premier sorti : m1 va au worker 1, m2 au worker 2 et m2 peut terminer avant m1. De toute façon, les files SQS standard ne promettent qu'un ordre au mieux. Un ordre strict exige un périmètre, avec un seul consommateur à la fois par périmètre :

  • SQS FIFO : l'ordre est conservé dans un groupe de messages (MessageGroupId), et les groupes s'exécutent en parallèle. Le débit est de 300 appels API par seconde et par action sans traitement par lots, de 3 000 messages par seconde avec des lots de 10, et davantage en mode haut débit.
  • Kafka : les enregistrements de même clé arrivent dans la même partition, lue par un consommateur par groupe.
  • Google Pub/Sub : les messages de même clé d'ordre, publiés dans une région, arrivent dans l'ordre sur un abonnement où cette option est activée. Chaque clé est limitée à 1 MBps en publication ; une relivraison entraîne aussi celle des messages suivants de la même clé.

Ordonnez par compte ou appareil, jamais globalement : un ordre global impose un consommateur et un plafond de débit.

Conservation et relecture : journal ou file

Une file est une liste de tâches : les messages acquittés sont supprimés et SQS fait expirer les messages non consommés après 4 jours par défaut (entre 60 secondes et 14 jours). Un journal est un historique : Kafka conserve les enregistrements pendant sa durée de rétention, qu'ils aient été lus ou non (log.retention.hours vaut 168 par défaut, soit sept jours). Chaque groupe de consommateurs ne stocke qu'un offset ; un nouveau groupe peut donc commencer au plus ancien enregistrement et un groupe existant revenir en arrière. Les streams RabbitMQ sont aussi des journaux, lus à partir d'un point défini par x-stream-offset. Google Pub/Sub est intermédiaire : les messages non acquittés restent 7 jours par défaut (entre 10 minutes et 31 jours), les messages acquittés sont conservés en option, et les abonnements peuvent revenir en arrière.

Relire un groupe Kafka après un mauvais déploiement, avec ses consommateurs arrêtés :

kafka-consumer-groups.sh --bootstrap-server localhost:9092 \
  --group billing --topic order-events \
  --reset-offsets --to-datetime 2026-11-28T00:00:00.000 --execute

La relecture reconstruit les modèles de lecture CQRS et recharge l'historique des nouveaux services ; chaque consommateur doit donc supporter un nouveau traitement. Le diagramme d'architecture Kafka détaille les partitions et les offsets.

Contre-pression, délais de visibilité et files de messages non distribuables

Les files absorbent les pointes de charge, car les consommateurs prennent le travail à leur rythme, et des files par canal dans un système de notifications empêchent un fournisseur SMS lent de retarder l'e-mail et le push. RabbitMQ pousse les messages vers les consommateurs ; limitez donc le nombre de messages non acquittés par consommateur avec un plafond de prefetch basic.qos.

Pendant qu'un consommateur travaille, le broker masque le message aux autres pendant une durée limitée, à la manière des baux d'un ordonnanceur de tâches. Si le traitement dure plus longtemps, le message réapparaît et un second consommateur le reçoit aussi. Fixez le délai au-delà de votre traitement normal le plus lent, ou prolongez-le :

Broker Bail pendant le traitement Prolongation Arrêt des tentatives
Amazon SQS Délai de visibilité : 30 s par défaut, 12 h maximum ChangeMessageVisibility maxReceiveCount, puis une file de messages non distribuables
Google Pub/Sub Délai d'acquittement : 10 s par défaut, 600 s maximum ModifyAckDeadline 5 tentatives par défaut (jusqu'à 100), puis un topic de messages non distribuables
Groupes partagés Kafka Verrou d'acquisition : 30 s par défaut Acquittement RENEW 5 tentatives par défaut, puis archivage de l'enregistrement ; Kafka 4.4 peut aussi l'écrire dans un topic de messages non distribuables

RabbitMQ relivre si le canal d'un consommateur se ferme avant l'acquittement, et passe par des dead-letter exchanges pour les messages en échec.

Les messages empoisonnés, qui échouent systématiquement, vont dans une file de messages non distribuables : déclenchez une alerte sur sa profondeur et prévoyez une procédure de réinjection. En pub/sub, les échecs restent isolés : un consommateur analytique défaillant ne grossit que son propre retard ; surveillez donc le plus ancien message non acquitté de chaque abonnement.

Choisir selon le cas d'usage

Cas d'usage Modèle Solutions adaptées
Tâches de fond : miniatures, PDF, e-mails File SQS standard, une file quorum RabbitMQ, un groupe partagé Kafka
Commandes ordonnées par compte File avec périmètre d'ordre SQS FIFO groupé par compte, Kafka avec une clé par compte
Événement auquel réagissent plusieurs services Pub/sub, une file par abonné SNS vers SQS, un exchange fanout RabbitMQ, des abonnements Pub/Sub, des groupes de consommateurs Kafka
Reconstruction d'état ou chargement d'historique d'un consommateur Journal Kafka, streams RabbitMQ
Processus à plusieurs étapes entre services Commandes sur des files, résultats sur pub/sub Le modèle saga

Le diagramme de file et de pub/sub

Deux lignes. En haut, Upload API envoie m1 à m3 à resize-jobs ; chaque worker reçoit un message. En bas, Order service publie dans order-events, qui copie les messages dans trois abonnements alimentant trois services.

18 composants · 11 connexions

Ouvrir dans Archboard
Contenu du diagramme
  • Upload API
  • resize-jobs
  • Resize worker 1
  • Resize worker 2
  • Resize worker 3
  • Order service
  • order-events
  • email-sub
  • billing-sub
  • analytics-sub
  • Email service
  • Billing service
  • Analytics service
  • send m1, m2, m3
  • m1
  • m2
  • m3
  • publish m1, m2, m3
  • copy
  • m1, m2, m3
Une file et un topic pub/sub côte à côte. La file répartit m1, m2 et m3 entre trois workers concurrents ; le topic les copie dans trois abonnements, pour que les services e-mail, facturation et analytique traitent chaque message.

Comment le lire :

  • Deux lignes, les mêmes identifiants de message. En haut : une file point à point. En bas : publication-abonnement. Chaque producteur envoie m1 à m3.
  • Ligne supérieure : la file resize-jobs remet chaque message à un worker différent, tous réplicas d'un même service.
  • Ligne inférieure : le topic order-events copie chaque message dans trois abonnements, un par service ; les services e-mail, facturation et analytique reçoivent donc chacun m1, m2 et m3.
  • Les flèches pleines représentent l'envoi, la publication et la copie ; les flèches pointillées représentent les livraisons asynchrones acquittées par les consommateurs.
  • Le bloc Markdown récapitule les valeurs par défaut des délais et de la rétention.

Dessiner clairement les diagrammes de messagerie

  • Dessinez les abonnements, pas seulement les topics. Les flèches directes d'un topic vers les services masquent le lieu d'attente des messages et le propriétaire de chaque retard.
  • Nommez les arêtes avec les noms ou identifiants des messages, pas simplement « événements » : m1, m2 et m3 montrent la différence entre répartition et copie.
  • Montrez les réplicas quand la concurrence importe, et indiquez la clé d'ordre et le chemin des messages non distribuables près de leur file ou topic.

Le guide du diagramme d'architecture événementielle étend cette notation à un système Kafka complet.

Le construire dans Archboard

  1. Connectez-vous avec Google ou GitHub et créez un diagramme.
  2. Ajoutez un titre Texte du pack Base pour chaque ligne.
  3. Ligne supérieure : ajoutez un Conteneur du pack Modèle C4 nommé Upload API, une File d'attente du pack Données nommée resize-jobs et trois nœuds Conteneur, Resize worker 1 à 3. Tracez une arête pleine « send m1, m2, m3 » vers la file et des arêtes pointillées m1, m2 et m3 vers les workers.
  4. Ligne inférieure : ajoutez un Conteneur nommé Order service, un Sujet du pack Données nommé order-events, trois nœuds File d'attente (email-sub, billing-sub, analytics-sub) et trois nœuds Conteneur pour les services e-mail, facturation et analytique. Nommez les arêtes du topic « copy » et les livraisons pointillées « m1, m2, m3 ».
  5. Colorez chaque ligne avec une couleur d'accent, bleue ou turquoise, et ajoutez une note Texte du pack Base sous la file et le topic.
  6. Ajoutez un bloc Markdown du pack Base contenant les valeurs par défaut.

Pour un système plus vaste, partez du modèle d'architecture événementielle ; pour les flux déjà en Mermaid, l'outil Mermaid vers un diagramme modifiable produit une première ébauche.

L'exemple utilise 14 nœuds de diagramme et reste dans les limites de l'offre Free.

FAQ

Quelle est la différence entre pub/sub et une file de messages ? Une file remet chaque message à un consommateur et le supprime après acquittement. Le pub/sub remet une copie à chaque abonnement, permettant à plusieurs services de réagir à un événement.

Kafka est-il une file de messages ou un système pub/sub ? Les deux. Chaque groupe de consommateurs lit chaque enregistrement, ce qui correspond au pub/sub ; les consommateurs d'un groupe se partagent les partitions comme une file. Les groupes partagés de Kafka 4.2 ajoutent l'acquittement par enregistrement.

Kafka, RabbitMQ ou SQS : lequel utiliser ? SQS pour une file gérée sur AWS sans infrastructure à exploiter, RabbitMQ pour un routage flexible et Kafka pour un débit élevé avec un historique relisible.

Ai-je besoin de SNS si j'utilise déjà SQS ? Seulement si plusieurs services ont besoin de chaque message. SNS copie alors chaque message dans une file SQS par service, chacune avec ses propres tentatives et sa file de messages non distribuables.

Une file de messages garantit-elle une livraison exactement une fois ? Pas de bout en bout. SQS FIFO, Google Pub/Sub et les transactions Kafka empêchent les doublons dans certaines limites, mais les e-mails ou paiements nécessitent toujours un consommateur idempotent.

Commencez gratuitement — un siège, sans carte bancaire.

Articles associés

← Retour au blog

Ouvrez un canevas en une minute

Connectez-vous avec Google ou GitHub. Gratuit pour un siège. Passez à un forfait supérieur quand l’équipe vous rejoint.