Mensageria Orientada a Eventos: Implementando RabbitMQ, Kafka e Azure Service Bus em .NET

Introdução à Mensageria Orientada a Eventos

A mensageria orientada a eventos é um padrão de arquitetura que permite a comunicação entre diferentes componentes de um sistema de forma assíncrona (LAZZARI; FARIAS, 2023). Este modelo é especialmente útil em sistemas distribuídos, onde a escalabilidade, a resiliência e a desacoplamento dos componentes são fundamentais. Neste artigo, exploraremos três das principais soluções de mensageria orientada a eventos: RabbitMQ, Kafka e Azure Service Bus, todas implementáveis em aplicações .NET.

RabbitMQ

RabbitMQ é um broker de mensagens open-source que implementa o protocolo AMQP (Advanced Message Queuing Protocol). É amplamente utilizado devido à sua simplicidade e robustez (RABBITMQ, 2025).

Instalação do RabbitMQ

Para instalar o RabbitMQ, você pode usar o Docker. Execute o seguinte comando:

docker run -d --hostname rabbit --name rabbit -p 5672:5672 -p 15672:15672 rabbitmq:3-management

Após isso, você pode acessar a interface de gerenciamento pelo navegador em http://localhost:15672 com as credenciais padrão (user: guest, password: guest).

Publicando e Consumindo Mensagens

A seguir, apresentamos um exemplo de como publicar e consumir mensagens usando RabbitMQ em uma aplicação .NET.

using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Text;

class Program
{
    static void Main()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel();

        channel.QueueDeclare(queue: "hello",
                             durable: false,
                             exclusive: false,
                             autoDelete: false,
                             arguments: null);

        string message = "Hello World!";
        var body = Encoding.UTF8.GetBytes(message);

        channel.BasicPublish(exchange: "",
                             routingKey: "hello",
                             basicProperties: null,
                             body: body);
        Console.WriteLine($" [x] Sent {message}");

        var consumer = new EventingBasicConsumer(channel);
        consumer.Received += (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = Encoding.UTF8.GetString(body);
            Console.WriteLine($" [x] Received {message}");
        };
        channel.BasicConsume(queue: "hello",
                             autoAck: true,
                             consumer: consumer);

        Console.ReadLine();
    }
}

Apache Kafka

Apache Kafka é uma plataforma de streaming distribuída que permite a publicação, assinatura, armazenamento e processamento de fluxos de registros em tempo real (APACHE KAFKA, 2025). É altamente escalável e resistente.

Instalação do Kafka

Para instalar o Kafka, você pode usar o Docker também. Execute os seguintes comandos:

docker run -d --network=host --name zookeeper -e ZOO_MY_ID=1 -e ZOO_SERVERS=1 zookeeper
docker run -d --network=host --name kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092 -e KAFKA_LISTENER_SECURITY_PROTOCOL_MAP=PLAINTEXT:PLAINTEXT -e KAFKA_ZOOKEEPER_CONNECT=localhost:2181 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 kafka

Publicando e Consumindo Mensagens

Para interagir com Kafka em .NET, você pode usar a biblioteca Confluent.Kafka. Aqui está um exemplo de como publicar e consumir mensagens:

using Confluent.Kafka;
using System;
using System.Threading;

