Publishing Events to Azure Event Hubs

This guide demonstrates how to publish events to an Azure Event Hub using various SDKs. Publishing events is a fundamental operation for streaming data into Event Hubs.

Prerequisites

• An Azure subscription.
• An Azure Event Hubs namespace.
• An Event Hub within your namespace.
• The connection string for your Event Hubs namespace.
• The required SDK installed for your chosen programming language.

Publishing Events with the .NET SDK

The Azure Event Hubs SDK for .NET provides a straightforward way to send events. We'll use the EventHubProducerClient class.

1. Install the NuGet Package

dotnet add package Azure.Messaging.EventHubs
            

2. Sample C# Code

using Azure.Messaging.EventHubs;
using System;
using System.Text;
using System.Threading.Tasks;

public class EventPublisher
{
    private const string eventHubNamespaceConnectionString = "";
    private const string eventHubName = "";

    public static async Task Main(string[] args)
    {
        await SendEventsAsync();
        Console.WriteLine("Events sent successfully!");
    }

    public static async Task SendEventsAsync()
    {
        // The Event Hubs client types are safe to instantiate and use multiple times and are best practices.
        await using (var producer = new EventHubProducerClient(eventHubNamespaceConnectionString, eventHubName))
        {
            try
            {
                // Create a batch of events
                using EventDataBatch eventBatch = await producer.CreateBatchAsync();

                for (int i = 0; i < 5; i++)
                {
                    var eventData = new EventData(Encoding.UTF8.GetBytes($"Event {i + 1}"));
                    if (!eventBatch.TryAdd(eventData))
                    {
                        // If the batch is full, send it and create a new one
                        await producer.SendAsync(eventBatch);
                        Console.WriteLine($"Sent batch containing {eventBatch.Count} events.");
                        eventBatch = await producer.CreateBatchAsync();
                        eventBatch.TryAdd(eventData); // Add the current event to the new batch
                    }
                }

                // Send the last batch if it's not empty
                if (eventBatch.Count > 0)
                {
                    await producer.SendAsync(eventBatch);
                    Console.WriteLine($"Sent last batch containing {eventBatch.Count} events.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error sending events: {ex.Message}");
                // Handle exceptions appropriately
            }
        }
    }
}
            

3. Replace Placeholders

Remember to replace <YOUR_EVENT_HUB_NAMESPACE_CONNECTION_STRING> and <YOUR_EVENT_HUB_NAME> with your actual connection string and Event Hub name.

Publishing Events with the Python SDK

The Azure Event Hubs SDK for Python allows you to send events similarly.

1. Install the Package

pip install azure-eventhubs
            

2. Sample Python Code

import asyncio
from azure.eventhub import EventHubProducerClient

EVENT_HUB_CONNECTION_STR = ""
EVENT_HUB_NAME = ""

async def run():
    # Create a producer client to send events to the Event Hub
    async with EventHubProducerClient.from_connection_string(
        EVENT_HUB_CONNECTION_STR, EVENT_HUB_NAME
    ) as producer:
        try:
            # Create an event data batch
            batch = await producer.create_batch()

            for i in range(5):
                event_data = f"Event {i + 1} from Python"
                if not batch.add(event_data):
                    # If the batch is full, send it and create a new one
                    await producer.send_batch(batch)
                    print(f"Sent batch containing {len(batch)} events.")
                    batch = await producer.create_batch()
                    batch.add(event_data) # Add current event to the new batch

            # Send the last batch if it's not empty
            if len(batch) > 0:
                await producer.send_batch(batch)
                print(f"Sent last batch containing {len(batch)} events.")

        except Exception as e:
            print(f"Error sending events: {e}")

if __name__ == "__main__":
    asyncio.run(run())
            

3. Replace Placeholders

Update EVENT_HUB_CONNECTION_STR and EVENT_HUB_NAME with your Azure Event Hubs credentials.

Key Concepts

• EventData: Represents a single event with its body and optional metadata.
• EventDataBatch: A container for multiple EventData objects. Event Hubs has a maximum size limit for batches.
• ProducerClient: The primary class for sending events to Event Hubs.
• Connection String: Provides authentication and access information to your Event Hubs namespace.

Next Steps

Now that you know how to publish events, learn how to consume them: