Service BUS – Criação de Filas (Queue)

Descrição: As filas oferecem a entrega de mensagens First In, First Out (FIFO), para um ou mais consumidores concorrentes. Ou seja, as mensagens normalmente são esperadas para serem recebidas e processadas pelos receptores na ordem em que foram adicionados à fila, e cada mensagem é recebida e processada por um único consumidor de mensagem. Um dos principais benefícios do uso de filas é conseguir um “desacoplamento temporal” dos componentes do aplicativo.

Em outras palavras, os produtores (remetentes) e os consumidores (receptores) não precisam enviar e receber mensagens ao mesmo tempo, pois as mensagens são armazenadas de forma durável na fila. Além disso, o produtor não precisa esperar uma resposta do consumidor para continuar a processar e enviar mensagens.

Um benefício relacionado é o “nivelamento de carga”, que permite aos produtores e consumidores enviarem e receberem mensagens a taxas diferentes. Em muitas aplicações, a carga do sistema varia ao longo do tempo. No entanto, o tempo de processamento necessário para cada unidade de trabalho é tipicamente constante. Os produtores de mensagens intermediárias e os consumidores com uma fila, apontam que o aplicativo consumidor só deve ser provisionado para gerenciar a carga média ao invés da carga máxima. A profundidade da fila cresce e se contrai à medida que a carga de entrada varia. Isso economiza diretamente dinheiro em relação à quantidade de infraestrutura necessária para atender a carga do aplicativo.

À medida que a carga aumenta, mais processos de trabalho podem ser adicionados para ler a fila. Cada mensagem é processada por apenas um dos processos de trabalho. Além disso, este balanceamento de carga baseado em pull, permite o uso ideal dos computadores do trabalhador, mesmo que os computadores do trabalhador difiram em relação ao poder de processamento, pois eles irão puxar as mensagens com sua própria taxa máxima. Esse padrão geralmente é denominado padrão de “concorrente consumidor”.

Requisitos: Pacote Windows.Azure.ServiceBus

Install-Package ServiceBus

