Applicazione .NET multilivello che usa code del bus di servizio

Articolo
10/18/2023

Microsoft Azure consente di sviluppare applicazioni con la stessa semplicità offerta da Visual Studio e Azure SDK gratuito per .NET. Questa esercitazione illustra i passaggi per creare un'applicazione che usa più risorse di Azure in esecuzione nell'ambiente locale.

Si apprenderà quanto segue:

Abilitare il computer in uso per lo sviluppo per Azure tramite un singolo download e una singola installazione.
Utilizzare Visual Studio per lo sviluppo per Azure.
Creare un'applicazione multilivello in Azure utilizzando ruoli Web e ruoli di lavoro.
Consentire le comunicazioni tra i livelli usando le code del bus di servizio.

Nota

Per completare l'esercitazione, è necessario un account Azure. È possibile attivare i vantaggi della sottoscrizione MSDN o registrarsi per ottenere un account gratuito.

In questa esercitazione si creerà ed eseguirà l'applicazione multilivello in un servizio cloud di Azure. Il front-end è un ruolo Web ASP.NET MVC e il back-end è un ruolo di lavoro che usa una coda del bus di servizio. È possibile creare la stessa applicazione multilivello con il front-end come progetto Web distribuito in un sito Web di Azure anziché in un servizio cloud. È anche possibile vedere l'esercitazione sull'applicazione .NET ibrida locale/sul cloud.

Lo screenshot seguente mostra l'applicazione completata.

Application's Submit page

Informazioni generali sullo scenario: comunicazione tra ruoli

Per inviare un ordine per l'elaborazione, è necessario che il componente dell'interfaccia utente front-end, in esecuzione nel ruolo Web, interagisca con la logica di livello intermedio in esecuzione nel ruolo di lavoro. Questo esempio usa la messaggistica del bus di servizio per la comunicazione tra i livelli.

L'uso della messaggistica del bus di servizio tra il livello Web e il livello intermedio consente di disaccoppiare i due componenti. A differenza della messaggistica diretta (ovvero TCP o HTTP), il livello Web non si connette direttamente al livello intermedio; esegue invece il push di unità di lavoro, come messaggi, in bus di servizio, che li mantiene in modo affidabile fino a quando il livello intermedio non è pronto per usarle ed elaborarle.

Il bus di servizio offre due entità per il supporto della messaggistica negoziata, ovvero le code e gli argomenti. Se si usano le code, ogni messaggio inviato alla coda viene usato da un ricevitore singolo. Gli argomenti supportano il modello pubblicazione/sottoscrizione, in cui ogni messaggio pubblicato viene reso disponibile a una sottoscrizione registrata per l'argomento. Ogni sottoscrizione mantiene in modo logico la propria coda di messaggi. È anche possibile configurare le sottoscrizioni specificando regole di filtro per limitare i set di messaggi passati alla coda della sottoscrizione ai soli messaggi corrispondenti al filtro. Nel seguente esempio vengono usate le code del bus di servizio.

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

Questo meccanismo di comunicazione presenta alcuni vantaggi rispetto alla messaggistica diretta:

Disaccoppiamento temporaneo. Quando si usa il modello di messaggistica asincrona, i producer e i consumer non devono essere online contemporaneamente. I messaggi vengono archiviati in modo affidabile nel bus di servizio fino a quando il consumer non sarà pronto per riceverli. Questo consente la disconnessione volontaria (ad esempio, per attività di manutenzione) o involontaria (a seguito di un guasto) dei componenti dell'applicazione distribuita senza ripercussioni sull'intero sistema. È inoltre possibile che l'applicazione consumer debba essere online solo in determinati orari.
Distribuzione ottimale dei carichi. In molte applicazioni il carico del sistema varia in base al momento, mentre il tempo di elaborazione richiesto per ogni unità di lavoro è in genere costante. L'interposizione di una coda tra producer e consumer di messaggi implica che è necessario solo eseguire il provisioning dell'applicazione consumer (il ruolo di lavoro) per consentire a quest'ultima di gestire un carico medio anziché il carico massimo. La profondità della coda aumenta e si contrae al variare del carico in ingresso. con un risparmio diretto in termini economici rispetto alle risorse infrastrutturali richieste per gestire il carico dell'applicazione.
Bilanciamento del carico. Con l'aumento del carico, è possibile aggiungere altri processi di lavoro per la lettura della coda. Ogni messaggio viene elaborato solo da uno dei processi di lavoro. Inoltre, questo bilanciamento del carico basato sul pull consente l'uso ottimale dei computer di lavoro anche se i computer di lavoro differiscono in termini di potenza di elaborazione, in quanto eseguiranno il pull dei messaggi alla propria velocità massima. Questo modello viene spesso definito modello del consumer concorrente.

