Lab 10: Elaborare messaggi in modo asincrono usando code del bus di servizio di Azure

Interfaccia utente di Microsoft Azure

Considerata la natura dinamica degli strumenti cloud di Microsoft, è possibile rilevare modifiche all’interfaccia utente di Azure apportate dopo lo sviluppo di questo contenuto per la formazione. È quindi possibile che le istruzioni e le procedure del lab non siano allineate correttamente.

Microsoft aggiorna questo corso di formazione quando la community segnala le modifiche necessarie. Poiché gli aggiornamenti cloud vengono apportati spesso, tuttavia, è possibile che si rilevino modifiche all’interfaccia utente prima degli aggiornamenti del contenuto per la formazione. In questo caso, adattarsi alle modifiche e quindi eseguire le operazioni necessarie nei lab.

Istruzioni

Prima di iniziare

Accedere all’ambiente lab

Accedere alla macchina virtuale Windows 10 usando le credenziali seguenti:

• Nome utente: Admin

• Password: Pa55w.rd

Nota: il docente fornirà le istruzioni necessarie per la connessione all’ambiente lab virtuale.

Esaminare le applicazioni installate

Trovare la barra delle applicazioni nel desktop di Windows 10. La barra delle applicazioni include le icone per le applicazioni che verranno usate nel lab, tra cui:

• Microsoft Edge

• Visual Studio Code

Diagramma dell’architettura

Esercizio 1: Creare risorse di Azure

Attività 1: Aprire il portale di Azure

1. Sulla barra delle applicazioni selezionare l’icona di Microsoft Edge.

2. Nella finestra del browser passare al portale di Azure (portal.azure.com) e accedere con l’account che si userà per questo lab.

   Nota: se si sta eseguendo l’accesso al portale di Azure per la prima volta, verrà visualizzata una presentazione del portale. Selezionare Attività iniziali per ignorare la presentazione e iniziare a usare il portale.

Attività 2: Creare una coda del bus di servizio di Azure

1. Nel portale di Azure usare la casella di testo Cerca risorse, servizi e documentazione per cercare Bus di servizio e quindi nell’elenco di risultati selezionare Bus di servizio.

2. Nel pannello Bus di servizio selezionare + Crea.

3. Nella scheda Informazioni di base del pannello Crea spazio dei nomi eseguire le azioni seguenti e selezionare Rivedi e crea:

   Impostazione	Azione
   Elenco a discesa Sottoscrizione	Mantenere il valore predefinito
   Sezione Gruppo di risorse	Selezionare Crea nuovo, immettere AsyncProcessor e quindi selezionare OK
   Casella di testo Nome spazio dei nomi	Immettere sbnamespace [nomeutente]
   Elenco a discesa Area	Selezionare qualsiasi area di Azure in cui è possibile distribuire un’istanza del bus di servizio di Azure
   Elenco a discesa Piano tariffario	Selezionare Basic

   Lo screenshot seguente mostra le impostazioni configurate nella scheda Informazioni di base del pannello Crea spazio dei nomi.

   

4. Nella scheda Rivedi e crea esaminare le opzioni selezionate durante i passaggi precedenti.

5. Selezionare Crea per creare lo Spazio dei nomi del bus di servizio usando la configurazione specificata.

   Nota: prima di procedere con il lab, attendere il completamento dell’attività di creazione.

6. Nel pannello Distribuzione selezionare il pulsante Vai alla risorsa per passare al pannello Spazio dei nomi del bus di servizio appena creato.

7. Nella sezione  Impostazioni del pannello Bus di servizio selezionare Criteri di accesso condiviso.

8. Nell’elenco dei criteri selezionare RootManageSharedAccessKey.

9. Nel riquadro Criteri di firma di accesso condiviso: RootManageSharedAccessKey, accanto alla voce Stringa di connessione primaria selezionare il pulsante Copia negli Appunti e registrare il valore copiato. Verrà usato più avanti in questo lab.

   Nota: non è importante quale delle due chiavi disponibili si sceglie. Sono intercambiabili.

10. Nel pannello  Bus di servizio, nella sezione Entità, selezionare Code e quindi + Coda.

11. Nel pannello Crea coda esaminare le impostazioni disponibili, nella casella di testo Nome immettere messagequeuee quindi selezionare Crea.

12. Selezionare messagequeue per visualizzare le proprietà della coda Bus di servizio.

