Cela fait un moment que j’ai envie d’apprendre un langage autre que le traditionnel Python, et après quelques recherches je me suis tourné vers Rust. Langage réputé pour sa sécurité et sa performance, il n’existe pas encore des masses de ressources à ce sujet, c’est pourquoi l’autoformation est essentielle. Pour faire mes premiers pas, je me suis penché sur la création d’un script utile pour tout sys admin ou devops qui se respecte : un moniteur système.

Comme c’est une première approche, ce script se veut simple et se contente de surveiller l’utilisation du CPU, de la mémoire, de l’espace disque, et de lister les interfaces réseau actives.

NB : ceci n’explique pas comment fonctionne les bases de Rust, je vous invite à lire cet article pour en comprendre les fondamentaux. Néanmoins si vous avez déjà un peu codé vous verrez qu’il y a quelques similitudes avec d’autres langages plus connus (bon, Rust a l’air un peu plus psycho-rigide, mais il a une réputation à tenir !)

Prérequis

Avant de commencer, assurez-vous d’avoir les éléments suivants :

  1. Rust installé : Installez Rust via rustup.
  2. Un éditeur de texte : Comme VS Code ou celui dont vous avez l’habitude
  3. Connaissances de base en Rust : Variables, structures, boucles et fonctions.

1. Initialisation du projet

Créez un nouveau projet Rust :

cargo new system_monitor
cd system_monitor

2. Ajouter les dépendances

Modifiez le fichier Cargo.toml pour inclure les crates (ou modules) suivantes :

[dependencies]
sysinfo = "0.29"
pnet = { version = "0.31.0", features = ["std"] }

Ces crates fournissent des outils pour surveiller les ressources système et lister les interfaces réseau.

Ensuite, mettez à jour les dépendances :

cargo update

3. Fonctionnalité 1 : Surveillance du CPU

Code

Ajoutez le code suivant dans le fichier src/main.rs pour surveiller l’utilisation du CPU :

use sysinfo::{System, SystemExt, CpuExt};
use std::thread::sleep;
use std::time::Duration;

fn main() {
    let mut system = System::new_all();

    // Rafraîchir les données système
    system.refresh_all();

    // Ajouter un délai pour permettre la collecte des données CPU
    sleep(Duration::from_secs(1));

    // Rafraîchir les données CPU après le délai
    system.refresh_cpu();

    // Afficher l'utilisation du CPU
    println!("=== Utilisation du CPU ===");
    println!("Nombre total de CPU : {}", system.cpus().len());
    for (i, cpu) in system.cpus().iter().enumerate() {
        println!("Processeur {}: {}%", i + 1, cpu.cpu_usage());
    }
}

Explications

  • System::new_all() : Initialise un objet pour collecter les informations du système.
  • system.refresh_all() : Rafraîchit toutes les données système disponibles.
  • system.refresh_cpu() : Actualise spécifiquement les données CPU.
  • Boucle for : Itère sur tous les processeurs pour afficher leur utilisation.

Compilez et exécutez le script pour tester cette première fonctionnalité :

cargo run

4. Fonctionnalité 2 : Surveillance de la mémoire

Code

Ajoutez ce bloc au script pour afficher l’utilisation de la mémoire :

    // Surveiller la mémoire
    println!("\n=== Utilisation de la Mémoire ===");
    println!(
        "Mémoire utilisée : {} MB / {} MB",
        system.used_memory() / 1024,
        system.total_memory() / 1024
    );

Explication

  • system.used_memory() : Retourne la mémoire utilisée en kilooctets.
  • system.total_memory() : Retourne la mémoire totale en kilooctets.
  • Division par 1024 : Convertit les valeurs en mégaoctets (MB).

Relancez le script pour voir les informations sur la mémoire :

cargo run

5. Fonctionnalité 3 : Surveillance des disques

Code

Ajoutez ce bloc au script pour surveiller l’espace disque :

    // Surveiller l'espace disque
    println!("\n=== Espace Disque ===");
    for disk in system.disks() {
        println!(
            "Nom : {} | Espace libre : {} GB | Total : {} GB",
            disk.name().to_string_lossy(),
            disk.available_space() / 1_073_741_824,
            disk.total_space() / 1_073_741_824
        );
    }

Explication

  • system.disks() : Retourne une liste de tous les disques disponibles.
  • disk.available_space() et disk.total_space() : Affichent l’espace libre et total en octets.
  • Division par 1_073_741_824 : Convertit les octets en gigaoctets (GB).

Testez cette nouvelle fonctionnalité avec :

cargo run

6. Fonctionnalité 4 : Liste des interfaces réseau

Code

Ajoutez ce bloc au script pour afficher les interfaces réseau et leurs adresses IP :

use pnet::datalink;

    // Lister les interfaces réseau
    println!("\n=== Interfaces Réseau ===");
    for iface in datalink::interfaces() {
        println!("Interface : {}", iface.name);

        for ip in iface.ips {
            println!("  Adresse IP : {}", ip);
        }
    }

Explication

  • datalink::interfaces() : Retourne une liste des interfaces réseau disponibles.
  • iface.ips : Contient les adresses IP associées à chaque interface.

Testez cette fonctionnalité pour vérifier les interfaces réseau :

cargo run

Et voilà ! Vous avez conçu un script de surveillance en Rust en ajoutant une fonctionnalité à la fois. Chaque étape vous a permis d’apprendre à utiliser les crates sysinfo et pnet pour collecter des informations système et réseau.

Suggestions d’amélioration

  1. Journalisation : Sauvegardez les données dans un fichier JSON ou texte.
  2. Alertes : Générez des alertes si certaines limites sont dépassées.
  3. Boucle continue : Exécutez le script en boucle pour une surveillance en temps réel.