Código da aplicação (criando uma fila no C#):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Messaging;
// É necessário instalar as referências do Azure Storage e ServiceBus

namespace ItearativeManipularQueue
{
    public class Program
    {
        // Chave
       
 const string StorageAccontName = "azureviacharp";

        // Valor : key
        const string StorageAccontKey = "mNJHID5W2DtWRtVqrRt5PI8mq8foTtndMhFh34k/wnEXkLvB2atFCCHwf7WZbARIQuIVMveHlOGrljDNUV5usw==";

        static void Main(string[] args)
        {
            var storageAccount = new CloudStorageAccount(new StorageCredentials(StorageAccontName, StorageAccontKey), true);

            // o contéudo da variavel nova_fila pode ser vindo via algum componente
            var new_queue = "minha-queue";

            // Create a custom queue description.
            QueueDescription customDescription = new QueueDescription("minha-queue ")
            {
                DefaultMessageTimeToLive = TimeSpan.FromHours(1),
                EnableDeadLetteringOnMessageExpiration = true,
                RequiresDuplicateDetection = true,
                DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(5),
                LockDuration = TimeSpan.FromMinutes(2),
                RequiresSession = true
            };

            var client = storageAccount.CreateCloudQueueClient();
            var queue = client.GetQueueReference(new_queue) ;

            // Cria nova Queue se não existe
            queue.CreateIfNotExists();

            for (int i = 0; i < 5; i++)
            {
                queue.AddMessage(new Microsoft.WindowsAzure.Storage.Queue.CloudQueueMessage(i.ToString()));
            }

            Console.WriteLine("Mensagens salvas com sucesso.");
            Console.ReadKey();
        }
    }
}

Service BUS – Criação de Topic

Em contraste com as filas, em que cada mensagem é processada por um único consumidor, os tópicos e as assinaturas fornecem uma forma de comunicação de um para muitos, em um padrão de publicação/assinatura. Útil para dimensionar para um grande número de destinatários, cada mensagem publicada é disponibilizada para cada inscrição registrada no tópico. As mensagens são enviadas para um tópico e entregues a uma ou mais assinaturas associadas, dependendo das regras de filtro que podem ser definidas por assinatura. As assinaturas podem usar filtros adicionais para restringir as mensagens que eles querem receber. As mensagens são enviadas para um tópico da mesma forma que são enviadas para uma fila, mas as mensagens não são recebidas diretamente do tópico. Em vez disso, eles são recebidos de inscrições. Uma assinatura de tópicos se assemelha a uma fila virtual, que recebe cópias das mensagens que são enviadas para o tópico. As mensagens são recebidas de uma inscrição de forma idêntica à forma como são recebidas de uma fila.

À título de comparação, a funcionalidade de envio de mensagens de uma fila mapeia diretamente para um tópico e sua função de recepção de mensagens é mapeada para uma assinatura. Entre outras coisas, isso significa que as assinaturas suportam os mesmos padrões descritos anteriormente nesta seção em relação às filas: consumidor concorrente, desacoplamento temporal, nivelamento de carga e balanceamento de carga.

https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use-topics-subscriptions

Código da aplicação (criando uma Topic no C#):

using System;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Messaging;

namespace ConfigTopic.Commands
{
    public class ServiceBusTopicCommandBase
    {
        /// Nome do namespace que será utilizada.
        private string _namespace;

        /// Login do usuário no Azure.
        private string _login;

        /// Senha do usuário no Azure.
        private string _key;

        /// Nome da Topic que será utilizado.
        private string _topicName;

        /// Assinatura do Topic que será utilizado.
        private string _signature;

        public object DataSource { get; private set; }


        // Método para criar um Topic.
        protected void ServiceBusCreateTopicCommandBase(string _namespace, string _login, string _key, string _topicName) 
        {
            var namespaceManager = NamespaceManager.CreateFromConnectionString(_namespace);

            if (!namespaceManager.TopicExists(_topicName))
            {
                // Configurando um Topic.
                var td = new TopicDescription(_topicName);
                td.MaxSizeInMegabytes = 1024;
                td.DefaultMessageTimeToLive = TimeSpan.FromMinutes(5);

                namespaceManager.CreateTopic(td);
            }
        }

        // Método para atribuir uma assinatura no Topic.
        protected void ServiceBusCreateSignatureTopicCommandBase(string _topicName, string _signature)
        {
            SharedSecretTokenProvider myTokenProvider = (SharedSecretTokenProvider)SharedSecretTokenProvider.CreateSharedSecretTokenProvider(_login, _key);
            Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", _namespace, String.Empty);
            NamespaceManager namespaceManager = new NamespaceManager(uri, myTokenProvider);

            // Cria assinatura no Topic
            SubscriptionDescription _subscription = namespaceManager.CreateSubscription(_topicName, _signature);
        }
    }

Diferença entre Topic e Filas

As filas fornecem um padrão fundamental para construir soluções de mensagens distribuídas flexivelmente, acopladas e confiáveis. A capacidade de adicionar consumidores/trabalhadores à um processo, a troca de mensagens de forma transparente do cliente/produtor, o desacoplamento temporal, o nivelamento de carga e a distribuição, tornam as filas bastante úteis.

No entanto, quando você tem mais de um assinante, não pode ser o cliente POS, pois queremos desacoplá-lo desse tipo de conhecimento íntimo. Adicionar esta responsabilidade a cada assinante, também é tão ruim quanto, porque associa o assinante a jusante à esse nível de detalhe.

Os tópicos não são nada novos. Eles têm sido o pilar dos sistemas baseados em JMS há anos e, assim, provaram sua utilidade no campo da computação distribuída como uma ótima maneira de associar logicamente mensagens a eventos de interesse e implementar pub-sub. Tradicionalmente, no mundo de Java, os Tópicos foram vinculados às Filas, mas dada a natureza lógica de um Tópico, não há nada a dizer que não pode andar em cima de qualquer canal de transporte. O transporte físico usado para os Tópicos do Bus do Serviço é o Serviço Bus filas, que permite que você aproveite as características de transporte das filas, mais a abstração lógica que os tópicos fornecem, incluindo regras para filtrar mensagens – e, opcionalmente, executar algum tipo de ação – antes de serem entregues. Também é possível e provável, que cada serviço exponha um contrato diferente e, portanto, a transformação entre uma mensagem canônica e a mensagem esperada deve ocorrer. Mas este é um assunto para um artigo posterior.