13. Lasciare aperta la finestra del browser. Verrà di nuovo usata più avanti in questo lab.

Verifica

In questo esercizio sono stati creati uno spazio dei nomi del bus di servizio di Azure e una coda del bus di servizio da usare nel resto del lab.

Esercizio 2: Creare un progetto .NET Core per pubblicare messaggi in una coda del bus di servizio

Attività 1: Creare un progetto .NET Core

1. Dal computer del lab avviare Visual Studio Code.

2. In Visual Studio Code scegliere Apri cartella dal menu File.

3. Nella finestra Apri cartella passare aAllfiles (F):\Allfiles\Labs\10\Starter\MessagePublisher e quindi selezionare Seleziona cartella.

4. Nella finestra di Visual Studio Code attivare il menu di scelta rapida e quindi selezionare Apri nel terminale integrato.

5. Al prompt del terminale eseguire il comando seguente per creare un nuovo progetto .NET denominato MessagePublisher nella cartella corrente:

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

   Nota: il comando dotnet new creerà un nuovo progetto console in una cartella con lo stesso nome del progetto.

6. Eseguire il comando seguente per importare la versione 7.8.1 del pacchetto Azure.Messaging.ServiceBus da NuGet:

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

   Nota: il comando dotnet add package aggiungerà il pacchetto Azure.Messaging.ServiceBus da NuGet. Per altre informazioni, passare a Azure.Messaging.ServiceBus.

7. Al prompt del terminale eseguire il comando seguente per compilare l’applicazione console .NET Core:

   dotnet build
   

8. Selezionare Termina il terminale (l’icona del Cestino) per chiudere il riquadro del terminale e tutti i processi associati.

Attività 2: Pubblicare messaggi in una coda del bus di servizio di Azure

1. Nel riquadro Esplora risorse della finestra di Visual Studio Code aprire il file Program.cs.

2. Nella scheda dell’editor di codice per il file  Program.cs eliminare tutto il codice nel file esistente.

3. Aggiungere le righe di codice seguenti per facilitare l’uso degli spazi dei nomi predefiniti a cui verrà fatto riferimento in questo file:

   using System;
   using System.Threading.Tasks;
   

4. Aggiungere il codice seguente per importare lo spazio dei nomi Azure.Messaging.ServiceBus incluso nel pacchetto Azure.Queues importato da NuGet:

   using Azure.Messaging.ServiceBus;
   

5. Immettere il codice seguente per creare una nuova classe Program nello spazio dei nomi MessagePublisher:

   namespace MessagePublisher
   {
      public class Program
      {
      }
   }
   

6. Nella classe Program immettere il codice seguente per creare una costante di tipo stringa denominata storageConnectionString:

   private const string serviceBusConnectionString = "";
   

7. Aggiornare la costante stringa serviceBusConnectionString impostandone il valore su Stringa di connessione primaria per lo spazio dei nomi del bus di servizio registrato in precedenza in questo lab.

8. Immettere il codice seguente per creare una costante stringa denominata queueName con un valore messagequeue, corrispondente al nome della coda del bus di servizio creata in precedenza in questo esercizio.

   private const string queueName = "messagequeue";
   

9. Immettere il codice seguente per creare una costante integer che archivia il numero di messaggi da inviare alla coda di destinazione:

   private const int numOfMessages = 3;
   

10. Immettere il codice seguente per creare un client del bus di servizio che sarà proprietario della connessione alla coda di destinazione:

    static ServiceBusClient client;
    

11. Immettere il codice seguente per creare un mittente del bus di servizio che sarà proprietario della connessione alla coda di destinazione:

    static ServiceBusSender sender;
    

12. Immettere il codice seguente per creare un metodo Main asincrono:

    public static async Task Main(string[] args)
    {
    }
    

13. Esaminare il file Program.cs, che ora dovrebbe includere il codice seguente. Si noti che il segnaposto <serviceBus-connection-string> rappresenta la stringa di connessione allo spazio dei nomi del bus di servizio di Azure di destinazione:

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    namespace MessagePublisher
    {
        public class Program
        {
            private const string serviceBusConnectionString = "<serviceBus-connection-string>";
            private const string queueName = "messagequeue";
            private const int numOfMessages = 3;
            static ServiceBusClient client = default!;
            static ServiceBusSender sender = default!;
            public static async Task Main(string[] args)
            {
            }
        }
    }
    

