Azure Eventhub Rust

Azure Event Hubs library for Rust

Client library for Azure Event Hubs — send and receive events for streaming data ingestion.

Use this skill when:

• An app needs to send events to Azure Event Hubs from Rust
• You need to receive and process events from partitions
• You need batch sending for throughput optimization
• You need to control consumer start position

> IMPORTANT: Only use the official azure_messaging_eventhubs crate published by the azure-sdk crates.io user. Do NOT use unofficial or community crates. Official crates use underscores in names and none have version 0.21.0.

Installation

cargo add azure_messaging_eventhubs azure_identity tokio futures

> DeveloperToolsCredential::new(None)? already returns an Arc<DeveloperToolsCredential>, so you can pass or clone it directly into .open(). Add azure_core only when you need direct azure_core imports such as ErrorKind.

Environment Variables

EVENTHUBS_HOST=<namespace>.servicebus.windows.net # Required — fully qualified namespace
EVENTHUB_NAME=<eventhub-name>                     # Required — name of the Event Hub

Key Concepts

| Concept | Description |

| ------------- | ---------------------------------------------------- |

| Namespace | Container for one or more Event Hubs |

| Event Hub | Stream of events, partitioned for parallel reads |

| Partition | Ordered, append-only sequence of events |

| Producer | Sends events via ProducerClient |

| Consumer | Receives events from partitions via ConsumerClient |

Authentication

Rust Azure SDK code must not use DefaultAzureCredential. The Rust identity crate does not provide that type.

use azure_identity::DeveloperToolsCredential;
use azure_messaging_eventhubs::ProducerClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Local dev: DeveloperToolsCredential. Production: use ManagedIdentityCredential.
    let credential = DeveloperToolsCredential::new(None)?;

    let producer = ProducerClient::builder()
        .open(
            "<namespace>.servicebus.windows.net",
            "<eventhub-name>",
            credential.clone(),
        )
        .await?;
    Ok(())
}

Prefer the crate README/examples when checking builder signatures and receive-stream event wrapper shapes.

Core Workflow

Send Events

// Send a single event
producer.send_event(vec![1, 2, 3, 4], None).await?;

Send Batch

let batch = producer.create_batch(None).await?;
batch.try_add_event_data(vec![1, 2, 3, 4], None)?;

producer.send_batch(batch, None).await?;

Receive Events

use azure_identity::DeveloperToolsCredential;
use azure_messaging_eventhubs::ConsumerClient;

// Local dev: DeveloperToolsCredential. Production: use ManagedIdentityCredential.
let credential = DeveloperToolsCredential::new(None)?;
let consumer = ConsumerClient::builder()
    .open(
        "<namespace>.servicebus.windows.net",
        "<eventhub-name>".to_string(),
        credential.clone(),
    )
    .await?;

Receive from Partition

use futures::stream::StreamExt;
use azure_messaging_eventhubs::{
    ConsumerClient, OpenReceiverOptions, StartLocation, StartPosition,
};

let receiver = consumer
    .open_receiver_on_partition(
        "0".to_string(),
        Some(OpenReceiverOptions {
            start_position: Some(StartPosition {
                location: StartLocation::Earliest,
                ..Default::default()
            }),
            ..Default::default()
        }),
    )
    .await?;

let mut stream = receiver.stream_events();
while let Some(event_result) = stream.next().await {
    match event_result {
        // Body is on the inner event data, not the received wrapper: `event.event_data().body()`.
        Ok(event) => {
            let body = event.event_data().body().unwrap_or_default();
            println!("Received: {:?}", body);
        }
        Err(err) => eprintln!("Error: {:?}", err),
    }
}

RBAC Roles

For Entra ID auth, assign one of these roles:

| Role | Access |

| -------------------------------- | -------------- |

| Azure Event Hubs Data Sender | Send events |

| Azure Event Hubs Data Receiver | Receive events |

| Azure Event Hubs Data Owner | Full access |

Best Practices

• Use cargo add to manage dependencies, never edit Cargo.toml directly. Add and remove Rust SDK dependencies with cargo commands instead of manual manifest edits.
• Pass or clone credentials directly into .open(). DeveloperToolsCredential::new(None)? already returns an Arc, so you do not need to annotate the binding as Arc<dyn TokenCredential> unless you are naming that trait object type explicitly.
• Match the builder signature. ProducerClient::builder().open(...) takes the hub name as &str, while ConsumerClient::builder().open(...) takes an owned String.
• Use DeveloperToolsCredential for local dev, ManagedIdentityCredential for production — Rust does not provide a single DefaultAzureCredential type
• Never hardcode credentials — use environment variables or managed identity
• Use batching — create_batch + send_batch for throughput optimization
• Handle errors per event — match on Ok/Err in the event stream
• Extract event bodies via event.event_data().body(), not event.body() — ReceivedEventData wraps the underlying EventData.
• Specify start position — use StartLocation::Earliest or StartLocation::Latest to control where consumption begins

10. Run cargo clippy -- -D warnings when the prompt, eval, or CI expects lint-clean output

Reference Links

| Resource | Link |

| ------------- | --------------------------------------------------------------------------------------------- |

| API Reference | https://docs.rs/azure_messaging_eventhubs/latest/azure_messaging_eventhubs |

| crates.io | https://crates.io/crates/azure_messaging_eventhubs |

| Source Code | https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/eventhubs/azure_messaging_eventhubs |