Travailler avec Kafka en Rust : bibliothèques et exemples pour débutants

Travailler avec Kafka en Rust : aperçu des bibliothèques et exemples pratiques

Apache Kafka est une plateforme distribuée de traitement de flux de données, largement utilisée pour construire des systèmes d'échange de messages fiables et évolutifs. Le langage Rust, grâce à ses performances et à sa sécurité mémoire, devient un choix de plus en plus populaire pour écrire des applications à forte charge fonctionnant avec Kafka. Dans cet article, nous examinerons les principales bibliothèques pour travailler avec Kafka en Rust, leur installation et présenterons des exemples de code simples.

Bibliothèques populaires pour Kafka en Rust

Actuellement, il existe deux approches principales pour travailler avec Kafka dans l'écosystème Rust :

• rdkafka — une surcouche de la bibliothèque C populaire librdkafka. Elle offre des performances et des fonctionnalités maximales, y compris la prise en charge de toutes les capacités modernes de Kafka (transactions, idempotence, garanties de livraison exactes).
• Kafka-Rust (kafka) — une implémentation pure du protocole Kafka en Rust, sans dépendances externes. Plus facile à compiler, mais peut être en retard en termes de fonctionnalités par rapport à rdkafka.

Pour la plupart des projets de production, il est recommandé d'utiliser rdkafka, car il est plus mature, performant et activement maintenu par la communauté.

Installation de rdkafka

Pour commencer, ajoutez la dépendance à votre Cargo.toml :

[dependencies]rdkafka = { version = "0.36", features = ["cmake-build"] }tokio = { version = "1", features = ["full"] }  # pour le travail asynchroneserde = { version = "1", features = ["derive"] }  # pour la sérialisation des donnéesserde_json = "1"  # pour travailler avec JSON

La bibliothèque rdkafka nécessite la présence de librdkafka sur le système. Vous pouvez l'installer via votre gestionnaire de paquets système ou utiliser la fonctionnalité cmake-build, comme dans l'exemple ci-dessus — dans ce cas, la bibliothèque sera compilée automatiquement.

Exemple : producteur de base (Producer)

Le producteur envoie des messages dans un topic Kafka spécifié. Voici un exemple simple de producteur asynchrone avec Tokio :

use rdkafka::config::ClientConfig;use rdkafka::producer::{FutureProducer, FutureRecord};use std::time::Duration;

#[tokio::main]async fn main() {    // Création de la configuration du producteur    let producer: FutureProducer = ClientConfig::new()        .set("bootstrap.servers", "localhost:9092")        .set("message.timeout.ms", "5000")        .create()        .expect("Erreur lors de la création du producteur");

    // Envoi d'un message dans le topic "my-topic"    let delivery_status = producer        .send(            FutureRecord::to("my-topic")                .payload("Bonjour, Kafka depuis Rust!")                .key("clé-du-message"),            Duration::from_secs(0),        )        .await;

    match delivery_status {        Ok(partition_offset) => println!("Message envoyé : {:?}", partition_offset),        Err((e, _)) => eprintln!("Erreur d'envoi : {}", e),    }}

Exemple : consommateur de base (Consumer)

Le consommateur lit les messages d'un topic. Voici un exemple de consommateur synchrone avec accusé de réception manuel (commit) :

use rdkafka::config::ClientConfig;use rdkafka::consumer::{Consumer, StreamConsumer};use rdkafka::message::Message;use rdkafka::util::get_rdkafka_version;

fn main() {    let consumer: StreamConsumer = ClientConfig::new()        .set("group.id", "my-consumer-group")        .set("bootstrap.servers", "localhost:9092")        .set("enable.auto.commit", "false")  // commit manuel        .set("auto.offset.reset", "earliest")  // lire depuis le début        .create()        .expect("Erreur lors de la création du consommateur");

    consumer.subscribe(&["my-topic"]).expect("Erreur d'abonnement");

    loop {        match consumer.recv() {            Ok(msg) => {                let paylo