14. Nel metodo Main aggiungere il codice seguente per inizializzare il client di tipo ServiceBusClient che fornirà connettività allo spazio dei nomi del bus di servizio e il mittente che sarà responsabile dell’invio di messaggi:

    client = new ServiceBusClient(serviceBusConnectionString);
    sender = client.CreateSender(queueName);  
    

    Nota: il client del bus di servizio è sicuro da memorizzare nella cache e usare come singleton per l’intera durata dell’applicazione. Questa è considerata una procedura consigliata quando si pubblicano e leggono regolarmente messaggi.

15. Nel metodo Main aggiungere il codice seguente per creare un oggetto ServiceBusMessageBatch che consentirà di combinare più messaggi in un batch usando il metodo TryAddMessage:

    using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
    

16. Nel metodo Main aggiungere le righe di codice seguenti per aggiungere messaggi a un batch e generare un’eccezione se le dimensioni di un messaggio superano i limiti supportati dal batch:

    for (int i = 1; i <= numOfMessages; i++)
    {
        if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
        {
            throw new Exception($"The message {i} is too large to fit in the batch.");
        }
    }
    

17. Nel metodo Main aggiungere le righe di codice seguenti per creare un blocco try, con l’oggetto mittente sender che pubblica in modo asincrono i messaggi nel batch nella coda di destinazione:

    try
    {
        await sender.SendMessagesAsync(messageBatch);
        Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
    }
    

18. Nel metodo Main aggiungere le righe di codice seguenti per creare un blocco finally che elimina in modo asincrono gli oggetti sender e client, rilasciando tutte le risorse di rete e non gestite:

    finally
    {
        await sender.DisposeAsync();
        await client.DisposeAsync();
    }
    

19. Esaminare il metodo Main, che ora dovrebbe essere costituito dal codice seguente:

    public static async Task Main(string[] args)
    {
        client = new ServiceBusClient(serviceBusConnectionString);
        sender = client.CreateSender(queueName);
        using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
        for (int i = 1; i <= numOfMessages; i++)
        {
            if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
            {
                throw new Exception($"The message {i} is too large to fit in the batch.");
            }
        }
        try
        {
            await sender.SendMessagesAsync(messageBatch);
            Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
        }
        finally
        {
            await sender.DisposeAsync();
            await client.DisposeAsync();
        }
    }
    

20. Salvare il file Program.cs .

21. Nella finestra di Visual Studio Code attivare il menu di scelta rapida e quindi selezionare Apri nel terminale integrato.

22. Al prompt del terminale eseguire il comando seguente per avviare l’app console .NET Core:

    dotnet run
    

    Nota: se si verificano errori, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\10\Solution\MessagePublisher.

23. Verificare che il messaggio della console visualizzato nel prompt del terminale indichi che un batch di tre messaggi è stato pubblicato nella coda.

24. Selezionare Termina il terminale (l’icona del Cestino) per chiudere il riquadro del terminale e tutti i processi associati.

25. Passare al browser Microsoft Edge che visualizza la coda del bus di servizio messagequeue nel portale di Azure.

26. Esaminare il riquadro Informazioni di base e notare che la coda contiene tre messaggi attivi.

    Lo screenshot seguente mostra le metriche della coda del bus di servizio e il numero di messaggi.

    

27. Selezionare il pannello Service Bus Explorer (anteprima) .

28. Nell’intestazione della scheda Modalità anteprima e nella scheda Coda selezionare il pulsante Visualizza in anteprima dall’inizio.

29. Verificare che la coda contenga tre messaggi.

30. Selezionare il primo messaggio ed esaminarne il contenuto nel riquadro Messaggio.

    Lo screenshot seguente mostra il contenuto del primo messaggio.

    

31. Chiudere il riquadro Messaggio.

Verifica

In questo esercizio è stato configurato un progetto .NET che ha pubblicato messaggi in una coda del bus di servizio di Azure.

Esercizio 3: Creare un progetto .NET Core per leggere i messaggi da una coda del bus di servizio

Attività 1: Creare un progetto .NET

1. Dal computer del lab avviare Visual Studio Code.

2. In Visual Studio Code scegliere Apri cartella dal menu File.

3. Nella finestra Apri cartella passare ad Allfiles (F):\Allfiles\Labs\10\Starter\MessageReader e quindi selezionare Seleziona cartella.

4. Nella finestra di Visual Studio Code attivare il menu di scelta rapida e quindi selezionare Apri nel terminale integrato.

5. Al prompt del terminale eseguire il comando seguente per creare un nuovo progetto .NET denominato MessageReader nella cartella corrente:

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

6. Eseguire il comando seguente per importare la versione 7.8.1 del pacchetto Azure.Messaging.ServiceBus da NuGet:

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

7. Al prompt del terminale eseguire il comando seguente per compilare l’applicazione console .NET Core:

   dotnet build
   

8. Selezionare Termina il terminale (l’icona del Cestino) per chiudere il riquadro del terminale e tutti i processi associati.

Attività 2: Leggere i messaggi da una coda del bus di servizio Azure

1. Nel riquadro Esplora risorse della finestra di Visual Studio Code aprire il file Program.cs.

2. Nella scheda dell’editor di codice per il file  Program.cs eliminare tutto il codice nel file esistente.

3. Aggiungere lo stesso codice incluso nel file Program.cs per consentire l’interazione con le code del bus di servizio di Azure, ma impostare lo spazio dei nomi su MessageReader:

   using System;
   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;  
   namespace MessageReader
   {
      public class Program
      {
         private const string serviceBusConnectionString = "";
         static string queueName = "messagequeue";
         static ServiceBusClient client = default!;
      }
   }
   

4. Come prima, aggiornare la costante stringa serviceBusConnectionString impostandone il valore su Stringa di connessione primaria per lo spazio dei nomi del bus di servizio registrato in precedenza in questo lab.

5. Immettere il codice seguente per creare un oggetto ServiceBusProcessor che verrà usato per elaborare i messaggi dalla coda:

   static ServiceBusProcessor processor = default!;
   

6. Immettere il codice seguente per creare un’attività MessageHandler asincrona statica che visualizza il corpo dei messaggi nella coda durante l’elaborazione e li elimina al termine dell’elaborazione:

   static async Task MessageHandler(ProcessMessageEventArgs args)
   {
       string body = args.Message.Body.ToString();
       Console.WriteLine($"Received: {body}");
       await args.CompleteMessageAsync(args.Message);
   }
   

7. Immettere il codice seguente per creare un’attività ErrorHandler asincrona statica che gestisce tutte le eccezioni riscontrate durante l’elaborazione dei messaggi:

   static Task ErrorHandler(ProcessErrorEventArgs args)
   {
       Console.WriteLine(args.Exception.ToString());
       return Task.CompletedTask;
   }
   

8. Immettere il codice seguente per creare un metodo Main asincrono:

   static async Task Main(string[] args)
   {
   }
   

9. Esaminare il file Program.cs, che ora dovrebbe includere il codice seguente. Il segnaposto <serviceBus-connection-string> rappresenta la stringa di connessione allo spazio dei nomi del bus di servizio di Azure di destinazione:

   using System;
   using System.Threading.Tasks;
   using Azure.Messaging.ServiceBus;
   namespace MessageReader
   {
       class Program
       {
           static string serviceBusConnectionString = "<serviceBus-connection-string>";
           static string queueName = "messagequeue";
           static ServiceBusClient client;
           static ServiceBusProcessor processor;
           static async Task MessageHandler(ProcessMessageEventArgs args)
           {
               string body = args.Message.Body.ToString();
               Console.WriteLine($"Received: {body}");
               await args.CompleteMessageAsync(args.Message);
           }
           static Task ErrorHandler(ProcessErrorEventArgs args)
           {
               Console.WriteLine(args.Exception.ToString());
               return Task.CompletedTask;
           }
           static async Task Main()
           {
           }
       }
   }
   

10. Nel metodo Main aggiungere il codice seguente per inizializzare il client di tipo ServiceBusClient che fornirà connettività allo spazio dei nomi del bus di servizio e il processore che sarà responsabile dell’invio di messaggi:

    client = new ServiceBusClient(serviceBusConnectionString);
    processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
    

    Nota: come si è detto in precedenza, il client del bus di servizio è sicuro da memorizzare nella cache e usare come singleton per l’intera durata dell’applicazione. Questa è considerata una procedura consigliata quando si pubblicano e leggono regolarmente messaggi.

