Planificador de tareas en Rust: revisión de bibliotecas e implementación

Planificador de tareas en Rust: guía completa sobre bibliotecas e implementación

En el desarrollo moderno de aplicaciones de servidor y sistemas de automatización, el planificador de tareas (task scheduler) es uno de los componentes clave. Rust, gracias a su rendimiento y seguridad de memoria, ofrece varias soluciones potentes para crear planificadores flexibles y eficientes. En este artículo, revisaremos en detalle las principales bibliotecas para la planificación de tareas en Rust, sus capacidades, ejemplos de uso y comparación con alternativas en Python.

Principales bibliotecas para la planificación de tareas en Rust

El ecosistema de Rust ofrece varias soluciones maduras para trabajar con planificadores de tareas. Consideremos las tres bibliotecas más populares:

• tokio-schedule — planificador asíncrono basado en tokio, compatible con expresiones cron y tareas por intervalos
• cron — biblioteca ligera para trabajar con expresiones cron, a menudo utilizada junto con tokio
• async-task-scheduler — planificador de alto nivel con soporte para prioridades, reintentos y reglas de ejecución complejas

Instalación y configuración de tokio-schedule

Para comenzar, agregue las dependencias a su Cargo.toml:

[dependencies]tokio = { version = "1.0", features = ["full"] }tokio-schedule = "0.4"chrono = "0.4"

Ejemplo 1: Planificador simple con intervalo

Creemos un planificador básico que ejecuta una tarea cada 5 segundos:

use tokio::time::{sleep, Duration};use tokio_schedule::Job;

#[tokio::main]async fn main() {    // Creamos una tarea que se ejecuta cada 5 segundos    let job = Job::new()        .every(Duration::from_secs(5))        .run(|| async {            println!("Tarea ejecutada en: {}", chrono::Local::now());        });

    println!("Planificador iniciado. Presione Ctrl+C para detener.");    job.start().await;        // Espera infinita    loop {        sleep(Duration::from_secs(1)).await;    }}

Ejemplo 2: Planificador con expresión cron

Un ejemplo más complejo usando sintaxis cron para un control preciso del tiempo de ejecución:

use tokio_schedule::Job;use std::sync::Arc;use std::sync::atomic::{AtomicU64, Ordering};

#[tokio::main]async fn main() {    let counter = Arc::new(AtomicU64::new(0));    let counter_clone = counter.clone();

    // Ejecución cada minuto en el segundo 30    let job = Job::new()        .cron("30 * * * * *") // segundo, minuto, hora, día, mes, día_semana        .run(move || {            let cnt = counter_clone.fetch_add(1, Ordering::SeqCst);            async move {                println!("[{}] Ejecución de tarea en: {}", cnt, chrono::Local::now());                // Aquí puede ir su lógica de negocio                simulate_work().await;            }        });

    println!("Planificador con cron iniciado.");    job.start().await;

    // Demostración de funcionamiento durante 2 minutos    tokio::time::sleep(Duration::from_secs(120)).await;}

async fn simulate_work() {    // Simulación de trabajo    tokio::time::sleep(Duration::from_millis(500)).await;}

Ejemplo 3: Planificador con múltiples tareas y prioridades

Uso de la biblioteca async-task-scheduler para gestionar múltiples tareas:

use async_task_scheduler::{Scheduler, Task, Priority};use std::time::Duration;

#[tokio::main]async fn main() {    let mut scheduler = Scheduler::new();

    // Tarea de alta prioridad — se ejecuta cada 2 segundos    scheduler.add_task(        Task::new("high_priority_task", || async {            println!("[HIGH] Tarea urgente ejecutada");        })        .interval(Duration::from_secs(2))        .priority(Priority::High)    );

    // Tarea de baja prioridad — se e