Laboratório 10: Processar mensagens de forma assíncrona usando as Filas do Barramento de Serviço do Azure

Interface de usuário do Microsoft Azure

Dada a natureza dinâmica das ferramentas de nuvem da Microsoft, você pode se deparar com alterações na IU do Azure que ocorram após o desenvolvimento deste conteúdo do treinamento. Como resultado, as instruções do laboratório e as etapas do laboratório podem não estar alinhadas corretamente.

A Microsoft atualiza este curso de treinamento quando a comunidade nos alerta sobre as alterações necessárias. No entanto, as atualizações na nuvem ocorrem com frequência, portanto você pode encontrar alterações na interface de usuário antes que esse conteúdo de treinamento seja atualizado. Se isso ocorrer, adapte-se às alterações e trabalhe com elas nos laboratórios, conforme necessário.

Instruções

Antes de começar

Entrar no ambiente de laboratório

Entre na máquina virtual (VM) do Windows 11 usando as seguintes credenciais:

  • Nome de usuário: Admin
  • Senha: Pa55w.rd

Observação: Seu instrutor fornecerá instruções para se conectar ao ambiente de laboratório virtual.

Examinar os aplicativos instalados

Localize a barra de tarefas na área de trabalho do Windows 11. A barra de tarefas contém os ícones dos aplicativos que você usará neste laboratório, incluindo:

  • Microsoft Edge
  • Visual Studio Code

Cenário do laboratório

Neste laboratório, você criará uma prova de conceito para este cenário empregando uma Fila do Barramento de Serviço do Azure. Para demonstrar como o sistema pode funcionar, você criará um projeto .NET que publicará mensagens no sistema e um segundo aplicativo .NET que lerá mensagens da fila. O primeiro aplicativo simulará dados provenientes de um sensor, enquanto o segundo aplicativo simulará o sistema que lerá as mensagens da fila para processamento.

Diagrama de arquitetura

Diagrama de arquitetura que mostra um usuário processando mensagens de forma assíncrona usando as Filas do Barramento de Serviço do Azure

Exercício 1: Criar recursos do Azure

Tarefa 1: Abrir o portal do Azure

  1. Na barra de tarefas, selecione o ícone Microsoft Edge.

  2. Na janela do navegador, navegue até o portal do Azure em https://portal.azure.com e entre com a conta que você usará neste laboratório.

    Observação: Se esta for a primeira vez que entra no portal do Azure, você receberá um tour pelo portal. Selecione Introdução para ignorar o tour e começar a usar o portal.

Tarefa 2: Criar uma fila do Barramento de Serviço do Azure

  1. No portal do Azure, use a caixa de texto Pesquisar recursos, serviços e documentos para pesquisar Barramento de Serviço e, na lista de resultados, selecione Barramento de Serviço.

  2. Na folha Barramento de Serviço, selecione + Criar.

  3. Na folha Criar namespace, na guia Básico, execute as seguintes ações e selecione Revisar + Criar:

    Configuração Ação
    Lista suspensa Assinatura Manter o valor padrão
    Seção Grupo de recursos  selecionar Criar novo, inserir AsyncProcessor e selecionar OK
    Caixa de texto Nome do namespace  Inserir sbnamespace[yourname]
    Lista suspensaRegião  Selecione qualquer região do Azure na qual você possa implantar um Barramento de Serviço do Azure
    Lista suspensa Tipo de preço  Selecione Básico

    A captura de tela a seguir exibe as configurações definidas na guia Básico na folha Criar namespace.

    Criar uma folha de namespace do Barramento de Serviço do Azure

  4. Na guia Revisar + criar, revise as opções selecionadas nas etapas anteriores.

  5. Selecione Criar para criar um namespace do Barramento de Serviço usando a configuração especificada.

    Observação: Aguarde a conclusão da tarefa de criação antes de prosseguir neste laboratório.

  6. Na folha Implantação, selecione o botão Ir para o recurso para navegar até a folha do namespace do Barramento de Serviço recém-criado.

  7. Na folha do namespace do Barramento de Serviço, na seção Configurações, selecione Políticas de acesso compartilhado.

  8. Na lista de políticas, selecione RootManageSharedAccessKey.

  9. No painel Política de SAS: RootManageSharedAccessKey, ao lado da entrada Cadeia de conexão primária, selecione o botão Copiar para a área de transferência e registre o valor copiado. Você o usará posteriormente neste laboratório.

    Observação: Não importa qual das duas chaves disponíveis você escolher. Eles são intercambiáveis.

  10. Na folha do namespace do Barramento de Serviço, na seçãoEntidades, selecione Filas e, depois, selecione + Fila.

  11. Na folha Criar fila, examine as configurações disponíveis, na caixa de texto Nome, insira . messagequeue e selecione Criar.

  12. Selecione messagequeue para exibir as propriedades da fila do Barramento de Serviço.

  13. Deixe a janela do navegador aberta. Você a usará posteriormente neste laboratório.

