Zelfstudie: voorraad bijwerken met Azure Portal en onderwerpen/abonnementen

Deze zelfstudie laat zien hoe u Service Bus-onderwerpen en -abonnementen gebruikt in een retailinventarisscenario. Het omvat het publiceren/abonneren van kanalen met behulp van Azure Portal en .NET. Een voorbeeld van dit scenario is het bijwerken van het voorraadassortiment voor meerdere winkels. In dit scenario ontvangt elke winkel of reeks winkels berichten op basis waarvan ze hun assortiment kunnen bijwerken.

Azure Service Bus is een berichtenservice voor meerdere tenants in de cloud waarmee informatie tussen toepassingen en services wordt verzonden. Asynchrone bewerkingen bieden flexibele, Brokered Messaging, samen met gestructureerde FIFO-berichtenuitwisseling (first in, first out) en mogelijkheden voor publiceren/abonneren. Raadpleeg Wat is Service Bus? voor een overzicht.

Deze zelfstudie laat zien hoe dit scenario met behulp van abonnementen en filters kan worden geïmplementeerd. Eerst maakt u een onderwerp met drie abonnementen, voegt u enkele regels en filters toe en verzendt en ontvangt u vervolgens berichten van het onderwerp en abonnementen.

In deze zelfstudie leert u het volgende:

Vereisten

Het volgende moet zijn geïnstalleerd om deze zelfstudie te voltooien:

• Een Azure-abonnement. Als u Azure-services, waaronder Azure Service Bus, wilt gebruiken, hebt u een abonnement nodig. U kunt een gratis account maken voordat u begint.
• Visual Studio 2019 of hoger.

Service Bus-onderwerpen en -abonnementen

Elk abonnement op een onderwerp kan een kopie van elk bericht ontvangen. Onderwerpen zijn qua protocol en semantiek volledig compatibel met Service Bus-wachtrijen. Service Bus-onderwerpen ondersteunen een breed scala aan selectieregels met filtervoorwaarden, met optionele acties waarmee berichteigenschappen worden ingesteld of gewijzigd. Telkens wanneer een regel overeenkomt, wordt er een bericht gegenereerd. Zie Onderwerpfilters en -acties voor meer informatie over regels, filters en acties.

Een naamruimte in de Azure-portal maken

Als u Service Bus-berichtenentiteiten in Azure wilt gaan gebruiken, maakt u een naamruimte met een naam die uniek is in Azure. Een naamruimte biedt een bereikcontainer voor Service Bus-resources, zoals wachtrijen en onderwerpen, in uw toepassing.

Ga als volgt te werk om een naamruimte te maken:

1. Meld u aan bij het Azure-portaal.

2. Selecteer het flyoutmenu linksboven en navigeer naar de pagina Alle services.

3. Selecteer Integratie in de linkernavigatiebalk.

4. Scroll naar beneden naar Berichtendiensten>Service Bus en selecteer Maken.

   

5. Voer op het tabblad Basis van de pagina Naamruimte maken de volgende stappen uit:

   1. Kies voor Abonnement een Azure-abonnement waarin u de naamruimte maakt.

   2. Kies voor resourcegroep een bestaande resourcegroep of maak een nieuwe.

   3. Voer een naamruimtenaam in die voldoet aan de volgende naamconventies:

      • De naam moet uniek zijn in Azure. In het systeem wordt onmiddellijk gecontroleerd of de naam beschikbaar is.
      • De naamlengte is ten minste 6 en maximaal 50 tekens.
      • De naam mag alleen letters, cijfers, afbreekstreepjes -bevatten.
      • De naam moet beginnen met een letter en eindigen op een letter of cijfer.
      • De naam eindigt niet op -sb of -mgmt.

   4. Kies voor Locatie de regio voor het hosten van uw naamruimte.

   5. Selecteer voor de prijscategorie de prijscategorie (Basic, Standard of Premium) voor de naamruimte. Voor deze quickstart selecteert u Standard.

      Als u de Premium-laag selecteert, kunt u geo-replicatie inschakelen voor de naamruimte. De functie voor geo-replicatie zorgt ervoor dat de metagegevens en gegevens van een naamruimte continu worden gerepliceerd van een primaire regio naar een of meer secundaire regio's.

      Belangrijk

      Kies Standard of Premium indien u gebruik wilt maken van onderwerpen en abonnementen. Onderwerpen en abonnementen worden niet ondersteund in de prijscategorie Basic.

      Als u de Prijscategorie Premium hebt geselecteerd, geeft u het aantal berichteneenheden op. De Premium-prijscategorie biedt isolatie van resources op het niveau van de CPU en het geheugen, zodat elke workload geïsoleerd wordt uitgevoerd. Deze resourcecontainer wordt een Messaging-eenheid genoemd. Een Premium-naamruimte heeft ten minste één Messaging-eenheid. U kunt 1, 2, 4, 8 of 16 berichteneenheden selecteren voor elke Service Bus Premium-naamruimte. Zie de Service Bus Premium Messaging-laag voor meer informatie.

   6. Selecteer Controleren en maken onderaan de pagina.

      

   7. Controleer de instellingen op de pagina Beoordelen en maken en selecteer Maken.