Il codice che consente di implementare questa architettura viene illustrato nelle sezioni seguenti.

Prerequisiti

In questa esercitazione si userà l'autenticazione di Microsoft Entra per creare ServiceBusClient oggetti e ServiceBusAdministrationClient . Si useranno DefaultAzureCredential anche e per usarlo, è necessario eseguire i passaggi seguenti per testare l'applicazione in locale in un ambiente di sviluppo.

Registrare un'applicazione nell'ID Microsoft Entra.
Aggiungere l'applicazione al Service Bus Data Owner ruolo.
Impostare le AZURE-CLIENT-IDvariabili di ambiente , AZURE-TENANT-ID, AND AZURE-CLIENT-SECRET . Per istruzioni, vedere questo articolo.

Per un elenco dei ruoli predefiniti di bus di servizio, vedere Ruoli predefiniti di Azure per bus di servizio.

Creare uno spazio dei nomi

Il primo passaggio consiste nel creare uno spazio dei nomi e ottenere una chiave di firma di accesso condiviso per tale spazio. Uno spazio dei nomi fornisce un limite per ogni applicazione esposta tramite il bus di servizio. Una chiave di firma di accesso condiviso viene generata dal sistema quando viene creato uno spazio dei nomi. La combinazione di spazio dei nomi e chiave di firma di accesso condiviso fornisce le credenziali che consentono al bus di servizio di autenticare l'accesso a un'applicazione.

Creare uno spazio dei nomi nel portale di Azure

Per iniziare a usare le entità di messaggistica del bus di servizio in Azure, prima di tutto è necessario creare uno spazio dei nomi con un nome univoco in Azure. Uno spazio dei nomi fornisce un contenitore di ambito per bus di servizio risorse (code, argomenti e così via) all'interno dell'applicazione.

Per creare uno spazio dei nomi:

Accedere al portale di Azure.
Passare alla pagina Tutti i servizi.
Sulla barra di spostamento a sinistra selezionare Integrazione nell'elenco delle categorie, passare il puntatore del mouse su bus di servizio e quindi selezionare + il pulsante nel riquadro bus di servizio.
Nel tag Informazioni di base della pagina Crea spazio dei nomi seguire questa procedura:
1. Per Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.
2. Per Gruppo di risorse scegliere un gruppo di risorse esistente in cui risiederà lo spazio dei nomi oppure crearne uno nuovo.
3. Immettere un nome per lo spazio dei nomi. Il nome dello spazio dei nomi deve rispettare le convenzioni di denominazione seguenti:
  - Il nome deve essere univoco in Azure. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.
  - La lunghezza del nome è almeno 6 e al massimo 50 caratteri.
  - Il nome può contenere solo lettere, numeri, trattini "-".
  - Il nome deve iniziare con una lettera e terminare con una lettera o un numero.
  - Il nome non termina con "-sb" o "-mgmt".
4. Per Localitàscegliere l'area in cui deve essere ospitato lo spazio dei nomi.
5. Per Piano tariffario selezionare il piano tariffario (Basic, Standard o Premium) per lo spazio dei nomi. Per questa guida introduttiva selezionare Standard.
  
  Importante
  
  Se si vogliono usare argomenti e sottoscrizioni, scegliere Standard o Premium. Gli argomenti e le sottoscrizioni non sono supportati nel piano tariffario Basic.
  
  Se è stato selezionato il piano tariffario Premium, specificare il numero di unità di messaggistica. Il piano Premium fornisce l'isolamento delle risorse a livello di CPU e memoria in modo che ogni carico di lavoro venga eseguito in isolamento. Questo contenitore di risorse viene chiamato unità di messaggistica. Uno spazio dei nomi Premium ha almeno un'unità di messaggistica. È possibile selezionare 1, 2, 4, 8 o 16 unità di messaggistica per ogni spazio dei nomi bus di servizio Premium. Per altre informazioni, vedere Messaggistica Premium del bus di servizio.
