Aplicação .NET multicamadas que utiliza as filas do Service Bus do Azure

Artigo
10/18/2023

O desenvolvimento para o Microsoft Azure é fácil através do Visual Studio e do Azure SDK gratuito para o .NET. Este tutorial explica os passos para criar uma aplicação que utiliza vários recursos do Azure em execução no ambiente local.

Você aprenderá o seguinte:

Como ativar o computador para o desenvolvimento para o Azure com uma única transferência e instalação.
Como utilizar o Visual Studio para desenvolvimento para o Azure.
Como criar uma aplicação multicamadas no Azure utilizando as funções da Web e de trabalho.
Como comunicar entre camadas utilizando as filas do Service Bus.

Nota

Para concluir este tutorial, precisa de uma conta do Azure. Pode ativar os benefícios de subscritor do MSDN ou inscrever-se numa conta gratuita.

Neste tutorial, você criará e executará o aplicativo de várias camadas em um serviço de nuvem do Azure. O front-end é uma função da Web de MVC do ASP.NET e o back-end é uma função de trabalho que utiliza uma fila do Service Bus. Pode criar a mesma aplicação multicamadas com o front-end como um projeto Web implementado para um Web site Azure em vez de um serviço em nuvem. Pode também experimentar o tutorial Aplicação .NET híbrida no local/nuvem.

A captura de tela a seguir mostra o aplicativo concluído.

Application's Submit page

Descrição geral do cenário: comunicação entre funções

Para submeter um pedido para processamento, o componente de IU do front-end, em execução na função da Web, deve interagir com a lógica da camada média em execução na função de trabalho. Este exemplo utiliza mensagens do Service Bus para a comunicação entre as camadas.

A utilização de mensagens do Service Bus entre as camadas média e da Web desacopla os dois componentes. Ao contrário das mensagens diretas (ou seja, TCP ou HTTP), a camada da Web não se conecta diretamente à camada intermediária; em vez disso, ele envia unidades de trabalho, como mensagens, para o Service Bus, que as retém de forma confiável até que a camada intermediária esteja pronta para consumi-las e processá-las.

O Service Bus fornece duas entidades para suportar mensagens mediadas: as filas e os tópicos. Com as filas, cada mensagem enviada para a fila é consumida por um único recetor. Os tópicos suportam o padrão publicar/subscrever em que cada mensagem publicada é disponibilizada para uma subscrição registada com o tópico. Cada subscrição mantém logicamente a sua própria fila de mensagens. As subscrições também podem ser configuradas com regras de filtragem que restringem o conjunto de mensagens transmitidas para a fila de subscrição para as correspondentes ao filtro. O exemplo seguinte utiliza as filas do Service Bus.

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

Este mecanismo de comunicação tem várias vantagens em relação às mensagens diretas:

Desacoplamento temporal. Quando você usa o padrão de mensagens assíncronas, produtores e consumidores não precisam estar online ao mesmo tempo. O Service Bus armazena de forma fiável as mensagens até a parte consumidora estar preparada para a respetiva receção. Isto permite que os componentes da aplicação distribuída estejam desligados, quer voluntariamente, por exemplo, para manutenção, quer devido a uma falha de componente, sem afetar o sistema como um todo. Além disso, a aplicação de consumo poderá apenas precisar de ficar online durante determinadas horas do dia.
Nivelamento de carga. Em muitas aplicações, a carga do sistema varia ao longo do tempo, enquanto o tempo de processamento necessário para cada unidade de trabalho é geralmente constante. A intermediação de produtores e consumidores de mensagens através de uma fila significa que a aplicação de consumo (o trabalho) apenas precisa de ser aprovisionada para acomodar uma carga média em vez de um pico de carga. A profundidade da fila aumenta e contrai à medida que a carga a receber varia. Tal poupa diretamente dinheiro em termos de quantidade de infraestrutura necessária para a manutenção da carga da aplicação.
Balanceamento de carga. À medida que a carga aumenta, podem ser adicionados mais processos de trabalho para a leitura a partir da fila. Cada mensagem é processada apenas por um dos processos de trabalho. Além disso, esse balanceamento de carga baseado em pull permite o uso ideal das máquinas de trabalho, mesmo que as máquinas de trabalho difiram em termos de poder de processamento, pois elas puxarão mensagens em sua própria taxa máxima. Este padrão é frequentemente denominado padrão de consumidor concorrente.

As secções seguintes abordam o código que implementa esta arquitetura.

Pré-requisitos

Neste tutorial, você usará a autenticação do Microsoft Entra para criar ServiceBusClient e ServiceBusAdministrationClient objetos. Você também DefaultAzureCredential usará e, para usá-lo, precisará executar as etapas a seguir para testar o aplicativo localmente em um ambiente de desenvolvimento.