Revisão

Neste exercício, você criou um namespace do Barramento de Serviço do Azure e uma fila do Barramento de Serviço que você usará no restante do laboratório.

Exercício 2: Criar um projeto do .NET Core para publicar mensagens em uma fila do Barramento de Serviço

Tarefa 1: Criar um projeto do .NET Core

  1. No computador do laboratório, inicie o Visual Studio Code.

  2. No Visual Studio Code, no menu Arquivo, selecione Abrir Pasta.

  3. Na janela Abrir Pasta, navegue até Allfiles (F):\Allfiles\Labs\10\Starter\MessagePublisher e selecione Selecionar Pasta.

  4. Na janela Visual Studio Code, na Barra de menus, selecione Terminal e, em seguida, selecione Novo Terminal.

  5. No prompt do terminal, execute o seguinte comando para criar um novo projeto do .NET chamado MessagePublisher na pasta atual:

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

    Observação: O comando dotnet new cria um novo projeto de console em uma pasta com o mesmo nome que o projeto.

  6. Execute o seguinte comando para importar a versão 7.17.3 do pacote Azure.Messaging.ServiceBus do NuGet:

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

    Observação: O comando dotnet add package adicionará o pacote Azure.Messaging.ServiceBus do NuGet. Para obter mais informações, consulte Azure.Messaging.ServiceBus.

  7. No prompt do terminal, execute o comando a seguir para criar o aplicativo de console do .NET Core:

     dotnet build

  8. Selecione Encerrar Terminal (o ícone da Lixeira) para fechar o painel do terminal e eventuais processos associados.