6. Selezionare Rivedi e crea nella parte inferiore della pagina.
7. Nella pagina Rivedi e crea rivedere le impostazioni e selezionare Crea.
Al termine della distribuzione della risorsa, selezionare Vai alla risorsa nella pagina di distribuzione.
Viene visualizzata la home page dello spazio dei nomi del bus di servizio.

Ottenere stringa di connessione allo spazio dei nomi (portale di Azure)

La creazione di un nuovo spazio dei nomi genera automaticamente un criterio di firma di accesso condiviso iniziale con chiavi primarie e secondarie e stringa di connessione primarie e secondarie che concedono il controllo completo su tutti gli aspetti dello spazio dei nomi. Per informazioni su come creare regole con diritti più limitati per mittenti e ricevitori, vedere Autenticazione e autorizzazione del bus di servizio.

Un client può usare il stringa di connessione per connettersi allo spazio dei nomi bus di servizio. Per copiare il stringa di connessione primario per lo spazio dei nomi, seguire questa procedura:

Nella pagina spazio dei nomi bus di servizio selezionare Criteri di accesso condiviso nel menu a sinistra.
Nella pagina Criteri di accesso condiviso selezionare RootManageSharedAccessKey.
Nella finestra Criteri: RootManageSharedAccessKey selezionare il pulsante copia accanto a Stringa di Connessione primaria per copiare il stringa di connessione negli Appunti per usarlo in un secondo momento. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.

È possibile usare questa pagina per copiare la chiave primaria, la chiave secondaria, la stringa di connessione primaria e le stringa di connessione secondarie.

Creare un ruolo Web

Creare in questa sezione il front-end dell'applicazione. Creare prima di tutto le pagine visualizzate dall'applicazione. Aggiungere quindi il codice per inviare elementi a una coda del bus di servizio e visualizzare informazioni relative allo stato della coda.

Creare il progetto

Usando i privilegi di amministratore, avviare Visual Studio: fare clic con il pulsante destro del mouse sull'icona del programma Visual Studio e quindi scegliere Esegui come amministratore. L'emulatore di calcolo di Azure, descritto più avanti in questo articolo, richiede l'avvio di Visual Studio con privilegi di amministratore.

In Visual Studio scegliere Nuovo dal menu File, quindi selezionare Progetto.
Nella pagina Modelli seguire questa procedura:
1. Selezionare C# per linguaggio di programmazione.
2. Selezionare Cloud per il tipo di progetto.
3. Selezionare Servizio cloud di Azure.
4. Selezionare Avanti.
Assegnare al progetto il nome MultiTierApp, selezionare il percorso per il progetto e quindi selezionare Crea.
Nella pagina Ruoli fare doppio clic su ASP.NET ruolo Web e selezionare OK.
Passare il puntatore del mouse su WebRole1 nella soluzione Servizio cloud di Azure, selezionare l'icona a forma di matita e rinominare il ruolo Web in FrontendWebRole. Selezionare OK. Assicurarsi di immettere "Frontend" con una 'e' minuscola, non "FrontEnd".
Nella finestra di dialogo Crea una nuova applicazione Web ASP.NET selezionare MVC e quindi crea.
In Esplora soluzioni, nel progetto FrontendWebRole fare clic con il pulsante destro del mouse su Riferimenti e quindi scegliere Gestisci pacchetti NuGet.
Selezionare la scheda Sfoglia e quindi cercare Azure.Messaging.ServiceBus. Selezionare il pacchetto Azure.Messaging.ServiceBus , selezionare Installa e accettare le condizioni per l'utilizzo.

