Erste Schritte mit dem AWS Message Processing Framework für.NET

Öffnen Sie eine Befehlszeile oder ein Terminal. Suchen oder erstellen Sie einen Betriebssystemordner, unter dem Sie ein .NET-Projekt erstellen können.

Führen Sie in diesem Ordner den folgenden Befehl aus, um das .NET-Projekt zu erstellen.

dotnet new webapi --name Publisher

Navigieren Sie in den Ordner des neuen Projekts. Fügen Sie eine Abhängigkeit vom AWS Message Processing Framework for .NET hinzu.

cd Publisher
dotnet add package AWS.Messaging

Ersetzen Sie den Code in Program.cs durch den folgenden Code.

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

Führen Sie den folgenden Befehl aus. Dadurch sollte ein Browserfenster mit der Swagger-Benutzeroberfläche geöffnet werden, mit der Sie Ihre API erkunden und testen können.

dotnet watch run <queue URL created earlier>

Öffnen Sie den /greeting Endpunkt und wählen Sie Try it out.

Geben Sie senderName greeting Werte für die Nachricht an und wählen Sie Ausführen. Dadurch wird Ihre API aufgerufen, die die SQS-Nachricht sendet.

Öffnen Sie eine Befehlszeile oder ein Terminal. Suchen oder erstellen Sie einen Betriebssystemordner, unter dem Sie ein .NET-Projekt erstellen können.

Führen Sie in diesem Ordner den folgenden Befehl aus, um das .NET-Projekt zu erstellen.

dotnet new console --name Handler

Navigieren Sie in den Ordner des neuen Projekts. Fügen Sie eine Abhängigkeit vom AWS Message Processing Framework for .NET hinzu. Fügen Sie außerdem das Microsoft.Extensions.Hosting Paket hinzu, mit dem Sie das Framework über den.NET Generic Host konfigurieren können.

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

Ersetzen Sie den Code in Program.cs durch den folgenden Code.

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

Führen Sie den folgenden Befehl aus. Dadurch wird ein Poller mit langer Laufzeit gestartet.

dotnet run <queue URL created earlier>

Kurz nach dem Start empfängt die Anwendung die Nachricht, die im ersten Teil dieses Tutorials gesendet wurde, und protokolliert die folgende Meldung:

Received message {greeting} from {senderName}

Drücken SieCtrl+C, um den Poller zu stoppen.