.NET-flernivåapp med hjälp av Azure Service Bus-köer

Artikel
12/06/2023

Att utveckla för Microsoft Azure är enkelt tack vare Visual Studio och det kostnadsfria utvecklingsverktyget Azure SDK för .NET. Den här självstudiekursen vägleder dig igenom stegen för att skapa en app som använder flera Azure-resurser som körs i din lokala miljö.

Du får lära dig följande:

Hur du förbereder datorn för Azure-utveckling med en enda nedladdning och installation.
Hur du använder Visual Studio för att utveckla för Azure.
Hur du skapar en flernivåapp i Azure genom att använda webb- och arbetsroller.
Hur du kan kommunicera mellan nivåer med hjälp av Service Bus-köer.

Kommentar

Du behöver ett Azure-konto för att slutföra den här självstudien. Du kan aktivera dina MSDN-prenumerationsfördelar eller registrera dig för ett kostnadsfritt konto.

I den här självstudien ska du skapa och köra flernivåprogrammet i en Azure-molntjänst. Klientdelen är en ASP.NET MVC-webbroll och serverdelen en arbetsroll som använder en Service Bus-kö. Du kan skapa samma flernivåapp med klientdelen som ett webbprojekt som distribueras till en Azure-webbplats i stället för till en molntjänst. Du kan också prova att gå igenom självstudiekursen .NET-hybridapp lokalt/i molnet.

Följande skärmbild visar det slutförda programmet.

Application's Submit page

Scenarioöversikt: kommunikation mellan roller

Om du vill skicka in en order för bearbetning måste klientdelens UI-komponent, som kör webbrollen, interagera med den mellannivålogik som kör arbetsrollen. I det här exemplet används en meddelandetjänst via Service Bus för kommunikation mellan nivåerna.

Genom att använda en meddelandetjänst mellan webben och mellannivåerna frikopplas de båda komponenterna. Till skillnad från direktmeddelanden (t.ex. TCP eller HTTP) ansluter inte webbnivån direkt till mellannivån. I stället push-överför den arbetsenheter, som meddelanden, till Service Bus, som på ett tillförlitligt sätt behåller dem tills mellannivån är redo att använda och bearbeta dem.

Service Bus innehåller två entiteter för att stödja den asynkrona meddelandetjänsten: köer och ämnen. När man använder köer förbrukas varje meddelande som skickas till kön av en enda mottagare. Ämnena stödjer det mönster för publicera/prenumerera där varje publicerat meddelande görs tillgängligt för en prenumeration som har registrerats med ämnet. Varje prenumeration underhåller logiskt nog sin egen meddelandekö. Prenumerationer kan också konfigureras med filterregler som begränsar den uppsättning av meddelanden som skickas vidare till prenumerationskön till dem som matchar filtret. I följande exempel används Service Bus-köer.

Diagram showing the communication between the Web Role, Service Bus, and the Worker Role.

Denna kommunikationsmekanism har flera fördelar jämfört med funktioner för direkta meddelanden:

Tidsbestämd frikoppling. När du använder det asynkrona meddelandemönstret behöver producenter och konsumenter inte vara online samtidigt. Service Bus lagrar meddelanden på ett säkert sätt tills den konsumerande parten är redo att ta emot dem. Detta gör att komponenterna i den distribuerade appen kan frikopplas, antingen frivilligt, till exempel för underhåll, eller på grund av en komponentkrasch, utan att detta påverkar hela systemet. Dessutom behöver den konsumerande appen endast kopplas upp och vara online under vissa tider på dagen.
Belastningsutjämning. I många program varierar systembelastningen beroende på tidpunkten, medan den bearbetningstid som krävs för varje arbetsenhet vanligtvis är konstant. Medlingen mellan meddelandeproducenter och -konsumenter med hjälp av en kö innebär att den konsumerande appen (arbetaren) endast måste konfigureras för att kunna hantera en genomsnittlig belastning i stället för mycket hög belastning vid vissa tider. Köns djup växer och dras samman allt eftersom den inkommande belastningen varierar. Detta sparar direkt pengar eftersom den mängd infrastruktur som krävs för att underhålla programbelastningen blir mindre.
Belastningsutjämning. Allt eftersom belastningen ökar kan fler arbetsprocesser läggas till för att läsa från kön. Varje meddelande bearbetas bara av en av arbetsprocesserna. Dessutom möjliggör den här pull-baserade belastningsutjämningen optimal användning av arbetsdatorerna även om arbetsdatorerna skiljer sig åt när det gäller bearbetningskraft, eftersom de hämtar meddelanden med sin egen högsta hastighet. Det här mönstret kallas ofta för ett konkurrerande konsument-mönster.