Sono ora disponibili riferimenti agli assembly client necessari e sono stati aggiunti nuovi file di codice.
Seguire la stessa procedura per aggiungere il Azure.Identity pacchetto NuGet al progetto.
In Esplora soluzioni espandere FronendWebRole, fare clic con il pulsante destro del mouse su Modelli e scegliere Aggiungi, quindi selezionare Classe. Nella casella Nome digitare il nome OnlineOrder.cs. Selezionare Aggiungi.

Scrivere il codice per il ruolo Web

Creare prima di tutto in questa sezione le diverse pagine visualizzate dall'applicazione.

In Visual Studio, nel file OnlineOrder.cs sostituire la definizione dello spazio dei nomi esistente con il codice seguente:

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

In Esplora soluzioni fare doppio clic su Controllers\HomeController.cs. Aggiungere le istruzioni using seguenti nella parte iniziale del file per includere gli spazi dei nomi per il modello appena creato, oltre al bus di servizio.
```
 using FrontendWebRole.Models;
 using Azure.Messaging.ServiceBus;    
```

Anche nel file HomeController.cs sostituire la definizione dello spazio dei nomi esistente con il seguente codice. Tale codice include metodi per la gestione dell'invio di elementi alla coda.

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

Dal menu Compila selezionare Compila soluzione per testare l'accuratezza del lavoro fino a questo momento.
Creare quindi la visualizzazione per il metodo Submit() creato in precedenza. Fare clic con il pulsante destro del mouse all'interno del Submit() metodo (l'overload di Submit() che non accetta parametri) nel file HomeController.cs , quindi scegliere Aggiungi visualizzazione.
Nella finestra di dialogo Aggiungi nuovo elemento con scaffolding selezionare Aggiungi.
Nella finestra di dialogo Aggiungi visualizzazione seguire questa procedura:
1. Nell'elenco Modello scegliere Crea.
2. Nell'elenco Classe modello selezionare la classe OnlineOrder.
3. Selezionare Aggiungi.
Modificare ora il nome visualizzato dell'applicazione. In Esplora soluzioni fare doppio clic sul file Views\Shared\_Layout.cshtml per aprirlo nell'editor di Visual Studio.
Sostituire tutte le occorrenze di My ASP.NET Application con Northwind Traders Products.
Rimuovere i collegamenti Home, About e Contact. Eliminare il codice evidenziato:
Modificare infine la pagina di invio in modo da includere informazioni sulla coda. In Esplora soluzioni fare doppio clic sul file Views\Home\Submit.cshtml per aprirlo nell'editor di Visual Studio. Aggiungere la riga seguente dopo <h2>Submit</h2>. Per ora ViewBag.MessageCount non contiene valori. Verrà popolato in un secondo momento.
```
<p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
```
L'interfaccia utente è stata implementata. È possibile premere F5 per eseguire l'applicazione e confermare che abbia l'aspetto previsto.

Scrivere codice per l'invio di elementi a una coda del bus di servizio

Aggiungere quindi il codice per l'invio di elementi a una coda. Creare prima di tutto una classe contenente le informazioni di connessione della coda del bus di servizio. Inizializzare quindi la connessione da Global.aspx.cs. Aggiornare infine il codice di invio creato in precedenza in HomeController.cs in modo da inviare effettivamente elementi alla coda del bus di servizio.

In Esplora soluzioni fare clic con il pulsante destro del mouse su FrontendWebRole. È necessario fare clic con il pulsante destro del mouse sul progetto, non sul ruolo. Selezionare Aggiungi e quindi Classe.
Assegnare alla classe il nome QueueConnector.cs. Selezionare Aggiungi per creare la classe.

Aggiungere ora codice che incapsula le informazioni di connessione e inizializza la connessione a una coda del bus di servizio. Sostituire l'intero contenuto di QueueConnector.cs con il codice seguente e immettere i valori per your Service Bus namespace, ovvero il nome dello spazio dei nomi, e yourKey, ovvero la chiave primaria ottenuta in precedenza dal portale di Azure.

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

