Övning – Skicka meddelanden mellan mikrotjänster via RabbitMQ

10 minuter

RabbitMQ är en tillförlitlig meddelandekö som tillhandahåller flexibla meddelandeutbyten och köer. Om du vill skicka och ta emot meddelanden via RabbitMQ i ett .NET Aspire-projekt måste du lägga till en RabbitMQ-container och sedan skapa kod som skickar meddelanden från en mikrotjänst och tar emot den i en annan.

I den här övningen skickar du meddelanden till en kö från projektet Catalog.API. Du lägger till ett nytt bakgrundstjänstprojekt som tar emot dessa meddelanden från kön och skickar dem till konsolloggen för visning.

Installationskrav

Förutsättningarna för .NET Aspire är:

.NET 8
Förhandsversion av Visual Studio 2022
Docker Desktop eller Podman
.NET Aspire-arbetsbelastning i Visual Studio

Om du redan har installerat dessa paket kan du gå vidare och börja arbeta med RabbitMQ.

Installera .NET 8

Följ den här .NET 8-länken och välj rätt installationsprogram för operativsystemet. Om du till exempel använder Windows 11 och en modern processor väljer du X64 .NET 8 SDK för Windows.

När nedladdningen är klar kör du installationsprogrammet och följer anvisningarna. I ett terminalfönster kör du följande kommando för att kontrollera att installationen lyckades:

dotnet --version

Du bör se versionsnumret för .NET SDK som du har installerat. Till exempel:

8.0.300-preview.24203.14

Installera Visual Studio 2022 Preview

Följ den här Visual Studio 2022 Preview-länken och välj Ladda ned förhandsversion. När nedladdningen är klar kör du installationsprogrammet och följer anvisningarna.

Installera Docker Desktop

Följ den här Docker Desktop-länken och välj rätt installationsprogram för operativsystemet. När nedladdningen är klar kör du installationsprogrammet och följer anvisningarna. Använd WSL 2-serverdelen för bästa prestanda och kompatibilitet.

Öppna Docker Desktop-programmet och godkänn tjänstavtalet.

Installera .NET Aspire-arbetsbelastningen i Visual Studio

Installera .NET Aspire-arbetsbelastningen med .NET CLI:

Öppna en terminal.

Uppdatera .NET-arbetsbelastningar med det här kommandot:

dotnet workload update

Du bör se ett meddelande om att arbetsbelastningarna har uppdaterats.

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): .

Installera .NET Aspire-arbetsbelastningen med det här kommandot:

dotnet workload install aspire

Du bör se ett meddelande om att Aspire-arbetsbelastningen är installerad.

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.

Kontrollera att .NET Aspire-arbetsbelastningen är installerad med det här kommandot:

dotnet workload list

Du bör se information om .NET Aspire-arbetsbelastningen.

 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.

Klona projekt

Vi använder git för att hämta en exempelapp som ännu inte använder en meddelandekö:

På kommandoraden bläddrar du till en mapp där du kan arbeta med kod.

Kör följande kommando för att klona exempelprogrammet:

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

Skapa RabbitMQ-containern

Vi börjar med att lägga till RabbitMQ i appvärdprojektet. När vi startar lösningen lägger .NET Aspire till en RabbitMQ-container i appen och skickar referenser till de projekt som använder den:

Starta Visual Studio och välj Öppna ett projekt eller en lösning.
Gå till mappen där du klonade projektet.
Dubbelklicka på startmappen, välj lösningen eShop.rabbitmq.sln och välj sedan Öppna.
Högerklicka på projektet eShop.AppHost i Solution Explorer, välj Lägg till och välj sedan .NET Aspire-paketet.
I söktextrutan skriver du RabbitMQ i slutet av den befintliga texten.
Välj Aspire.Hosting.RabbitMQ-paketet .
I listan Version väljer du den senaste versionen 8.0.0 och väljer sedan Installera.
Om dialogrutan Förhandsgranskningsändringar visas väljer du Använd.
I dialogrutan Godkännande av licens väljer du Jag accepterar.
I Solution Explorer expanderar du eShop.AppHost och dubbelklickar sedan på Program.cs.

Leta upp följande kodrad:

var builder = DistributedApplication.CreateBuilder(args);

Om du vill registrera en RabbitMQ-server omedelbart efter koden lägger du till den här koden:
```
var messaging = builder.AddRabbitMQ("messaging");
```

Leta upp följande kod som registrerar Catalog.API-projektet för .NET Aspire-orkestrering:

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

Om du vill skicka RabbitMQ-tjänsten till projektet Catalog.API ändrar du koden så att den matchar den här koden:

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

Lägg till RabbitMQ i projektet Catalog.API

Nu kan vi installera och konfigurera RabbitMQ i projektet Catalog.API:

Högerklicka på projektet Catalog.API i Solution Explorer i Visual Studio, välj Lägg till och välj sedan .NET Aspire-paketet.
I söktextrutan skriver du RabbitMQ i slutet av den befintliga texten.
Välj paketet Aspire.RabbitMQ.Client.
I listan Version väljer du den senaste versionen 8.0.0 och väljer sedan Installera.
Om dialogrutan Förhandsgranskningsändringar visas väljer du Använd.
I dialogrutan Godkännande av licens väljer du Jag accepterar.
Expandera projektet Catalog.API i Solution Explorer och dubbelklicka sedan på Program.cs.

Leta upp följande kodrad i filen Program.cs :

var builder = WebApplication.CreateBuilder(args);

Omedelbart efter den raden lägger du till den här koden för att registrera RabbitMQ-anslutningen:
```
builder.AddRabbitMQClient("messaging");
```

Skicka ett meddelande till en RabbitMQ-kö

När en användare begär objekten i katalogen vill vi skicka ett meddelande till en RabbitMQ-kö som beskriver information om begäran. Nu ska vi lägga till koden:

I Solution Explorer expanderar du Catalog.API > Apis och dubbelklickar sedan på CatalogApi.cs.

Leta upp följande kod, som deklarerar GetAllItems() metoden:

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

Om du vill använda beroendeinmatning för att hämta anslutningen till RabbitMQ ändrar du koden så att den matchar följande rader:

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

Leta upp följande kodrad:

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

Lägg till den här koden direkt efter den raden för att skapa en RabbitMQ-meddelandekanal:
```
var channel = connection.CreateModel();
```

Lägg till den här koden på nästa rad för att skapa en meddelandekö:

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

Lägg till den här koden på nästa rad för att skicka meddelandet:

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

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

Lägga till ett meddelandekonsumentprojekt

Om du vill ta emot meddelanden från RabbitMQ-kön skapar vi ett nytt projekt:

Högerklicka på lösningen i Solution Explorer, peka på Lägg till och välj sedan Nytt projekt.
I textrutan Sök efter mallar skriver du Konsol.
Välj mallen C# -konsolapp och välj sedan Nästa.
I textrutan Projektnamn skriver du RabbitConsumer och väljer sedan Nästa.
I listan Framework kontrollerar du att .NET 8.0 är markerat och väljer sedan Skapa.
Högerklicka på AppHost-projektet i Solution Explorer, peka på Lägg till och välj sedan Projektreferens.
I listan över projekt kontrollerar du att RabbitConsumer har valts och väljer sedan OK.
I Solution Explorer expanderar du AppHost och dubbelklickar sedan på Program.cs.

Leta upp följande kod:

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

Lägg till följande kod direkt efter koden för att lägga till RabbitConsumer-projektet i .NET Aspire-orkestrering:
```
builder.AddProject<Projects.RabbitConsumer>("consumers")
    .WithReference(messaging);
```

Konfigurera meddelandekonsumentprojektet

Innan vi kan ta emot meddelanden i det nya meddelandekonsumentprojektet måste vi konfigurera det så att det använder RabbitMQ-säkerhetskopieringstjänsten från AppHost:

Högerklicka på Projektet RabbitConsumer i Solution Explorer i Visual Studio, välj Lägg till och välj sedan .NET Aspire-paketet.
I söktextrutan skriver du RabbitMQ i slutet av den befintliga texten.
Välj paketet Aspire.RabbitMQ.Client.
I listan Version väljer du den senaste versionen 8.0.0 och väljer sedan Installera.
Om dialogrutan Förhandsgranskningsändringar visas väljer du Använd.
I dialogrutan Godkännande av licens väljer du Jag accepterar.
Högerklicka på Projektet RabbitConsumer i Solution Explorer, peka på Lägg till och välj sedan Projektreferens.
I listan över projekt kontrollerar du att eShop.ServiceDefaults har valts och väljer sedan OK.
Expandera Projektet RabbitConsumer i Solution Explorer och dubbelklicka sedan på Program.cs.

Ta bort all standardkod och ersätt den med följande rader:

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

var builder = Host.CreateApplicationBuilder(args);

builder.AddServiceDefaults();

builder.AddRabbitMQClient("messaging");

var host = builder.Build();

host.Run();

Observera att koden använder .NET Aspire-orkestrering för att lägga till RabbitMQ-tjänsten i konsumentprojektet. Du använder den tjänsten för att hämta meddelanden.

Ta emot ett RabbitMQ-meddelande

För att få ett meddelande måste vi skapa en integrering som körs i bakgrunden i väntan på att meddelanden ska tas emot. Använd en BackgroundService klass för den här uppgiften:

Högerklicka på projektet RabbitConsumer i Solution Explorer, peka på Lägg till och välj sedan Klass.
I textrutan Namn skriver du CatalogProcessingJob och väljer sedan Lägg till.

I klassen CatalogProcessingJob.cs tar du bort all standardkod och ersätter den med följande rader:

 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;
    }
}

Dubbelklicka på Program.cs i Projektet RabbitConsumer i Solution Explorer.