Linux Command Line & Bash Scripting Mastery · Leçon

Créer des scripts de contrôle d’état et d’alerte du système

Collectez les métriques de charge, de mémoire et de disque, puis déclenchez des alertes fondées sur des seuils depuis des scripts planifiés.

Créer des scripts de contrôle d’état et d’alerte du système est une leçon Linux Command Line & Bash Scripting Mastery gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Linux Command Line & Bash Scripting Mastery, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Linux Command Line & Bash Scripting Mastery comprend 4 leçons au total.

Pourquoi les vérifications de l’état du système sont importantes

Les serveurs de production peuvent se dégrader silencieusement. Les pics d’utilisation du CPU, les fuites de mémoire et les disques saturés provoquent des interruptions de service — mais seulement si personne ne les détecte à temps. Les scripts de vérification de l’état du système automatisent la boucle de surveillance : collecter les métriques, les comparer à des seuils et déclencher des alertes avant que les utilisateurs n’en subissent les conséquences.

Planifiés avec cron, ils s’exécutent toutes les quelques minutes sans intervention humaine
Ils produisent une sortie cohérente, horodatée, adaptée à l’agrégation des journaux
Une logique fondée sur des seuils rend les alertes pertinentes — chaque petit incident ne déclenche pas une page pour l’équipe d’astreinte

Dans cette leçon, vous allez créer de zéro un script de vérification de l’état du système de qualité production, couche par couche, en couvrant la charge moyenne, la pression mémoire et l’utilisation des disques.

Relever la charge moyenne

Linux expose les charges moyennes sur 1, 5 et 15 minutes via /proc/loadavg et la commande uptime. Pour les scripts, /proc/loadavg est la source la plus propre : aucun problème de paramètres régionaux et aucune variation d’analyse entre les distributions.

L’extrait ci-dessous lit la charge moyenne sur 1 minute et la stocke dans une variable pour la comparer à un seuil. cut extrait le premier champ ; awk supprime la partie décimale pour permettre une comparaison entière, en utilisant bc pour les calculs en virgule flottante.

#!/usr/bin/env bash
# Read 1-minute load average from /proc/loadavg
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
echo "Raw load average: $LOAD_RAW"

# Number of CPU cores — used to normalise load
CPU_CORES=$(nproc)
echo "CPU cores: $CPU_CORES"

# Compute load percentage (load / cores * 100) using bc
LOAD_PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)
echo "Load %: $LOAD_PCT"

Comparer un seuil avec des valeurs en virgule flottante

Bash ne peut pas comparer nativement les nombres en virgule flottante — [ 1.5 -gt 1.2 ] provoque une erreur. Les deux solutions idiomatiques sont les suivantes :

bc — renvoie 1 (vrai) ou 0 (faux) pour une expression de comparaison
awk — peut évaluer des conditions sur des nombres flottants au sein d’un pipeline

Utiliser bc rend la logique lisible et facile à tester. Le modèle $(echo "$A > $B" | bc) renvoie 1 lorsque la condition est satisfaite ; vous le testez avec [ ... -eq 1 ].

#!/usr/bin/env bash
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
CPU_CORES=$(nproc)
THRESHOLD=80  # alert when load % exceeds 80%

LOAD_PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)

# bc returns 1 if the expression is true
if [ "$(echo "$LOAD_PCT > $THRESHOLD" | bc)" -eq 1 ]; then
    echo "ALERT: Load is ${LOAD_PCT}% (threshold ${THRESHOLD}%)"
else
    echo "OK: Load is ${LOAD_PCT}%"
fi

Collecter les métriques de mémoire

/proc/meminfo est la source de référence des statistiques mémoire sous Linux. Champs principaux :

MemTotal — quantité totale de RAM physique en ko
MemAvailable — quantité estimée de ko disponible pour de nouvelles allocations sans échange mémoire (plus pertinent que MemFree)

awk associé à une recherche par motif est la méthode la plus propre pour extraire ces valeurs. Diviser MemAvailable par MemTotal, puis soustraire le résultat de 100, donne le pourcentage de mémoire utilisée, qui détermine le seuil de votre alerte.

#!/usr/bin/env bash
# Extract memory figures from /proc/meminfo (values in kB)
MEM_TOTAL=$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)
MEM_AVAIL=$(awk '/^MemAvailable:/ {print $2}' /proc/meminfo)

# Used memory percentage
MEM_USED_PCT=$(echo "scale=2; (1 - $MEM_AVAIL / $MEM_TOTAL) * 100" | bc)

echo "Total RAM : ${MEM_TOTAL} kB"
echo "Available : ${MEM_AVAIL} kB"
echo "Used      : ${MEM_USED_PCT}%"

Collecter les métriques d’utilisation des disques

La commande df indique l’utilisation des systèmes de fichiers. Pour les scripts, deux options sont essentielles :

-h — tailles lisibles par un humain (à utiliser uniquement pour l’affichage ; à éviter dans les calculs)
--output=pcent,target — colonnes analysables par une machine (outils principaux GNU)

Parcourir tous les systèmes de fichiers montés permet au script de signaler toute partition presque pleine, et pas seulement /. Le signe % est supprimé avec tr -d '%' avant la comparaison entière.

#!/usr/bin/env bash
DISK_THRESHOLD=85

# Skip header line with tail -n +2
# --output=pcent,target gives "85% /var" style lines
df --output=pcent,target | tail -n +2 | while read -r USED_PCT MOUNT; do
    # Remove the % sign for arithmetic
    USED_INT=${USED_PCT//%/}

    if [ "$USED_INT" -ge "$DISK_THRESHOLD" ]; then
        echo "ALERT: Disk $MOUNT is ${USED_PCT} full"
    else
        echo "OK   : Disk $MOUNT is ${USED_PCT} full"
    fi
done

Structurer la sortie des alertes avec des horodatages

Des messages d’alerte sans horodatage sont presque inutiles dans les fichiers journaux ou les rapports par e-mail. Un préfixe cohérent simplifie considérablement l’analyse des journaux avec grep ou des agents d’expédition des journaux.

Définissez une petite fonction d’alerte en haut de votre script. Elle ajoute au début un horodatage ISO-8601, un niveau de gravité et le nom de la vérification. Toutes les alertes sont écrites à la fois dans stdout et dans un fichier journal via tee.

date -u +"%Y-%m-%dT%H:%M:%SZ" — horodatage UTC indépendant des paramètres régionaux
L’écriture dans stderr pour ALERT et dans stdout pour OK sépare les informations importantes du bruit dans les pipelines

#!/usr/bin/env bash
LOG_FILE="/var/log/healthcheck.log"

alert() {
    local LEVEL="$1"   # OK | WARN | ALERT
    local CHECK="$2"
    local MSG="$3"
    local TS
    TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    local LINE="[$TS] [$LEVEL] [$CHECK] $MSG"

    if [ "$LEVEL" = "ALERT" ]; then
        echo "$LINE" | tee -a "$LOG_FILE" >&2
    else
        echo "$LINE" | tee -a "$LOG_FILE"
    fi
}

# Usage examples
alert "OK"    "DISK"  "/ is 42% full"
alert "ALERT" "DISK"  "/var is 91% full"

Envoyer des alertes par e-mail avec mail et sendmail

Le mécanisme d’alerte le plus simple sur un serveur est l’e-mail via le MTA local (postfix, sendmail ou msmtp). La commande mail (fournie par mailutils ou bsd-mailx) compose et envoie un message en une seule ligne.

-s — objet du message
Transmettez le corps via stdin
Sur les serveurs dépourvus de MTA local, remplacez mail par un appel curl vers une API d’e-mail transactionnel

Protégez l’envoi avec un verrou de déduplication afin qu’une condition bruyante ne sature pas la boîte de réception.

#!/usr/bin/env bash
ALERT_EMAIL="ops@example.com"
LOCK_DIR="/tmp/healthcheck_locks"
mkdir -p "$LOCK_DIR"

send_alert() {
    local CHECK="$1"
    local MSG="$2"
    local LOCK="$LOCK_DIR/${CHECK}.lock"

    # Only send if no lock exists (prevents repeated emails within the hour)
    if [ ! -f "$LOCK" ]; then
        echo "$MSG" | mail -s "[ALERT] $CHECK on $(hostname)" "$ALERT_EMAIL"
        touch "$LOCK"
        # Lock expires after 1 hour via cron or find+delete
        echo "Alert sent for $CHECK"
    else
        echo "Alert suppressed for $CHECK (lock active)"
    fi
}

send_alert "HIGH_LOAD" "Load average exceeded 80% on $(hostname) at $(date)"

Composer le script complet de vérification de l’état du système

Combinez maintenant les trois vérifications — charge, mémoire et disque — dans un script cohérent unique, avec des seuils configurables au début. C’est le modèle utilisé dans l’automatisation de l’administration système en production :

Constantes déclarées au début pour faciliter les ajustements sans modifier la logique
Chaque vérification isolée dans une fonction pour améliorer la lisibilité et permettre les tests unitaires
Une fonction main orchestre les appels
Code de sortie 1 si une alerte a été déclenchée, 0 sinon — le script peut ainsi être combiné avec des infrastructures de supervision comme Nagios/Icinga

#!/usr/bin/env bash
set -euo pipefail

# ── Thresholds ───────────────────────────────────────────
LOAD_THRESHOLD=80   # percent of CPU capacity
MEM_THRESHOLD=90    # percent used
DISK_THRESHOLD=85   # percent used
ALERT_EMAIL="ops@example.com"
LOG_FILE="/var/log/healthcheck.log"
ALERT_FIRED=0

# ── Helpers ──────────────────────────────────────────────
ts()    { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
log()   { echo "[$(ts)] $*" | tee -a "$LOG_FILE"; }
alert() { log "ALERT: $*"; echo "$*" | mail -s "[ALERT] $(hostname)" "$ALERT_EMAIL" 2>/dev/null; ALERT_FIRED=1; }

# ── Checks ───────────────────────────────────────────────
check_load() {
    local raw cores pct
    raw=$(cut -d' ' -f1 /proc/loadavg)
    cores=$(nproc)
    pct=$(echo "scale=2; $raw / $cores * 100" | bc)
    if [ "$(echo "$pct > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
        alert "Load ${pct}% exceeds ${LOAD_THRESHOLD}%"
    else
        log "OK load=${pct}%"
    fi
}

check_memory() {
    local total avail pct
    total=$(awk '/^MemTotal:/    {print $2}' /proc/meminfo)
    avail=$(awk '/^MemAvailable:/{print $2}' /proc/meminfo)
    pct=$(echo "scale=2; (1 - $avail / $total) * 100" | bc)
    if [ "$(echo "$pct > $MEM_THRESHOLD" | bc)" -eq 1 ]; then
        alert "Memory ${pct}% used (threshold ${MEM_THRESHOLD}%)"
    else
        log "OK memory=${pct}%"
    fi
}

check_disk() {
    df --output=pcent,target | tail -n +2 | while read -r used mnt; do
        local pct_int=${used//%/}
        if [ "$pct_int" -ge "$DISK_THRESHOLD" ]; then
            alert "Disk $mnt at ${used}"
        else
            log "OK disk $mnt=${used}"
        fi
    done
}

main() {
    log "=== Health check START ==="
    check_load
    check_memory
    check_disk
    log "=== Health check END (alerts=$ALERT_FIRED) ==="
    exit "$ALERT_FIRED"
}

main

Planifier l’exécution avec Cron

Un script de vérification de l’état du système n’est utile que lorsqu’il s’exécute automatiquement. cron est le planificateur standard d’Unix. Modifiez la crontab système ou un fichier dédié dans /etc/cron.d/ pour planifier votre script.

Exécuter toutes les 5 minutes : */5 * * * *
Utilisez toujours des chemins absolus dans cron — $PATH est minimal dans l’environnement de cron
Redirigez la sortie pour empêcher cron d’envoyer un courriel à chaque exécution : >> /var/log/healthcheck.log 2>&1
Utilisez MAILTO="" au début de la crontab pour désactiver les courriels envoyés par cron lui-même

# /etc/cron.d/healthcheck
# Run the health check every 5 minutes as root
MAILTO=""
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

*/5 * * * * root /usr/local/sbin/healthcheck.sh >> /var/log/healthcheck.log 2>&1

Éviter les tempêtes d’alertes avec des verrous de temporisation

Lorsqu’un seuil est dépassé en continu, un script naïf déclenche une alerte toutes les 5 minutes — des dizaines de courriels avant qu’un ingénieur puisse intervenir. Un verrou de temporisation supprime les alertes répétées pendant une période configurable.

Le principe : écrire un fichier de verrou lors de la première alerte ; ignorer les alertes suivantes tant que le fichier est plus récent que la période de temporisation ; find avec -mmin vérifie l’ancienneté du fichier de manière atomique, sans calcul de dates.

#!/usr/bin/env bash
LOCK_DIR="/tmp/hc_locks"
COOLDOWN_MIN=60  # suppress repeat alerts for 60 minutes
mkdir -p "$LOCK_DIR"

should_alert() {
    local check="$1"
    local lock="$LOCK_DIR/${check}.lock"

    if [ ! -f "$lock" ]; then
        # No lock — allow alert and create lock
        touch "$lock"
        return 0  # true: send alert
    fi

    # Lock exists — check if it is older than the cooldown
    # find returns the filename only if it's OLDER than COOLDOWN_MIN
    local expired
    expired=$(find "$lock" -mmin +"$COOLDOWN_MIN" 2>/dev/null)

    if [ -n "$expired" ]; then
        touch "$lock"  # refresh lock timestamp
        return 0       # cooldown expired — allow alert
    fi

    return 1  # still within cooldown — suppress
}

# Usage
if should_alert "HIGH_LOAD"; then
    echo "Sending load alert..."
    # mail -s "..." ops@example.com <<< "Load too high"
else
    echo "Load alert suppressed (cooldown active)"
fi

Tester et valider votre script de vérification de l’état du système

Avant le déploiement, validez le script de trois façons :

Vérification de la syntaxe : bash -n healthcheck.sh détecte les erreurs d’analyse sans exécuter le script
Mode traçage : bash -x healthcheck.sh affiche chaque commande au moment de son exécution — ce qui est très utile pour le débogage
Remplacement des seuils : abaissez temporairement les seuils presque à zéro afin que le script déclenche des alertes sur un hôte sain, et vérifiez ainsi que le chemin d’alerte fonctionne de bout en bout

Pour le chemin d’envoi des courriels, redirigez mail vers un fichier journal pendant les tests à l’aide d’un indicateur MOCK_MAIL :

#!/usr/bin/env bash
# Smoke-test the alert path without sending real email
MOCK_MAIL=true
ALERT_EMAIL="ops@example.com"

send_mail() {
    local subject="$1"
    local body="$2"
    if [ "$MOCK_MAIL" = true ]; then
        echo "[MOCK MAIL] To: $ALERT_EMAIL | Subject: $subject"
        echo "[MOCK MAIL] Body: $body"
    else
        echo "$body" | mail -s "$subject" "$ALERT_EMAIL"
    fi
}

# Override threshold to guarantee an alert fires
LOAD_THRESHOLD=0   # Any load will exceed 0%
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
CPU_CORES=$(nproc)
PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)

if [ "$(echo "$PCT > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
    send_mail "[ALERT] Load on $(hostname)" "Load is ${PCT}%"
fi

Vérification des connaissances : stratégie de temporisation

Considérez le scénario suivant : votre tâche cron de vérification de l’état du système s’exécute toutes les 5 minutes. L’utilisation du disque sur /var dépasse 85 % et reste à ce niveau pendant 3 heures. Vous souhaitez que l’ingénieur d’astreinte reçoive une alerte une fois par heure, et non toutes les 5 minutes. Quelle stratégie d’implémentation est la plus appropriée ?

Récapitulatif de la leçon : scripts de vérification de l’état du système

Dans cette leçon, vous avez créé une chaîne complète et prête pour la production de vérification de l’état du système et de gestion des alertes. Voici les principes essentiels à retenir :

Source de vérité : lisez les métriques dans /proc/loadavg et /proc/meminfo — elles sont stables, indépendantes de la langue et disponibles sur tous les hôtes Linux
Arithmétique flottante : utilisez bc pour comparer des seuils à virgule flottante ; la comparaison entière de Bash (-gt) ne fonctionne qu’avec des nombres entiers
Parcours des disques : utilisez df --output=pcent,target pour vérifier chaque système de fichiers monté, et pas seulement /
Journalisation structurée : préfixez chaque ligne avec un horodatage UTC et un niveau de gravité afin que les journaux puissent être facilement traités par grep et transmis proprement aux systèmes de journalisation centralisée
Verrous de temporisation : les fichiers de verrou vérifiés avec find -mmin empêchent les tempêtes d’alertes sans modifier la planification cron
Combinabilité : quittez avec le code 1 lorsqu’une alerte est déclenchée afin que le script s’intègre à Nagios, Icinga ou d’autres infrastructures de supervision
Tests : utilisez bash -n pour vérifier la syntaxe, bash -x pour le débogage par traçage et un indicateur MOCK_MAIL pour valider le chemin d’alerte sur des hôtes sains

Planifiez le script terminé via /etc/cron.d/ et votre infrastructure surveillera son état en continu, en ne déclenchant des alertes que lorsque les seuils sont réellement dépassés.

Questions Fréquemment Posées

La leçon « Créer des scripts de contrôle d’état et d’alerte du système » est-elle gratuite ?

Oui — le texte complet de « Créer des scripts de contrôle d’état et d’alerte du système » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Linux Command Line & Bash Scripting Mastery, passe à CoddyKit PRO. Le cours Linux Command Line & Bash Scripting Mastery comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer des scripts de contrôle d’état et d’alerte du système » ?

Collectez les métriques de charge, de mémoire et de disque, puis déclenchez des alertes fondées sur des seuils depuis des scripts planifiés. Tu pratiques Linux Command Line & Bash Scripting Mastery avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Linux Command Line & Bash Scripting Mastery ?

Aucune expérience préalable n'est requise. Linux Command Line & Bash Scripting Mastery sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Créer des scripts de contrôle d’état et d’alerte du système » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Linux Command Line & Bash Scripting Mastery ?

Oui. Chaque leçon Linux Command Line & Bash Scripting Mastery inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Automatiser la création d’utilisateurs et de groupes
Contrôler les services systemd et écrire des fichiers d’unité
Automatiser les disques, systèmes de fichiers et montages
Créer des scripts de contrôle d’état et d’alerte du système

← Retour à Linux Command Line & Bash Scripting Mastery