Usando o Azure EventHub para enviar eventos no .NET 5
Atualmente, quando estamos trabalhando com ingestão ou gerenciamento de eventos em tempo real, o Azure Event Hub se torna um serviço bastante útil, pois com ele conseguimos trabalhar com milhões de eventos por segundo, se necessário, além de ser bem fácil de se integrar, não sendo um impeditivo a tecnologia com a qual você está trabalhando agora.
Neste artigo, entenderemos um pouco mais de como funciona o EventHub da Azure e como podemos integrar um producer e receiver de eventos utilizando o .NET 5 (Não muda muita coisa nas versões anteriores da SDK).
Entendendo na teoria
O EventHub funciona como um hub de eventos assíncrono, sendo composto de algumas partes:
- Producer => Consiste na entidade executável (uma aplicação) que será responsável por enviar os eventos para o EventHub. Aqui podemos ter qualquer aplicação e estas podem enviar os eventos utilizando protocolos como HTTPS, AMPQ (comum em serviços de mensageria) ou até mesmo usando um client do Apache Kafka (Faz sentido quando você quer migrar de um cluster customizado de Kafka para o EventHub).
- Entities => Quando criamos um novo recurso de EventHub no Azure Portal, definimos um namespace para esse hub e dentro dele podemos criar entidades diferentes do HUB, que funcionam como divisões para processar grupos diferentes de eventos.
- Consumer Group => O nome evidência bastante a sua função, pois consistem em possíveis agrupamentos que podemos construir com diferentes receivers para os eventos que estiverem sendo processados.
- Receiver => Consiste nas entidades executáveis (uma aplicação também) que será responsável por se triggar em um hub de eventos e processar os eventos que por lá estão transitando. É importante ressaltar que outros recursos do Azure como os serviços de ETL (Azure Databricks, Stream Analytics, etc), Storage, entre outros, podem também utilizar o EventHub como serviço de ingestão de eventos.
Em termos de provisão de cloud, o EventHub funciona como um PaaS(Plataforma como serviço), ou seja, não é necessário pensar em termos de infra para começar a utilizá-lo, pois ele já vem praticamente todo provisionado para nós, Devs, utilizarmos.
É importante ressaltar também que por se tratar de uma tecnologia cloud-native gerenciada, não é possível subir ele em VM´s em arquiteturas on-premise.
Aplicando na prática
Para começarmos a utilizar o EventHub, vamos criar uma aplicação console, onde esta funcionará como producer para uma instância(também chamado de tópico) que vamos criar lá na Azure.
Pode vir uma preocupação inicial quanto ao valor que isso custaria, mas não se preocupe, o Azure permite que você crie uma conta e inicie uma avaliação gratuita por 30 dias, tendo uma cota de $200.00 para utilizar como quiser.
Criando um namespace para o EventHub no Portal do Azure
A forma mais simples de começar a trabalhar com o EventHub, é criar um novo namespace desse recurso dentro de um Resource Group de uma subscription já existente na Azure. Existem duas principais formas de se fazer isso, utilizando a UI do Portal do Azure ou utilizando a Azure CLI. Vamos criar pela interface do portal por ser mais intuitivo:
- 1° — Devemos acessar o portal do Azure, no endereço: portal.azure.com
- 2 ° — Tendo uma subscription configurada (Você pode facilmente configurar uma no módulo gratuito que comentei previamente), devemos procurar por “Event Hub” e criar um novo namespace de Event Hub:
- 3° — Após clicar em create, abrirá uma tela semelhante a essa:
Existem alguns pontos interessantes a serem levados em conta quando criamos um novo namespace no EventHub. Primeiro, devemos considerar o namespace como um container onde ficarão contidas as nossas instâncias do EH, além disso, existem algumas outras principais configurações a se observar:
O resource group consiste no agrupamento de um conjunto de recursos gerenciados do Azure, possibilitando uma visualização mais interessante de billing, gerenciamento de acessos com RBAC, entre outros aspectos e é onde o recurso do EH será agrupado.
O namespace é bem evidente, indica o nome do namespace a ser criado, mas é importante ressaltar que os recursos no Azure apresentam um padrão de abreviatura como boa prática. Isso vai ajudar muito o seu time de governança de TI, sendo para o namespace do EventHub o padrão evhns- e para os resource groups, rg- . Você pode consultar outros padrões nesse link: https://docs.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/resource-abbreviations
Os Throughput Units representam unidades de vazão propriamente ditas pré-adquiridas que representam o volume máximo de ingestão e egresso de mensagens que o namespace será capaz de processar como um todo. Uma Throughput Unit representa um volume de ingestão de 1000 eventos por segundo ou 1MB e de egresso de até 4096 eventos por segundo ou 2MB. Você pode consultar mais detalhes nesse docs que trata dos aspecto de escalabilidade: https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-scalability
É importante se atentar ao Princing Tier também, pois ele define a quantidade possível de conexões ativas e a quantidade de Consumer Groups que podem ser criados. Além disso, apenas alguns tiers tem acesso a features do EH, como por exemplo, somente a partir do Standard, temos acesso a feature de Capture, que permite a persistência dos eventos em um storage.
- 3° — Tendo o namespace criado, agora podemos criar a instância do EventHub. Basta ir até o recurso criado e clicar em “+EventHub”:
Agora, podemos configurar nossa instância (topic) do Event Hub:
Quando vamos criar uma instância do EventHub, temos algumas informações importantes a considerar.
Primeiramente, é importante definirmos o número de partições dessa instância, isso significa a quantidade de “filas” em paralelo que poderão processar os eventos, sendo que cada partição normalmente está ligada a uma aplicação que irá consumir daquele EH, aumentando a vazão e o processamento em paralelo. É possível personalizar uma série de configurações ao enviar eventos para partições, como qual a ordem de prioridade daquele evento com o offset ou até especificar para qual partição vai ser enviado(quando a ordem é importante).
Por padrão, o EventHub vai aplicar um algoritmo de round-robin na hora de escolher as partições, isso é, não dará prioridade aos eventos na hora de distribui-los entre as partições, criando uma lista circular entre elas.
Outro fato interessante de observar é que como selecionamos o tier mais básico de pricing, temos direito a mensagens sendo retidas por apenas 24h depois que foram recebidas pelo EH e não podemos ativar a feature de capture.
Implementando Console Application para enviar eventos
Agora, finalmente, depois de nossa infra criada, vamos partir para a implementação da aplicação que será responsável por enviar os eventos para o EH. Primeiramente, é importante observar que o EventHub tem seu client para envio agnóstico a tecnologia, isso é, você pode implementar o envio em diferentes linguagens, como Java, Javascript, C, C#, Go e Python.
Mas como o título do artigo evidencia, vamos utilizar o C# 9 no SDK do .NET 5 (Não muda muita coisa em relação as versões antigas do framework).
Primeiro, precisamos criar um token SAS(Shared Access Signature) na nossa instância do EH, para conseguirmos uma connectionString. Nada mais é do que uma chave de assinatura que possibilita acesso a quem possui-la sob certas condições.
Precisamos agora instalar o Nuget package referente ao EventHub na ConsoleApplication criada:
Install-Package Azure.Messaging.EventHubsAgora, podemos implementar a Console Application que enviará nossos eventos:
Primeiro, definimos dois atributos com as chaves que vamos precisar, sendo a connectionString com o SAS e o nome da instância. É claro que por fins de demonstração, foram definidas como meros atributos na classe, mas em um cenário real, é muito importante atribuir um lugar seguro para chaves desse tipo, sendo armazenadas em cofres seguros fora da aplicação, podendo utilizar de recursos como o próprio Azure Key Vault.
Em seguida, instanciamos um EventHubProducerClient, que encapsula a implementação para o envio de eventBatchs para o EH. Um detalhe importante aqui é utilizar a keyWord await using, para que ao finalizar a utilização da instância, possa ser invocado o DisposeAsync limpando os recursos utilizados para não dar muito trabalho para o GC(Garbage Collector) depois.
Após isso, instanciamos um EventBatch que funcionará realmente como um batch para uma série de eventos em bytes que vamos serializar. Geramos o eventData que é composto de um simples tipo complexo que chamei de POCOUser. Serializamos essa coleção de EventData, adicionamos ao batch e invocamos o producerClient para enviar o eventBatch para o EH.
Implementação da POCOUser:
Executando a aplicação:
Se observarmos o gráfico de processamento da instância do EH, podemos ver que ele já processou as mensagens após executarmos a aplicação.
Por enquanto é isso. Tentei por meio desse artigo explicar alguns conceitos por trás da tecnologia que é o Event Hub e como podemos enviar, de forma simples, mensagens para as instâncias em namespaces que criamos.
No próximo artigo, demonstrarei como podemos consumir essas mensagens, utilizando uma aplicação serverless, como uma Azure Function.
Espero que tenham gostado e até a próxima! :)
Repositório com a Console Application:
https://github.com/GFernandesS/poc-event-hub-sender
Referências:
https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-dotnet-standard-getstarted-send
