Lab 10: Asynchrone Verarbeitung von Nachrichten mithilfe von Azure Service Bus-Warteschlangen

Microsoft Azure-Benutzeroberfläche

Aufgrund der dynamischen Natur der Microsoft-Cloudtools kann es vorkommen, dass sich die Azure-Benutzeroberfläche nach der Entwicklung dieses Trainingsinhalts ändert. Daher sind die Lab-Anweisungen und Lab-Schritte möglicherweise nicht mehr zutreffend.

Microsoft aktualisiert diesen Trainingskurs, wenn die Community uns über die erforderlichen Änderungen informiert. Cloudupdates kommen jedoch häufig vor, sodass möglicherweise Änderungen an der Benutzeroberfläche auftreten, bevor diese Trainingsinhalte aktualisiert werden. Wenn dies der Fall ist, stellen Sie sich auf die Veränderungen ein, und arbeiten Sie sie bei Bedarf in den Labs durch.

Anweisungen

Vorbereitung

Anmelden bei der Laborumgebung

Melden Sie sich mithilfe der folgenden Anmeldeinformationen bei Ihrer Windows 11-VM an:

• Benutzername: Admin
• Kennwort: Pa55w.rd

Hinweis: Ihr Kursleiter stellt Anweisungen zum Herstellen einer Verbindung mit der virtuellen Laborumgebung zur Verfügung.

Überprüfen der installierten Anwendungen

Suchen Sie auf Ihrem Windows 11-Desktop nach der Taskleiste. Die Taskleiste enthält die Symbole für die Anwendungen, die Sie in diesem Lab verwenden, darunter:

• Microsoft Edge
• Visual Studio Code

Übungsszenario

In diesem Lab erstellen Sie mithilfe einer Azure Service Bus-Warteschlange einen Proof of Concept für dieses Szenario. Um zu veranschaulichen, wie das System funktionieren könnte, erstellen Sie ein .NET-Projekt, das Meldungen im System veröffentlicht, und eine zweite .NET-Anwendung, die Meldungen aus der Warteschlange liest. Die erste App simuliert Daten, die von einem Sensor stammen, während die zweite App das System simuliert, das die Nachrichten zur Verarbeitung aus der Warteschlange liest.

Architekturdiagramm

Übung 1: Erstellen von Azure-Ressourcen

Aufgabe 1: Öffnen des Azure-Portals

1. Wählen Sie auf der Taskleiste das Symbol Microsoft Edge aus.

2. Navigieren Sie im Browserfenster zum Azure-Portal unter https://portal.azure.com, und melden Sie sich mit dem Konto an, das Sie für dieses Lab verwenden werden.

   Hinweis: Wenn Sie sich zum ersten Mal am Azure-Portal anmelden, wird Ihnen eine Tour durch das Portal angeboten. Wählen Sie Erste Schritte aus, um die Tour zu überspringen und mit der Verwendung des Portals zu beginnen.

Aufgabe 2: Erstellen einer Azure Service Bus-Warteschlange

1. Verwenden Sie im Azure-Portal das Textfeld Ressourcen, Dienste und Dokumente durchsuchen, um nach Service Bus zu suchen. Wählen Sie in der Ergebnisliste dann Service Bus aus.

2. Klicken Sie auf dem Blatt Service Bus auf + Erstellen.

3. Führen Sie im Blatt Namespace erstellen auf der Registerkarte Grundlagen die folgenden Aktionen aus, und wählen Sie Überprüfen und erstellen aus:

   Einstellung	Aktion
   Dropdownliste Abonnement	Übernehmen Sie den Standardwert.
   Abschnitt Ressourcengruppe	Wählen Sie Neu erstellen aus, geben Sie AsyncProcessor ein, und wählen Sie dann OK aus.
   Textfeld Namespacename	Geben Sie sbnamespace [Ihr_Name] ein.
   Dropdownliste Region	Wählen Sie eine beliebige Azure-Region aus, in der Sie eine Azure Service Bus-Instanz bereitstellen können.
   Dropdownliste Tarif	Wählen Sie Basic aus.

   Der folgende Screenshot zeigt die konfigurierten Einstellungen auf der Registerkarte Grundlagen im Blatt Namespace erstellen.

   