I följande avsnitt pratar vi om den kod som implementerar denna arkitektur.

Förutsättningar

I den här självstudien använder du Microsoft Entra-autentisering för att skapa ServiceBusClient och ServiceBusAdministrationClient objekt. Du kommer också att använda DefaultAzureCredential och för att använda det måste du göra följande steg för att testa programmet lokalt i en utvecklingsmiljö.

Registrera ett program i Microsoft Entra-ID:t.
Lägg till programmet i Service Bus Data Owner rollen.
AZURE-CLIENT-IDAnge miljövariablerna , AZURE-TENANT-ID, OCHAZURE-CLIENT-SECRET. Anvisningar finns i den här artikeln.

En lista över inbyggda Roller i Service Bus finns i Inbyggda Azure-roller för Service Bus.

Skapa ett namnområde

Det första steget är att skapa ett namnområde och hämta en SAS-nyckel (Signatur för delad åtkomst) för namnområdet. Ett namnområde ger en appgräns för varje app som exponeras via Service Bus. SAS-nyckeln genereras av systemet när ett namnområde har skapats. Kombinationen av namnet på namnområdet och SAS-nyckeln tillhandahåller autentiseringsuppgifterna för Service Bus som används för att tillåta åtkomst till ett program.

Skapa ett namnområde i Azure Portal

För att komma igång med Service Bus-meddelandeentiteter i Azure måste du först skapa ett namnområde med ett namn som är unikt i Azure. Ett namnområde tillhandahåller en omfångscontainer för Service Bus-resurser (köer, ämnen osv.) i ditt program.

Så här skapar du ett namnområde:

Logga in på Azure-portalen.
Gå till sidan Alla tjänster.
I det vänstra navigeringsfältet väljer du Integrering i listan över kategorier, hovra musen över Service Bus och välj + sedan knappen på Service Bus-panelen.
Följ dessa steg i taggen Grundläggande på sidan Skapa namnområde:
1. För Prenumeration väljer du en Azure-prenumeration där du ska skapa namnrymden.
2. För Resursgrupp väljer du en befintlig resursgrupp där namnrymden ska finnas, eller så skapar du en ny.
3. Ange ett namn för namnrymden. Namnområdesnamnet bör följa följande namngivningskonventioner:
  - Namnet måste vara unikt i Hela Azure. Systemet kontrollerar omedelbart om namnet är tillgängligt.
  - Namnlängden är minst 6 och högst 50 tecken.
  - Namnet får endast innehålla bokstäver, siffror, bindestreck "-".
  - Namnet måste börja med en bokstav och sluta med en bokstav eller siffra.
  - Namnet slutar inte med "-sb" eller "-mgmt".
4. För Plats väljer du land eller region där namnrymden ska finnas.
5. För Prisnivå väljer du prisnivån (Basic, Standard eller Premium) för namnområdet. För den här snabbstarten väljer du Standard.
  
  Viktigt!
  
  Om du vill använda ämnen och prenumerationer väljer du antingen Standard eller Premium. Ämnen/prenumerationer stöds inte på prisnivån Basic.
  
  Om du har valt prisnivån Premium anger du antalet meddelandeenheter. Premium-nivån ger resursisolering på processor- och minnesnivå så att varje arbetsbelastning körs självständigt. Den här resurscontainern kallas för en meddelandefunktionsenhet. Ett premiumnamnområde har minst en meddelandeenhet. Du kan välja 1, 2, 4, 8 eller 16 meddelandeenheter för varje Service Bus Premium-namnområde. Mer information finns i Service Bus Premium-meddelanden.
6. Välj Granska + skapa längst ned på sidan.
7. På sidan Granska + skapa granskar du inställningarna och väljer Skapa.
När distributionen av resursen har slutförts väljer du Gå till resurs på distributionssidan.
Startsidan för din Service Bus-namnrymd visas.

Hämta anslutningssträng till namnområdet (Azure-portalen)

När du skapar ett nytt namnområde genereras automatiskt en inledande SAS-princip (Signatur för delad åtkomst) med primära och sekundära nycklar och primära och sekundära anslutningssträng som var och en ger fullständig kontroll över alla aspekter av namnområdet. Se Service Bus – autentisering och auktorisering för mer information om hur du skapar regler med mer begränsade rättigheter för regelbundna sändare och mottagare.

En klient kan använda anslutningssträng för att ansluta till Service Bus-namnområdet. Så här kopierar du den primära anslutningssträng för ditt namnområde:

På sidan Service Bus-namnområde väljer du Principer för delad åtkomst på den vänstra menyn.
På sidan Principer för delad åtkomst väljer du RootManageSharedAccessKey.
I fönstret Princip: RootManageSharedAccessKey väljer du kopieringsknappen bredvid Primär Anslut ionssträng för att kopiera anslutningssträng till Urklipp för senare användning. Klistra in det här värdet i Anteckningar eller på en tillfällig plats.

Du kan använda den här sidan för att kopiera primärnyckel, sekundär nyckel, primär anslutningssträng och sekundär anslutningssträng.

Skapa en webbroll

I det här avsnittet ska du skapa klientdelen för din app. Först skapar du de sidor som din app visar. Efter det lägger du till kod som skickar objekt till en Service Bus-kö och visar statusinformation om denna kö.

Skapa projektet

Starta Visual Studio med administratörsbehörighet: högerklicka på Visual Studio-programikonen och välj sedan Kör som administratör. Azure Compute-emulatorn, som beskrivs senare i den här artikeln, kräver att Visual Studio startas med administratörsbehörighet.

I Visual Studio går du till File-menyn (Arkiv-menyn) och väljer New (Nytt). Välj sedan Project (Projekt).
Följ dessa steg på sidan Mallar :
1. Välj C# för programmeringsspråk.
2. Välj Moln som projekttyp.
3. Välj Azure Cloud Service.
4. Välj Nästa.
Ge projektet namnet MultiTierApp, välj plats för projektet och välj sedan Skapa.
På sidan Roller dubbelklickar du på ASP.NET webbroll och väljer OK.
Hovra över WebRole1 under Azure Cloud Service-lösningen, välj pennikonen och byt namn på webbrollen till FrontendWebRole. Välj sedan OK. (Kontrollera att du anger ”Frontend” med ett litet ”e”, det vill säga, inte ”FrontEnd”).
I dialogrutan Skapa ett nytt ASP.NET webbprogram väljer du MVC och sedan Skapa.
Högerklicka på Referenser i Projektet FrontendWebRole i Solution Explorer och välj sedan Hantera NuGet-paket.
Välj fliken Bläddra och sök sedan efter Azure.Messaging.ServiceBus. Välj paketet Azure.Messaging.ServiceBus, välj Installera och godkänn användningsvillkoren.

Observera att de obligatoriska klientsammansättningarna nu refereras och vissa nya kodfiler har lagts till.
Följ samma steg för att lägga till Azure.Identity NuGet-paketet i projektet.
I Solution Explorer expanderar du FronendWebRole, högerklickar på Modeller och väljer Lägg till och väljer sedan Klass. I rutan Namn anger du namnet OnlineOrder.cs. Välj Lägg till.

