Configuração de um Consumidor de Fila no Azure Service Bus em uma Web API com .NET 8

Com o lançamento do .NET 6, a Microsoft introduziu um modelo de programação simplificado para aplicações ASP.NET Core, eliminando a necessidade de métodos como Configure e ConfigureServices em arquivos separados. Em .NET 8, esse modelo continua a ser aprimorado. Este artigo detalha como configurar um consumidor de fila no Azure Service Bus em uma Web API usando .NET 8.

Passos para Configurar o Consumidor de Fila no Azure Service Bus

1. Crie uma Web API com .NET 8

Primeiro, crie um novo projeto Web API:

dotnet new webapi -n MyServiceBusConsumerApp
cd MyServiceBusConsumerApp

2. Adicione os Pacotes Necessários

Adicione o pacote do Azure Service Bus ao seu projeto:

dotnet add package Azure.Messaging.ServiceBus

3. Configure o appsettings.json

Adicione as configurações de conexão ao Azure Service Bus no seu arquivo appsettings.json:

{
  "ServiceBus": {
    "ConnectionString": "YourServiceBusConnectionString",
    "QueueName": "YourQueueName"
  }
}

4. Implemente o Consumidor de Fila

Crie uma interface para o serviço do consumidor de mensagens:

public interface IServiceBusConsumer
{
    Task RegisterOnMessageHandlerAndReceiveMessages();
    Task CloseQueueAsync();
}

Em seguida, implemente a classe do consumidor de mensagens:

using Azure.Messaging.ServiceBus;

public class ServiceBusConsumer : IServiceBusConsumer
{
    private readonly ServiceBusClient _serviceBusClient;
    private readonly ServiceBusProcessor _processor;

    public ServiceBusConsumer(ServiceBusClient serviceBusClient, IConfiguration configuration)
    {
        _serviceBusClient = serviceBusClient;
        var queueName = configuration["ServiceBus:QueueName"];
        _processor = _serviceBusClient.CreateProcessor(queueName, new ServiceBusProcessorOptions());
    }

    public async Task RegisterOnMessageHandlerAndReceiveMessages()
    {
        _processor.ProcessMessageAsync += MessageHandler;
        _processor.ProcessErrorAsync += ErrorHandler;

        await _processor.StartProcessingAsync();
    }

    private async Task MessageHandler(ProcessMessageEventArgs args)
    {
        string body = args.Message.Body.ToString();
        Console.WriteLine($"Received: {body}");

        await args.CompleteMessageAsync(args.Message);
    }

    private Task ErrorHandler(ProcessErrorEventArgs args)
    {
        Console.WriteLine(args.Exception.ToString());
        return Task.CompletedTask;
    }

    public async Task CloseQueueAsync()
    {
        await _processor.CloseAsync();
    }
}

5. Configure a Injeção de Dependência e Inicie o Consumidor

No novo modelo de configuração de .NET 8, toda a configuração pode ser feita diretamente no Program.cs. Adicione a configuração necessária para registrar e iniciar o consumidor de mensagens:

using Azure.Messaging.ServiceBus;

var builder = WebApplication.CreateBuilder(args);

// Adicione os serviços ao contêiner.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Configure o Service Bus
builder.Services.AddSingleton<ServiceBusClient>(serviceProvider =>
{
    var configuration = serviceProvider.GetRequiredService<IConfiguration>();
    var connectionString = configuration["ServiceBus:ConnectionString"];
    return new ServiceBusClient(connectionString);
});

builder.Services.AddSingleton<IServiceBusConsumer, ServiceBusConsumer>();

var app = builder.Build();

// Configure o pipeline HTTP.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

// Registra e inicia o consumidor de mensagens
var serviceBusConsumer = app.Services.GetRequiredService<IServiceBusConsumer>();
await serviceBusConsumer.RegisterOnMessageHandlerAndReceiveMessages();

app.Run();

6. Teste a Aplicação

Execute a aplicação:

dotnet run

Sua Web API agora está configurada para consumir mensagens de uma fila do Azure Service Bus. As mensagens recebidas serão processadas e exibidas no console.

Conclusão

Com o .NET 8, configurar um consumidor de fila no Azure Service Bus ficou ainda mais simples graças ao modelo de programação minimalista. Seguindo os passos descritos, você pode integrar facilmente o Azure Service Bus em sua Web API e garantir que as mensagens sejam processadas de maneira eficiente.