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á.

Publique mensagens com o AWS Message Processing Framework para.NET

O AWS Message Processing Framework para.NET oferece suporte à publicação de um ou mais tipos de mensagens, ao processamento de um ou mais tipos de mensagens ou à realização de ambos no mesmo aplicativo.

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

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 a estrutura durante a inicialização, injete o genérico IMessagePublisher em seu código. Chame seu PublishAsync método para publicar qualquer um dos tipos de mensagem que foram configurados acima. O editor genérico determinará o destino para o qual rotear a mensagem com base em seu tipo.

No exemplo a seguir, um controlador ASP.NET MVC recebe ChatMessage mensagens e OrderInfo eventos dos usuários e os publica no Amazon SQS e no Amazon SNS, respectivamente. Ambos os tipos de mensagem podem ser publicados usando o editor genérico que foi 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 rotear uma mensagem para a lógica de tratamento apropriada, a estrutura 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 manipulando mensagens, esse mecanismo funciona bem se você 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 outras estruturas 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");
    });
});

Editores específicos de serviços

O exemplo mostrado acima usa o genéricoIMessagePublisher, que pode ser publicado em qualquer AWS serviço compatível com base no tipo de mensagem configurado. A estrutura também fornece editores específicos de serviços para Amazon SQS, Amazon SNS e Amazon. EventBridge Esses editores específicos expõem opções que se aplicam somente a esse serviço e podem ser injetadas usando os tiposISQSPublisher, e. ISNSPublisher IEventBridgePublisher

Por exemplo, ao enviar mensagens para uma fila FIFO do SQS, você deve definir o ID do grupo de mensagens apropriado. O código a seguir mostra o ChatMessage exemplo novamente, mas agora usando an 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 EventBridge, usando ISNSPublisher e, 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 determinado tipo são enviadas para o destino configurado com antecedência. No entanto, você pode substituir o destino de uma única mensagem usando os editores específicos da mensagem. Você também pode substituir o AWS SDK for .NET cliente subjacente usado para publicar a mensagem, o que pode ser útil em aplicativos multilocatários nos quais você precisa alterar funções ou credenciais, dependendo do destino.

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