Der AWS SDK für .NET V3 ist in den Wartungsmodus übergegangen.

Wir empfehlen Ihnen, auf [AWS SDK für .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in unserer [Ankündigung zum Wartungsmodus](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS Message Processing Framework für.NET
<a name="msg-proc-fw"></a>

Das AWS Message Processing Framework for .NET ist ein AWS natives Framework, das die Entwicklung von.NET-Nachrichtenverarbeitungsanwendungen vereinfacht, die AWS Dienste wie Amazon Simple Queue Service (SQS), Amazon Simple Notification Service (SNS) und Amazon verwenden. EventBridge Das Framework reduziert den Umfang an Standardcode, den Entwickler schreiben müssen, sodass Sie sich bei der Veröffentlichung und Nutzung von Nachrichten auf Ihre Geschäftslogik konzentrieren können. Einzelheiten darüber, wie das Framework Ihre Entwicklung vereinfachen kann, finden Sie im Blogbeitrag [Introducing the AWS Message Processing Framework for .NET (Preview)](https://aws.amazon.com/blogs/developer/introducing-the-aws-message-processing-framework-for-net-preview/). Insbesondere der erste Teil enthält eine Demonstration, die den Unterschied zwischen der Verwendung von API-Aufrufen auf niedriger Ebene und der Verwendung des Frameworks zeigt.

Das Message Processing Framework unterstützt die folgenden Aktivitäten und Funktionen:
+ Senden von Nachrichten an SQS und Veröffentlichen von Ereignissen in SNS und. EventBridge
+ Empfangen und Verarbeiten von Nachrichten von SQS mithilfe eines Pollers mit langer Laufzeit, der normalerweise in Hintergrunddiensten verwendet wird. Dazu gehört die Verwaltung des Sichtbarkeits-Timeouts während der Bearbeitung einer Nachricht, um zu verhindern, dass andere Clients sie verarbeiten.
+ Umgang mit Nachrichten in AWS Lambda Funktionen.
+ FIFO (first-in-first-out) SQS-Warteschlangen und SNS-Themen.
+ OpenTelemetry für die Protokollierung.

Einzelheiten zu diesen Aktivitäten und Funktionen finden Sie im Abschnitt **Funktionen** des [Blogbeitrags](https://aws.amazon.com/blogs/developer/introducing-the-aws-message-processing-framework-for-net-preview/) und in den unten aufgeführten Themen.

Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).

**Weitere Ressourcen**
+ Das [https://www.nuget.org/packages/AWS.Messaging/](https://www.nuget.org/packages/AWS.Messaging/)Paket auf [NuGet.org](https://www.nuget.org/).
+ Die [API-Referenz](https://aws.github.io/aws-dotnet-messaging/).
+ Die `README` Datei im GitHub Repo unter [https://github.com/aws/aws-dotnet-messaging/](https://github.com/aws/aws-dotnet-messaging/)
+ [.NET-Abhängigkeitsinjektion](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) von Microsoft.
+ [.NET Generic Host](https://learn.microsoft.com/en-us/dotnet/core/extensions/generic-host) von Microsoft.

**Topics**
+ [Erste Schritte](msg-proc-fw-get-started.md)
+ [Nachrichten veröffentlichen](msg-proc-fw-publish.md)
+ [Nachrichten konsumieren](msg-proc-fw-consume.md)
+ [FIFO](msg-proc-fw-fifo.md)
+ [Protokollierung und offene Telemetrie](msg-proc-fw-telemetry.md)
+ [Anpassen](msg-proc-fw-customize.md)
+ [Sicherheit](msg-proc-fw-security.md)

# Erste Schritte mit dem AWS Message Processing Framework für.NET
<a name="msg-proc-fw-get-started"></a>

Bevor Sie beginnen, stellen Sie sicher, dass Sie [Ihre Umgebung und Ihr Projekt eingerichtet](net-dg-config.md) haben. Lesen Sie auch die Informationen unter[SDK-Funktionen](net-dg-sdk-features.md).

Dieses Thema enthält Informationen, die Ihnen den Einstieg in die Verwendung des Message Processing Framework erleichtern. Zusätzlich zu den Voraussetzungen und zur Konfiguration wird ein Tutorial bereitgestellt, das Ihnen zeigt, wie Sie ein gängiges Szenario implementieren.

## Voraussetzungen und Konfiguration
<a name="mpf-get-started-prereq"></a>
+ Die Anmeldeinformationen, die Sie für Ihre Anwendung angeben, müssen über die entsprechenden Berechtigungen für den Messaging-Dienst und die von ihr verwendeten Vorgänge verfügen. Weitere Informationen finden Sie in den Sicherheitsthemen für [SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html) und [SNS](https://docs.aws.amazon.com/sns/latest/dg/security-iam.html) sowie [EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-iam.html)in den entsprechenden Entwicklerhandbüchern. [Lesen Sie auch den Teil der [README-Datei](https://github.com/aws/aws-dotnet-messaging/), in dem bestimmte Berechtigungen GitHub beschrieben werden.](https://github.com/aws/aws-dotnet-messaging/blob/main/README.md#permissions)
+ Um das AWS Message Processing Framework für.NET verwenden zu können, müssen Sie das [https://www.nuget.org/packages/AWS.Messaging](https://www.nuget.org/packages/AWS.Messaging) NuGetPaket zu Ihrem Projekt hinzufügen. Zum Beispiel:

  ```
  dotnet add package AWS.Messaging
  ```
+ Das Framework lässt sich in den [Dienstcontainer Dependency Injection (DI) von](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) .NET integrieren. Sie können das Framework beim Start Ihrer Anwendung konfigurieren, indem Sie es aufrufen`AddAWSMessageBus`, um es dem DI-Container hinzuzufügen.

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

## Tutorial
<a name="mpf-get-started-tutorial"></a>

Dieses Tutorial zeigt, wie Sie das AWS Message Processing Framework für.NET verwenden. Es erstellt zwei Anwendungen: eine ASP.NET Core Minimal API, die Nachrichten an eine Amazon SQS SQS-Warteschlange sendet, wenn sie eine Anfrage an einem API-Endpunkt empfängt, und eine Konsolenanwendung mit langer Laufzeit, die nach diesen Nachrichten fragt und sie verarbeitet. 
+ Die Anweisungen in diesem Tutorial bevorzugen die .NET-CLI, aber Sie können dieses Tutorial entweder mit plattformübergreifenden Tools wie dem.NET-CLI oder Microsoft Visual Studio ausführen. Informationen zu Tools finden Sie unter[Installieren und konfigurieren Sie Ihre Toolchain](net-dg-dev-env.md).
+ In dieser Anleitung wird davon ausgegangen, dass Sie Ihr `[default]` Profil für Anmeldeinformationen verwenden. Es wird auch davon ausgegangen, dass kurzfristige Anmeldeinformationen mit entsprechenden Berechtigungen für das Senden und Empfangen von Amazon SQS SQS-Nachrichten verfügbar sind. Weitere Informationen finden Sie unter [Konfigurieren Sie die SDK-Authentifizierung mit AWS](creds-idc.md) und in den Sicherheitsthemen für [SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html).

**Anmerkung**  
Wenn Sie dieses Tutorial ausführen, können Ihnen Kosten für SQS-Messaging entstehen.

### Schritte
<a name="mpf-tutorial-steps"></a>
+ [Erstellen Sie eine SQS-Warteschlange](#mpf-tutorial-queue)
+ [Erstellen Sie die Veröffentlichungsanwendung und führen Sie sie aus](#mpf-tutorial-publish)
+ [Erstellen Sie die Handling-Anwendung und führen Sie sie aus](#mpf-tutorial-handle)
+ [Bereinigen](#mpf-tutorial-cleanup)

### Erstellen Sie eine SQS-Warteschlange
<a name="mpf-tutorial-queue"></a>

Für dieses Tutorial ist eine SQS-Warteschlange erforderlich, an die Nachrichten gesendet und von der Nachrichten empfangen werden können. Eine Warteschlange kann erstellt werden, indem Sie einen der folgenden Befehle für AWS CLI oder für verwenden. AWS -Tools für PowerShell Notieren Sie sich die zurückgegebene Warteschlangen-URL, damit Sie sie in der folgenden Framework-Konfiguration angeben können.

------
#### [ AWS CLI ]

```
aws sqs create-queue --queue-name DemoQueue
```

------
#### [ AWS -Tools für PowerShell ]

```
New-SQSQueue -QueueName DemoQueue
```

------

### Erstellen Sie die Veröffentlichungsanwendung und führen Sie sie aus
<a name="mpf-tutorial-publish"></a>

Gehen Sie wie folgt vor, um die Veröffentlichungsanwendung zu erstellen und auszuführen.

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

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

   ```
   dotnet new webapi --name Publisher
   ```

1. 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
   ```
**Anmerkung**  
Wenn Sie AWS IAM Identity Center für die Authentifizierung verwenden, achten Sie darauf, auch `AWSSDK.SSO` und hinzuzufügen`AWSSDK.SSOOIDC`.

1. 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; }
       }
   }
   ```

1. 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>
   ```

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

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

### Erstellen Sie die Handling-Anwendung und führen Sie sie aus
<a name="mpf-tutorial-handle"></a>

Gehen Sie wie folgt vor, um die Bearbeitungsanwendung zu erstellen und auszuführen.

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

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

   ```
   dotnet new console --name Handler
   ```

1. 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](https://learn.microsoft.com/en-us/dotnet/core/extensions/generic-host) konfigurieren können.

   ```
   cd Handler
   dotnet add package AWS.Messaging
   dotnet add package Microsoft.Extensions.Hosting
   ```
**Anmerkung**  
Wenn Sie AWS IAM Identity Center für die Authentifizierung verwenden, stellen Sie sicher, dass Sie auch `AWSSDK.SSO` und hinzufügen`AWSSDK.SSOOIDC`.

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

1. 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}
   ```

1. Drücken Sie`Ctrl+C`, um den Poller zu stoppen.

### Bereinigen
<a name="mpf-tutorial-cleanup"></a>

Verwenden Sie einen der folgenden Befehle für AWS CLI oder, AWS -Tools für PowerShell um die Warteschlange zu löschen.

------
#### [ AWS CLI ]

```
aws sqs delete-queue --queue-url "<queue URL created earlier>"
```

------
#### [ AWS -Tools für PowerShell ]

```
Remove-SQSQueue -QueueUrl "<queue URL created earlier>"
```

------

# Veröffentlichen Sie Nachrichten mit dem AWS Message Processing Framework for .NET
<a name="msg-proc-fw-publish"></a>

Das AWS Message Processing Framework for .NET unterstützt das Veröffentlichen eines oder mehrerer Nachrichtentypen, das Verarbeiten eines oder mehrerer Nachrichtentypen oder beides in derselben Anwendung. 

Der folgende Code zeigt eine Konfiguration für eine Anwendung, die verschiedene Nachrichtentypen für verschiedene AWS Dienste veröffentlicht. 

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

Nachdem Sie das Framework beim Start registriert haben, fügen Sie das Generikum `IMessagePublisher` in Ihren Code ein. Rufen Sie seine `PublishAsync` Methode auf, um einen der oben konfigurierten Nachrichtentypen zu veröffentlichen. Der generische Herausgeber bestimmt das Ziel, an das die Nachricht weitergeleitet werden soll, anhand ihres Typs. 

 Im folgenden Beispiel empfängt ein ASP.NET-MVC-Controller sowohl `ChatMessage` Nachrichten als auch `OrderInfo` Ereignisse von Benutzern und veröffentlicht sie dann in Amazon SQS bzw. Amazon SNS. Beide Nachrichtentypen können mit dem generischen Herausgeber veröffentlicht werden, der oben konfiguriert wurde.

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

Um eine Nachricht an die entsprechende Verarbeitungslogik weiterzuleiten, verwendet das Framework Metadaten, die als *Nachrichtentyp-ID* bezeichnet werden. Standardmäßig ist dies der vollständige Name des.NET-Typs der Nachricht, einschließlich des Assemblynamens. Wenn Sie Nachrichten sowohl senden als auch bearbeiten, funktioniert dieser Mechanismus gut, wenn Sie die Definition Ihrer Nachrichtenobjekte projektübergreifend gemeinsam verwenden. Wenn die Nachrichten jedoch in verschiedenen Namespaces neu definiert werden oder wenn Sie Nachrichten mit anderen Frameworks oder Programmiersprachen austauschen, müssen Sie möglicherweise die ID des Nachrichtentyps überschreiben.

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

## Dienstspezifische Herausgeber
<a name="service-specific-publishers"></a>

Das oben gezeigte Beispiel verwendet das Generikum`IMessagePublisher`, das basierend auf dem konfigurierten Nachrichtentyp in jedem unterstützten AWS Dienst veröffentlichen kann. Das Framework bietet auch servicespezifische Herausgeber für Amazon SQS, Amazon SNS und Amazon. EventBridge Diese speziellen Herausgeber stellen Optionen zur Verfügung, die nur für diesen Service gelten und mit den Typen`ISQSPublisher`, `ISNSPublisher` und eingegeben werden können. `IEventBridgePublisher`

Wenn Sie beispielsweise Nachrichten an eine SQS-FIFO-Warteschlange senden, müssen Sie die entsprechende [Nachrichtengruppen-ID](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-key-terms.html) festlegen. Der folgende Code zeigt das `ChatMessage` Beispiel erneut, verwendet aber jetzt eine, `ISQSPublisher` um SQS-spezifische Optionen festzulegen.

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

Dasselbe kann für SNS und jeweils mit `ISNSPublisher` und EventBridge gemacht werden. `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>
});
```

Standardmäßig werden Nachrichten eines bestimmten Typs an das Ziel gesendet, das im Voraus konfiguriert wurde. Sie können das Ziel für eine einzelne Nachricht jedoch mithilfe der nachrichtenspezifischen Herausgeber außer Kraft setzen. Sie können auch den zugrundeliegenden AWS SDK für .NET Client überschreiben, der zum Veröffentlichen der Nachricht verwendet wird. Dies kann in Mehrmandantenanwendungen nützlich sein, bei denen Sie je nach Ziel Rollen oder Anmeldeinformationen ändern müssen.

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

# Nachrichten mit dem AWS Message Processing Framework for .NET konsumieren
<a name="msg-proc-fw-consume"></a>

Das AWS Message Processing Framework für.NET ermöglicht es Ihnen, Nachrichten zu verarbeiten, die mithilfe des Frameworks oder eines der Messaging-Dienste [veröffentlicht](msg-proc-fw-publish.md) wurden. Die Nachrichten können auf verschiedene Arten konsumiert werden, von denen einige im Folgenden beschrieben werden.

## Nachrichten-Handler
<a name="handle-a-message"></a>

Um Nachrichten zu verarbeiten, implementieren Sie einen Message-Handler, der die `IMessageHandler` Schnittstelle für jeden Nachrichtentyp verwendet, den Sie verarbeiten möchten. Die Zuordnung zwischen Nachrichtentypen und Nachrichtenhandlern wird beim Start des Projekts konfiguriert.

```
await Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // Register the AWS Message Processing Framework for .NET
        services.AddAWSMessageBus(builder =>
        {
            // Register an SQS Queue that the framework will poll for messages.
            // NOTE: The URL given below is an example. Use the appropriate URL for your SQS Queue.
            builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd");

            // Register all IMessageHandler implementations with the message type they should process. 
            // Here messages that match our ChatMessage .NET type will be handled by our ChatMessageHandler
            builder.AddMessageHandler<ChatMessageHandler, ChatMessage>();
        });
    })
    .Build()
    .RunAsync();
```

Der folgende Code zeigt ein Beispiel für einen Nachrichtenhandler für eine `ChatMessage` Nachricht. 

```
public class ChatMessageHandler : IMessageHandler<ChatMessage>
{
    public Task<MessageProcessStatus> HandleAsync(MessageEnvelope<ChatMessage> messageEnvelope, CancellationToken token = default)
    {
        // Add business and validation logic here.
        if (messageEnvelope == null)
        {
            return Task.FromResult(MessageProcessStatus.Failed());
        }

        if (messageEnvelope.Message == null)
        {
            return Task.FromResult(MessageProcessStatus.Failed());
        }

        ChatMessage message = messageEnvelope.Message;

        Console.WriteLine($"Message Description: {message.MessageDescription}");

        // Return success so the framework will delete the message from the queue.
        return Task.FromResult(MessageProcessStatus.Success());
    }
}
```

Der äußere `MessageEnvelope` enthält Metadaten, die vom Framework verwendet werden. Seine `message` Eigenschaft ist der Nachrichtentyp (in diesem Fall`ChatMessage`).

Sie können zurückkehren, `MessageProcessStatus.Success()` um anzugeben, dass die Nachricht erfolgreich verarbeitet wurde und das Framework die Nachricht aus der Amazon SQS SQS-Warteschlange löscht. Bei der Rücksendung verbleibt die Nachricht in der Warteschlange`MessageProcessStatus.Failed()`, wo sie erneut verarbeitet oder, sofern konfiguriert, in eine [Warteschlange für unzustellbare Briefe](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) verschoben werden kann.

## Umgang mit Nachrichten in einem lang andauernden Prozess
<a name="long-running-process"></a>

Sie können `AddSQSPoller` mit einer URL für die SQS-Warteschlange aufrufen, um einen Long-Running zu starten, der kontinuierlich [https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice)die Warteschlange abfragt und Nachrichten verarbeitet.

```
await Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // Register the AWS Message Processing Framework for .NET
        services.AddAWSMessageBus(builder =>
        {
            // Register an SQS Queue that the framework will poll for messages.
            // NOTE: The URL given below is an example. Use the appropriate URL for your SQS Queue.
            builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd", options => 
            {
                // The maximum number of messages from this queue that the framework will process concurrently on this client.
                options.MaxNumberOfConcurrentMessages = 10;

                // The duration each call to SQS will wait for new messages.
                options.WaitTimeSeconds = 20; 
            });

            // Register all IMessageHandler implementations with the message type they should process.
            builder.AddMessageHandler<ChatMessageHandler, ChatMessage>();
        });
    })
    .Build()
    .RunAsync();
```

### Den SQS Message Poller konfigurieren
<a name="config-msg-poller"></a>

Der SQS-Nachrichtenabfrage kann beim Aufrufen konfiguriert werden. `SQSMessagePollerOptions` `AddSQSPoller`
+ `MaxNumberOfConcurrentMessages`- Die maximale Anzahl von Nachrichten aus der Warteschlange, die gleichzeitig verarbeitet werden sollen. Der Standardwert lautet 10.
+ `WaitTimeSeconds`- Die Dauer (in Sekunden), für die der `ReceiveMessage` SQS-Aufruf darauf wartet, dass eine Nachricht in der Warteschlange eintrifft, bevor er zurückkehrt. Wenn eine Nachricht verfügbar ist, kehrt der Anruf früher als zurück. `WaitTimeSeconds` Der Standardwert ist 20.

**Behandlung von Timeouts bei der Sichtbarkeit von Nachrichten**

SQS-Nachrichten haben ein [Zeitlimit für die Sichtbarkeit](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html). Wenn ein Verbraucher mit der Bearbeitung einer bestimmten Nachricht beginnt, verbleibt sie in der Warteschlange, wird aber vor anderen Verbrauchern verborgen, um zu vermeiden, dass sie mehr als einmal verarbeitet wird. Wenn die Nachricht nicht bearbeitet und gelöscht wird, bevor sie wieder sichtbar wird, versucht möglicherweise ein anderer Verbraucher, dieselbe Nachricht zu bearbeiten.

Das Framework verfolgt Nachrichten, die es gerade bearbeitet, und versucht, das Sichtbarkeits-Timeout zu verlängern. Sie können dieses Verhalten `SQSMessagePollerOptions` beim Aufrufen `AddSQSPoller` konfigurieren.
+ `VisibilityTimeout`- Die Dauer in Sekunden, für die empfangene Nachrichten vor nachfolgenden Abrufanfragen verborgen sind. Der Standardwert lautet 30.
+ `VisibilityTimeoutExtensionThreshold`- Wenn das Sichtbarkeits-Timeout einer Nachricht innerhalb dieser Sekunden abläuft, verlängert das Framework das Sichtbarkeits-Timeout (um weitere `VisibilityTimeout` Sekunden). Der Standardwert ist 5.
+ `VisibilityTimeoutExtensionHeartbeatInterval`- Gibt an, wie oft (in Sekunden) das Framework nach Nachrichten sucht, deren Ablauffrist innerhalb von `VisibilityTimeoutExtensionThreshold` Sekunden abläuft, und dann deren Sichtbarkeits-Timeout verlängert. Der Standardwert lautet 1.

 Im folgenden Beispiel sucht das Framework alle 1 Sekunde nach Nachrichten, die noch bearbeitet werden. Für Nachrichten innerhalb von 5 Sekunden, nachdem sie wieder sichtbar werden, verlängert das Framework automatisch das Sichtbarkeits-Timeout jeder Nachricht um weitere 30 Sekunden.

```
// NOTE: The URL given below is an example. Use the appropriate URL for your SQS Queue.
builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd", options => 
{
    options.VisibilityTimeout = 30;
    options.VisibilityTimeoutExtensionThreshold = 5;
    VisibilityTimeoutExtensionHeartbeatInterval = 1;
});
```

## Umgang mit Nachrichten in Funktionen AWS Lambda
<a name="lambda-functions"></a>

Sie können das AWS Message Processing Framework für.NET mit der [Integration von SQS mit Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html) verwenden. Dies wird durch das Paket bereitgestellt. `AWS.Messaging.Lambda` Lesen Sie die [README-Datei](https://github.com/aws/aws-dotnet-messaging/blob/main/src/AWS.Messaging.Lambda/README.md), um loszulegen.

# Verwenden von FIFO mit dem AWS Message Processing Framework für.NET
<a name="msg-proc-fw-fifo"></a>

[Für Anwendungsfälle, in denen Nachrichtenreihenfolge und Nachrichtendeduplizierung entscheidend sind, unterstützt das AWS Message Processing Framework for .NET [Amazon SQS SQS-Warteschlangen first-in-first-out (FIFO) und Amazon SNS SNS-Themen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-fifo-queues.html).](https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html)

## Veröffentlichen
<a name="mpf-fifo-publish"></a>

Wenn Sie Nachrichten in einer FIFO-Warteschlange oder einem FIFO-Thema veröffentlichen, müssen Sie die Nachrichtengruppen-ID festlegen, die die Gruppe angibt, zu der die Nachricht gehört. Nachrichten innerhalb einer Gruppe werden der Reihe nach verarbeitet. Sie können dies für die SQS-spezifischen und SNS-spezifischen Nachrichtenherausgeber festlegen.

```
await _sqsPublisher.PublishAsync(message, new SQSOptions
{
    MessageDeduplicationId = <message-deduplication-id>,
    MessageGroupId = <message-group-id>
});
```

## Abonnieren
<a name="mpf-fifo-subscribe"></a>

Bei der Verarbeitung von Nachrichten aus einer FIFO-Warteschlange behandelt das Framework Nachrichten innerhalb einer bestimmten Nachrichtengruppe in der Reihenfolge, in der sie bei jedem Anruf empfangen wurden. `ReceiveMessages` Das Framework wechselt automatisch in diesen Betriebsmodus, wenn es mit einer Warteschlange konfiguriert ist, die mit endet. `.fifo`

```
await Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // Register the AWS Message Processing Framework for .NET.
        services.AddAWSMessageBus(builder =>
        {
            // Because this is a FIFO queue, the framework automatically handles these messages in order.
            builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MPF.fifo");
            builder.AddMessageHandler<OrderMessageHandler, OrderMessage>();
        });
    })
    .Build()
    .RunAsync();
```

# Logging und offene Telemetrie für das AWS Message Processing Framework für.NET
<a name="msg-proc-fw-telemetry"></a>

Das AWS Message Processing Framework für.NET ist so konzipiert, dass OpenTelemetry es [Ablaufverfolgungen](https://opentelemetry.io/docs/concepts/signals/traces/) für jede Nachricht protokolliert, die vom Framework veröffentlicht oder verarbeitet wird. Dies wird durch das [https://www.nuget.org/packages/AWS.Messaging.Telemetry.OpenTelemetry](https://www.nuget.org/packages/AWS.Messaging.Telemetry.OpenTelemetry)Paket bereitgestellt. Lesen Sie die [README-Datei](https://github.com/aws/aws-dotnet-messaging/blob/main/src/AWS.Messaging.Telemetry.OpenTelemetry/README.md), um loszulegen.

**Anmerkung**  
Sicherheitsinformationen im Zusammenhang mit der Protokollierung finden Sie unter[Sicherheit für das AWS Message Processing Framework für.NET](msg-proc-fw-security.md).

# Das AWS Message Processing Framework für.NET anpassen
<a name="msg-proc-fw-customize"></a>

Das AWS Message Processing Framework für.NET erstellt, sendet und verarbeitet Nachrichten in drei verschiedenen „Ebenen“:

1. Auf der äußersten Ebene erstellt das Framework die AWS-native Anfrage oder Antwort, die für einen Dienst spezifisch ist. Mit Amazon SQS erstellt es beispielsweise [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)Anfragen und arbeitet mit den [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Message.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Message.html)Objekten, die durch den Service definiert sind.

1. [In der SQS-Anfrage und -Antwort setzt das Framework das `MessageBody` Element (oder `Message` für Amazon SNS oder `Detail` für Amazon EventBridge) auf ein JSON-Format. CloudEvent](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/formats/json-format.md) Dies enthält vom Framework festgelegte Metadaten, auf die bei der Bearbeitung einer Nachricht über das `MessageEnvelope` Objekt zugegriffen werden kann.

1. Auf der innersten Ebene enthält das `data` Attribut innerhalb des CloudEvent JSON-Objekts eine JSON-Serialisierung des .NET-Objekts, das als Nachricht gesendet oder empfangen wurde.

   ```
   {
       "id":"b02f156b-0f02-48cf-ae54-4fbbe05cffba",
       "source":"/aws/messaging",
       "specversion":"1.0",
       "type":"Publisher.Models.ChatMessage",
       "time":"2023-11-21T16:36:02.8957126+00:00",
       "data":"<the ChatMessage object serialized as JSON>"
   }
   ```

Sie können anpassen, wie der Nachrichtenumschlag konfiguriert und gelesen wird:
+ `"id"`identifiziert die Nachricht eindeutig. Standardmäßig ist es auf eine neue GUID gesetzt, aber dies kann überschrieben werden, indem Sie Ihre eigene GUID implementieren `IMessageIdGenerator` und diese in den DI-Container einfügen. 
+ `"type"`steuert, wie die Nachricht an die Handler weitergeleitet wird. Standardmäßig wird dabei der vollständige Name des.NET-Typs verwendet, der der Nachricht entspricht. Sie können dies über den `messageTypeIdentifier` Parameter überschreiben, wenn Sie den Nachrichtentyp über `AddSQSPublisher``AddSNSPublisher`, oder dem Ziel zuordnen`AddEventBridgePublisher`.
+ `"source"`gibt an, welches System oder welcher Server die Nachricht gesendet hat.
  + Dies ist der Funktionsname bei der Veröffentlichung von AWS Lambda, der Clustername und der Task-ARN bei Amazon ECS, die Instance-ID bei Amazon EC2, andernfalls ein Fallback-Wert von`/aws/messaging`. 
  + Sie können dies über `AddMessageSource` oder `AddMessageSourceSuffix` auf dem `MessageBusBuilder` überschreiben.
+ `"time"`auf den aktuellen Wert DateTime in UTC gesetzt. Dies kann außer Kraft gesetzt werden, indem Sie Ihr eigenes implementieren `IDateTimeHandler` und dieses in den DI-Container einfügen.
+ `"data"`enthält eine JSON-Darstellung des .NET-Objekts, das als Nachricht gesendet oder empfangen wurde:
  + `ConfigureSerializationOptions`on `MessageBusBuilder` ermöglicht es Ihnen, das zu konfigurieren [https://learn.microsoft.com/en-us/dotnet/api/system.text.json.jsonserializeroptions](https://learn.microsoft.com/en-us/dotnet/api/system.text.json.jsonserializeroptions), das beim Serialisieren und Deserialisieren der Nachricht verwendet wird.
  + Um zusätzliche Attribute einzufügen oder den Nachrichtenumschlag zu transformieren, sobald das Framework ihn erstellt hat, können Sie dies über on implementieren `ISerializationCallback` und registrieren. `AddSerializationCallback` `MessageBusBuilder`

# Sicherheit für das AWS Message Processing Framework für.NET
<a name="msg-proc-fw-security"></a>

Das AWS Message Processing Framework für .NET basiert auf der AWS SDK für .NET für die Kommunikation mit AWS. Weitere Hinweise zur Sicherheit finden Sie AWS SDK für .NET unter[Sicherheit für dieses AWS Produkt oder diese Dienstleistung](security.md).

Aus Sicherheitsgründen protokolliert das Framework keine vom Benutzer gesendeten Datennachrichten. Wenn Sie diese Funktionalität zu Debugging-Zwecken aktivieren möchten, müssen Sie den Message Bus wie folgt aufrufen`EnableDataMessageLogging()`:

```
builder.Services.AddAWSMessageBus(bus =>
{
    builder.EnableDataMessageLogging();
});
```

Wenn Sie ein potenzielles Sicherheitsproblem entdecken, finden Sie Informationen zur Meldung in der [Sicherheitsrichtlinie](https://github.com/aws/aws-dotnet-messaging/security/policy).