Azure Event Hubs Documentation

Getting Started with Azure Event Hubs

New to Event Hubs? This guide will walk you through the essential steps to get up and running.

1. What is Azure Event Hubs?

Azure Event Hubs is a highly scalable data streaming platform and event ingestion service. It can receive and process millions of events per second. Event Hubs is designed for scenarios where large volumes of data need to be ingested and processed in near real-time. It acts as a buffer between your event producers and event consumers.

2. Core Concepts to Understand

Before diving in, familiarize yourself with these key terms:

• Event Producers: Applications or devices that send data to an Event Hub.
• Event Consumers: Applications that read data from an Event Hub.
• Event Hub: The central entity where events are sent. You can think of it as a very large buffer.
• Partition: An Event Hub is divided into partitions. Each partition acts as an independent stream of events. Data is appended to partitions in order.
• Consumer Group: A specific view of an Event Hub. Each consumer group allows multiple applications to read from the Event Hub independently and at their own pace.

3. Creating an Event Hub Namespace and Event Hub

To start using Event Hubs, you need to create an Event Hub Namespace in your Azure subscription. Within this namespace, you can then create one or more Event Hubs.

1. Sign in to the Azure portal.
2. Search for "Event Hubs" and select it.
3. Click "Create".
4. Choose your subscription, resource group, and a region.
5. Provide a unique name for your Event Hub Namespace.
6. Select a pricing tier (e.g., Basic, Standard).
7. Click "Review + create" and then "Create".
8. Once the namespace is deployed, navigate to it and click "+ Event Hub".
9. Give your Event Hub a name (e.g., "myeventhub").
10. Configure the number of partitions and the message retention period.
11. Click "Create".

4. Obtaining Connection Strings

Your event producers and consumers will need connection strings to interact with your Event Hub. You can find these in the Azure portal:

1. Navigate to your Event Hub Namespace.
2. In the left menu, under "Settings", select "Shared access policies".
3. Click on the "RootManageSharedAccessKey" policy (or create a new one with appropriate permissions).
4. Copy the "Primary Connection String". This string contains the endpoint and keys needed to connect.

5. Sending and Receiving Events

You can use various SDKs (Software Development Kits) provided by Azure to send and receive events. Here's a conceptual example using a placeholder for a generic SDK:

Sending an Event (Producer)

// Conceptual example using a hypothetical SDK
const connectionString = "YOUR_EVENTHUB_CONNECTION_STRING";
const eventHubName = "myeventhub";

const producer = new EventHubProducerClient(connectionString, eventHubName);

async function sendEvent() {
    const eventData = {
        body: JSON.stringify({ message: "Hello, Event Hubs!", timestamp: new Date() }),
        partitionKey: "some-key" // Optional: for consistent ordering within a partition
    };
    await producer.sendEvent(eventData);
    console.log("Event sent successfully!");
}

sendEvent().catch(err => console.error("Error sending event:", err));
            

Receiving Events (Consumer)

// Conceptual example using a hypothetical SDK
const connectionString = "YOUR_EVENTHUB_CONNECTION_STRING";
const eventHubName = "myeventhub";
const consumerGroupName = "$Default"; // Or your custom consumer group

const consumerClient = new EventHubConsumerClient(consumerGroupName, connectionString, eventHubName);

async function processEvents() {
    const subscription = consumerClient.subscribe({
        async onReceived(eventData, context) {
            console.log(`Received event: ${JSON.stringify(eventData.body)}`);
            // Process the event data here
        }
    });

    console.log("Listening for events...");

    // To stop listening after some time or based on a condition:
    // setTimeout(() => {
    //     subscription.close();
    //     console.log("Stopped listening.");
    // }, 60000); // Stop after 1 minute
}

processEvents().catch(err => console.error("Error processing events:", err));
            

Next Steps

Now that you have a basic understanding, explore the quickstarts to implement sending and receiving events in your preferred programming language. Delve deeper into partitions and event processors to build robust streaming applications.