Enregistrer les avertissements de ressources

Introduction

FRAME Studio veut conserver une courte session de travail, plutôt qu’un affichage de terminal qui disparaît. Le collecteur de ressources est déjà complet dans cette instance indépendante. Vous transformerez les observations en avertissements explicites et les ajouterez sans perdre le relevé antérieur de l’opérateur.

Vous implémenterez trois fonctions : classifier une mesure, enregistrer une ligne complète et répéter l’action de collecte fournie. Variables, fonctions, conditions et boucles Bash sont des prérequis ; le premier laboratoire explique les indicateurs. Aucun fichier précédent n’est requis. Les seuils sont une politique pédagogique locale, pas une recommandation universelle de production. La durée est une estimation de l’auteur.

Donner un état explicite à chaque mesure

Dans cette étape, vous transformerez un pourcentage et son seuil en décision d’avertissement réutilisable.

Commencez dans Terminal. Cette instance indépendante contient déjà un metrics.sh fonctionnel ; aucun ancien fichier n’est nécessaire. Entrez dans l’espace de travail :

cd /home/labex/project/resource-watch

Observez une mesure actuelle :

bash snapshot.sh

Les quatre champs séparés par tabulations sont l’horodatage UTC, le processeur non inactif, la pression mémoire et l’utilisation du système cible. Ils décrivent cette instance, pas une flotte de production. Un avertissement de ressources ne prouve pas l’échec de l’export photo.

cat affiche la politique sans la modifier :

cat policy.sh

Lisez les trois limites et les chemins complets de cible et journal. Ici les limites processeur et mémoire sont 80, celle du disque 50. Ce sont des choix pédagogiques. La règle est WARN si une lecture est supérieure ou égale à sa propre limite, sinon OK. L’égalité importe. Préservez la politique et le collecteur fournis.

Ouvrez les fonctions incomplètes avec nano :

Ce laboratoire repart avec un fichier de métriques prêt et fonctionnel. Modifiez le fichier de fonctions de surveillance nommé dans la prochaine commande, au lieu de copier ici les métriques précédentes. Les trois valeurs LIMIT de la politique sont des pourcentages entiers ; TARGET est le répertoire observé et LOG le chemin de l'historique. Lire la politique ne la modifie pas.

nano monitor-functions.sh

Remplacez seulement classify par :

classify() {
    if (( $1 >= $2 )); then
        echo WARN
    else
        echo OK
    fi
}

Le premier argument est la lecture, le second sa limite. ((...)) compare des nombres ; >= inclut l’égalité. Les deux branches affichent un état : une lecture normale indique OK au lieu de rester silencieuse. Enregistrez avec Ctrl+O, Enter, Ctrl+X.

source charge les définitions. Lancez les tests dans bash -c, car le shell interactif est Zsh. Les apostrophes conservent les commandes pour Bash :

bash -c 'source ./monitor-functions.sh; classify 79 80; classify 80 80; classify 81 80'

OK
WARN
WARN

Ces lectures fournies testent la règle ; ce ne sont pas les mesures processeur actuelles. Une fonction donnant toujours WARN ou toujours OK est incorrecte même si le poste présente aujourd’hui cet état.

Ajouter un enregistrement complet

Dans cette étape, vous enregistrerez toutes les mesures et leurs états distincts sans remplacer l’historique.

Restez dans Terminal, dans /home/labex/project/resource-watch. Lisez d’abord l’historique de l’opérateur :

cat history.tsv

Sa ligne originale doit rester identique octet pour octet au début. history.tsv est le véritable livrable, pas un rapport à remplir à la main. Chaque nouvelle ligne comporte sept champs séparés par tabulations : horodatage UTC, processeur, mémoire, disque, puis leurs trois états dans le même ordre.

Ouvrez les fonctions :

nano monitor-functions.sh

Remplacez seulement record_sample par :

record_sample() {
    local stamp=$1 cpu=$2 memory=$3 disk=$4 logfile=$5
    printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
        "$stamp" "$cpu" "$memory" "$disk" \
        "$(classify "$cpu" "$CPU_LIMIT")" \
        "$(classify "$memory" "$MEMORY_LIMIT")" \
        "$(classify "$disk" "$DISK_LIMIT")" >> "$logfile"
}

printf remplace chaque %s, \t écrit une tabulation et \n termine la ligne. Une barre oblique inverse en fin de ligne poursuit la même commande. $(...) capture la sortie d’une fonction. Les guillemets préservent chaque valeur et un chemin de journal contenant des espaces. >> ajoute ; > détruirait les enregistrements précédents. Enregistrez avec Ctrl+O, Enter, Ctrl+X.

Essayez un enregistrement fourni dans un fichier d’entraînement séparé. source ./policy.sh charge les seuils dans ce processus Bash. Ces variables ne persistent pas automatiquement dans un autre terminal ou un prochain appel à bash -c.

bash -c 'source ./policy.sh; source ./monitor-functions.sh; record_sample 2026-01-02T03:04:05Z 10 85 20 practice.tsv'

cat practice.tsv

2026-01-02T03:04:05Z 10 85 20 OK WARN OK

L’avertissement mémoire compare 85 à 80 ; il ne transforme pas les deux autres états en WARN. Répéter l’appel ajoute une ligne d’entraînement. N’ajoutez pas de valeurs d’exemple à history.tsv : ce fichier est réservé aux mesures réelles.

Lisez les sept champs de l'exemple d'entraînement de gauche à droite :

Les tabulations peuvent ressembler à des espaces irréguliers dans Terminal. Conservez les vraies tabulations produites par la fonction ; n'alignez pas manuellement l'historique réel avec des espaces. La ligne initiale est un contexte préparé, sa date plus ancienne est donc normale. Seul le fichier d'entraînement séparé reçoit cet exemple fourni.

Répéter la collecte en conservant le passé

Dans cette étape, vous répéterez de vraies mesures, lirez le résultat et relancerez sans perdre la progression.

Restez dans Terminal, dans /home/labex/project/resource-watch. Le programme fourni monitor.sh définit capture_once target logfile : il acquiert une nouvelle observation, appelle votre fonction et affiche la ligne sauvegardée. Votre boucle doit transmettre les chemins inchangés et appeler l’action exactement le nombre demandé. Chaque acquisition inclut un nouvel intervalle processeur d’une seconde ; il s’agit d’une surveillance bornée, pas d’un ordonnanceur précis.

nano monitor-functions.sh

Remplacez seulement run_monitor par :

run_monitor() {
    local count=$1 target=$2 logfile=$3
    local n
    for ((n = 0; n < count; n++)); do
        capture_once "$target" "$logfile"
    done
}

La boucle arithmétique commence à zéro, continue tant que n est inférieur à count et incrémente n après chaque acquisition. Les guillemets protègent les chemins. Une boucle while équivalente est également valide. Enregistrez avec Ctrl+O, Enter, Ctrl+X.

Collectez trois véritables observations :

bash monitor.sh 3

Trois lignes doivent apparaître avant le retour du prompt. Chaque horodatage UTC doit être ultérieur au précédent. Les valeurs varient et une exécution normale peut ne comporter aucun avertissement. Le pilote accepte de 1 à 30 mesures. Pendant une longue observation, Ctrl+C arrête le script au premier plan ; les lignes ajoutées restent. N’arrêtez aucun autre processus.

Lisez le résultat et comptez les lignes. wc -l compte les lignes terminées par un saut de ligne :

cat history.tsv

wc -l history.tsv

Après la première exécution documentée, le fichier contient quatre lignes : l’originale et trois nouvelles. Si vous avez collecté davantage, conservez ces observations valides.

Continuez avec une observation :

bash monitor.sh 1

wc -l history.tsv

Le compte augmente d’une ligne. Relancer est sûr parce que votre fonction ajoute au lieu de remplacer. Comparez chaque état à sa mesure et à son seuil dans policy.sh.

Essayez volontairement une erreur d’entrée courante : zéro est refusé avant toute mesure.

bash monitor.sh 0

Use a sample count from 1 to 30.

Cet échec attendu retourne le statut 2 et laisse l’historique intact. Reprenez avec un nombre valide, sans réinitialiser la VM ni éditer le journal :

bash monitor.sh 1

Une nouvelle ligne est ajoutée. Le collecteur rejette aussi les sorties métriques incomplètes au lieu d’ajouter une observation vide mais plausible.

Vérifier le résultat

• La ligne initiale de l'opérateur reste au début, suivie de vos nouvelles observations.
• Le premier lancement ajoute trois lignes ; poursuivre avec un échantillon en ajoute une. Des lignes valides supplémentaires sont permises si vous avez répété une commande.
• Lisez d'abord les trois pourcentages, puis comparez chacun à sa propre limite. Trois états OK sont un résultat valide ; inutile de créer de la charge ou de supprimer des fichiers pour déclencher un avertissement.
• Chaque capture attend un nouvel intervalle CPU. Une courte pause est normale : n'appuyez pas répétitivement sur Enter pendant la mesure. Le retour de l'invite marque la fin du lancement limité. Fermer Terminal ne laisse pas fonctionner un moniteur continu.

Résumé

Vous avez implémenté une règle incluant l’égalité, ajouté des enregistrements complets avec trois états indépendants et répété une collecte réelle en préservant l’historique. Vous pouvez lancer une courte observation, lire les éléments enregistrés et poursuivre. Le défi indépendant change la cible et la politique avec les mêmes outils et contrats enseignés.