Files d'attente de tâches en Rust : Aperçu des bibliothèques pour le traitement asynchrone

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

Rust est un langage de programmation système qui gagne en popularité dans le développement web et la création de microservices à forte charge. L'une des exigences clés pour les applications backend modernes est le traitement asynchrone des tâches en arrière-plan : envoi d'e-mails, génération de rapports, traitement de fichiers téléchargés ou interaction avec des API externes. Dans cet article, nous verrons comment organiser une file d'attente de tâches en Rust, quelles bibliothèques existent à cet effet et comment les utiliser en pratique.

Pourquoi une file d'attente de tâches ?

Dans une application synchrone, chaque opération est exécutée séquentiellement. Si un utilisateur lance une tâche longue (par exemple, le traitement d'une vidéo), le serveur sera bloqué jusqu'à son achèvement. La file d'attente de tâches résout ce problème : les tâches sont placées dans un courtier (file d'attente), et des workers spéciaux les récupèrent et les exécutent de manière asynchrone. Cela permet de :

• Décharger le thread principal de l'application ;
• Mettre à l'échelle le traitement horizontalement (ajouter des workers) ;
• Garantir l'exécution de la tâche même en cas de panne (grâce aux accusés de réception et aux tentatives répétées).

Bibliothèques populaires pour organiser des files d'attente en Rust

L'écosystème Rust propose plusieurs solutions matures. Examinons trois approches principales.

1. Celery-rs (Rust Celery)

Celery-rs est une implémentation en Rust du populaire Python Celery. La bibliothèque permet d'utiliser les courtiers Redis ou RabbitMQ. Elle est idéale si vous migrez de Python vers Rust ou si vous souhaitez une compatibilité avec une infrastructure Celery existante.

Exemple de worker de base :

use celery::Celery;use celery::task::Task;

#[celery::task]fn add(x: i32, y: i32) -> i32 {    x + y}

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let celery = Celery::builder("redis://localhost:6379/0")        .with_task(add)        .build().await?;

    // Démarrage du worker    celery.run().await?;

    // Envoi de la tâche    let task_id = add.delay(&celery, 1, 2).await?;    println!("Task ID: {}", task_id);

    Ok(())}

Avantages : API familière pour les développeurs Python, prise en charge de scénarios complexes (retry, ETA, tâches chord).
Inconvénients : dépendance à Redis/RabbitMQ, un peu lourde pour les cas simples.

2. Lapin + Tokio (travail direct avec RabbitMQ)

Lapin est un client AMQP haute performance pour Rust, fonctionnant sur Tokio. Si vous avez besoin d'un contrôle total sur les files d'attente, les exchanges et les routing keys, Lapin est le meilleur choix. Il ne fournit pas d'abstractions de tâches "prêtes à l'emploi", mais offre de la flexibilité.

Exemple d'envoi et de réception d'un message :

use lapin::{options::*, types::FieldTable, Connection, ConnectionProperties};use tokio_amqp::*;

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

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

    // Envoi de la tâche    let payload = b"Hello, task!";    channel.basic_publish(        "",        "task_queue",        BasicPublishOptions::default(),        payload,        BasicProperties::default(),    ).await?;

    // Réception de la tâche (worker)    let consumer = channel.basic_consume(        "task_queue",        "consumer",        BasicConsumeOptions::default(),        FieldTable::default(),    ).await?;

    while let Some(delivery) = consumer.next().await {        let delivery = delivery?;        println!("Received task: {:?}", delivery.data);        delivery.a