Azure Event Hubs Documentation

Introduction to Azure Event Hubs

Azure Event Hubs is a big data streaming platform and event-ingestion service. It can be used for real-time analytics, disaster recovery, and offline processing. Event Hubs handles tens of thousands of events per second, allowing you to process and analyze streams of data from various sources.

It provides a distributed log that is highly available, scalable, and durable. Event Hubs is designed to ingest millions of events per second from a multitude of sources. The service is used for applications that process large volumes of events in near real-time.

Key Concepts

Understanding these core concepts is crucial for working effectively with Event Hubs:

Producers: Applications that send events to an Event Hub.
Consumers: Applications that read events from an Event Hub.
Event Hub: The central entity for receiving events. An Event Hub is composed of partitions.
Partitions: A stream of events that is ordered by time. Event Hubs guarantees that an event is placed into only one partition. Partitions allow Event Hubs to scale horizontally.
Consumer Groups: A named logical view of an Event Hub. Each consumer group allows a separate, independent consumption of the event stream.
Offsets: A unique identifier for an event within a partition. Consumers track their position in a partition using offsets.

Getting Started with Event Hubs

Follow these steps to quickly set up and start using Azure Event Hubs:

Create an Event Hubs Namespace: A namespace provides a unique scoping container for Event Hubs.
Create an Event Hub: Within the namespace, create your Event Hub instance, specifying the number of partitions and retention period.
Obtain Connection Strings: Get the connection string for your namespace to allow producers and consumers to connect.
Send Events: Use an SDK (e.g., .NET, Java, Python, Node.js) or the REST API to send events to your Event Hub.
Receive Events: Configure consumer groups and use an SDK to read events from the Event Hub.

For a detailed guide, see the tutorials section.

Key Features

High Throughput: Ingest millions of events per second.
Scalability: Horizontally scalable to handle fluctuating loads.
Low Latency: Real-time event processing.
Durability: Data is retained for a configurable period.
Security: Azure Active Directory integration and Shared Access Signatures (SAS) for authentication and authorization.
Standard and Basic Tiers: Choose a tier that fits your performance and cost requirements.

Common Use Cases

Telemetry Streaming: Collect and process telemetry data from IoT devices, applications, and sensors.
Log Aggregation: Aggregate logs from distributed systems for centralized analysis and monitoring.
Real-time Analytics: Power dashboards and insights with live data streams.
Event-Driven Architectures: Build responsive applications that react to events in real-time.
Data Archiving and Replay: Store event streams for compliance, debugging, or replaying.

API Reference

Event Hubs provides comprehensive SDKs for various programming languages and a REST API.

Code Samples

Explore these examples to see Event Hubs in action:

                    
// Example: Sending an event using Azure SDK for .NET
using Azure.Messaging.EventHubs;
using System;
using System.Text;
using System.Threading.Tasks;

public class EventSender
{
    private const string connectionString = "";
    private const string eventHubName = "";

    public static async Task SendEventAsync(string message)
    {
        await using var producerClient = new EventProducerClient(connectionString, eventHubName);

        try
        {
            var eventBody = Encoding.UTF8.GetBytes(message);
            await producerClient.SendAsync(new EventData(eventBody));
            Console.WriteLine($"Sent event: {message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error sending event: {ex.Message}");
        }
    }

    // Example usage:
    // await SendEventAsync("Hello from Event Hubs!");
}
                    
                

                    
# Example: Receiving events using Azure SDK for Python
from azure.eventhub import EventHubConsumerClient

connection_str = ""
consumer_group = "$Default"
eh_name = ""

def process_event(event):
    print(f"Received event: {event.body_as_str()}")

consumer_client = EventHubConsumerClient.from_connection_string(
    connection_str,
    consumer_group,
    event_hub_name=eh_name
)

with consumer_client:
    consumer_client.subscribe(
        process_event,
        partition_id="0" # Subscribe to a specific partition or omit for all
    )
    # To run indefinitely, you would typically use a loop or keep the application running
    # For demonstration purposes, we might process a limited number of events or run for a set time.
    # Example: consumer_client.run_for_time(time_in_seconds=60)
    print("Starting consumer...")
    # In a real application, you would keep this running
    import time
    time.sleep(30) # Keep running for 30 seconds for demo
    print("Stopping consumer.")

                