Skriva koden för webbrollen

I detta avsnitt ska du skapa de olika sidor som din app visar.

Ersätt den befintliga definitionen för namnområdet med följande kod i filen OnlineOrder.cs i Visual Studio:

namespace FrontendWebRole.Models
{
    public class OnlineOrder
    {
        public string Customer { get; set; }
        public string Product { get; set; }
    }
}

I Solution Explorer dubbelklickar du på Controllers\HomeController.cs. Lägg till följande using-uttryck högst upp i filen för att inkludera namnområdena för den modell som du precis har skapat, samt Service Bus.
```
 using FrontendWebRole.Models;
 using Azure.Messaging.ServiceBus;    
```

Ersätt även den befintliga definitionen för namnområdet med följande kod i filen HomeController.cs i Visual Studio. Den här koden innehåller metoder för att hantera överföring av objekt till kön.

namespace FrontendWebRole.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            // Simply redirect to Submit, since Submit will serve as the
            // front page of this application.
            return RedirectToAction("Submit");
        }

        public ActionResult About()
        {
            return View();
        }

        // GET: /Home/Submit.
        // Controller method for a view you will create for the submission
        // form.
        public ActionResult Submit()
        {
            // Will put code for displaying queue message count here.

            return View();
        }

        // POST: /Home/Submit.
        // Controller method for handling submissions from the submission
        // form.
        [HttpPost]
        // Attribute to help prevent cross-site scripting attacks and
        // cross-site request forgery.  
        [ValidateAntiForgeryToken]
        public ActionResult Submit(OnlineOrder order)
        {
            if (ModelState.IsValid)
            {
                // Will put code for submitting to queue here.

                return RedirectToAction("Submit");
            }
            else
            {
                return View(order);
            }
        }
    }
}

På menyn Skapa väljer du Skapa lösning för att testa noggrannheten i ditt arbete hittills.
Nu ska du skapa vyn för den Submit()-metod som du skapade tidigare. Högerklicka i Submit() metoden (överlagringen av Submit() som inte tar några parametrar) i filen HomeController.cs och välj sedan Lägg till vy.
I dialogrutan Lägg till nytt autogenererat objekt väljer du Lägg till.
Gör följande i dialogrutan Lägg till vy:
1. Välj Skapa i listan Mall.
2. Välj klassen OnlineOrder i listan Modellklass.
3. Markera Lägga till.
Nu ska du ändra visningsnamnet för din app. Dubbelklicka på filen Views\Shared\_Layout.cshtml i Solution Explorer för att öppna den i Visual Studio-redigeraren.
Ersätt alla förekomster av My ASP.NET Application med Northwind Traders Products.
Ta bort länkarna för Start, Om och Kontakt. Ta bort den markerade koden:
Slutligen ändrar du överföringssidan för att inkludera information om kön. Dubbelklicka på filen Views\Home\Submit.cshtml i Solution Explorer för att öppna den i Visual Studio-redigeraren. Lägg till följande rad efter <h2>Submit</h2>. Just nu är ViewBag.MessageCount tom. Du fyller i den senare.
```
<p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
```
Du har nu implementerat ditt användargränssnitt (UI). Du kan trycka på F5 för att köra programmet och bekräfta att det ser ut som du förväntar dig att det ska göra.

Skriva koden för att skicka objekt till en Service Bus-kö

Nu ska du lägga till kod för att skicka objekt till en kö. Först måste du skapa en klass som innehåller anslutningsinformation för Service Bus-kön. Sedan initierar du anslutningen från Global.aspx.cs. Slutligen uppdaterar du den överföringskod som du skapade tidigare i HomeController.cs för att den faktiskt ska skicka objekt till en Service Bus-kö.

Högerklicka på FrontendWebRole (högerklicka på projektet, inte på rollen) i Solution Explorer. Välj Lägg till och välj sedan Klass.
Ge klassen namnet QueueConnector.cs. Välj Lägg till för att skapa klassen.

Lägg nu till kod som innehåller anslutningsinformationen och initierar anslutningen till en Service Bus-kö. Ersätt hela innehållet i QueueConnector.cs med följande kod och ange värden för your Service Bus namespace (namnet på ditt namnområde) och yourKey, som är den primärnyckel som du tidigare hämtade från Azure Portal.

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Threading.Tasks;
 using Azure.Messaging.ServiceBus;
 using Azure.Messaging.ServiceBus.Administration;

namespace FrontendWebRole
{
     public static class QueueConnector
     {
         // object to send messages to a Service Bus queue
         internal static ServiceBusSender SBSender;

         // object to create a queue and get runtime properties (like message count) of queue
         internal static ServiceBusAdministrationClient SBAdminClient;

         // Fully qualified Service Bus namespace
         private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";

         // The name of your queue.
         internal const string QueueName = "OrdersQueue";

         public static async Task Initialize()
         {
             // Create a Service Bus client that you can use to send or receive messages
             ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());

             // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
             SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());

             // create the OrdersQueue if it doesn't exist already
             if (!(await SBAdminClient.QueueExistsAsync(QueueName)))
             {
                 await SBAdminClient.CreateQueueAsync(QueueName);
             }

             // create a sender for the queue 
             SBSender = SBClient.CreateSender(QueueName);    
         }
     }    
}

Se nu till att din initiera-metod anropas. Dubbelklicka på Global.asax\Global.asax.cs i Solution Explorer.
Lägg till följande kodrad i slutet av metoden Application_Start.
```
 FrontendWebRole.QueueConnector.Initialize().Wait();
```
Slutligen uppdaterar du den webbkod som du skapade tidigare, för att på så sätt skicka objekt till kön. I Solution Explorer dubbelklickar du på Controllers\HomeController.cs.

Uppdatera metoden Submit() (överlagring som inte tar några parametrar) enligt följande anvisningar för att hämta meddelanderäknaren för kön.

     public ActionResult Submit()
     {
         QueueRuntimeProperties properties = QueueConnector.adminClient.GetQueueRuntimePropertiesAsync(QueueConnector.queueName).Result;
         ViewBag.MessageCount = properties.ActiveMessageCount;

         return View();
     }

Uppdatera metoden Submit(OnlineOrder order) (överlagring som inte tar några parametrar) enligt följande anvisningar för att skicka orderinformation till kön.

     public ActionResult Submit(OnlineOrder order)
     {
         if (ModelState.IsValid)
         {
             // create a message 
             var message = new ServiceBusMessage(new BinaryData(order));

             // send the message to the queue
             QueueConnector.sbSender.SendMessageAsync(message);

             return RedirectToAction("Submit");
         }
         else
         {
             return View(order);
         }
     }

Du kan nu köra appen igen. Varje gång du skickar en order, ökar antalet meddelanden.

Skapa arbetsrollen

Nu ska du skapa arbetsrollen som bearbetar orderöverföringarna. I det här exemplet använder vi den projektmall för Visual Studio som heter Arbetsroll med Service Bus-kö. Du har redan fått de autentiseringsuppgifter som krävs från portalen.