Registre um aplicativo na ID do Microsoft Entra.
Adicione o aplicativo à Service Bus Data Owner função.
Defina as variáveis de AZURE-CLIENT-IDambiente , AZURE-TENANT-ID, AND AZURE-CLIENT-SECRET . Veja este artigo para obter as instruções.

Para obter uma lista de funções internas do Service Bus, consulte Funções internas do Azure para Service Bus.

Criar um espaço de nomes

A primeira etapa é criar um namespace e obter uma chave SAS (Assinatura de Acesso Compartilhado) para esse namespace. Um espaço de nomes proporciona um limite de aplicação para cada aplicação exposta através do Service Bus. O sistema gera uma chave SAS quando um espaço de nomes é criado. A combinação do nome do espaço de nomes e da chave SAS fornece as credenciais do Service Bus para autenticar o acesso a uma aplicação.

Criar um espaço de nomes no portal do Azure

Para começar a utilizar as entidades de mensagens do Service Bus no Azure, tem de, primeiro, criar um espaço de nomes que seja exclusivo em todo o Azure. Um namespace fornece um contêiner de escopo para recursos do Service Bus (filas, tópicos, etc.) em seu aplicativo.

Para criar um espaço de nomes:

Inicie sessão no portal do Azure.
Navegue até a página Todos os serviços.
Na barra de navegação esquerda, selecione Integração na lista de categorias, passe o mouse sobre o Service Bus e selecione + o botão no bloco do Service Bus.
Na marca Basics da página Criar namespace, siga estas etapas:
1. Em Assinatura, escolha uma assinatura do Azure na qual criar o namespace.
2. Para Grupo de recursos, escolha um grupo de recursos existente no qual o namespace viverá ou crie um novo.
3. Insira um nome para o namespace. O nome do namespace deve aderir às seguintes convenções de nomenclatura:
  - O nome deve ser exclusivo no Azure. O sistema verifica imediatamente a disponibilidade do nome.
  - O comprimento do nome é de pelo menos 6 e no máximo 50 caracteres.
  - O nome pode conter apenas letras, números hífenes "-".
  - O nome deve começar com uma letra e terminar com uma letra ou número.
  - O nome não termina com "-sb" ou "-mgmt".
4. Em Local, escolha a região na qual seu namespace deve ser hospedado.
5. Em Nível de preço, selecione o nível de preço (Básico, Standard ou Premium) para o namespace. Para este início rápido, selecione Padrão.
  
  Importante
  
  Se você quiser usar tópicos e assinaturas, escolha Standard ou Premium. Não há suporte para tópicos/assinaturas no nível de preço Básico.
  
  Se você selecionou o nível de preço Premium, especifique o número de unidades de mensagens. A camada premium fornece isolamento de recursos no nível de CPU e memória para que cada carga de trabalho seja executada isoladamente. Este contentor de recursos é designado por unidade de mensagens. Um namespace premium tem pelo menos uma unidade de mensagens. Você pode selecionar 1, 2, 4, 8 ou 16 unidades de mensagens para cada namespace Premium do Service Bus. Para obter mais informações, consulte Mensagens Premium do Service Bus.
6. Selecione Rever + criar na parte inferior da página.
7. Na página Rever + criar, reveja as definições e selecione Criar.
Quando a implantação do recurso for bem-sucedida, selecione Ir para o recurso na página de implantação.
Você vê a home page do namespace do barramento de serviço.

Obter cadeia de conexão para o namespace (portal do Azure)

A criação de um novo namespace gera automaticamente uma política inicial de Assinatura de Acesso Compartilhado (SAS) com chaves primárias e secundárias e cadeias de conexão primárias e secundárias que concedem controle total sobre todos os aspetos do namespace. Consulte Autenticação e autorização do Service Bus para obter informações sobre como criar regras com direitos mais restritos para remetentes e destinatários regulares.

Um cliente pode usar a cadeia de conexão para se conectar ao namespace do Service Bus. Para copiar a cadeia de conexão primária para seu namespace, execute estas etapas:

Na página Namespace do Service Bus, selecione Políticas de acesso compartilhado no menu à esquerda.
Na página Políticas de acesso compartilhado, selecione RootManageSharedAccessKey.
Na janela Policy: RootManageSharedAccessKey, selecione o botão de cópia ao lado de Cadeia de conexão primária, para copiar a cadeia de conexão para a área de transferência para uso posterior. Cole este valor no Bloco de Notas ou noutra localização temporária.

Você pode usar esta página para copiar chave primária, chave secundária, cadeia de conexão primária e cadeia de conexão secundária.

Criar uma função da Web

Nesta secção, compile o front-end da sua aplicação. Em primeiro ligar, crie as páginas a serem apresentadas pela aplicação. Em seguida, adicione o código que submete itens para a fila do Service Bus e mostra as informações de estado sobre a fila.