4. Überprüfen Sie auf der Registerkarte Überprüfen und erstellen die Optionen, die Sie in den vorherigen Schritten ausgewählt haben.

5. Wählen Sie Erstellen aus, um den Service Bus-Namespace mit Ihrer angegebenen Konfiguration zu erstellen.

   Hinweis: Warten Sie, bis der Erstellungstask abgeschlossen ist, bevor Sie mit diesem Lab fortfahren.

6. Wählen Sie im Blatt Bereitstellung die Schaltfläche Gehe zu Ressource aus, um zum Blatt des neu erstellten Service Bus-Namespace zu navigieren.

7. Wählen Sie auf dem Blatt mit dem Service Bus-Namespace im Abschnitt Einstellungen die Option Richtlinien für gemeinsamen Zugriff aus.

8. Wählen Sie in der Liste der Richtlinien RootManageSharedAccessKey aus.

9. Wählen Sie im Bereich SAS-Richtlinie: RootManageSharedAccessKey neben dem Eintrag Primäre Verbindungszeichenfolge die Schaltfläche In Zwischenablage kopieren aus, und zeichnen Sie den kopierten Wert auf. Sie werden ihn später in diesem Lab brauchen.

   Hinweis: Es spielt keine Rolle, welchen der beiden verfügbaren Schlüssel Sie auswählen. Sie können synonym verwendet werden.

10. Wählen Sie auf dem Blatt mit dem Service Bus-Namespace im Abschnitt Entitäten die Option Warteschlangen und dann + Warteschlange aus.

11. Überprüfen Sie im Blatt Warteschlange erstellen die verfügbaren Einstellungen, geben Sie im Textfeld Name den Namen messagequeueein, und wählen Sie dann Erstellen aus.

12. Wählen Sie messagequeue aus, um die Eigenschaften der Service Bus-Warteschlange anzuzeigen.

13. Lassen Sie das Browserfenster geöffnet. Sie werden es später in diesem Lab wieder brauchen.

Überprüfung

In dieser Übung haben Sie einen Azure Service Bus-Namespace und eine Service Bus-Warteschlange erstellt, die Sie im weiteren Verlauf des Labs verwenden werden.

Übung 2: Erstellen eines .NET Core-Projekts zum Veröffentlichen von Nachrichten in einer Service Bus-Warteschlange

Aufgabe 1: Erstellen eines .NET Core-Projekts

1. Starten Sie auf dem Lab-Computer Visual Studio Code.

2. Wählen Sie in Visual Studio Code im Menü Datei die Option Ordner öffnen aus.

3. Navigieren Sie im Fenster Ordner öffnen zu Allfiles (F):\Allfiles\Labs\10\Starter\MessagePublisher, und wählen Sie dann Ordner auswählen aus.

4. Wählen Sie im Fenster Visual Studio Code auf der Menüleiste Terminal und dann Neues Terminal aus.

5. Führen Sie an der Terminaleingabeaufforderung den folgenden Befehl aus, um ein neues .NET-Projekt mit dem Namen MessagePublisher im aktuellen Ordner zu erstellen:

    dotnet new console --framework net8.0 --name MessagePublisher --output .
   

   Hinweis: Der Befehl dotnet new erstellt ein neues Konsolenprojekt in einem Ordner mit dem gleichen Namen wie das Projekt.

6. Führen Sie den folgenden Befehl aus, um Version 7.17.3 des Pakets Azure.Messaging.ServiceBus aus NuGet zu importieren:

    dotnet add package Azure.Messaging.ServiceBus --version 7.17.3
   

   Hinweis: Mit dem Befehl dotnet add package wird das Paket Azure.Messaging.ServiceBus aus NuGet hinzugefügt. Weitere Informationen finden Sie unter Azure.Messaging.ServiceBus.

