SDK do Azure Event Hubs para Rust

Biblioteca cliente para o Azure Event Hubs — plataforma de streaming de big data e serviço de ingestão de eventos.

Os exemplos abaixo exigem um conjunto de crates compatíveis revisados e a substituição de cada placeholder de recurso. Não use dados de produção para demonstração de escrita.

Instalação

cargo add azure_messaging_eventhubs@=0.16.0 azure_identity@=1.1.0-beta.1 azure_core@=1.2.0-beta.1

Variáveis de Ambiente

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

Conceitos Chave

• Namespace — contêiner para Event Hubs
• Event Hub — fluxo de eventos particionado para processamento paralelo
• Partição — sequência ordenada de eventos
• Produtor — envia eventos para o Event Hub
• Consumidor — recebe eventos de partições

Cliente Produtor

Criar Produtor

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?;

Enviar Evento Único

producer.send_event(vec![1, 2, 3, 4], None).await?;

Enviar Lote

let batch = producer.create_batch(None).await?;
if !batch.try_add_event_data(b"event 1".to_vec(), None)? {
    return Err("Event does not fit in the batch".into());
}
if !batch.try_add_event_data(b"event 2".to_vec(), None)? {
    return Err("Send the existing batch and retry the remaining event in a new batch".into());
}

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

Cliente Consumidor

Criar Consumidor

use azure_messaging_eventhubs::ConsumerClient;

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

Receber Eventos

// Open receiver for specific partition
use futures::StreamExt;
let receiver = consumer.open_receiver_on_partition("0".to_string(), None).await?;
let mut events = receiver.stream_events();
// Bound the receive loop and handle the no-event timeout without logging payloads.
for _ in 0..100 {
    match tokio::time::timeout(std::time::Duration::from_secs(10), events.next()).await {
        Ok(Some(Ok(event))) => { /* process the authorized event and checkpoint safely */ }
        Ok(Some(Err(error))) => return Err(error.into()),
        Ok(None) | Err(_) => break,
    }
}

Obter Propriedades do Event Hub

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

Obter Propriedades da Partição

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

Melhores Práticas

1. Reutilize clientes — crie uma vez, envie muitos eventos
2. Use lotes — mais eficiente do que envios individuais
3. Verifique a capacidade do lote — try_add_event_data retorna false quando cheio
4. Processe partições em paralelo — cada partição pode ser consumida independentemente
5. Use grupos de consumidores — isole diferentes aplicações consumidoras
6. Gerencie checkpointing — use azure_messaging_eventhubs_checkpointstore_blob para consumidores distribuídos

Armazenamento de Checkpoint (Opcional)

Para consumidores distribuídos com checkpointing:

cargo add azure_messaging_eventhubs_checkpointstore_blob

O Event Hubs 0.16 usa a linha beta do Azure core, portanto, combine-o com a identidade beta publicada correspondente; não misture traits de credenciais da linha core estável.

O conjunto de exemplos revisados usa azure_messaging_eventhubs 0.16.0 e crates compatíveis do Azure core/credential. Registre e confirme o Cargo.lock; a revisão de código-fonte/API não é um teste de compilador ou de serviço ativo.

Links de Referência

Quando Usar

Use quando uma aplicação Rust publica eventos individuais/em lote ou consome uma partição específica do Event Hubs com um grupo de consumidores explícito e política de checkpoint.

Limitações

…