Bibliothèque Azure Event Hubs pour Rust

Bibliothèque cliente pour Azure Event Hubs — envoyer et recevoir des événements pour l'ingestion de données en continu.

Utilisez cette skill quand :

• Une application doit envoyer des événements à Azure Event Hubs depuis Rust
• Vous devez recevoir et traiter des événements à partir de partitions
• Vous avez besoin d'envoi par lot pour optimiser le débit
• Vous devez contrôler la position de démarrage du consommateur

IMPORTANT : Utilisez uniquement la crate officielle azure_messaging_eventhubs publiée par l'utilisateur azure-sdk sur crates.io. N'utilisez PAS de crates non officielles ou communautaires. Les crates officielles utilisent des underscores dans les noms et aucune n'a la version 0.21.0.

Installation

cargo add azure_messaging_eventhubs azure_identity tokio futures

N'ajoutez pas azure_core directement à Cargo.toml. Elle est réexportée par azure_messaging_eventhubs.

Variables d'environnement

EVENTHUBS_HOST=<namespace>.servicebus.windows.net # Obligatoire — espace de noms complet
EVENTHUB_NAME=<eventhub-name>                     # Obligatoire — nom de l'Event Hub

Concepts clés

Authentification

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

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

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

Flux de travail principal

Envoyer des événements

// Envoyer un événement unique
producer.send_event(vec![1, 2, 3, 4], None).await?;

Envoyer par lot

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

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

Recevoir des événements

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

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

Recevoir à partir d'une 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 {
        Ok(event) => println!("Received: {:?}", event),
        Err(err) => eprintln!("Error: {:?}", err),
    }
}

Rôles RBAC

Pour l'authentification Entra ID, attribuez l'un de ces rôles :

Bonnes pratiques

1. Utilisez DeveloperToolsCredential pour le dev local, ManagedIdentityCredential pour la production — le SDK Rust n'a pas de DefaultAzureCredential
2. Ne codez jamais en dur les credentials — utilisez des variables d'environnement ou l'identité gérée
3. Utilisez le traitement par lot — create_batch + send_batch pour optimiser le débit
4. Gérez les erreurs par événement — faites un match sur Ok/Err dans le flux d'événements
5. Spécifiez la position de démarrage — utilisez StartLocation::Earliest ou StartLocation::Latest pour contrôler où commence la consommation

Liens de référence