7. Führen Sie an der Terminaleingabeaufforderung den folgenden Befehl aus, um die .NET Core-Konsolenanwendung zu erstellen:

    dotnet build
   

8. Wählen Sie Terminal beenden (das Symbol Papierkorb) aus, um den Terminal-Bereich und alle zugehörigen Prozesse zu schließen.

Aufgabe 2: Veröffentlichen von Nachrichten in einer Azure Service Bus-Warteschlange

1. Öffnen Sie im Bereich Explorer des Visual Studio Code-Fensters die Datei Program.cs.

2. Löschen Sie auf der Registerkarte „Code-Editor“ für die Datei Program.cs den gesamten Code in der vorhandenen Datei.

3. Fügen Sie den folgenden Code hinzu:

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    namespace MessagePublisher
    {
        public class Program
        {
            /* The `<serviceBus-connection-string>` placeholder represents
               the connection string to the target Azure Service Bus namespace */
            private const string serviceBusConnectionString = "<serviceBus-connection-string>";
   
            /* To create a string constant named "queueName" with a value
               of "messagequeue", matching the name of the Service Bus queue.*/
            private const string queueName = "messagequeue";
   
            /* Stores the number of messages to be sent to the target queue */
            private const int numOfMessages = 3;
   
            /* To create a Service Bus client that will own the connection to the target queue */
            static ServiceBusClient client = default!;
   
            /* To create a Service Bus sender that will be 
               used to publish messages to the target queue */
            static ServiceBusSender sender = default!;
   
            public static async Task Main(string[] args)
            {   
                /* To initialize "client" of type "ServiceBusClient" that will 
                   provide connectivity to the Service Bus namespace and "sender"
                   that will be responsible for sending messages */
                client = new ServiceBusClient(serviceBusConnectionString);
                sender = client.CreateSender(queueName);
   
                /* To create a "ServiceBusMessageBatch" object that will allow you to combine
                   multiple messages into a batch by using the "TryAddMessage" method */
                using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
   
                /* To add messages to a batch and throw an exception if a message
                   size exceeds the limits supported by the batch */
                for (int i = 1; i <= numOfMessages; i++)
                {
                    if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
                    {
                        throw new Exception($"The message {i} is too large to fit in the batch.");
                    }
                }
                try
                {
                    /* To create a try block, with "sender" asynchronously 
                       publishing messages in the batch to the target queue */
                    await sender.SendMessagesAsync(messageBatch);
                    Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
                }
                finally
                {
                    /* To create a finally block that asynchronously disposes of the "sender"
                       and "client" objects, releasing any network and unmanaged resources */
                    await sender.DisposeAsync();
                    await client.DisposeAsync();
                }
            }
        }
    }
   

   Hinweis: Aktualisieren Sie die Zeichenfolgenkonstante serviceBusConnectionString, indem Sie ihren Wert auf Primäre Verbindungszeichenfolge des ServiceBus-Namespace festlegen und verifizieren, dass die queueName-Konstante auf messagequeue festgelegt ist und dem Namen der zuvor in dieser Übung erstellten ServiceBus-Warteschlange entspricht.

   Hinweis: Der Service Bus-Client kann für die Lebensdauer der Anwendung problemlos zwischengespeichert und als Singleton verwendet werden. Dies gilt als eine der bewährten Methoden beim Veröffentlichen und Lesen von Nachrichten in regelmäßigen Abständen.

4. Speichern Sie die Datei  Program.cs .

5. Führen Sie an der Terminaleingabeaufforderung den folgenden Befehl aus, um die .NET Core-Konsolenanwendung zu starten:

    dotnet run
   

   Hinweis: Überprüfen Sie die Datei Program.cs im Ordner Allfiles (F):\Allfiles\Labs\10\Solution\MessagePublisher, wenn Fehler auftreten.