Tarefa 2: Publicar mensagens em uma fila do Barramento de Serviço do Azure

  1. No painel Explorer da janela do Visual Studio Code, abra o arquivo Program.cs.

  2. Na guia do editor de código do arquivo Program.cs , exclua todo o código no arquivo existente.

  3. Adicione os códigos a seguir:

     using System;
 using System.Threading.Tasks;
 using Azure.Messaging.ServiceBus;
 namespace MessagePublisher
 {
     public class Program
     {
         /* The `<serviceBus-connection-string>` placeholder represents
            the connection string to the target Azure Service Bus namespace */
         private const string serviceBusConnectionString = "<serviceBus-connection-string>";

         /* To create a string constant named "queueName" with a value
            of "messagequeue", matching the name of the Service Bus queue.*/
         private const string queueName = "messagequeue";

         /* Stores the number of messages to be sent to the target queue */
         private const int numOfMessages = 3;

         /* To create a Service Bus client that will own the connection to the target queue */
         static ServiceBusClient client = default!;

         /* To create a Service Bus sender that will be 
            used to publish messages to the target queue */
         static ServiceBusSender sender = default!;

         public static async Task Main(string[] args)
         {   
             /* To initialize "client" of type "ServiceBusClient" that will 
                provide connectivity to the Service Bus namespace and "sender"
                that will be responsible for sending messages */
             client = new ServiceBusClient(serviceBusConnectionString);
             sender = client.CreateSender(queueName);

             /* To create a "ServiceBusMessageBatch" object that will allow you to combine
                multiple messages into a batch by using the "TryAddMessage" method */
             using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

             /* To add messages to a batch and throw an exception if a message
                size exceeds the limits supported by the 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.");
                 }
             }
             try
             {
                 /* To create a try block, with "sender" asynchronously 
                    publishing messages in the batch to the target queue */
                 await sender.SendMessagesAsync(messageBatch);
                 Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
             }
             finally
             {
                 /* To create a finally block that asynchronously disposes of the "sender"
                    and "client" objects, releasing any network and unmanaged resources */
                 await sender.DisposeAsync();
                 await client.DisposeAsync();
             }
         }
     }
 }

    Observação: Atualize a constante de cadeia de caracteres serviceBusConnectionString definindo seu valor como Cadeia de Conexão Primária do namespace do Barramento de Serviço e verifique se a constante queueName está definida como messagequeue, correspondendo ao nome da fila do Barramento de Serviço que você criou anteriormente neste exercício

    Observação: O cliente do Barramento de Serviço é seguro para armazenar em cache e usar como um singleton durante a vida útil do aplicativo. Essa é considerada uma das práticas recomendadas ao publicar e ler mensagens regularmente.

  4. Salve o arquivo Program.cs .

  5. No prompt do terminal, execute o comando a seguir para iniciar o aplicativo de console do .NET Core:

     dotnet run

    Observação: Se você encontrar algum erro, faça uma revisão do arquivo Program.cs na pasta Allfiles (F):\Allfiles\Labs\10\Solution\MessagePublisher.

  6. Verifique se a mensagem do console exibida no prompt do terminal indica que um lote de três mensagens foi publicado na fila.

  7. Selecione Encerrar Terminal (o ícone da Lixeira) para fechar o painel do terminal e eventuais processos associados.

  8. Alterne para o navegador do Microsoft Edge que exibe a fila do Barramento de Serviço messagequeue no portal do Azure.

  9. Examine o painel do Essentials e observe que há três mensagens ativas na fila.

    A captura de tela a seguir exibe a contagem de mensagens e as métricas de fila do Barramento de Serviço.

    Métricas de fila do Barramento de Serviço e contagem de mensagens no portal do Azure

  10. Selecione Service Bus Explorer.

  11. Com o cabeçalho da guia Modo de Espiar selecionado, na guia Fila, selecione o botão Espiar do início.

  12. Verifique se há três mensagens na fila.

  13. Selecione a primeira mensagem e examine seu conteúdo no painel Mensagem.

    A captura de tela a seguir exibe o conteúdo da primeira mensagem.

    Conteúdo da fila do Barramento de Serviço no Service Bus Explorer

  14. Feche o painel Mensagem.

Revisão

Neste exercício, você configurou seu projeto .NET que publicou mensagens em uma fila do Barramento de Serviço do Azure.

Exercício 3: Criar um projeto do .NET Core para ler mensagens em uma fila do Barramento de Serviço

Tarefa 1: Criar um projeto do .NET

  1. No computador do laboratório, inicie o Visual Studio Code.

  2. No Visual Studio Code, no menu Arquivo, selecione Abrir Pasta.

  3. Na janela Abrir Pasta, navegue até Allfiles (F):\Allfiles\Labs\10\Starter\MessageReader e selecione Selecionar Pasta.

  4. Na janela Visual Studio Code, na Barra de menus, selecione Terminal e, em seguida, selecione Novo Terminal.

  5. No prompt do terminal, execute o seguinte comando para criar um novo projeto do .NET chamado MessageReader na pasta atual:

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

  6. Execute o seguinte comando para importar a versão 7.17.3 do pacote Azure.Messaging.ServiceBus do NuGet:

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

  7. No prompt do terminal, execute o comando a seguir para criar o aplicativo de console do .NET Core:

     dotnet build

  8. Selecione Encerrar Terminal (o ícone da Lixeira) para fechar o painel do terminal e eventuais processos associados.

