Commencez avec le cadre de traitement des AWS messages pour .NET

Ouvrez une invite de commande ou un terminal. Recherchez ou créez un dossier de système d'exploitation sous lequel vous pouvez créer un projet .NET.

Dans ce dossier, exécutez la commande suivante pour créer le projet .NET.

dotnet new webapi --name Publisher

Accédez au dossier du nouveau projet. Ajoutez une dépendance à l'infrastructure de traitement des AWS messages pour .NET.

cd Publisher
dotnet add package AWS.Messaging

Remplacez le code Program.cs par le code suivant.

using AWS.Messaging;
using Microsoft.AspNetCore.Mvc;
using Publisher;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle.
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();


// Configure the AWS Message Processing Framework for .NET.
builder.Services.AddAWSMessageBus(builder =>
{
    // Check for input SQS URL.
    // The SQS URL should be passed as a command line argument or set in the Debug launch profile.
    if ((args.Length == 1) && (args[0].Contains("https://sqs.")))
    {
        // Register that you'll publish messages of type GreetingMessage:
        // 1. To a specified queue.
        // 2. Using the message identifier "greetingMessage", which will be used
        //    by handlers to route the message to the appropriate handler.
        builder.AddSQSPublisher<GreetingMessage>(args[0], "greetingMessage");
    }
    // You can map additional message types to queues or topics here as well.
});
var app = builder.Build();


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

app.UseHttpsRedirection();

// Create an API Endpoint that receives GreetingMessage objects
// from the caller and then sends them as an SQS message.
app.MapPost("/greeting", async ([FromServices] IMessagePublisher publisher, Publisher.GreetingMessage message) =>
    {
        return await PostGreeting(message, publisher);
    })
.WithName("SendGreeting")
.WithOpenApi();

app.Run();

public partial class Program
{
    /// <summary>
    /// Endpoint for posting a greeting message.
    /// </summary>
    /// <param name="greetingMessage">The greeting message.</param>
    /// <param name="messagePublisher">The message publisher.</param>
    /// <returns>Async task result.</returns>
    public static async Task<IResult> PostGreeting(GreetingMessage greetingMessage,
        IMessagePublisher messagePublisher)
    {
        if (greetingMessage.SenderName == null || greetingMessage.Greeting == null)
        {
            return Results.BadRequest();
        }

        // Publish the message to the queue configured above.
        await messagePublisher.PublishAsync(greetingMessage);

        return Results.Ok();
    }
}

namespace Publisher
{
    /// <summary>
    /// This class represents the message contents.
    /// </summary>
    public class GreetingMessage
    {
        public string? SenderName { get; set; }
        public string? Greeting { get; set; }
    }
}

Exécutez la commande suivante. Cela devrait ouvrir une fenêtre de navigateur avec l'interface utilisateur Swagger, qui vous permettra d'explorer et de tester votre API.

dotnet watch run <queue URL created earlier>

Ouvrez le /greeting point de terminaison et choisissez Try it out.

Spécifiez greeting les valeurs senderName et les valeurs du message, puis choisissez Execute. Cela appelle votre API, qui envoie le message SQS.

Ouvrez une invite de commande ou un terminal. Recherchez ou créez un dossier de système d'exploitation sous lequel vous pouvez créer un projet .NET.

Dans ce dossier, exécutez la commande suivante pour créer le projet .NET.

dotnet new console --name Handler

Accédez au dossier du nouveau projet. Ajoutez une dépendance à l'infrastructure de traitement des AWS messages pour .NET. Ajoutez également le Microsoft.Extensions.Hosting package, qui vous permet de configurer le framework via le .NET Generic Host.

cd Handler
dotnet add package AWS.Messaging
dotnet add package Microsoft.Extensions.Hosting

Remplacez le code Program.cs par le code suivant.

using AWS.Messaging;
using Handler;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = Host.CreateDefaultBuilder(args);

builder.ConfigureServices(services =>
{
    // Register the AWS Message Processing Framework for .NET.
    services.AddAWSMessageBus(builder =>
    {
        // Check for input SQS URL.
        // The SQS URL should be passed as a command line argument or set in the Debug launch profile.
        if ((args.Length == 1) && (args[0].Contains("https://sqs.")))
        {
            // Register you'll poll the following queue.
            builder.AddSQSPoller(args[0]);

            // And that messages of type "greetingMessage" should be:
            // 1. Deserialized as GreetingMessage objects.
            // 2. Which are then passed to GreetingMessageHandler.
            builder.AddMessageHandler<GreetingMessageHandler, GreetingMessage>("greetingMessage");

        }
        // You can add additional message handlers here, using different message types. 
    });
});

var host = builder.Build();
await host.RunAsync();

namespace Handler
{
    /// <summary>
    /// This class represents the message contents.
    /// </summary>
    public class GreetingMessage
    {
        public string? SenderName { get; set; }
        public string? Greeting { get; set; }
    }

    /// <summary>
    /// This handler is invoked each time you receive the message.
    /// </summary>
    public class GreetingMessageHandler : IMessageHandler<GreetingMessage>
    {
        public Task<MessageProcessStatus> HandleAsync(
            MessageEnvelope<GreetingMessage> messageEnvelope,
            CancellationToken token = default)
        {
            Console.WriteLine(
                $"Received message {messageEnvelope.Message.Greeting} from {messageEnvelope.Message.SenderName}");
            return Task.FromResult(MessageProcessStatus.Success());
        }
    }
}

Exécutez la commande suivante. Cela lance un sondage de longue haleine.

dotnet run <queue URL created earlier>

Peu de temps après le démarrage, l'application recevra le message envoyé dans la première partie de ce didacticiel et enregistrera le message suivant :

Received message {greeting} from {senderName}

Appuyez Ctrl+C pour arrêter le sondeur.