6. Vergewissern Sie sich, dass in der Konsolenmeldung, die an der Eingabeaufforderung im Terminal angezeigt wird, gesagt wird, dass ein Batch von drei Nachrichten in der Warteschlange veröffentlicht wurde.

7. Wählen Sie Terminal beenden (das Symbol Papierkorb) aus, um den Terminal-Bereich und alle zugehörigen Prozesse zu schließen.

8. Wechseln Sie zum Microsoft Edge-Browser, in dem die Service Bus-Warteschlange messagequeue im Azure-Portal angezeigt wird.

9. Überprüfen Sie den Bereich Zusammenfassung. Sie sehen, dass die Warteschlange drei aktive Nachrichten enthält.

   Die Service Bus-Warteschlangenmetriken und die Nachrichtenanzahl sind im folgenden Screenshot dargestellt.

   

10. Wählen Sie Service Bus Explorer aus.

11. Wenn der Registerkartenheader Vorschaumodus ausgewählt ist, wählen Sie auf der Registerkarte Warteschlange die Schaltfläche Vorschau ab Start aus.

12. Überprüfen Sie, ob die Warteschlange drei Nachrichten enthält.

13. Wählen Sie die erste Nachricht aus, und überprüfen Sie deren Inhalt im Bereich Nachricht.

    Der Inhalt der ersten Nachricht ist im folgenden Screenshot dargestellt.

    

14. Schließen Sie den Bereich Nachricht.

Überprüfung

In dieser Übung haben Sie Ihr .NET-Projekt konfiguriert, das Nachrichten in einer Azure Service Bus-Warteschlange veröffentlicht.

Übung 3: Erstellen eines .NET Core-Projekts zum Lesen von Nachrichten aus einer Service Bus-Warteschlange

Aufgabe 1: Erstellen eines .NET-Projekts

1. Starten Sie auf dem Lab-Computer Visual Studio Code.

2. Wählen Sie in Visual Studio Code im Menü Datei die Option Ordner öffnen aus.

3. Navigieren Sie im Fenster Ordner öffnen zu Allfiles (F):\Allfiles\Labs\10\Starter\MessageReader, und wählen Sie dann Ordner auswählen aus.

4. Wählen Sie im Fenster Visual Studio Code auf der Menüleiste Terminal und dann Neues Terminal aus.

5. Führen Sie an der Terminaleingabeaufforderung den folgenden Befehl aus, um ein neues .NET-Projekt mit dem Namen MessageReader im aktuellen Ordner zu erstellen:

    dotnet new console --framework net8.0 --name MessageReader --output .
   

6. Führen Sie den folgenden Befehl aus, um Version 7.17.3 des Pakets Azure.Messaging.ServiceBus aus NuGet zu importieren:

    dotnet add package Azure.Messaging.ServiceBus --version 7.17.3
   

7. Führen Sie an der Terminaleingabeaufforderung den folgenden Befehl aus, um die .NET Core-Konsolenanwendung zu erstellen:

    dotnet build
   

8. Wählen Sie Terminal beenden (das Symbol Papierkorb) aus, um den Terminal-Bereich und alle zugehörigen Prozesse zu schließen.

Aufgabe 2: Lesen von Nachrichten aus einer Azure Service Bus-Warteschlange

1. Öffnen Sie im Bereich Explorer des Visual Studio Code-Fensters die Datei Program.cs.

2. Löschen Sie auf der Registerkarte „Code-Editor“ für die Datei Program.cs den gesamten Code in der vorhandenen Datei.