Tarefa 2: Ler mensagens de uma fila do Barramento de Serviço do Azure

  1. No painel Explorer da janela do Visual Studio Code, abra o arquivo Program.cs.

  2. Na guia do editor de código do arquivo Program.cs , exclua todo o código no arquivo existente.

  3. Adicione os códigos a seguir:

     using System;
 using System.Threading.Tasks;
 using Azure.Messaging.ServiceBus;
 namespace MessageReader
 {
     class Program
     {   
         /* The `<serviceBus-connection-string>` placeholder represents
            the connection string to the target Azure Service Bus namespace */
         static string serviceBusConnectionString = "<serviceBus-connection-string>";
            
         /* To create a string constant named "queueName" with a value
            of "messagequeue", matching the name of the Service Bus queue.*/
         static string queueName = "messagequeue";
         static ServiceBusClient client= default!;

         /* Create a ServiceBusProcessor that will be used to process messages from the queue */
         static ServiceBusProcessor processor = default!;


         static async Task MessageHandler(ProcessMessageEventArgs args)
         {   
             /* To create a static async "MessageHandler" task that displays 
                the body of messages in the queue as they are being processed 
                and deletes them after the processing completes */

             string body = args.Message.Body.ToString();
             Console.WriteLine($"Received: {body}");
             await args.CompleteMessageAsync(args.Message);
         }
         static Task ErrorHandler(ProcessErrorEventArgs args)
         {   
             /* To create a static async "ErrorHandler" task that manages 
                any exceptions encountered during message processing */
             Console.WriteLine(args.Exception.ToString());
             return Task.CompletedTask;
         }

         static async Task Main()
         {   
             /* To initialize "client" of type "ServiceBusClient" that will provide 
                connectivity to the Service Bus namespace and "processor" that will
                be responsible for processing of messages */
             client = new ServiceBusClient(serviceBusConnectionString);
             processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
             try
             {   
                 /* To create a try block, which first implements a message and error
                     processing handler, initiates message processing, and stops
                     processing following a user input */
                 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
             {
                /* To create a finally block that asynchronously disposes of the "processor"
                    and "client" objects, releasing any network and unmanaged resources */
                 await processor.DisposeAsync();
                 await client.DisposeAsync();
             }
         }
     }
 }

    Observação: Atualize a constante de cadeia de caracteres serviceBusConnectionString definindo seu valor como Cadeia de Conexão Primária do namespace do Barramento de Serviço registrado anteriormente neste laboratório.

  4. Salve o arquivo Program.cs .

  5. No prompt do terminal, execute o comando a seguir para iniciar o aplicativo de console do .NET Core:

     dotnet run

    Observação: Se você encontrar algum erro, faça uma revisão do arquivo Program.cs na pasta Allfiles (F):\Allfiles\Labs\10\Solution\MessageReader.

  6. Verifique se a mensagem do console exibida no prompt do terminal indica que cada uma das três mensagens na fila foi recebida.

  7. No prompt do terminal, pressione qualquer tecla para interromper o receptor e encerrar a execução do aplicativo.

  8. Selecione Encerrar Terminal (o ícone da Lixeira) para fechar o painel do terminal e eventuais processos associados.

  9. Volte para o navegador do Microsoft Edge que exibe a fila do Barramento de Serviço messagequeue no portal do Azure.

  10. Na folha Service Bus Explorer (versão prévia), selecione Espiar do início e observe que o número de mensagens ativas na fila foi alterado para 0.

Revisão

Neste exercício, você leu e excluiu mensagens da fila do Barramento de Serviço do Azure usando a biblioteca .NET.