6. Nadat de implementatie van de resource is geslaagd, selecteert u Ga naar de resource op de implementatiepagina.

   

7. U ziet de startpagina voor uw Service Bus-naamruimte.

   

Verbindingsreeks naar de naamruimte (Azure Portal)

Als u een nieuwe naamruimte maakt, wordt automatisch een eerste SAS-beleid (Shared Access Signature) gegenereerd. Het beleid bevat primaire en secundaire sleutels en primaire en secundaire verbindingsreeksen die elk volledige controle verlenen over alle aspecten van de naamruimte. Zie Service Bus-verificatie en -autorisatie voor meer informatie over het maken van regels met meer beperkte rechten voor reguliere afzenders en ontvangers.

Een client kan de verbindingsreeks gebruiken om verbinding te maken met de Service Bus-naamruimte. Voer de volgende stappen uit om de primaire verbindingsreeks voor uw naamruimte te kopiëren:

1. Vouw instellingen uit op de pagina Service Bus-naamruimte en selecteer beleid voor gedeelde toegang.

2. Selecteer RootManageSharedAccessKey op de pagina Beleid voor gedeelde toegang.

3. Selecteer in het venster SAS-beleid: RootManageSharedAccessKey de kopieerknop naast primaire verbindingsreeks. Met deze actie kopieert u de verbindingsreeks naar het Klembord voor later gebruik. Plak deze waarde in Kladblok of een andere tijdelijke locatie.

   

   U kunt deze pagina gebruiken om de primaire sleutel, secundaire sleutel, primaire verbindingsreeks en secundaire verbindingsreeks te kopiëren.

Een onderwerp maken met de Azure-portal

1. Vouw op de pagina Service Bus-naamruimteentiteiten uit in het navigatiemenu aan de linkerkant en selecteer Onderwerpen.

2. Selecteer + Onderwerp.

3. Voer een naam in voor het onderwerp. Houd voor de overige opties de standaardwaarden aan.

4. Selecteer Maken.

   

Abonnementen op het onderwerp maken

1. Selecteer het onderwerp dat u in de vorige sectie hebt gemaakt.

   

2. Selecteer + Abonnement op de pagina Service Bus-onderwerp.

   

3. Voer op de pagina Abonnement maken de volgende stappen uit:

   1. Voer S1 in als de naam van het abonnement.

   2. Selecteer vervolgens Maken om het abonnement te maken.

      

4. Herhaal de vorige stap tweemaal om abonnementen met de naam S2 en S3 te maken.

Filterregels voor abonnementen maken

Nadat u de naamruimte, onderwerpen en abonnementen hebt ingericht en de verbindingsreeks voor de naamruimte hebt opgehaald, kunt u filterregels voor de abonnementen maken. Daarna kunt u berichten verzenden en ontvangen. U kunt de code in deze GitHub-voorbeeldmap controleren.

Berichten verzenden en ontvangen

Voer de volgende stappen uit om de code uit te voeren:

1. Kloon in een opdrachtpromptvenster of bij een PowerShell-prompt de Service Bus GitHub-opslagplaats:

   git clone https://github.com/Azure/azure-service-bus.git
   

2. Navigeer naar de voorbeeldmap azure-service-bus\samples\DotNet\Azure.Messaging.ServiceBus\BasicSendReceiveTutorialWithFilters.

3. Haal de verbindingsreeks op die je eerder in deze handleiding naar Kladblok hebt gekopieerd. U hebt ook de naam nodig van het onderwerp dat u hebt gemaakt.

4. Typ de volgende opdracht bij de opdrachtprompt:

   dotnet build
   

5. Navigeer naar de map BasicSendReceiveTutorialWithFilters\bin\Debug\netcoreapp3.1.

6. Voer de volgende opdracht in om het programma uit te voeren. Zorg ervoor dat u myConnectionString vervangt door uw waarde en myTopicName door de naam van het onderwerp dat u hebt gemaakt:

   dotnet --roll-forward Major BasicSendReceiveTutorialWithFilters.dll -ConnectionString "myConnectionString" -TopicName "myTopicName"
   