3. Fügen Sie den folgenden Code hinzu:

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    namespace MessageReader
    {
        class Program
        {   
            /* The `<serviceBus-connection-string>` placeholder represents
               the connection string to the target Azure Service Bus namespace */
            static string serviceBusConnectionString = "<serviceBus-connection-string>";
               
            /* To create a string constant named "queueName" with a value
               of "messagequeue", matching the name of the Service Bus queue.*/
            static string queueName = "messagequeue";
            static ServiceBusClient client= default!;
   
            /* Create a ServiceBusProcessor that will be used to process messages from the queue */
            static ServiceBusProcessor processor = default!;
   
   
            static async Task MessageHandler(ProcessMessageEventArgs args)
            {   
                /* To create a static async "MessageHandler" task that displays 
                   the body of messages in the queue as they are being processed 
                   and deletes them after the processing completes */
   
                string body = args.Message.Body.ToString();
                Console.WriteLine($"Received: {body}");
                await args.CompleteMessageAsync(args.Message);
            }
            static Task ErrorHandler(ProcessErrorEventArgs args)
            {   
                /* To create a static async "ErrorHandler" task that manages 
                   any exceptions encountered during message processing */
                Console.WriteLine(args.Exception.ToString());
                return Task.CompletedTask;
            }
   
            static async Task Main()
            {   
                /* To initialize "client" of type "ServiceBusClient" that will provide 
                   connectivity to the Service Bus namespace and "processor" that will
                   be responsible for processing of messages */
                client = new ServiceBusClient(serviceBusConnectionString);
                processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
                try
                {   
                    /* To create a try block, which first implements a message and error
                        processing handler, initiates message processing, and stops
                        processing following a user input */
                    processor.ProcessMessageAsync += MessageHandler;
                    processor.ProcessErrorAsync += ErrorHandler;
   
                    await processor.StartProcessingAsync();
                    Console.WriteLine("Wait for a minute and then press any key to end the processing");
                    Console.ReadKey();
   
                    Console.WriteLine("\nStopping the receiver...");
                    await processor.StopProcessingAsync();
                    Console.WriteLine("Stopped receiving messages");
                }
                finally
                {
                   /* To create a finally block that asynchronously disposes of the "processor"
                       and "client" objects, releasing any network and unmanaged resources */
                    await processor.DisposeAsync();
                    await client.DisposeAsync();
                }
            }
        }
    }
   

   Hinweis: Aktualisieren Sie die Zeichenfolgenkonstante serviceBusConnectionString, indem Sie den Wert auf Primary Connection String des Service Bus-Namespace festlegen, den Sie zuvor in diesem Lab erstellt haben.

4. Speichern Sie die Datei  Program.cs .

5. Führen Sie an der Terminaleingabeaufforderung den folgenden Befehl aus, um die .NET Core-Konsolenanwendung zu starten:

    dotnet run
   

   Hinweis: Überprüfen Sie die Datei Program.cs im Ordner Allfiles (F):\Allfiles\Labs\10\Solution\MessageReader, wenn Fehler auftreten.

6. Vergewissern Sie sich, dass in der Konsolenmeldung, die an der Eingabeaufforderung im Terminal angezeigt wird, gesagt wird, dass alle drei Nachrichten in der Warteschlange empfangen wurden.

7. Drücken Sie an der Terminaleingabeaufforderung eine beliebige Taste, um den Empfänger anzuhalten und die Ausführung der App zu beenden.

8. Wählen Sie Terminal beenden (das Symbol Papierkorb) aus, um den Terminal-Bereich und alle zugehörigen Prozesse zu schließen.

9. Wechseln Sie wieder zurück zum Microsoft Edge-Browser, in dem die Service Bus-Warteschlange messagequeue im Azure-Portal angezeigt wird.

10. Wählen Sie auf dem Blatt Service Bus Explorer (Vorschau) die Option Vorschau ab Start aus. Sie sehen, dass sich die Anzahl der aktiven Nachrichten in der Warteschlange zu 0 geändert hat.

Überprüfung

In dieser Übung haben Sie mithilfe der .NET-Bibliothek Nachrichten aus der Azure Service Bus-Warteschlange gelesen und gelöscht.