Criar o projeto

Usando privilégios de administrador, inicie o Visual Studio: clique com o botão direito do mouse no ícone do programa Visual Studio e selecione Executar como administrador. O Emulador de Computação do Azure, discutido posteriormente neste artigo, requer que o Visual Studio seja iniciado com privilégios de administrador.

No Visual Studio, no menu File (Ficheiro), selecione New (Novo) e, em seguida, selecione Project (Projeto).
Na página Modelos, siga estes passos:
1. Selecione C# para linguagem de programação.
2. Selecione Nuvem para o tipo de projeto.
3. Selecione Serviço de Nuvem do Azure.
4. Selecione Seguinte.
Nomeie o projeto MultiTierApp, selecione o local para o projeto e, em seguida, selecione Criar.
Na página Funções, clique duas vezes em ASP.NET Função Web e selecione OK.
Passe o cursor sobre WebRole1 na solução do Serviço de Nuvem do Azure, selecione o ícone de lápis e renomeie a função Web para FrontendWebRole. Em seguida, selecione OK. (Certifique-se de que introduz "Frontend" com um "e" em minúsculas e não "FrontEnd".)
Na caixa de diálogo Criar um novo aplicativo Web ASP.NET, selecione MVC e, em seguida, selecione Criar.
No Gerenciador de Soluções, no projeto FrontendWebRole, clique com o botão direito do mouse em Referências e selecione Gerenciar Pacotes NuGet.
Selecione a guia Procurar e procure Azure.Messaging.ServiceBus. Selecione o pacote Azure.Messaging.ServiceBus , selecione Instalar e aceite os termos de uso.

Tenha em atenção que os conjuntos de clientes necessários estão agora referenciados e foram adicionados alguns ficheiros de código novos.
Siga as mesmas etapas para adicionar o Azure.Identity pacote NuGet ao projeto.
No Gerenciador de Soluções, expanda FronendWebRole, clique com o botão direito do mouse em Modelos e selecione Adicionar e, em seguida, selecione Classe. Na caixa Nome, escreva o nome OnlineOrder.cs. Em seguida, selecione Adicionar.

Escrever o código para a função da Web

Nesta secção, crie as várias páginas a serem apresentadas pela aplicação.

No ficheiro OnlineOrder.cs no Visual Studio, substitua a definição de espaço de nomes existente pelo código seguinte:

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

No Explorador de Soluções, faça duplo clique em Controllers\HomeController.cs. Adicione as seguintes instruções using na parte superior do ficheiro para incluir os espaços de nomes para o modelo que acabou de criar, bem como o Service Bus.
```
 using FrontendWebRole.Models;
 using Azure.Messaging.ServiceBus;    
```

Também no ficheiro HomeController.cs no Visual Studio, substitua a definição de espaço de nomes existente pelo código seguinte. Este nome contém métodos para processar a submissão de itens para a fila.

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

No menu Compilar, selecione Compilar solução para testar a precisão do seu trabalho até agora.
Agora, crie a vista para o método Submit() que criou anteriormente. Clique com o botão direito do mouse dentro do Submit() método (a sobrecarga que não usa parâmetros) no arquivo HomeController.csSubmit() e, em seguida, escolha Adicionar exibição.
Na caixa de diálogo Adicionar Novo Item de Andaime, selecione Adicionar.
Na caixa de diálogo Adicionar Vista, siga estes passos:
1. Na lista Modelo, escolha Criar.
2. Na lista Classe de modelo, selecione a classe OnlineOrder.
3. Selecione Adicionar.
Agora, altere o nome apresentado da sua aplicação. No Gerenciador de Soluções, clique duas vezes no arquivo Views\Shared\_Layout.cshtml para abri-lo no editor do Visual Studio.
Substitua todas as ocorrências de A Minha Aplicação ASP.NET por Produtos da Northwind Traders.
Remova as hiperligações Home, Sobre e Contacto. Elimine o código realçado:
Por fim, modifique a página de submissão para incluir algumas informações sobre a fila. No Explorador de Soluções, faça duplo clique no ficheiro Views\Home\Submit.cshtml para abri-lo no editor do Visual Studio. Adicione a linha seguinte após <h2>Submit</h2>. Por agora, o ViewBag.MessageCount está vazio. Você irá preenchê-lo mais tarde.
```
<p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
```
Implementou agora a sua IU. Pode premir F5 para executar a aplicação e confirmar que tem o aspeto esperado.

Escrever o código para submeter itens para uma fila do Service Bus

