Exercice : Envoyer des messages entre les microservices avec RabbitMQ

10 minutes

RabbitMQ est un répartiteur de messages fiable qui fournit des échangeurs et des files d’attente de messagerie flexibles. Pour envoyer et recevoir des messages avec RabbitMQ dans un projet .NET Aspire, vous devez ajouter un conteneur RabbitMQ, puis créer du code qui envoie des messages à partir d’un microservice et le reçoit dans un autre.

Dans cet exercice, vous envoyez des messages à une file d’attente à partir du projet Catalog.API. Vous ajoutez un nouveau projet de service en arrière-plan qui reçoit ces messages de la file d’attente et les envoie au journal de console pour les afficher.

Prérequis à installer

Les prérequis pour .NET Aspire sont les suivants :

.NET 8
Préversion de Visual Studio 2022
Docker Desktop ou Podman
Charge de travail .NET Aspire dans Visual Studio

Si vous avez déjà installé ces packages, vous pouvez passer à l’étape suivante pour commencer à utiliser RabbitMQ.

Installez .NET 8

Suivez ce lien .NET 8 et sélectionnez le programme d’installation approprié pour votre système d’exploitation. Par exemple, si vous utilisez Windows 11 et un processeur moderne, sélectionnez le kit de développement logiciel (SDK) .NET 8 x64 pour Windows.

Une fois le téléchargement terminé, exécutez le programme d’installation et suivez les instructions. Dans une fenêtre de terminal, exécutez la commande suivante pour vérifier que l’installation a réussi :

dotnet --version

Vous devez voir le numéro de version du kit de développement logiciel (SDK) .NET que vous avez installé. Par exemple :

8.0.300-preview.24203.14

Installer la préversion de Visual Studio 2022

Suivez ce lien de préversion de Visual Studio 2022, puis sélectionnez Télécharger la préversion. Une fois le téléchargement terminé, exécutez le programme d’installation et suivez les instructions.

Installer Docker Desktop

Suivez ce lien Docker Desktop, puis sélectionnez le programme d’installation approprié pour votre système d’exploitation. Une fois le téléchargement terminé, exécutez le programme d’installation et suivez les instructions. Pour optimiser les performances et la compatibilité, utilisez le serveur principal WSL 2.

Ouvrez l’application Docker Desktop et acceptez le contrat de service.

Installer la charge de travail .NET Aspire dans Visual Studio

Installez la charge de travail .NET Aspire à l’aide de l’interface CLI .NET :

Ouvrez un terminal.

Mettez à jour les charges de travail .NET avec cette commande :

dotnet workload update

Vous devez voir un message indiquant que les charges de travail sont mises à jour.

No workloads installed for this feature band. To update workloads installed with earlier SDK versions, include the --from-previous-sdk option.
Updated advertising manifest microsoft.net.sdk.ios.
Updated advertising manifest microsoft.net.workload.mono.toolchain.net6.
Updated advertising manifest microsoft.net.sdk.android.
Updated advertising manifest microsoft.net.workload.emscripten.net7.
Updated advertising manifest microsoft.net.workload.emscripten.net6.
Updated advertising manifest microsoft.net.sdk.macos.
Updated advertising manifest microsoft.net.workload.emscripten.current.
Updated advertising manifest microsoft.net.workload.mono.toolchain.current.
Updated advertising manifest microsoft.net.sdk.maui.
Updated advertising manifest microsoft.net.workload.mono.toolchain.net7.
Updated advertising manifest microsoft.net.sdk.maccatalyst.
Updated advertising manifest microsoft.net.sdk.tvos.
Updated advertising manifest microsoft.net.sdk.aspire.
No workloads installed for this feature band. To update workloads installed with earlier SDK versions, include the --from-previous-sdk option.

Successfully updated workload(s): .

Installez la charge de travail .NET Aspire avec cette commande :

dotnet workload install aspire

Vous devez voir un message indiquant que la charge de travail Aspire est installée.

Installing Aspire.Hosting.Sdk.Msi.x64 ...... Done
Installing Aspire.ProjectTemplates.Msi.x64 ..... Done
Installing Aspire.Hosting.Orchestration.win-x64.Msi.x64 ............. Done
Installing Aspire.Hosting.Msi.x64 ..... Done
Installing Aspire.Dashboard.Sdk.win-x64.Msi.x64 ....... Done

Successfully installed workload(s) aspire.

Vérifiez que la charge de travail .NET Aspire est installée avec cette commande :

dotnet workload list

Vous devez voir les détails de la charge de travail .NET Aspire.

 Installed Workload Id      Manifest Version      Installation Source
---------------------------------------------------------------------------------------------
aspire                     8.0.0/8.0.100         SDK 8.0.300-preview.24203, VS 17.10.34902.84

Use `dotnet workload search` to find additional workloads to install.

Cloner le projet

Nous utilisons git pour obtenir un exemple d’application qui n’utilise pas encore de répartiteur de messages :

Dans la ligne de commande, accédez à un dossier de votre choix dans lequel vous pouvez utiliser du code.

Exécutez la commande suivante pour cloner l’exemple d’application :

git clone -b aspire-rabbitmq  https://github.com/MicrosoftDocs/mslearn-aspire-starter

Créer le conteneur RabbitMQ

Commençons par ajouter RabbitMQ au projet d’hôte d’application. Quand nous démarrons la solution, .NET Aspire ajoute un conteneur RabbitMQ à l’application et passe des références aux projets qui l’utilisent :

Démarrez Visual Studio et sélectionnez Ouvrir un projet ou une solution.
Accédez au dossier où vous avez cloné le projet.
Double-cliquez sur le dossier de démarrage, sélectionnez la solution eShop.rabbitmq.sln, puis sélectionnez Ouvrir.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet eShop.AppHost, sélectionnez Ajouter, puis Package .NET Aspire.
Dans la zone de texte de recherche, à la fin du texte existant, tapez RabbitMQ.
Sélectionnez le package Aspire.Hosting.RabbitMQ.
Dans la liste Version, sélectionnez la dernière version 8.0.0, puis sélectionnez Installer.
Si la boîte de dialogue Aperçu des modifications s’affiche, sélectionnez Appliquer.
Dans la boîte de dialogue Acceptation de la licence, sélectionnez J’accepte.
Dans l’Explorateur de solutions, développez eShop.AppHost, puis double-cliquez sur Program.cs.

Recherchez la ligne de code suivante :

var builder = DistributedApplication.CreateBuilder(args);

Immédiatement après ce code, pour inscrire un serveur RabbitMQ, ajoutez ce code :
```
var messaging = builder.AddRabbitMQ("messaging");
```

Recherchez le code suivant, qui inscrit le projet Catalog.API à l’orchestration .NET Aspire :

var catalogApi = builder.AddProject<Catalog_API>("catalog-api")
    .WithReference(catalogDb);

Pour passer le service RabbitMQ au projet Catalog.API, modifiez ce code de la façon suivante :

var catalogApi = builder.AddProject<Catalog_API>("catalog-api")
    .WithReference(catalogDb)
    .WithReference(messaging);

Ajouter RabbitMQ au projet Catalog.API

À présent, nous pouvons installer et configurer RabbitMQ dans le projet Catalog.API :

Dans Visual Studio, dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Catalog.API, sélectionnez Ajouter, puis sélectionnez Package .NET Aspire.
Dans la zone de texte de recherche, à la fin du texte existant, tapez RabbitMQ.
Sélectionnez le package Aspire.RabbitMQ.Client.
Dans la liste Version, sélectionnez la dernière version 8.0.0, puis sélectionnez Installer.
Si la boîte de dialogue Aperçu des modifications s’affiche, sélectionnez Appliquer.
Dans la boîte de dialogue Acceptation de la licence, sélectionnez J’accepte.
Dans l’Explorateur de solutions, développez le projet Catalog.API, puis double-cliquez sur Program.cs.
Dans le fichier Program.cs, recherchez la ligne de code suivante :
```
var builder = WebApplication.CreateBuilder(args);
```
Immédiatement après cette ligne, pour inscrire la connexion RabbitMQ, ajoutez ce code :
```
builder.AddRabbitMQClient("messaging");
```

Envoyer un message à une file d’attente RabbitMQ

Quand un utilisateur demande les éléments du catalogue, nous voulons envoyer un message à une file d’attente RabbitMQ qui décrit les détails de la demande. Ajoutons maintenant ce code :

Dans l’Explorateur de solutions, développez Catalog.API > Api, puis double-cliquez sur CatalogApi.cs.

Recherchez le code suivant, qui déclare la méthode GetAllItems() :

public static async Task<Results<Ok<PaginatedItems<CatalogItem>>, BadRequest<string>>> GetAllItems(
    [AsParameters] PaginationRequest paginationRequest,
    [AsParameters] CatalogServices services)
{

Pour utiliser l’injection de dépendances afin d’obtenir la connexion à RabbitMQ, modifiez le code pour qu’il corresponde aux lignes suivantes :

public static async Task<Results<Ok<PaginatedItems<CatalogItem>>, BadRequest<string>>> GetAllItems(
    [AsParameters] PaginationRequest paginationRequest,
    [AsParameters] CatalogServices services,
    RabbitMQ.Client.IConnection connection)
{

Recherchez la ligne de code suivante :

var totalItems = await services.DbContext.CatalogItems
    .LongCountAsync();

Immédiatement après cette ligne, pour créer un canal de messagerie RabbitMQ, ajoutez ce code :
```
var channel = connection.CreateModel();
```

Sur la ligne suivante, pour créer une file d’attente de messages, ajoutez ce code :

channel.QueueDeclare(queue: "catalogEvents",
                     durable: false,
                     exclusive: false,
                     autoDelete: false,
                     arguments: null);

Sur la ligne suivante, pour envoyer le message, ajoutez ce code :

var body = Encoding.UTF8.GetBytes("Getting all items in the catalog.");

channel.BasicPublish(exchange: string.Empty,
                     routingKey: "catalogEvents",
 					 mandatory: false,
                     basicProperties: null,
                     body: body);

Ajouter un projet consommateur de messages

Pour recevoir des messages de la file d’attente RabbitMQ, nous créons un autre projet :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution, pointez sur Ajouter, puis sélectionnez Nouveau projet.
Dans la zone de texte Rechercher des modèles, tapez Console.
Sélectionnez le modèle Application console C# , puis Suivant.
Dans la zone de texte Nom du projet, tapez RabbitConsumer, puis sélectionnez Suivant.
Dans la liste Framework, vérifiez que .NET 8.0 est sélectionné, puis sélectionnez Créer.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur AppHost, pointez sur Ajouter, puis sélectionnez Référence de projet.
Dans la liste des projets, vérifiez que RabbitConsumer est sélectionné, puis sélectionnez OK.
Dans l’Explorateur de solutions, développez AppHost, puis double-cliquez sur Program.cs.

Recherchez le code suivant :

builder.AddProject<WebApp>("webapp")
    .WithReference(catalogApi);

Immédiatement après ce code, pour ajouter le projet RabbitConsumer à l’orchestration .NET Aspire, ajoutez le code suivant :
```
builder.AddProject<Projects.RabbitConsumer>("consumers")
    .WithReference(messaging);
```

Configurer le projet consommateur de messages

Avant de pouvoir recevoir des messages dans le nouveau projet consommateur de messages, nous devons le configurer pour utiliser le service de stockage RabbitMQ à partir d’AppHost :

Dans Visual Studio, dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet RabbitConsumer, sélectionnez Ajouter, puis sélectionnez Package .NET Aspire.
Dans la zone de texte de recherche, à la fin du texte existant, tapez RabbitMQ.
Sélectionnez le package Aspire.RabbitMQ.Client.
Dans la liste Version, sélectionnez la dernière version 8.0.0, puis sélectionnez Installer.
Si la boîte de dialogue Aperçu des modifications s’affiche, sélectionnez Appliquer.
Dans la boîte de dialogue Acceptation de la licence, sélectionnez J’accepte.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur RabbitConsumer, pointez sur Ajouter, puis sélectionnez Référence de projet.
Dans la liste des projets, vérifiez que eShop.ServiceDefaults est sélectionné, puis sélectionnez OK.
Dans l’Explorateur de solutions, développez le projet RabbitConsumer, puis double-cliquez sur Program.cs.

Supprimez tout le code par défaut et remplacez-le par les lignes suivantes :

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

builder.AddServiceDefaults();

builder.AddRabbitMQClient("messaging");

var host = builder.Build();

host.Run();

Notez que le code utilise l’orchestration .NET Aspire pour ajouter le service RabbitMQ au projet consommateur. Vous utilisez ce service pour récupérer les messages.

Recevoir un message RabbitMQ

Pour recevoir un message, nous devons créer une intégration qui s’exécute en arrière-plan et qui attend l’arrivée des messages. Utilisez une classe BackgroundService pour cette tâche :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur RabbitConsumer, pointez sur Ajouter, puis sélectionnez Classe.
Dans la zone de texte Nom, tapez CatalogProcessingJob, puis sélectionnez Ajouter.

Dans la classe CatalogProcessingJob, supprimez tout le code par défaut et remplacez-le par les lignes suivantes :

 namespace RabbitConsumer;

using System.Text;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;

public class CatalogProcessingJob : BackgroundService
{
    private readonly ILogger<CatalogProcessingJob> _logger;
    private readonly IConfiguration _config;
    private readonly IServiceProvider _serviceProvider;
    private IConnection? _messageConnection;
    private IModel? _messageChannel;
 	private EventingBasicConsumer consumer;

    public CatalogProcessingJob(ILogger<CatalogProcessingJob> logger, IConfiguration config, IServiceProvider serviceProvider, IConnection? messageConnection)
    {
        _logger = logger;
        _config = config;
        _serviceProvider = serviceProvider;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        string queueName = "catalogEvents";

        _messageConnection = _serviceProvider.GetRequiredService<IConnection>();

        _messageChannel = _messageConnection.CreateModel();
        _messageChannel.QueueDeclare(queue: queueName,
            durable: false,
            exclusive: false,
            autoDelete: false,
            arguments: null);

        consumer = new EventingBasicConsumer(_messageChannel);
        consumer.Received += ProcessMessageAsync;

        _messageChannel.BasicConsume(queue:  queueName,
            autoAck: true, 
            consumer: consumer);

        return Task.CompletedTask;
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        await base.StopAsync(cancellationToken);
        consumer.Received -= ProcessMessageAsync;
        _messageChannel?.Dispose();
    }

    private void ProcessMessageAsync(object? sender, BasicDeliverEventArgs args)
    {

        string messagetext = Encoding.UTF8.GetString(args.Body.ToArray());
        _logger.LogInformation("All products retrieved from the catalog at {now}. Message Text: {text}", DateTime.Now, messagetext);

        var message = args.Body;
    }
}

Dans l’Explorateur de solutions, dans le projet RabbitConsumer, double-cliquez sur Program.cs.