Publicar mensagens com o AWS Message Processing Framework para .NET - AWS SDK para .NET (V3)
Publicadores específicos do serviço

A versão 4 (V4) do AWS SDK para .NET foi lançada!

Para começar a usar a nova versão do SDK, consulte o Guia do desenvolvedor AWS SDK para .NET (V4), especialmente o tópico sobre migração para a versão 4.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Publicar mensagens com o AWS Message Processing Framework para .NET

O AWS Message Processing Framework para .NET comporta a publicação de um ou mais tipos de mensagens, o processamento de um ou mais tipos de mensagens ou a realização de ambos na mesma aplicação.

O código a seguir mostra a configuração de uma aplicação que está publicando diferentes tipos de mensagens em serviços distintos da AWS. 

var builder = WebApplication.CreateBuilder(args);

// Register the AWS Message Processing Framework for .NET
builder.Services.AddAWSMessageBus(builder =>
{
    // Register that you'll send messages of type ChatMessage to an existing queue
    builder.AddSQSPublisher<ChatMessage>("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd");

    // Register that you'll publish messages of type OrderInfo to an existing SNS topic
    builder.AddSNSPublisher<OrderInfo>("arn:aws:sns:us-west-2:012345678910:MyAppProd");

    // Register that you'll publish messages of type FoodItem to an existing EventBridge bus
    builder.AddEventBridgePublisher<FoodItem>("arn:aws:events:us-west-2:012345678910:event-bus/default");
});

Depois de registrar o framework durante a inicialização, injete o IMessagePublisher genérico em seu código. Chame o respectivo método PublishAsync para publicar qualquer um dos tipos de mensagem configurados acima. O publicador genérico determinará o destino para o qual direcionar a mensagem com base no tipo.

No exemplo a seguir, um controlador ASP.NET MVC recebe mensagens ChatMessage e eventos OrderInfo dos usuários e, depois, os publica no Amazon SQS e no Amazon SNS, respectivamente. Os dois tipos de mensagem podem ser publicados usando o publicador genérico configurado acima.

[ApiController]
[Route("[controller]")]
public class PublisherController : ControllerBase
{
    private readonly IMessagePublisher _messagePublisher;

    public PublisherController(IMessagePublisher messagePublisher)
    {
        _messagePublisher = messagePublisher;
    }

    [HttpPost("chatmessage", Name = "Chat Message")]
    public async Task<IActionResult> PublishChatMessage([FromBody] ChatMessage message)
    {
        // Perform business and validation logic on the ChatMessage here.
        if (message == null)
        {
            return BadRequest("A chat message was not submitted. Unable to forward to the message queue.");
        }
        if (string.IsNullOrEmpty(message.MessageDescription))
        {
            return BadRequest("The MessageDescription cannot be null or empty.");
        }

        // Send the ChatMessage to SQS, using the generic publisher.
        await _messagePublisher.PublishAsync(message);

        return Ok();
    }

    [HttpPost("order", Name = "Order")]
    public async Task<IActionResult> PublishOrder([FromBody] OrderInfo message)
    {
        if (message == null)
        {
            return BadRequest("An order was not submitted.");
        }

        // Publish the OrderInfo to SNS, using the generic publisher.
        await _messagePublisher.PublishAsync(message);

        return Ok();
    }
}

Para direcionar uma mensagem para a lógica de processamento apropriada, o framework usa metadados chamados identificador do tipo de mensagem. Por padrão, esse é o nome completo do tipo .NET da mensagem, incluindo seu nome de montagem. Se você estiver enviando e processando mensagens, esse mecanismo funcionará bem se compartilhar a definição dos objetos de mensagem entre projetos. No entanto, se as mensagens forem redefinidas em namespaces diferentes ou se você estiver trocando mensagens com outros frameworks ou linguagens de programação, talvez seja necessário substituir o identificador do tipo de mensagem.

var builder = Host.CreateDefaultBuilder(args);

builder.ConfigureServices(services =>
{
    // Register the AWS Message Processing Framework for .NET
    services.AddAWSMessageBus(builder =>
    {
        // Register that you'll publish messages of type GreetingMessage to an existing queue
        builder.AddSQSPublisher<GreetingMessage>("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd", "greetingMessage");
    });
});

Publicadores específicos do serviço

O exemplo mostrado acima usa o IMessagePublisher genérico, que pode publicar em qualquer serviço aceito da AWS com base no tipo de mensagem configurado. O framework também fornece publicadores específicos de serviços para Amazon SQS, Amazon SNS e Amazon EventBridge. Esses publicadores específicos expõem opções que se aplicam somente a esse serviço e podem ser injetadas usando os tiposISQSPublisher, ISNSPublisher e IEventBridgePublisher.

Por exemplo, ao enviar mensagens a uma fila FIFO do SQS, você deve precisa o ID do grupo de mensagens apropriado. O código a seguir mostra o exemplo ChatMessage novamente, mas agora usando um ISQSPublisher para definir opções específicas do SQS.

public class PublisherController : ControllerBase
{
    private readonly ISQSPublisher _sqsPublisher;

    public PublisherController(ISQSPublisher sqsPublisher)
    {
        _sqsPublisher = sqsPublisher;
    }

    [HttpPost("chatmessage", Name = "Chat Message")]
    public async Task<IActionResult> PublishChatMessage([FromBody] ChatMessage message)
    {
        // Perform business and validation logic on the ChatMessage here
        if (message == null)
        {
            return BadRequest("A chat message was not submitted. Unable to forward to the message queue.");
        }
        if (string.IsNullOrEmpty(message.MessageDescription))
        {
            return BadRequest("The MessageDescription cannot be null or empty.");
        }

        // Send the ChatMessage to SQS using the injected ISQSPublisher, with SQS-specific options
        await _sqsPublisher.SendAsync(message, new SQSOptions
        {
            DelaySeconds = <delay-in-seconds>,
            MessageAttributes = <message-attributes>,
            MessageDeduplicationId = <message-deduplication-id>,
            MessageGroupId = <message-group-id>
        });

        return Ok();
    }
}

O mesmo pode ser feito para o SNS e o EventBridge, utilizando o ISNSPublisher e o IEventBridgePublisher respectivamente.

await _snsPublisher.PublishAsync(message, new SNSOptions
{
    Subject = <subject>,
    MessageAttributes = <message-attributes>,
    MessageDeduplicationId = <message-deduplication-id>,
    MessageGroupId = <message-group-id>
});
await _eventBridgePublisher.PublishAsync(message, new EventBridgeOptions
{
    DetailType = <detail-type>,
    Resources = <resources>,
    Source = <source>,
    Time = <time>,
    TraceHeader = <trace-header>
});

Por padrão, as mensagens de um tipo específico são enviadas ao destino configurado com antecedência. No entanto, é possível substituir o destino de uma única mensagem usando os respectivos publicadores específicos. Você também pode substituir o cliente do AWS SDK para .NET subjacente utilizado para publicar a mensagem, o que pode ser útil em aplicações multilocatárias nas quais você precisa alterar perfis ou credenciais, dependendo do destino.

await _sqsPublisher.SendAsync(message, new SQSOptions
{
    OverrideClient = <override IAmazonSQS client>,
    QueueUrl = <override queue URL>
});