Tutorial: Aktualisieren des Bestands mit dem Azure-Portal und mit Themen/Abonnements
Azure Service Bus ist ein mehrinstanzenfähiger Cloudmessagingdienst, der Informationen zwischen Anwendungen und Diensten sendet. Asynchrone Vorgänge ermöglichen ein flexibles Brokermessaging sowie strukturiertes First-In-First-Out-Messaging (FIFO) und Funktionen zum Veröffentlichen/Abonnieren. Eine ausführliche Übersicht zu Azure Service Bus finden Sie unter Was ist Service Bus?.
In diesem Tutorial wird veranschaulicht, wie Sie Service Bus-Themen und -Abonnements in einem Einzelhandelsbestands-Szenario mit Veröffentlichen/Abonnieren-Kanälen über das Azure-Portal und .NET verwenden. Ein Beispiel dieses Szenarios ist eine Aktualisierung des Bestandssortiments für mehrere Einzelhandelsgeschäfte. Hierbei erhält jedes Geschäft bzw. jede Gruppe von Geschäften Nachrichten, die jeweils die Aktualisierung der Sortimente betreffen. In diesem Tutorial wird veranschaulicht, wie Sie dieses Szenario mit Abonnements und Filtern implementieren. Zunächst erstellen Sie ein Thema mit drei Abonnements, fügen einige Regeln und Filter hinzu und führen dann das Senden und Empfangen von Nachrichten aus den Themen und Abonnements durch.
In diesem Tutorial lernen Sie Folgendes:
- Erstellen eines Service Bus-Themas und eines oder mehrerer Abonnements für das Thema mit dem Azure-Portal
- Hinzufügen von Filtern für Abonnements mithilfe von .NET-Code
- Erstellen von Nachrichten mit unterschiedlichem Inhalt
- Senden der Nachrichten und Überprüfen des Eingangs in den entsprechenden Abonnements
- Empfangen von Nachrichten aus den Abonnements
Voraussetzungen
Damit Sie dieses Tutorial ausführen können, benötigen Sie folgende Komponenten:
- Azure-Abonnement. Für die Verwendung von Azure-Diensten benötigen Sie ein Abonnement. Das gilt auch für Azure Service Bus. Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.
- Visual Studio 2019 oder höher
Service Bus-Themen und -Abonnements
Jedes Abonnement eines Themas kann eine Kopie jeder Nachricht empfangen. Die Themen sind in Bezug auf das Protokoll und die Semantik vollständig mit Service Bus-Warteschlangen kompatibel. Service Bus-Themen unterstützen ein umfassendes Auswahlregel-Array mit Filterbedingungen. Es sind optionale Aktionen vorhanden, mit denen Nachrichteneigenschaften festgelegt oder geändert werden. Jedes Mal, wenn sich für eine Regel eine Übereinstimmung ergibt, wird eine Nachricht erzeugt. Weitere Informationen zu Regeln, Filtern und Aktionen finden Sie unter diesem Link.
Erstellen eines Namespace im Azure-Portal
Um mit der Verwendung von Service Bus-Nachrichtenentitäten in Azure beginnen zu können, müssen Sie zuerst einen Namespace mit einem in Azure eindeutigen Namen erstellen. Ein Namespace ist ein Bereichscontainer für Service Bus-Ressourcen (Warteschlangen, Themen usw.) innerhalb Ihrer Anwendung.
So erstellen Sie einen Namespace
Melden Sie sich beim Azure-Portal an.
Navigieren Sie zur Seite Alle Dienste.
Wählen Sie im linken Navigationsbereich in der Kategorienliste Integration aus, zeigen Sie mit dem Mauszeiger auf Service Bus, und wählen Sie auf der Service Bus-Kachel die Schaltfläche + aus.
Führen Sie auf der Seite Namespace erstellen auf der Registerkarte Grundlagen die folgenden Schritte aus:
Wählen Sie unter Abonnement ein Azure-Abonnement aus, in dem der Namespace erstellt werden soll.
Wählen Sie unter Ressourcengruppe eine vorhandene Ressourcengruppe für den Namespace aus, oder erstellen Sie eine neue Ressourcengruppe.
Geben Sie einen Namen für den Namespace ein. Der Namespacename sollte den folgenden Namenskonventionen entsprechen:
- Der Name muss innerhalb von Azure eindeutig sein. Das System überprüft sofort, ob dieser Name verfügbar ist.
- Die Länge des Namens beträgt mindestens 6 und maximal 50 Zeichen.
- Der Name darf nur Buchstaben, Zahlen und Bindestriche („-“) enthalten.
- Der Name muss mit einem Buchstaben beginnen und mit einem Buchstaben oder einer Ziffer enden.
- Der Name endet nicht mit „-sb“ oder „-mgmt“.
Wählen Sie unter Standort die Region aus, in der Ihr Namespace gehostet werden soll.
Wählen Sie unter Tarif den Tarif (Basic, Standard oder Premium) für den Namespace aus. Wählen Sie für diesen Schnellstart die Option Standard aus.
Wichtig
Wenn Sie Themen und Abonnements nutzen möchten, wählen Sie entweder Standard oder Premium aus. Themen/Abonnements werden für den Basic-Tarif nicht unterstützt.
Wenn Sie den Tarif Premium auswählen, geben Sie die Anzahl von Messagingeinheiten an. Der Premium-Tarif bietet Ressourcenisolierung auf CPU- und Arbeitsspeicherebene, sodass die einzelnen Workloads voneinander isoliert ausgeführt werden. Dieser Ressourcencontainer wird als Messagingeinheit bezeichnet. Ein Premium-Namespace verfügt über mindestens eine Messagingeinheit. Sie können 1, 2, 4, 8 oder 16 Messagingeinheiten für jeden Service Bus Premium-Namespace auswählen. Weitere Informationen finden Sie unter Service Bus Premium- und Standard-Preisstufe für Messaging.
Wählen Sie am unteren Rand der Seite die Option Bewerten + erstellen aus.
Überprüfen Sie die Einstellungen auf der Seite Überprüfen und erstellen, und wählen Sie Erstellen aus.
Wählen Sie nach der erfolgreichen Bereitstellung der Ressource auf der Bereitstellungsseite Zur Ressource wechseln aus.
Die Startseite für Ihren Service Bus-Namespace wird angezeigt.
Abrufen der Verbindungszeichenfolge zum Namespace (Azure-Portal)
Beim Erstellen eines neuen Namespace wird automatisch eine anfängliche SAS-Richtlinie (Shared Access Signature) mit primären und sekundären Schlüsseln sowie primären und sekundären Verbindungszeichenfolgen generiert, mit denen Sie jeweils die volle Kontrolle über sämtliche Aspekte des Namespace haben. Unter Service Bus-Authentifizierung und -Autorisierung erfahren Sie, wie Sie Regeln mit stärker eingeschränkten Rechten für reguläre Absender und Empfänger erstellen.
Ein Client kann die Verbindungszeichenfolge verwenden, um eine Verbindung mit dem Service Bus-Namespace herzustellen. Führen Sie die folgenden Schritte aus, um die primäre Verbindungszeichenfolge für Ihren Namespace zu kopieren:
Wählen Sie auf der Seite Service Bus-Namespace im linken Menü die Option Freigegebene Zugriffsrichtlinien aus.
Wählen Sie auf der Seite Freigegebene Zugriffsrichtlinien die Option RootManageSharedAccessKey aus.
Wählen Sie im Fenster Richtlinie: RootManageSharedAccessKey neben Primäre Verbindungszeichenfolge die Schaltfläche „Kopieren“ aus, um die Verbindungszeichenfolge zur späteren Verwendung in die Zwischenablage zu kopieren. Fügen Sie diesen Wert in den Editor oder an einem anderen temporären Speicherort ein.
Auf dieser Seite können Sie den Primärschlüssel, den sekundären Schlüssel, die primäre Verbindungszeichenfolge und die sekundäre Verbindungszeichenfolge kopieren.
Erstellen eines Themas mit dem Azure-Portal
Wählen Sie auf der Seite Service Bus-Namespace im linken Menü die Option Themen aus.
Wählen Sie auf der Symbolleiste die Option + Thema aus.
Geben Sie unter Name einen Namen für das Thema ein. Behalten Sie bei den anderen Optionen die Standardwerte bei.
Klicken Sie auf Erstellen.
Erstellen von Abonnements für das Thema
Wählen Sie das Thema aus, das Sie im vorherigen Abschnitt erstellt haben.
Wählen Sie auf der Seite Service Bus-Thema im linken Menü die Option Abonnements und anschließend auf der Symbolleiste die Option + Abonnement aus.
Führen Sie auf der Seite Abonnement erstellen die folgenden Schritte aus:
Geben Sie S1 für Name des Abonnements ein.
Wählen Sie dann Erstellen, um das Abonnement zu erstellen.
Wiederholen Sie den vorherigen Schritt zweimal, um die Abonnements mit den Namen S2 und S3 zu erstellen.
Erstellen von Filterregeln zu Abonnements
Nachdem der Namespace und das Thema bzw. die Abonnements bereitgestellt wurden und Sie über die Verbindungszeichenfolge zum Namespace verfügen, sind Sie zum Erstellen von Filterregeln für die Abonnements bereit und können dann Nachrichten senden und empfangen. Sie können sich den Code in diesem GitHub-Ordner mit Beispielen ansehen.
Senden und Empfangen von Nachrichten
Führen Sie die folgenden Schritte aus, um den Code auszuführen:
Klonen Sie in einem Eingabeaufforderungsfenster bzw. einer PowerShell-Eingabeaufforderung das Service Bus-GitHub-Repository, indem Sie den folgenden Befehl ausführen:
git clone https://github.com/Azure/azure-service-bus.gitNavigieren Sie zum Beispielordner
azure-service-bus\samples\DotNet\Azure.Messaging.ServiceBus\BasicSendReceiveTutorialWithFilters.Rufen Sie die Zeichenfolge ab, die Sie zuvor in diesem Tutorial in den Editor kopiert haben. Außerdem benötigen Sie den Namen des Themas, das Sie im vorherigen Abschnitt erstellt haben.
Geben Sie an der Eingabeaufforderung den folgenden Befehl ein:
dotnet buildNavigieren Sie zum Ordner
BasicSendReceiveTutorialWithFilters\bin\Debug\netcoreapp3.1.Geben Sie den folgenden Befehl ein, um das Programm auszuführen. Ersetzen Sie
myConnectionStringdurch den abgerufenen Wert undmyTopicNamedurch den Namen des von Ihnen erstellten Themas:dotnet --roll-forward Major BasicSendReceiveTutorialWithFilters.dll -ConnectionString "myConnectionString" -TopicName "myTopicName"Befolgen Sie die Anleitung in der Konsole, um zuerst die Filtererstellung auszuwählen. Ein Teil der Erstellung von Filtern ist das Entfernen der Standardfilter. Beim Verwenden von PowerShell oder der CLI müssen Sie den Standardfilter nicht entfernen. Dies ist nur erforderlich, wenn Sie die Erstellung per Code durchführen. Die Konsolenbefehle 1 und 3 dienen zum Verwalten der Filter für die Abonnements, die Sie zuvor erstellt haben:
Ausführung von Befehl 1: Standardfilter entfernen
Ausführung von Befehl 2: Eigene Filter hinzufügen
Ausführen 3: Überspringen Sie diesen Schritt für das Tutorial. Diese Option entfernt optional Ihre eigenen Filter. Die Standardfilter werden bei diesem Vorgang nicht neu erstellt.
Nach der Filtererstellung können Sie Nachrichten senden. Drücken Sie 4, und verfolgen Sie, wie zehn Nachrichten an das Thema gesendet werden:
Drücken Sie 5, und verfolgen Sie, wie die Nachrichten empfangen werden. Falls Sie nicht 10 Nachrichten zurückerhalten, können Sie durch Drücken von „m“ das Menü anzeigen und dann erneut 5 drücken.
Bereinigen von Ressourcen
Führen Sie die folgenden Schritte aus, um nicht mehr benötigte Ressourcen zu bereinigen.
- Navigieren Sie im Azure-Portal zu Ihrem Namespace.
- Wählen Sie auf der Seite Service Bus Namespace die Option Löschen auf der Befehlsleiste aus, um den Namespace und die Ressourcen (Warteschlangen, Themen und Abonnements) darin zu löschen.
Grundlagen des Beispielcodes
Dieser Abschnitt enthält weitere Details zur Funktionsweise des Beispielcodes.
Abrufen der Verbindungszeichenfolge und des Themas
Zuerst wird im Code ein Satz mit Variablen für die verbleibende Ausführung des Programms deklariert.
string ServiceBusConnectionString;
string TopicName;
static string[] Subscriptions = { "S1", "S2", "S3" };
static IDictionary<string, string[]> SubscriptionFilters = new Dictionary<string, string[]> {
{ "S1", new[] { "StoreId IN('Store1', 'Store2', 'Store3')", "StoreId = 'Store4'"} },
{ "S2", new[] { "sys.To IN ('Store5','Store6','Store7') OR StoreId = 'Store8'" } },
{ "S3", new[] { "sys.To NOT IN ('Store1','Store2','Store3','Store4','Store5','Store6','Store7','Store8') OR StoreId NOT IN ('Store1','Store2','Store3','Store4','Store5','Store6','Store7','Store8')" } }
};
// You can have only have one action per rule and this sample code supports only one action for the first filter, which is used to create the first rule.
static IDictionary<string, string> SubscriptionAction = new Dictionary<string, string> {
{ "S1", "" },
{ "S2", "" },
{ "S3", "SET sys.Label = 'SalesEvent'" }
};
static string[] Store = { "Store1", "Store2", "Store3", "Store4", "Store5", "Store6", "Store7", "Store8", "Store9", "Store10" };
static string SysField = "sys.To";
static string CustomField = "StoreId";
static int NrOfMessagesPerStore = 1; // Send at least 1.
Die Verbindungszeichenfolge und der Themenname werden wie gezeigt über Befehlszeilenparameter übergeben und dann in der Main()-Methode gelesen:
static void Main(string[] args)
{
string ServiceBusConnectionString = "";
string TopicName = "";
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-ConnectionString")
{
Console.WriteLine($"ConnectionString: {args[i + 1]}");
ServiceBusConnectionString = args[i + 1]; // Alternatively enter your connection string here.
}
else if (args[i] == "-TopicName")
{
Console.WriteLine($"TopicName: {args[i + 1]}");
TopicName = args[i + 1]; // Alternatively enter your queue name here.
}
}
if (ServiceBusConnectionString != "" && TopicName != "")
{
Program P = StartProgram(ServiceBusConnectionString, TopicName);
P.PresentMenu().GetAwaiter().GetResult();
}
else
{
Console.WriteLine("Specify -Connectionstring and -TopicName to execute the example.");
Console.ReadKey();
}
}
Entfernen von Standardfiltern
Wenn Sie ein Abonnement erstellen, erstellt Service Bus einen Standardfilter pro Abonnement. Dieser Filter ermöglicht den Empfang aller Nachrichten, die an das Thema gesendet werden. Falls Sie benutzerdefinierte Filter verwenden möchten, können Sie den Standardfilter entfernen, wie im folgenden Code gezeigt:
private async Task RemoveDefaultFilters()
{
Console.WriteLine($"Starting to remove default filters.");
try
{
var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
foreach (var subscription in Subscriptions)
{
await client.DeleteRuleAsync(TopicName, subscription, CreateRuleOptions.DefaultRuleName);
Console.WriteLine($"Default filter for {subscription} has been removed.");
}
Console.WriteLine("All default Rules have been removed.\n");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
await PresentMenu();
}
Erstellen von Filtern
Mit dem folgenden Code werden die in diesem Tutorial definierten benutzerdefinierten Filter hinzugefügt:
private async Task CreateCustomFilters()
{
try
{
for (int i = 0; i < Subscriptions.Length; i++)
{
var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
string[] filters = SubscriptionFilters[Subscriptions[i]];
if (filters[0] != "")
{
int count = 0;
foreach (var myFilter in filters)
{
count++;
string action = SubscriptionAction[Subscriptions[i]];
if (action != "")
{
await client.CreateRuleAsync(TopicName, Subscriptions[i], new CreateRuleOptions
{
Filter = new SqlRuleFilter(myFilter),
Action = new SqlRuleAction(action),
Name = $"MyRule{count}"
});
}
else
{
await client.CreateRuleAsync(TopicName, Subscriptions[i], new CreateRuleOptions
{
Filter = new SqlRuleFilter(myFilter),
Name = $"MyRule{count}"
});
}
}
}
Console.WriteLine($"Filters and actions for {Subscriptions[i]} have been created.");
}
Console.WriteLine("All filters and actions have been created.\n");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
await PresentMenu();
}
Entfernen Ihrer erstellten benutzerdefinierten Filter
Falls Sie alle Filter für Ihr Abonnement entfernen möchten, können Sie die Vorgehensweise dem folgenden Code entnehmen:
private async Task CleanUpCustomFilters()
{
foreach (var subscription in Subscriptions)
{
try
{
var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
IAsyncEnumerator<RuleProperties> rules = client.GetRulesAsync(TopicName, subscription).GetAsyncEnumerator();
while (await rules.MoveNextAsync())
{
await client.DeleteRuleAsync(TopicName, subscription, rules.Current.Name);
Console.WriteLine($"Rule {rules.Current.Name} has been removed.");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
Console.WriteLine("All default filters have been removed.\n");
await PresentMenu();
}
Senden von Nachrichten
Das Senden von Nachrichten an ein Thema ähnelt dem Senden von Nachrichten an eine Warteschlange. In diesem Beispiel wird veranschaulicht, wie Sie Nachrichten senden, indem Sie eine Aufgabenliste und die asynchrone Verarbeitung verwenden:
public async Task SendMessages()
{
try
{
await using var client = new ServiceBusClient(ServiceBusConnectionString);
var taskList = new List<Task>();
for (int i = 0; i < Store.Length; i++)
{
taskList.Add(SendItems(client, Store[i]));
}
await Task.WhenAll(taskList);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
Console.WriteLine("\nAll messages sent.\n");
}
private async Task SendItems(ServiceBusClient client, string store)
{
// create the sender
ServiceBusSender tc = client.CreateSender(TopicName);
for (int i = 0; i < NrOfMessagesPerStore; i++)
{
Random r = new Random();
Item item = new Item(r.Next(5), r.Next(5), r.Next(5));
// Note the extension class which is serializing an deserializing messages
ServiceBusMessage message = item.AsMessage();
message.To = store;
message.ApplicationProperties.Add("StoreId", store);
message.ApplicationProperties.Add("Price", item.GetPrice().ToString());
message.ApplicationProperties.Add("Color", item.GetColor());
message.ApplicationProperties.Add("Category", item.GetItemCategory());
await tc.SendMessageAsync(message);
Console.WriteLine($"Sent item to Store {store}. Price={item.GetPrice()}, Color={item.GetColor()}, Category={item.GetItemCategory()}"); ;
}
}
Empfangen von Nachrichten
Die Nachrichten werden wieder über eine Aufgabenliste empfangen, und im Code wird die Batchverarbeitung verwendet. Sie können das Senden und Empfangen per Batchverarbeitung durchführen, aber in diesem Beispiel wird dies nur für den Empfangsvorgang gezeigt. In einem realen Fall würden Sie die Schleife nicht unterbrechen, sondern fortführen und einen längeren Zeitraum festlegen, z. B. eine Minute. Der Empfangsaufruf für den Broker wird für diesen Zeitraum offen gehalten. Wenn Nachrichten eingehen, werden sie sofort zurückgegeben, und es wird ein neuer Aufruf durchgeführt. Dieses Konzept wird als Long Polling (langes Abrufintervall) bezeichnet. Die Verwendung des „Empfangspump“-Vorgangs, der in der Schnellstartanleitung und in verschiedenen anderen Beispielen im Repository beschrieben wird, ist eine gängigere Option.
public async Task Receive()
{
var taskList = new List<Task>();
for (var i = 0; i < Subscriptions.Length; i++)
{
taskList.Add(this.ReceiveMessages(Subscriptions[i]));
}
await Task.WhenAll(taskList);
}
private async Task ReceiveMessages(string subscription)
{
await using var client = new ServiceBusClient(ServiceBusConnectionString);
ServiceBusReceiver receiver = client.CreateReceiver(TopicName, subscription);
// In reality you would not break out of the loop like in this example but would keep looping. The receiver keeps the connection open
// to the broker for the specified amount of seconds and the broker returns messages as soon as they arrive. The client then initiates
// a new connection. So in reality you would not want to break out of the loop.
// Also note that the code shows how to batch receive, which you would do for performance reasons. For convenience you can also always
// use the regular receive pump which we show in our Quick Start and in other GitHub samples.
while (true)
{
try
{
//IList<Message> messages = await receiver.ReceiveAsync(10, TimeSpan.FromSeconds(2));
// Note the extension class which is serializing an deserializing messages and testing messages is null or 0.
// If you think you did not receive all messages, just press M and receive again via the menu.
IReadOnlyList<ServiceBusReceivedMessage> messages = await receiver.ReceiveMessagesAsync(maxMessages: 100);
if (messages.Any())
{
foreach (ServiceBusReceivedMessage message in messages)
{
lock (Console.Out)
{
Item item = message.As<Item>();
IReadOnlyDictionary<string, object> myApplicationProperties = message.ApplicationProperties;
Console.WriteLine($"StoreId={myApplicationProperties["StoreId"]}");
if (message.Subject != null)
{
Console.WriteLine($"Subject={message.Subject}");
}
Console.WriteLine(
$"Item data: Price={item.GetPrice()}, Color={item.GetColor()}, Category={item.GetItemCategory()}");
}
await receiver.CompleteMessageAsync(message);
}
}
else
{
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
Hinweis
Sie können Service Bus-Ressourcen mit dem Service Bus-Explorer verwalten. Mit dem Service Bus-Explorer können Benutzer eine Verbindung mit einem Service Bus-Namespace herstellen und Messagingentitäten auf einfache Weise verwalten. Das Tool stellt erweiterte Features wie Import-/Exportfunktionen oder Testmöglichkeiten für Themen, Warteschlangen, Abonnements, Relaydienste, Notification Hubs und Event Hubs zur Verfügung.
Nächste Schritte
In diesem Tutorial haben Sie mit dem Azure-Portal Ressourcen bereitgestellt und anschließend Nachrichten für ein Service Bus-Thema und die dazugehörigen Abonnements gesendet und empfangen. Sie haben Folgendes gelernt:
- Erstellen eines Service Bus-Themas und eines oder mehrerer Abonnements für das Thema mit dem Azure-Portal
- Hinzufügen von Themenfiltern per .NET-Code
- Erstellen von zwei Nachrichten mit unterschiedlichem Inhalt
- Senden der Nachrichten und Überprüfen des Eingangs in den entsprechenden Abonnements
- Empfangen von Nachrichten aus den Abonnements
Falls Sie sich weitere Beispiele für das Senden und Empfangen von Nachrichten ansehen möchten, sind die Service Bus-Beispiele auf GitHub ein guter Einstieg.
Fahren Sie mit dem nächsten Tutorial fort, um weitere Informationen zur Verwendung der Veröffentlichen/Abonnieren-Funktionen von Service Bus zu erhalten.