7. Volg de instructies in de console om eerst filters te maken. Een onderdeel van het maken van filters is het verwijderen van de standaardfilters. Wanneer u PowerShell of CLI gebruikt, hoeft u het standaardfilter niet te verwijderen. Als u code gebruikt om filters te maken, verwijdert u eerst het standaardfilter. De consoleopdrachten 1 en 3 helpen bij het beheren van de filters voor de abonnementen die u eerder hebt gemaakt:

   • Voer 1: uit om de standaardfilters te verwijderen.
   • Voer 2: uit om uw eigen filters toe te voegen.
   • Voer 3 uit: Sla deze stap over voor de zelfstudie. Met deze optie kunt u eventueel uw eigen filters verwijderen. De standaardfilters worden niet opnieuw gemaakt.

   

8. Nadat de filters zijn gemaakt, kunt u berichten verzenden. Druk op 4 en u ziet dat er 10 berichten naar het onderwerp worden verzonden:

   

9. Druk op 5 en u ziet dat er berichten binnenkomen. Als u geen 10 berichten terug hebt ontvangen, drukt u op 'm' om het menu weer te geven en drukt u nogmaals op 5.

   

Resources opschonen

Wanneer u deze stappen niet meer nodig hebt, volgt u deze stappen om resources op te schonen.

1. Navigeer naar uw naamruimte in Azure Portal.
2. Selecteer op de pagina Service Bus-naamruimte Verwijderen in de opdrachtbalk om de naamruimte en resources (wachtrijen, onderwerpen en abonnementen) erin te verwijderen.

De voorbeeldcode begrijpen

Deze sectie bevat meer informatie over de werking van de voorbeeldcode.

Verbindingsreeks en onderwerp ophalen

De code declareert eerst een set variabelen die de uitvoering van de rest van het programma bepalen.

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.

De verbindingsreeks en onderwerpnaam worden doorgegeven met behulp van opdrachtregelparameters, zoals wordt weergegeven. Ze worden gelezen in de Main() methode:

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

Standaardfilters verwijderen

Wanneer u een abonnement maakt, maakt Service Bus een standaardfilter per abonnement. Dit filter maakt het mogelijk om elk bericht te ontvangen dat naar het onderwerp wordt verzonden. Als u aangepaste filters wilt gebruiken, kunt u het standaardfilter verwijderen, zoals wordt weergegeven in de volgende code:

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

Filters maken

Met de volgende code worden de aangepaste filters toegevoegd die zijn gedefinieerd in deze zelfstudie:

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

Uw aangepaste filters verwijderen

Als u alle filters uit uw abonnement wilt verwijderen, kunt u in de volgende code zien hoe u dat doet:

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

Berichten verzenden

Het verzenden van berichten naar een onderwerp is vergelijkbaar met het verzenden van berichten naar een wachtrij. Dit voorbeeld laat zien hoe u berichten kunt verzenden met behulp van een takenlijst en asynchrone verwerking:

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

Berichten ontvangen

Berichten worden opnieuw ontvangen met behulp van een takenlijst en de code maakt gebruik van batchverwerking. U kunt verzenden en ontvangen met behulp van batchverwerking, maar in dit voorbeeld wordt alleen ontvangen gedemonstreerd. In werkelijkheid zou u niet uit de lus breken, maar herhalen en een hogere tijdsduur instellen, zoals één minuut. De ontvangstoproep van de broker wordt gedurende deze tijd geopend gehouden. Als berichten binnenkomen, worden ze onmiddellijk geretourneerd. Er wordt een nieuwe ontvangstoproep uitgegeven.

Dit concept wordt long polling genoemd. Het gebruik van de ontvangstpomp, die u in verschillende voorbeelden in de repository kunt zien, is een gebruikelijkere optie. Zie Azure Portal gebruiken om een Service Bus-naamruimte en een wachtrij te maken voor meer informatie.

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

Verwante inhoud

In deze zelfstudie hebt u resources ingericht met behulp van Azure Portal en vervolgens berichten verzonden en ontvangen van een Service Bus-onderwerp en de daarbij behorende abonnementen. U hebt geleerd hoe u:

Zie Service Bus-voorbeelden op GitHub voor meer voorbeelden van het verzenden en ontvangen van berichten.

Ga naar de volgende zelfstudie voor meer informatie over het gebruik van de mogelijkheden voor publiceren/abonneren van Service Bus.