11. Nel metodo Main aggiungere le righe di codice seguenti per creare un blocco try, che per prima cosa implementa un gestore di elaborazione di messaggi ed errori, avvia l’elaborazione dei messaggi e interrompe l’elaborazione a seguito di un input dell’utente:

    try
    {
        processor.ProcessMessageAsync += MessageHandler;
        processor.ProcessErrorAsync += ErrorHandler;
        await processor.StartProcessingAsync();
        Console.WriteLine("Wait for a minute and then press any key to end the processing");
        Console.ReadKey();
        Console.WriteLine("\nStopping the receiver...");
        await processor.StopProcessingAsync();
        Console.WriteLine("Stopped receiving messages");
    }
    

12. Nel metodo Main aggiungere le righe di codice seguenti per creare un blocco finally che elimina in modo asincrono gli oggetti processor e client, rilasciando tutte le risorse di rete e non gestite:

    finally
    {
        await processor.DisposeAsync();
        await client.DisposeAsync();
    }
    

13. Esaminare il metodo Main, che ora dovrebbe essere costituito dal codice seguente:

    static async Task Main()
    {
        client = new ServiceBusClient(serviceBusConnectionString);
        processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
        try
        {
            processor.ProcessMessageAsync += MessageHandler;
            processor.ProcessErrorAsync += ErrorHandler;
    
            await processor.StartProcessingAsync();
            Console.WriteLine("Wait for a minute and then press any key to end the processing");
            Console.ReadKey();
    
            Console.WriteLine("\nStopping the receiver...");
            await processor.StopProcessingAsync();
            Console.WriteLine("Stopped receiving messages");
        }
        finally
        {
            await processor.DisposeAsync();
            await client.DisposeAsync();
        }
    }
    

14. Salvare il file Program.cs .

15. Nella finestra di Visual Studio Code attivare il menu di scelta rapida e quindi selezionare Apri nel terminale integrato.

16. Al prompt del terminale eseguire il comando seguente per avviare l’app console .NET Core:

    dotnet run
    

    Nota: se si verificano errori, esaminare il file Program.cs nella cartella Allfiles (F):\Allfiles\Labs\10\Solution\MessageReader.

17. Verificare che il messaggio della console visualizzato nel prompt del terminale indichi che ognuno dei tre messaggi nella coda è stato ricevuto.

18. Al prompt del terminale premere un tasto qualsiasi per arrestare il ricevitore e terminare l’esecuzione dell’app.

19. Selezionare Termina il terminale (l’icona del Cestino) per chiudere il riquadro del terminale e tutti i processi associati.

20. Tornare al browser Microsoft Edge che visualizza la coda del bus di servizio messagequeue nel portale di Azure.

21. Nel pannello Service Bus Explorer (anteprima) selezionare Visualizza in anteprima dall’inizio e notare che il numero di messaggi attivi nella coda è cambiato in 0.

Verifica

In questo esercizio sono stati letti ed eliminati messaggi dalla coda del bus di servizio di Azure usando la libreria .NET.

Esercizio 4: Pulire la sottoscrizione

Attività 1: Aprire Azure Cloud Shell

1. Nel portale di Azure selezionare l’icona di Cloud Shell per aprire una nuova sessione di Bash. Se in Cloud Shell viene aperta per impostazione predefinita una sessione di PowerShell, selezionare PowerShell e nel menu a discesa selezionare Bash.

   Nota: se è la prima volta che si avvia Cloud Shell, quando viene richiesto di selezionare Bash o PowerShell selezionare PowerShell. Quando viene visualizzato il messaggio Non sono state montate risorse di archiviazione, selezionare la sottoscrizione usata in questo lab e selezionare Crea risorsa di archiviazione.

Attività 2: Eliminare i gruppi di risorse

1. Nel riquadro Cloud Shell eseguire il comando seguente per eliminare il gruppo di risorse AsyncProcessor:

   az group delete --name AsyncProcessor --no-wait --yes
   

   Nota: il comando viene eseguito in modo asincrono, in base a quanto determinato dal parametro –no-wait, quindi, sebbene sia possibile eseguire un altro comando dell’interfaccia della riga di comando di Azure immediatamente dopo nella stessa sessione Bash, il gruppo di risorse verrà effettivamente rimosso dopo alcuni minuti.

2. Chiudere il riquadro Cloud Shell nel portale.

Attività 3: Chiudere le applicazioni attive

1. Chiudere l’applicazione Microsoft Edge in esecuzione.

2. Chiudere l’applicazione Visual Studio Code in esecuzione.

Verifica

In questo esercizio è stata pulita la sottoscrizione mediante la rimozione dei gruppi di risorse usati in questo lab.