class Program
{
    public static void Main(string[] args)
    {
        var config = new ProducerConfig { BootstrapServers = "localhost:9092" };

        using (var producer = new ProducerBuilder<Null, string>(config).Build())
        {
            try
            {
                var dr = producer.ProduceAsync("test-topic", new Message<Null, string> { Value = "Hello Kafka!" }).Result;
                Console.WriteLine($"Delivered '{dr.Value}' to '{dr.TopicPartitionOffset}'");
            }
            catch (ProduceException<Null, string> e)
            {
                Console.WriteLine($"Delivery failed: {e.Error.Reason}");
            }
        }

        var consumerConfig = new ConsumerConfig
        {
            BootstrapServers = "localhost:9092",
            GroupId = "test-consumer-group",
            AutoOffsetReset = AutoOffsetReset.Earliest
        };

        using (var consumer = new ConsumerBuilder<Ignore, string>(consumerConfig).Build())
        {
            consumer.Subscribe("test-topic");

            CancellationTokenSource cts = new CancellationTokenSource();
            Console.CancelKeyPress += (_, e) => {
                e.Cancel = true; // prevent the process from terminating
                cts.Cancel();
            };

            try
            {
                while (true)
                {
                    try
                    {
                        var cr = consumer.Consume(cts.Token);
                        Console.WriteLine($"Consumed message '{cr.Value}' at: '{cr.TopicPartitionOffset}'.");
                    }
                    catch (ConsumeException e)
                    {
                        Console.WriteLine($"Error occurred: {e.Error.Reason}");
                    }
                }
            }
            catch (OperationCanceledException)
            {
                consumer.Close();
            }
        }
    }
}

Azure Service Bus

O Azure Service Bus é um serviço de mensageria gerenciado que fornece filas e tópicos para comunicação assíncrona entre aplicativos (SABBAG FILHO, 2025). É ideal para aplicações que precisam de alta disponibilidade e escalabilidade.

Configuração do Azure Service Bus

Para começar a usar o Azure Service Bus, você deve criar um namespace no portal do Azure e obter a string de conexão.

Publicando e Consumindo Mensagens

Aqui está um exemplo de como interagir com o Azure Service Bus usando a biblioteca Azure.Messaging.ServiceBus:

using Azure.Messaging.ServiceBus;
using System;
using System.Threading.Tasks;

class Program
{
    const string connectionString = "Your_Connection_String";
    const string queueName = "test-queue";

    static async Task Main()
    {
        await SendMessageAsync("Hello Azure Service Bus!");
        await ReceiveMessagesAsync();
    }

    static async Task SendMessageAsync(string messageContent)
    {
        var client = new ServiceBusClient(connectionString);
        var sender = client.CreateSender(queueName);

        var message = new ServiceBusMessage(messageContent);
        await sender.SendMessageAsync(message);
        Console.WriteLine($"Sent: {messageContent}");

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

    static async Task ReceiveMessagesAsync()
    {
        var client = new ServiceBusClient(connectionString);
        var processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());

        processor.ProcessMessageAsync += MessageHandler;
        processor.ProcessErrorAsync += ErrorHandler;

        await processor.StartProcessingAsync();

        Console.WriteLine("Press any key to stop the processing...");
        Console.ReadKey();

        await processor.StopProcessingAsync();
        await processor.DisposeAsync();
        await client.DisposeAsync();
    }

    static Task MessageHandler(ProcessMessageEventArgs args)
    {
        Console.WriteLine($"Received: {args.Message.Body.ToString()}");
        return args.CompleteMessageAsync(args.Message);
    }

    static Task ErrorHandler(ProcessErrorEventArgs args)
    {
        Console.WriteLine($"Error: {args.Exception.Message}");
        return Task.CompletedTask;
    }
}

Comparação entre RabbitMQ, Kafka e Azure Service Bus

Ao escolher uma solução de mensageria, é importante considerar as características de cada uma:

• RabbitMQ: Ideal para aplicações que requerem uma comunicação simples e rápida. Possui suporte a mensagens persistentes e diversas opções de roteamento.
• Kafka: Melhor para aplicações de streaming de dados e grandes volumes de transações. É altamente escalável e permite o processamento em tempo real.
• Azure Service Bus: Ótimo para aplicações na nuvem que exigem um serviço gerenciado. Oferece integração fácil com outros serviços do Azure e suporte a transações.

Conclusão

A mensageria orientada a eventos é um componente crucial em arquiteturas modernas de software. RabbitMQ, Kafka e Azure Service Bus oferecem soluções robustas para diferentes necessidades. A escolha da ferramenta certa depende dos requisitos específicos do seu projeto, incluindo volume de dados, complexidade do sistema e infraestrutura existente.