Assicurarsi che venga chiamato il metodo Initialize. In Esplora soluzioni fare doppio clic su Global.asax\Global.asax.cs.
Aggiungere la riga di codice seguente alla fine del metodo Application_Start.
```
 FrontendWebRole.QueueConnector.Initialize().Wait();
```
Verrà infine aggiornato il codice Web creato in precedenza, in modo da inviare elementi alla coda. In Esplora soluzioni fare doppio clic su Controllers\HomeController.cs.

Aggiornare il metodo Submit(), ovvero l'overload che non accetta parametri, come indicato di seguito per ottenere il numero di messaggi per la coda.

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

         return View();
     }

Aggiornare il metodo Submit(OnlineOrder order), ovvero l'overload che accetta un parametro, come indicato di seguito per inviare alla coda le informazioni relative all'ordine.

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

È ora possibile eseguire di nuovo l'applicazione. Ogni volta che si invia un ordine, il conteggio dei messaggi aumenta.

Creare il ruolo di lavoro

A questo punto si creerà il ruolo di lavoro che elabora gli invii degli ordini. In questo esempio viene usato il modello di progetto Worker Role with Service Bus Queue di Visual Studio. Le credenziali necessarie sono già state ottenute dal portale.

Assicurarsi che Visual Studio sia connesso all'account Azure.
In Esplora soluzioni in Visual Studio fare clic con il pulsante destro del mouse sulla cartella Roles nel progetto MultiTierApp.
Selezionare Aggiungi e quindi Nuovo progetto ruolo di lavoro. Viene visualizzata la finestra di dialogo Aggiungi nuovo progetto di ruolo.
Nella finestra di dialogo Aggiungi nuovo progetto ruolo selezionare Ruolo di lavoro. Non selezionare Ruolo di lavoro con coda bus di servizio perché genera codice che usa l'SDK di bus di servizio legacy.
Nella casella Nome assegnare il nome OrderProcessingRole. Selezionare Aggiungi.
In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto OrderProcessingRole e scegliere Gestisci pacchetti NuGet.
Selezionare la scheda Sfoglia e quindi cercare Azure.Messaging.ServiceBus. Selezionare il pacchetto Azure.Messaging.ServiceBus , selezionare Installa e accettare le condizioni per l'utilizzo.
Seguire la stessa procedura per aggiungere il Azure.Identity pacchetto NuGet al progetto.
Creare una classe OnlineOrder che rappresenti gli ordini elaborati dalla coda. È possibile riutilizzare una classe creata in precedenza. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla classe OrderProcessingRole. È necessario fare clic con il pulsante destro del mouse sull'icona della classe, non sul ruolo. Selezionare Aggiungi, quindi selezionare Elemento esistente.
Selezionare la sottocartella per FrontendWebRole\Modelse fare doppio clic su OnlineOrder.cs per aggiungerlo al progetto corrente.

Aggiungere l'istruzione seguente using al file WorkerRole.cs nel progetto OrderProcessingRole .

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

In WorkerRole.cs aggiungere le proprietà seguenti.

Importante

Usare il stringa di connessione per lo spazio dei nomi annotato come parte dei prerequisiti.

    // 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;

Aggiornare il OnStart metodo per creare un ServiceBusClient oggetto e quindi un ServiceBusReceiver oggetto per ricevere messaggi da 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);
        }
    }

Aggiornare il RunAsync metodo per includere il codice per ricevere messaggi.

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

L'applicazione è stata completata. È possibile testare l'applicazione completa facendo clic con il pulsante destro del mouse sul progetto MultiTierApp in Esplora soluzioni. Selezionare quindi Imposta come progetto di avvio e premere F5. Il conteggio dei messaggi non aumenta, perché il ruolo di lavoro elabora gli elementi dalla coda e li contrassegna come completi. È possibile verificare l'output di traccia del ruolo di lavoro visualizzando l'interfaccia utente dell'emulatore di calcolo di Azure. Per eseguire questa operazione, fare clic con il pulsante destro del mouse sull'icona dell'emulatore nell'area di notifica della barra delle applicazioni, quindi scegliere Show Compute Emulator UI (Mostra interfaccia utente dell'emulatore di calcolo).

Passaggi successivi

Per ulteriori informazioni sul bus di servizio, vedere le risorse seguenti: