Gestion des files d’attente de lettres mortes (DLQ) dans RabbitMQ avec Java Spring Boot

Introduction

Rabbit MQ est un courtier de messages open source principalement utilisé comme middleware (ou courtier) pour communiquer entre les micro-services. Le microservice qui produit ou envoie un message au courtier est appelé « Producteur » tandis que le service qui reçoit le message est appelé « Consommateur ».

On peut imaginer le flux de communication comme : Producteur -> Courtier de messages -> Consommateur.

Message Broker comprend deux parties clés :
1) Échange
2) File d’attente

Les messages du producteur sont d’abord envoyés à l’échange, puis ils sont acheminés vers la file d’attente à l’aide d’une clé de routage. Ce phénomène est connu sous le nom « Obligatoire ». Et puis le consommateur consomme le message de la file d’attente.

Parfois, les consommateurs ne parviennent pas à consommer et à accuser réception du message de la file d’attente en raison de divers facteurs, tels qu’un format non valide, un échec de traitement ou un échec de routage. Dans de tels cas, des files d’attente de lettres mortes (DLQ) sont utilisées pour capturer ces messages, permettant ainsi l’analyse, le dépannage et le retraitement potentiel sans perturber le flux normal des messages.

Pour chaque file d’attente, nous pouvons avoir une file d’attente de lettres mortes et un échange distincts. Il aide à maintenir l’intégrité du système, à identifier les problèmes et à faciliter la gestion et la résolution appropriées des erreurs dans les systèmes distribués :

1) Mécanisme de gestion des erreurs et de nouvelle tentative : Cela garantit que le système ne perd pas de messages critiques en raison d’un échec de traitement.

2) Visibilité et débogage : Il permet au développeur ou à l’administrateur d’identifier et d’inspecter facilement les messages qui n’ont pas pu être traités.

3) Retraitement et récupération : Les messages du DQ peuvent être retraités manuellement ou automatiquement, permettant au système de se remettre d’un échec de traitement et de garantir la cohérence des données.

4) Audit et conformité : Le stockage des messages ayant échoué fournit les enregistrements de tous les messages pris en compte, contribuant ainsi à l’intégrité et à la transparence globales du système.

Nous pouvons créer des échanges de lettres mortes et des files d’attente via la gestion de l’interface utilisateur RabbitMQ ainsi que via le code en Java avec Spring Boot en utilisant « Printemps pour Rabbit MQ« dépendance. Vous trouverez ci-dessous le code de dépendance Maven de RabbitMQ :

dependencies {
 implementation 'org.springframework.boot:spring-boot-starter-amqp'
 testImplementation 'org.springframework.amqp:spring-rabbit-test'
}  

Vous trouverez ci-dessous l’implémentation de la configuration DLQ en Java avec Spring Boot :
1) Définir un bean de Dead Letter Exchange (dlx)
2) Définir un bean de Dead Letter Queue (dlq)
3) Liez le dlx et le dlq
4) Associez le dlx ci-dessus à la file d’attente que vous utilisez.

a) Variables paramètres des clés de file d’attente, d’échange et de routage : nous définissons la variable d’instance et attribuons les valeurs à l’aide de l’annotation « @Value » à l’aide de la paire clé-valeur définie dans le fichier de propriétés de l’application.

b) Valeurs des champs ci-dessus attribuées dans le fichier de propriétés de l’application au format clé-valeur.

c) Configuration de l’échange de lettres mortes et de la file d’attente dans le fichier de configuration.

d) Le code ci-dessus crée le bean pour la file d’attente pour laquelle nous configurons le DLQ. À l’aide de la méthode « with Argument », nous pouvons spécifier le nom de l’échange et sa clé de routage pour établir la connexion entre la file d’attente principale et l’échange de lettres mortes.

e) Le code crée la file d’attente de lettres mortes et son bean.

f) Ensuite, créez l’échange de lettres mortes et son bean.

g) Enfin, liez l’échange de lettres mortes et la file d’attente de lettres mortes avec la clé de routage.

Et n’oubliez pas d’utiliser la bibliothèque ci-dessous pour les différentes classes, interfaces et annotations de RabbitMQ utilisées dans la classe de configuration :

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.QueueBuilder;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

Les messages ayant échoué seront acheminés vers la file d’attente des lettres mortes. De plus, on peut également spécifier le délai d’expiration lors de l’envoi du message et définir le TTL (durée de vie) lors de la création du bean de la file d’attente. Ainsi, après ce délai d’expiration, si le message n’est pas consommé, il sera acheminé vers le bean. file d’attente des lettres mortes. Vous pouvez utiliser l’aide du code ci-dessous pour l’implémenter.

1) Lors de l’envoi du message :

rabbitTemplate.convertAndSend(MAIN_QUEUE, message, messagePostProcessor -> {
messagePostProcessor.getMessageProperties().setExpiration(“60000”); // TTL in milliseconds (e.g., 60 seconds)
return messagePostProcessor;
});

2) Lors de la création du bean de la file d’attente :

@Bean
public Queue mainQueue() {
return QueueBuilder.durable(MAIN_QUEUE)
.ttl(60000) // TTL in milliseconds (e.g., 60 seconds)
.build();
}

Au niveau du consommateur, il faut gérer les messages ayant échoué dans le traitement. L’une des méthodes peut être la suivante :

J’espère que vous avez apprécié l’article sur Dead Letter Queue dans Rabbit MQ.

Merci! 🙂

VOUS TROUVEZ CECI UTILE ? PARTAGEZ-LE