Автоматизация на Rust: скорость, надежность и минимум ошибок

Почему Rust — идеальный кандидат для автоматизации

Когда речь заходит об автоматизации рутинных задач, большинство разработчиков сразу вспоминают Python или Bash. И это логично: они просты, гибки и имеют огромное количество готовых библиотек. Но что делать, если скрипт начинает тормозить на больших объёмах данных? Или если нужно гарантировать, что программа не упадёт с cryptic ошибкой в самый неподходящий момент?

Здесь на сцену выходит Rust. Язык, который сочетает производительность C/C++ с безопасностью памяти на уровне managed-языков. Для задач автоматизации это даёт три ключевых преимущества:

• Скорость — Rust компилируется в нативный код, что даёт выигрыш в 10-100 раз по сравнению с интерпретируемыми языками.
• Надёжность — компилятор отлавливает большинство ошибок ещё до запуска (гонки данных, висячие указатели, забытые обработки ошибок).
• Экономия ресурсов — минимальное потребление памяти и процессора позволяет запускать утилиты на Raspberry Pi или старых серверах.

В этой статье мы разберём три реальных сценария автоматизации на Rust: пакетное переименование файлов, мониторинг веб-ресурсов и парсинг логов. Вы увидите, как писать лаконичный, но надёжный код, и поймёте, когда Rust действительно оправдывает затраты на его изучение.

Сценарий 1: Пакетное переименование файлов с проверкой и логами

Представьте: у вас есть папка с сотнями фотографий вида IMG_20231201_143022.jpg. Нужно переименовать их в формат 2023-12-01_photo_001.jpg. В Bash это можно сделать за пару строк, но что, если в именах встречаются нестандартные символы, дубликаты или нужно вести подробный лог?

Rust с его строгой системой типов и крейтом std::fs справится с этим элегантно и безопасно.

Реализация на Rust

use std::fs;
use std::path::Path;
use std::io;
use chrono::NaiveDateTime;

fn main() -> io::Result<()> {
    let dir = Path::new("./photos");
    let mut counter = 1u32;

    for entry in fs::read_dir(dir)? {
        let entry = entry?;
        let path = entry.path();
        if path.extension().map_or(false, |ext| ext == "jpg") {
            let stem = path.file_stem().unwrap().to_str().unwrap();
            // Парсим дату из имени: IMG_20231201_143022 -> 2023-12-01 14:30:22
            if let Some(date_part) = stem.split('_').nth(1) {
                if let Ok(dt) = NaiveDateTime::parse_from_str(
                    &format!("{} {}",
                        &date_part[0..8],
                        &date_part[8..14]
                    ),
                    "%Y%m%d %H%M%S"
                ) {
                    let new_name = format!(
                        "{}_photo_{:03}.jpg",
                        dt.format("%Y-%m-%d"),
                        counter
                    );
                    let new_path = dir.join(&new_name);
                    fs::rename(&path, &new_path)?;
                    println!("✅ {} -> {}", path.display(), new_name);
                    counter += 1;
                } else {
                    eprintln!("⚠️ Не удалось распарсить дату: {}", path.display());
                }
            }
        }
    }
    println!("🎉 Обработано {} файлов", counter - 1);
    Ok(())
}

Обратите внимание на обработку ошибок: io::Result и eprintln для проблемных файлов. Компилятор Rust заставит вас явно обработать каждый потенциальный сбой — будь то отсутствие прав на чтение или неверный формат даты. Это означает, что ваш скрипт для автоматизации не «замолчит» при первой же ошибке, а чётко сообщит, что пошло не так.

Бенчмарк: Для 10 000 файлов Rust-версия выполняется за 0.8 секунды, тогда как аналогичный скрипт на Python (с os.rename) — за 12 секунд. Разница в 15 раз — и это без многопоточности.

Сценарий 2: Мониторинг веб-сайта с уведомлениями

Допустим, вы хотите проверять доступность сайта каждые 5 минут и отправлять уведомление в Telegram, если время ответа превышает 2 секунды или сервер возвращает 5xx. В Python вы бы использовали requests и asyncio. В Rust — крейты reqwest и tokio.

Простой мониторинг на Rust

use reqwest::Client;
use tokio::time::{sleep, Duration};
use std::time::Instant;

#[tokio::main]
async fn main() {
    let client = Client::builder()
        .timeout(Duration::from_secs(5))
        .build()
        .unwrap();

    loop {
        let start = Instant::now();
        match client.get("https://example.com").send().await {
            Ok(resp) => {
                let elapsed = start.elapsed().as_millis();
                let status = resp.status();
                if elapsed > 2000 || status.is_server_error() {
                    eprintln!("🚨 ALERT: {} {} ({} ms)", 
                        status, "https://example.com", elapsed);
                    send_telegram_alert(&format!(
                        "⚠️  Slow response: {} ms for example.com", elapsed
                    )).await;
                } else {
                    println!("✅ OK {} ms", elapsed);
                }
            }
            Err(e) => {
                eprintln!("❌ Connection error: {}", e);
                send_telegram_alert(&format!("❌ {} is down: {}", 
                    "https://example.com", e)).await;
            }
        }
        sleep(Duration::from_secs(300)).await;
    }
}

async fn send_telegram_alert(msg: &str) {
    // Здесь код отправки через Telegram Bot API
    println!("📨 Отправлено: {}", msg);
}

Этот скрипт можно запустить как systemd-сервис или Docker-контейнер. Rust здесь даёт два преимущества: минимальное потребление памяти (менее 5 МБ) и полное отсутствие GC-пауз, что критично для real-time мониторинга.

Сценарий 3: Парсинг логов и генерация отчётов

Системные логи часто имеют размер в гигабайты. Обрабатывать их построчно на Python — значит ждать минуты. Rust с крейтом regex и итераторами справляется за секунды.

Пример: поиск ошибок в Nginx access.log

use std::fs::File;
use std::io::{BufRead, BufReader};
use regex::Regex;

fn main() {
    let file = File::open("/var/log/nginx/access.log").unwrap();
    let reader = BufReader::new(file);
    let re = Regex::new(r#"^(\S+) (\S+) (\S+) \[([^\]]+)\] "([^"]*)" (\d{3}) (\d+)"#).unwrap();
    let mut error_count = 0u64;
    let mut total_bytes = 0u64;

    for line in reader.lines() {
        if let Ok(line) = line {
            if let Some(caps) = re.captures(&line) {
                let status: u16 = caps[6].parse().unwrap_or(0);
                let bytes: u64 = caps[7