Agora adicione o código para submeter itens para uma fila. Em primeiro lugar, crie uma classe com as informações de ligação da fila do Service Bus. Em seguida, inicialize a ligação a partir de Global.aspx.cs. Por fim, atualize o código de submissão criado anteriormente em HomeController.cs para submeter, de facto, itens para uma fila do Service Bus.

No Explorador de Soluções, clique com o botão direito em FrontendWebRole (clique com o botão direito no projeto e não na função). Selecione Adicionar e, em seguida, selecione Classe.
Atribua o nome QueueConnector.cs à classe. Selecione Adicionar para criar a classe.

Agora, adicione o código que contém as informações de ligação e inicializa a ligação para uma fila do Service Bus. Substitua os conteúdos integrais de QueueConnector.cs pelo código seguinte e introduza os valores para your Service Bus namespace (o nome do espaço de nomes) e yourKey, que é a chave primária obtida anteriormente a partir do Portal do 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);    
         }
     }    
}

Agora, certifique-se de que o método Initialize é chamado. No Explorador de Soluções, faça duplo clique em Global.asax\Global.asax.cs.
Adicione a seguinte linha de código no final do método Application_Start.
```
 FrontendWebRole.QueueConnector.Initialize().Wait();
```
Por fim, atualize o código Web que criou anteriormente para submeter itens para a fila. No Explorador de Soluções, faça duplo clique em Controllers\HomeController.cs.

Atualize o método Submit() (a sobrecarga que não recebe parâmetros) do seguinte modo para obter a contagem de mensagens para a fila.

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

         return View();
     }

Atualize o método Submit(OnlineOrder order) (a sobrecarga que recebe um parâmetro) do seguinte modo para submeter informações de pedidos para a fila.

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

Pode agora executar novamente a aplicação. Sempre que submete um pedido, a contagem de mensagens aumenta.

Criar a função de trabalho

Agora você criará a função de trabalho que processa os envios de pedidos. Este exemplo utiliza o modelo de projeto Função de Trabalho com Fila do Service Bus do Visual Studio. Já obteve as credenciais necessárias a partir do portal.

Certifique-se de que ligou o Visual Studio à sua conta do Azure.
No Visual Studio, no Explorador de Soluções, clique com o botão direito na pasta Funções no projeto MultiTierApp.
Selecione Adicionar e, em seguida, selecione Novo Projeto de Função de Trabalho. Aparece a caixa de diálogo Adicionar Novo Projeto de Função.
Na caixa de diálogo Adicionar Novo Projeto de Função, selecione Função de Trabalho. Não selecione Função de Trabalho com Fila do Service Bus, pois ela gera código que usa o SDK herdado do Service Bus.
Na caixa Nome, atribua o nome OrderProcessingRole ao projeto. Em seguida, selecione Adicionar.
No Gerenciador de Soluções, clique com o botão direito do mouse no projeto OrderProcessingRole e selecione Gerenciar Pacotes NuGet.
Selecione a guia Procurar e procure Azure.Messaging.ServiceBus. Selecione o pacote Azure.Messaging.ServiceBus , selecione Instalar e aceite os termos de uso.
Siga as mesmas etapas para adicionar o Azure.Identity pacote NuGet ao projeto.
Crie uma classe OnlineOrder para representar os pedidos à medida que processa os mesmos a partir da fila. Pode reutilizar uma classe já criada. No Explorador de Soluções, clique com o botão direito na classe OrderProcessingRole (clique com o botão direito no ícone da classe e não na função). Selecione Adicionar e, em seguida, selecione Item existente.
Navegue para a subpasta para FrontendWebRole\Models e, em seguida, faça duplo clique em OnlineOrder.cs para adicioná-lo a este projeto.

Adicione a seguinte using instrução ao arquivo WorkerRole.cs no projeto OrderProcessingRole .

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

Em WorkerRole.cs, adicione as seguintes propriedades.

Importante

Use a cadeia de conexão para o namespace que você anotou como parte dos pré-requisitos.

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

Atualize o OnStart método para criar um ServiceBusClient objeto e, em OrdersQueueseguida, um ServiceBusReceiver objeto para receber mensagens do .

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

Atualize o RunAsync método para incluir o código para receber mensagens.

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

Preencheu a candidatura. Pode testar a aplicação completa clicando com o botão direito no projeto MultiTierApp no Explorador de Soluções, selecionando Configurar como Projeto de Arranque e premindo, em seguida, F5. A contagem de mensagens não aumenta, porque a função de trabalho processa itens da fila e os marca como concluídos. Pode ver os resultados de rastreio da função de trabalho visualizando a IU do Emulador de Computação do Azure. Pode fazer isto clicando com o botão direito no ícone do emulador na área de notificação da barra de tarefas e selecionando Mostrar a IU do Emulador de Computação.

Próximos passos

Para obter mais informações sobre o Service Bus, consulte os seguintes recursos: