Files d'attente de tâches pour Rust : Aperçu des bibliothèques et outils populaires

Files d'attente de tâches pour Rust : aperçu des outils et bibliothèques

Rust est un langage de programmation système de plus en plus utilisé pour créer des services web et des microservices à forte charge. L'une des tâches clés dans de tels projets est l'organisation du traitement asynchrone des tâches à l'aide de files d'attente. Dans cet article, nous examinerons les principales bibliothèques et approches pour travailler avec les files d'attente de tâches en Rust, y compris les mécanismes intégrés et les intégrations avec les courtiers de messages populaires.

Pourquoi des files d'attente de tâches ?

Les files d'attente de tâches (task queues) permettent de séparer l'exécution d'opérations longues ou en arrière-plan du flux principal de traitement des requêtes. Cas d'utilisation typiques :

• Envoi de notifications par email
• Traitement d'images et de vidéos
• Exécution de tâches périodiques (tâches cron)
• Calculs distribués

Dans l'écosystème Rust, il existe plusieurs approches à cet effet : de l'utilisation des runtimes asynchrones intégrés à l'intégration avec des courtiers externes.

1. Tokio + async-std : la base de l'asynchronisme

Avant de parler de files d'attente spécifiques, il convient de mentionner les deux principaux runtimes asynchrones en Rust : Tokio et async-std. Ils fournissent des mécanismes de base pour travailler avec les tâches :

• tokio::spawn — lancement d'une tâche en arrière-plan
• async_std::task::spawn — équivalent pour async-std
• Canaux (channels) pour la transmission de messages entre tâches

Exemple d'une file d'attente simple sur les canaux Tokio :

use tokio::sync::mpsc;use tokio::time::{sleep, Duration};

#[tokio::main]async fn main() {    let (tx, mut rx) = mpsc::channel::<String>(32);

    // Envoyer des tâches    tokio::spawn(async move {        for i in 0..5 {            tx.send(format!("Tâche {}", i)).await.unwrap();            sleep(Duration::from_millis(100)).await;        }    });

    // Traiter les tâches    while let Some(task) = rx.recv().await {        println!("Traitement : {}", task);    }}

Cette approche convient aux cas simples, mais ne possède pas de persistance ni de mise à l'échelle entre processus.

2. lapin — client AMQP pour RabbitMQ

lapin est l'une des bibliothèques les plus populaires pour travailler avec RabbitMQ en Rust. Elle prend en charge l'ensemble des fonctionnalités AMQP 0-9-1 :

• Files d'attente, échangeurs (exchanges), liaisons (bindings)
• Confirmations de livraison (publisher confirms)
• Lettres mortes (dead letter exchanges)
• Consommation asynchrone de messages

Exemple de publication et de consommation de messages :

use lapin::{options::*, types::FieldTable, Connection, ConnectionProperties};use futures_util::stream::StreamExt;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let conn = Connection::connect(        "amqp://guest:guest@localhost:5672",        ConnectionProperties::default(),    ).await?;

    let channel = conn.create_channel().await?;    channel.queue_declare(        "task_queue",        QueueDeclareOptions::default(),        FieldTable::default(),    ).await?;

    // Publication d'une tâche    channel.basic_publish(        "",        "task_queue",        BasicPublishOptions::default(),        b"Bonjour, RabbitMQ!",        BasicProperties::default(),    ).await?;

    // Consommation des tâches    let mut consumer = channel.basic_consume(        "task_queue",        "consumer",        BasicConsumeOptions::default(),        FieldTable::default(),    ).await?;

    while let Some(delivery) = consumer.next().await {        let delivery = delivery?;        println!("Reçu : {:?}", delivery.data);        delivery.ack(BasicAckOptions::default()).await?;    }    Ok(())}

lapin est activement maintenu et bien docume