Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Publica mensajes con el marco de procesamiento de AWS mensajes para.NET

El marco de procesamiento de AWS mensajes para .NET permite publicar uno o más tipos de mensajes, procesar uno o más tipos de mensajes o hacer ambas cosas en la misma aplicación.

El código siguiente muestra la configuración de una aplicación que publica distintos tipos de mensajes en distintos AWS servicios.

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

Una vez que haya registrado el marco durante el inicio, introduzca el genérico IMessagePublisher en el código. Llame a su PublishAsync método para publicar cualquiera de los tipos de mensajes que se configuraron anteriormente. El publicador genérico determinará el destino al que se debe enrutar el mensaje en función de su tipo.

En el siguiente ejemplo, un controlador MVC de ASP.NET recibe ChatMessage mensajes y OrderInfo eventos de los usuarios y, a continuación, los publica en Amazon SQS y Amazon SNS, respectivamente. Ambos tipos de mensajes se pueden publicar con el editor genérico que se configuró anteriormente.

[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 dirigir un mensaje a la lógica de gestión adecuada, el marco utiliza metadatos denominados identificador del tipo de mensaje. De forma predeterminada, es el nombre completo del tipo.NET del mensaje, incluido su nombre de ensamblado. Si envía y gestiona mensajes a la vez, este mecanismo funciona bien si comparte la definición de los objetos de mensaje entre proyectos. Sin embargo, si los mensajes se redefinen en espacios de nombres diferentes o si intercambias mensajes con otros marcos o lenguajes de programación, es posible que tengas que anular el identificador del tipo de mensaje.

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 de servicios específicos

El ejemplo que se muestra arriba usa el genéricoIMessagePublisher, que puede publicarse en cualquier AWS servicio compatible en función del tipo de mensaje configurado. El marco también proporciona editores de servicios específicos para Amazon SQS, Amazon SNS y Amazon. EventBridge Estos editores específicos exponen opciones que solo se aplican a ese servicio y se pueden insertar mediante los tiposISQSPublisher, y. ISNSPublisher IEventBridgePublisher

Por ejemplo, al enviar mensajes a una cola FIFO de SQS, debe establecer el ID de grupo de mensajes correspondiente. El código siguiente vuelve a mostrar el ChatMessage ejemplo, pero ahora se utiliza una ISQSPublisher para configurar las opciones específicas de 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();
    }
}

Se puede hacer lo mismo con SNS y EventBridge, utilizando ISNSPublisher y respectivamente. IEventBridgePublisher

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

De forma predeterminada, los mensajes de un tipo determinado se envían al destino que se haya configurado de antemano. Sin embargo, puede anular el destino de un solo mensaje utilizando los editores específicos del mensaje. También puede anular el AWS SDK for .NET cliente subyacente que se utiliza para publicar el mensaje, lo que puede resultar útil en aplicaciones con varios usuarios en las que es necesario cambiar las funciones o las credenciales, según el destino.

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