Kontrollera att du har anslutit Visual Studio till ditt Azure-konto.
Högerklicka på Roller i Visual Studio, i Solution Explorer, under projektet MultiTierApp.
Välj Lägg till och välj sedan Nytt arbetsrollprojekt. Dialogrutan Lägg till nytt rollprojekt visas.
I dialogrutan Lägg till nytt rollprojekt väljer du Arbetsroll. Välj inte Arbetsroll med Service Bus-kö eftersom den genererar kod som använder den äldre Service Bus SDK:t.
Ge projektet namnet OrderProcessingRole i rutan Namn. Välj Lägg till.
I Solution Explorer högerklickar du på Projektet OrderProcessingRole och väljer Hantera NuGet-paket.
Välj fliken Bläddra och sök sedan efter Azure.Messaging.ServiceBus. Välj paketet Azure.Messaging.ServiceBus, välj Installera och godkänn användningsvillkoren.
Följ samma steg för att lägga till Azure.Identity NuGet-paketet i projektet.
Skapa en OnlineOrder-klass för att representera ordrarna allt eftersom du behandlar dem från kön. Du kan återanvända en klass som du redan har skapat. Högerklicka på klassen OrderProcessingRole (högerklicka på klassikonen, inte på rollen) i Solution Explorer. Välj Lägg till och välj sedan Befintligt objekt.
Bläddra till undermappen för FrontendWebRole\Models och dubbelklicka sedan på OnlineOrder.cs för att lägga till den i projektet.

Lägg till följande using instruktion i filen WorkerRole.cs i Projektet OrderProcessingRole .

using FrontendWebRole.Models;
using Azure.Messaging.ServiceBus;
using Azure.Messaging.ServiceBus.Administration;

Lägg till följande egenskaper i WorkerRole.cs.

Viktigt!

Använd anslutningssträng för namnområdet som du antecknade som en del av kraven.

    // Fully qualified Service Bus namespace
    private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";

    // The name of your queue.
    private const string QueueName = "OrdersQueue";

    // Service Bus Receiver object to receive messages message the specific queue
    private ServiceBusReceiver SBReceiver;

OnStart Uppdatera metoden för att skapa ett ServiceBusClient objekt och sedan ett ServiceBusReceiver objekt för att ta emot meddelanden från OrdersQueue.

    public override bool OnStart()
    {
        // Create a Service Bus client that you can use to send or receive messages
        ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());

        CreateQueue(QueueName).Wait();

        // create a receiver that we can use to receive the message
        SBReceiver = SBClient.CreateReceiver(QueueName);

        return base.OnStart();
    }
    private async Task CreateQueue(string queueName)
    {
        // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
        ServiceBusAdministrationClient SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());

        // create the OrdersQueue if it doesn't exist already
        if (!(await SBAdminClient.QueueExistsAsync(queueName)))
        {
            await SBAdminClient.CreateQueueAsync(queueName);
        }
    }

RunAsync Uppdatera metoden så att den innehåller koden för att ta emot meddelanden.

    private async Task RunAsync(CancellationToken cancellationToken)
    {
        // TODO: Replace the following with your own logic.
        while (!cancellationToken.IsCancellationRequested)
        {
            // receive message from the queue
            ServiceBusReceivedMessage receivedMessage = await SBReceiver.ReceiveMessageAsync();

            if (receivedMessage != null)
            {
                Trace.WriteLine("Processing", receivedMessage.SequenceNumber.ToString());

                // view the message as an OnlineOrder
                OnlineOrder order = receivedMessage.Body.ToObjectFromJson<OnlineOrder>();
                Trace.WriteLine(order.Customer + ": " + order.Product, "ProcessingMessage");

                // complete message so that it's removed from the queue
                await SBReceiver.CompleteMessageAsync(receivedMessage);
            }
        }
    }

Du har slutfört programmet. Du kan testa den kompletta appen genom att högerklicka på MultiTierApp-projektet i Solution Explorer och välja Ställ in som startprojekt. Slutligen trycker du på F5. Antalet meddelanden ökar inte eftersom arbetsrollen bearbetar objekt från kön och markerar dem som slutförda. Du kan se spårad utdata från arbetsrollen genom att titta i användargränssnittet för Azure Compute Emulator. Du kan göra detta genom att högerklicka på emulatorikonen i aktivitetsfältets meddelandefält och välja Visa Compute Emulator UI.

Nästa steg

Om du vill lära dig mer om Service Bus kan du använda följande resurser: