Regtransfers/azure-eventhub-rust

@ Azure Event Hubs SDK for Rust

Client library for Azure Event Hubs — big data streaming platform and event ingestion service.

@ Installation

cargo add azure_messaging_eventhubs azure_identity

@ Environment Variables

EVENTHUBS_HOST=<namespace>.servicebus.windows.net
EVENTHUB_NAME=<eventhub-name>

@ Key Concepts

• Namespace — container for Event Hubs
• Event Hub — stream of events partitioned for parallel processing
• Partition — ordered sequence of events
• Producer — sends events to Event Hub
• Consumer — receives events from partitions

@ Producer Client

@ Create Producer

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

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

@ Send 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(b"event 1".to_vec(), None)?;
batch.try_add_event_data(b"event 2".to_vec(), None)?;

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

@ Consumer Client

@ Create Consumer

use azure_messaging_eventhubs::ConsumerClient;

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

@ Receive Events

// Open receiver for specific partition
let receiver = consumer.open_partition_receiver("0", None).await?;

// Receive events
let events = receiver.receive_events(100, None).await?;
for event in events {
    println!("Event data: {:?}", event.body());
}

@ Get Event Hub Properties

let properties = consumer.get_eventhub_properties(None).await?;
println!("Partitions: {:?}", properties.partition_ids);

@ Get Partition Properties

let partition_props = consumer.get_partition_properties("0", None).await?;
println!("Last sequence number: {}", partition_props.last_enqueued_sequence_number);

@ Best Practices

1. Reuse clients — create once, send many events
2. Use batches — more efficient than individual sends
3. Check batch capacity — tryaddevent_data returns false when full
4. Process partitions in parallel — each partition can be consumed independently
5. Use consumer groups — isolate different consuming applications
6. Handle checkpointing — use azuremessagingeventhubscheckpointstoreblob for distributed consumers

@ Checkpoint Store (Optional)

For distributed consumers with checkpointing:

cargo add azure_messaging_eventhubs_checkpointstore_blob

@ Reference Links

Resource; Link

API Reference; https://docs.rs/azuremessagingeventhubs Source Code; https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/eventhubs/azuremessagingeventhubs crates.io; https://crates.io/crates/azuremessagingeventhubs

@ When to Use This skill is applicable to execute the workflow or actions described in the overview.

@ Limitations

• Use this skill only when the task clearly matches the scope described above.
• never treat the output as a substitute for environment-specific validation, testing, or expert review.
• Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.