Tests de conditions Linux

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser les tests de conditions Linux pour automatiser les vérifications et les validations système. Linux propose la puissante commande test qui vous permet d'évaluer des conditions et d'exécuter des actions en fonction des résultats. Comprendre comment utiliser cette commande est essentiel pour écrire des scripts shell capables de prendre des décisions et de répondre à différentes conditions.

Tout au long de ce laboratoire, vous travaillerez sur divers aspects de la commande test, notamment les tests de fichiers, la comparaison de chaînes de caractères et l'évaluation numérique. À la fin de cette session, vous serez en mesure d'écrire des scripts qui peuvent effectuer des vérifications automatisées sur votre système et contribuer à maintenir son intégrité.

Comprendre les bases de la commande test

La commande test sous Linux est un outil essentiel pour évaluer des conditions dans les scripts shell. Elle vous permet de vérifier les propriétés des fichiers, de comparer des chaînes de caractères, d'évaluer des valeurs numériques, et bien plus encore. Lorsque la condition testée est vraie, test renvoie un code de sortie égal à zéro ; sinon, il renvoie un code de sortie non nul.

Commençons par les bases. Tout d'abord, accédez au répertoire de votre projet :

cd ~/project

La commande test peut être écrite de deux manières :

1. En utilisant le mot test suivi de la condition
2. En utilisant des crochets carrés [ ] autour de la condition

Essayons les deux méthodes pour vérifier si un répertoire existe :

## Méthode 1 : Utilisation du mot 'test'
test -d ~/project && echo "Le répertoire du projet existe."

## Méthode 2 : Utilisation de crochets carrés
[ -d ~/project ] && echo "Le répertoire du projet existe."

Vous devriez voir la sortie suivante pour les deux commandes :

Le répertoire du projet existe.

L'option -d vérifie si un répertoire existe. L'opérateur && est utilisé pour exécuter la commande echo uniquement si la condition de test est vraie.

Voici quelques options de test de fichiers courantes :

• -d fichier : Vrai si le fichier existe et est un répertoire
• -e fichier : Vrai si le fichier existe
• -f fichier : Vrai si le fichier existe et est un fichier ordinaire
• -r fichier : Vrai si le fichier existe et est lisible
• -w fichier : Vrai si le fichier existe et est écrivable
• -x fichier : Vrai si le fichier existe et est exécutable
• -s fichier : Vrai si le fichier existe et a une taille supérieure à zéro

Créons un fichier de test et vérifions ses propriétés :

## Créer un fichier de test
echo "Hello, Linux condition testing!" > test_file.txt

## Vérifier si le fichier existe
test -e test_file.txt && echo "Le fichier existe."

## Vérifier si le fichier est lisible
[ -r test_file.txt ] && echo "Le fichier est lisible."

## Vérifier si le fichier est vide
[ -s test_file.txt ] && echo "Le fichier n'est pas vide."

Ces commandes devraient produire la sortie suivante :

Le fichier existe.
Le fichier est lisible.
Le fichier n'est pas vide.

Maintenant, créons un simple script shell qui utilise la commande test pour vérifier si un fichier existe, et s'il n'existe pas, le créer :

## Créer un fichier de script
cat > check_file.sh << 'EOF'
#!/bin/bash

FILENAME="status.txt"

if [ ! -e "$FILENAME" ]; then
  echo "Le fichier $FILENAME n'existe pas. Je le crée maintenant."
  echo "This is a status file." > "$FILENAME"
else
  echo "Le fichier $FILENAME existe déjà."
fi

## Afficher le contenu du fichier
echo "Contenu de $FILENAME :"
cat "$FILENAME"
EOF

## Rendre le script exécutable
chmod +x check_file.sh

## Exécuter le script
./check_file.sh

Lorsque vous exécutez le script, vous devriez voir une sortie similaire à :

Le fichier status.txt n'existe pas. Je le crée maintenant.
Contenu de status.txt :
This is a status file.

Si vous exécutez le script à nouveau, vous verrez :

Le fichier status.txt existe déjà.
Contenu de status.txt :
This is a status file.

Cela démontre comment utiliser la commande test pour vérifier l'existence d'un fichier et prendre des actions différentes en fonction du résultat.

Tester les conditions de chaînes de caractères

Dans cette étape, vous apprendrez à utiliser la commande test pour comparer des chaînes de caractères. Cela est utile lorsque vous devez valider les entrées utilisateur, vérifier les variables d'environnement ou prendre des décisions en fonction du contenu textuel.

Les opérateurs de comparaison de chaînes courants incluent :

• == : Égal à
• != : Différent de
• -z : Vrai si la chaîne est vide
• -n : Vrai si la chaîne n'est pas vide

Commençons par tester différentes conditions de chaînes de caractères :

## Tester si deux chaînes sont égales
str1="linux"
str2="linux"
[ "$str1" == "$str2" ] && echo "Les chaînes sont égales."

## Tester si deux chaînes sont différentes
str3="ubuntu"
[ "$str1" != "$str3" ] && echo "Les chaînes sont différentes."

## Tester si une chaîne est vide
empty_str=""
[ -z "$empty_str" ] && echo "La chaîne est vide."

## Tester si une chaîne n'est pas vide
[ -n "$str1" ] && echo "La chaîne n'est pas vide."

La sortie devrait être :

Les chaînes sont égales.
Les chaînes sont différentes.
La chaîne est vide.
La chaîne n'est pas vide.

Maintenant, créons un script qui demande un mot de passe et vérifie s'il répond à certains critères :

## Créer un script de validation de mot de passe
cat > password_check.sh << 'EOF'
#!/bin/bash

echo "Entrez un mot de passe :"
read -s password

## Vérifier si le mot de passe est vide
if [ -z "$password" ]; then
  echo "Erreur : Le mot de passe ne peut pas être vide."
  exit 1
fi

## Vérifier la longueur du mot de passe
if [ ${#password} -lt 8 ]; then
  echo "Erreur : Le mot de passe doit comporter au moins 8 caractères."
  exit 1
fi

## Vérifier si le mot de passe contient le mot "password"
if [[ "$password" == *password* ]]; then
  echo "Erreur : Le mot de passe ne peut pas contenir le mot 'password'."
  exit 1
fi

echo "Le mot de passe est valide !"
EOF

## Rendre le script exécutable
chmod +x password_check.sh

## Exécuter le script
echo "Vous pouvez tester le script en exécutant : ./password_check.sh"

Essayez d'exécuter le script avec différents mots de passe pour voir comment il valide les entrées :

## Tester avec un mot de passe court
echo "short" | ./password_check.sh

## Tester avec un mot de passe contenant "password"
echo "mypassword123" | ./password_check.sh

## Tester avec un mot de passe valide
echo "SecurePass123" | ./password_check.sh

Les deux premiers tests devraient échouer, tandis que le troisième devrait réussir.

Créons un autre script qui traite le statut du système en fonction d'une entrée textuelle :

## Créer un script de statut du système
cat > system_status.sh << 'EOF'
#!/bin/bash

echo "Entrez le statut du système (normal, warning, critical) :"
read status

if [ -z "$status" ]; then
  echo "Aucun statut fourni. On suppose un fonctionnement normal."
  status="normal"
fi

case "$status" in
  "normal")
    echo "Le système fonctionne normalement. Aucune action requise."
    ;;
  "warning")
    echo "Avertissement : Le système nécessite attention. Vérifiez les fichiers journaux."
    ;;
  "critical")
    echo "CRITIQUE : Une action immédiate est requise ! La stabilité du système est compromise."
    ;;
  *)
    echo "Statut inconnu : $status. Veuillez utiliser normal, warning ou critical."
    ;;
esac
EOF

## Rendre le script exécutable
chmod +x system_status.sh

## Exécuter le script
echo "Vous pouvez tester le script en exécutant : ./system_status.sh"

Essayez d'exécuter le script avec différentes entrées de statut :

## Tester avec le statut "normal"
echo "normal" | ./system_status.sh

## Tester avec le statut "warning"
echo "warning" | ./system_status.sh

## Tester avec le statut "critical"
echo "critical" | ./system_status.sh

## Tester avec un statut invalide
echo "unstable" | ./system_status.sh

## Tester avec une entrée vide
echo "" | ./system_status.sh

Chaque entrée devrait produire une sortie différente en fonction de la logique conditionnelle du script.

Tester les conditions numériques

Dans cette étape, vous apprendrez à utiliser la commande test pour les comparaisons numériques. Cela est utile pour vérifier l'utilisation des ressources, valider les entrées utilisateur ou prendre des décisions basées sur des valeurs numériques.

Les opérateurs de comparaison numérique courants incluent :

• -eq : Égal à
• -ne : Différent de
• -lt : Inférieur à
• -le : Inférieur ou égal à
• -gt : Supérieur à
• -ge : Supérieur ou égal à

Commençons par quelques comparaisons numériques de base :

## Comparer deux nombres
num1=10
num2=20

## Égal à
[ $num1 -eq 10 ] && echo "$num1 est égal à 10"

## Différent de
[ $num1 -ne $num2 ] && echo "$num1 n'est pas égal à $num2"

## Inférieur à
[ $num1 -lt $num2 ] && echo "$num1 est inférieur à $num2"

## Supérieur à
[ $num2 -gt $num1 ] && echo "$num2 est supérieur à $num1"

## Inférieur ou égal à
[ $num1 -le 10 ] && echo "$num1 est inférieur ou égal à 10"

## Supérieur ou égal à
[ $num2 -ge 20 ] && echo "$num2 est supérieur ou égal à 20"

La sortie devrait ressembler à :

10 est égal à 10
10 n'est pas égal à 20
10 est inférieur à 20
20 est supérieur à 10
10 est inférieur ou égal à 10
20 est supérieur ou égal à 20

Maintenant, créons un script qui vérifie l'espace disque et alerte lorsqu'il est en dessous d'un certain seuil :

## Créer un script de vérification de l'espace disque
cat > disk_check.sh << 'EOF'
#!/bin/bash

## Obtenir le pourcentage d'utilisation du disque (en supprimant le signe %)
DISK_USAGE=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

## Définir les seuils
WARNING_THRESHOLD=70
CRITICAL_THRESHOLD=90

echo "Utilisation actuelle du disque : $DISK_USAGE%"

if [ $DISK_USAGE -ge $CRITICAL_THRESHOLD ]; then
  echo "CRITIQUE : L'utilisation du disque est extrêmement élevée !"
  echo "Action : Nettoyez immédiatement les fichiers inutiles."
elif [ $DISK_USAGE -ge $WARNING_THRESHOLD ]; then
  echo "AVERTISSEMENT : L'utilisation du disque augmente."
  echo "Action : Pensez à nettoyer certains fichiers bientôt."
else
  echo "OK : L'utilisation du disque est normale."
  echo "Aucune action requise."
fi
EOF

## Rendre le script exécutable
chmod +x disk_check.sh

## Exécuter le script
./disk_check.sh

Le script affichera l'utilisation actuelle du disque et affichera un message différent en fonction de la saturation du disque.

Créons un autre script qui simule un système de surveillance de température :

## Créer un script de surveillance de température
cat > temp_monitor.sh << 'EOF'
#!/bin/bash

## Fonction pour générer une température aléatoire entre 15 et 35
generate_temp() {
  echo $((RANDOM % 21 + 15))
}

## Générer une température aléatoire
TEMP=$(generate_temp)
echo "Température actuelle : ${TEMP}°C"

## Seuils de température
MIN_TEMP=18
MAX_TEMP=26

if [ $TEMP -lt $MIN_TEMP ]; then
  echo "Action : Augmentez le chauffage. La température est en dessous du seuil minimum."
elif [ $TEMP -gt $MAX_TEMP ]; then
  echo "Action : Activez la climatisation. La température est au-dessus du seuil maximum."
else
  echo "Statut : La température est dans la plage acceptable."
fi

## Vérification supplémentaire pour les températures extrêmes
if [ $TEMP -ge 30 ]; then
  echo "AVERTISSEMENT : La température est très élevée. Vérifiez les systèmes de climatisation."
fi
if [ $TEMP -le 17 ]; then
  echo "AVERTISSEMENT : La température est très basse. Vérifiez les systèmes de chauffage."
fi
EOF

## Rendre le script exécutable
chmod +x temp_monitor.sh

## Exécuter le script
./temp_monitor.sh

Chaque fois que vous exécutez ce script, il générera une température aléatoire et répondra en conséquence. Essayez de l'exécuter plusieurs fois pour voir différents résultats :

## Exécuter le script de surveillance de température plusieurs fois
./temp_monitor.sh
./temp_monitor.sh
./temp_monitor.sh

Ces exemples démontrent comment utiliser des conditions numériques pour surveiller les paramètres du système et prendre les actions appropriées en fonction des valeurs de seuil.

Combinaison de conditions avec des opérateurs logiques

Dans cette étape, vous apprendrez à combiner plusieurs conditions en utilisant des opérateurs logiques. Cela est essentiel pour créer une logique de prise de décision complexe dans vos scripts.

Les trois principaux opérateurs logiques sont :

• && (ET) : Vrai si les deux conditions sont vraies
• || (OU) : Vrai si au moins une condition est vraie
• ! (NON) : Vrai si la condition est fausse

Commençons par quelques exemples de base :

## Créer un fichier de test
touch test_file.txt
chmod 644 test_file.txt

## Opérateur ET - les deux conditions doivent être vraies
[ -f test_file.txt ] && [ -r test_file.txt ] && echo "Le fichier existe et est lisible."

## Opérateur OU - au moins une condition doit être vraie
[ -x test_file.txt ] || [ -w test_file.txt ] && echo "Le fichier est soit exécutable, soit inscriptible."

## Opérateur NON - inverse la condition
[ ! -x test_file.txt ] && echo "Le fichier n'est pas exécutable."

## Combinaison de plusieurs opérateurs
[ -f test_file.txt ] && [ -r test_file.txt ] && [ ! -x test_file.txt ] && echo "Le fichier existe, est lisible, mais n'est pas exécutable."

Vous devriez voir une sortie similaire à :

Le fichier existe et est lisible.
Le fichier est soit exécutable, soit inscriptible.
Le fichier n'est pas exécutable.
Le fichier existe, est lisible, mais n'est pas exécutable.

La commande test vous permet également de combiner des conditions dans un seul ensemble de crochets en utilisant ces opérateurs :

• -a (ET)
• -o (OU)

Par exemple :

## ET dans une seule commande test
[ -f test_file.txt -a -r test_file.txt ] && echo "Le fichier existe et est lisible."

## OU dans une seule commande test
[ -x test_file.txt -o -w test_file.txt ] && echo "Le fichier est soit exécutable, soit inscriptible."

Créons un script plus complexe qui vérifie les ressources système :

## Créer un script de vérification des ressources système
cat > resource_check.sh << 'EOF'
#!/bin/bash

echo "Vérification des ressources système..."

## Vérifier l'utilisation de la mémoire
MEM_THRESHOLD=80
MEM_USED=$(free | grep Mem | awk '{print int($3/$2 * 100)}')

echo "Utilisation de la mémoire : ${MEM_USED}%"

## Vérifier l'espace disque
DISK_THRESHOLD=70
DISK_USED=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

echo "Utilisation du disque : ${DISK_USED}%"

## Vérifier la charge CPU (moyenne sur 1 minute)
LOAD_THRESHOLD=1.0
CPU_LOAD=$(cat /proc/loadavg | awk '{print $1}')

echo "Moyenne de la charge CPU : ${CPU_LOAD}"

## Vérification des conditions combinées
if [ $MEM_USED -gt $MEM_THRESHOLD ] && [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "CRITIQUE : L'utilisation de la mémoire et du disque est élevée !"
  echo "Action : Libérez immédiatement des ressources."
elif [ $MEM_USED -gt $MEM_THRESHOLD ] || [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "AVERTISSEMENT : L'utilisation de la mémoire ou du disque est élevée."
  echo "Action : Surveillez le système de près."
else
  echo "OK : L'utilisation de la mémoire et du disque est dans les limites acceptables."
fi

## Vérifier si la charge est numérique avant de comparer
if [[ $CPU_LOAD =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
  ## Nous devons utiliser bc pour la comparaison à virgule flottante
  if (( $(echo "$CPU_LOAD > $LOAD_THRESHOLD" | bc -l) )); then
    echo "AVERTISSEMENT : La charge CPU est élevée. Vérifiez les processus gourmands en ressources."
  else
    echo "OK : La charge CPU est normale."
  fi
else
  echo "Erreur : Impossible d'analyser la valeur de la charge CPU."
fi
EOF

## Rendre le script exécutable
chmod +x resource_check.sh

## Exécuter le script
./resource_check.sh

Ce script vérifie l'utilisation de la mémoire, l'espace disque et la charge CPU, puis fournit différentes sorties en fonction de combinaisons de ces conditions.

Enfin, créons un script qui valide les entrées utilisateur avec plusieurs conditions :

## Créer un script de validation d'entrée
cat > validate_input.sh << 'EOF'
#!/bin/bash

echo "Entrez un nom d'utilisateur (seules les lettres minuscules, 3 à 8 caractères) :"
read username

echo "Entrez votre âge (doit être 18 ans ou plus) :"
read age

## Validation du nom d'utilisateur
is_valid_username=true

## Vérifier si le nom d'utilisateur est vide
if [ -z "$username" ]; then
  echo "Erreur : Le nom d'utilisateur ne peut pas être vide."
  is_valid_username=false
fi

## Vérifier la longueur du nom d'utilisateur
if [ ${#username} -lt 3 ] || [ ${#username} -gt 8 ]; then
  echo "Erreur : Le nom d'utilisateur doit comporter entre 3 et 8 caractères."
  is_valid_username=false
fi

## Vérifier si le nom d'utilisateur ne contient que des lettres minuscules
if [[ ! "$username" =~ ^[a-z]+$ ]]; then
  echo "Erreur : Le nom d'utilisateur doit contenir uniquement des lettres minuscules."
  is_valid_username=false
fi

## Validation de l'âge
is_valid_age=true

## Vérifier si l'âge est un nombre
if [[ ! "$age" =~ ^[0-9]+$ ]]; then
  echo "Erreur : L'âge doit être un nombre."
  is_valid_age=false
fi

## Vérifier si l'âge est d'au moins 18 ans
if [ "$is_valid_age" = true ] && [ $age -lt 18 ]; then
  echo "Erreur : Vous devez avoir au moins 18 ans."
  is_valid_age=false
fi

## Validation finale
if [ "$is_valid_username" = true ] && [ "$is_valid_age" = true ]; then
  echo "Inscription réussie !"
  echo "Bienvenue, $username. Votre compte a été créé."
else
  echo "Inscription échouée. Veuillez corriger les erreurs et réessayer."
fi
EOF

## Rendre le script exécutable
chmod +x validate_input.sh

## Exécuter le script
echo "Vous pouvez tester le script en exécutant : ./validate_input.sh"

Essayez d'exécuter le script avec différentes entrées pour voir comment les conditions combinées fonctionnent ensemble pour valider les entrées utilisateur :

## Tester avec une entrée valide
echo -e "john\n25" | ./validate_input.sh

## Tester avec un nom d'utilisateur invalide (trop court)
echo -e "jo\n25" | ./validate_input.sh

## Tester avec un nom d'utilisateur invalide (contient des majuscules)
echo -e "John\n25" | ./validate_input.sh

## Tester avec un âge invalide (moins de 18 ans)
echo -e "john\n17" | ./validate_input.sh

## Tester avec un âge invalide (pas un nombre)
echo -e "john\nabc" | ./validate_input.sh

Ces exemples démontrent comment combiner plusieurs conditions pour créer une logique de validation complexe dans vos scripts.

Création d'un script de surveillance système complet

Dans cette étape finale, vous allez combiner tout ce que vous avez appris pour créer un script de surveillance système complet. Ce script vérifiera divers paramètres système et fournira un rapport de synthèse.

Créons un script qui surveille plusieurs aspects du système :

## Créer un script de surveillance système
cat > system_monitor.sh << 'EOF'
#!/bin/bash

echo "========================================"
echo "    Rapport de surveillance système"
echo "    $(date)"
echo "========================================"
echo

## 1. Vérifier si les fichiers système importants existent
echo "1. Vérification des fichiers système :"
important_files=("/etc/passwd" "/etc/hosts" "/etc/resolv.conf")
all_files_exist=true

for file in "${important_files[@]}"; do
  if [ -e "$file" ]; then
    echo "   [OK] $file existe"
    
    ## Vérifier si le fichier est vide
    if [ ! -s "$file" ]; then
      echo "   [AVERTISSEMENT] $file est vide"
    fi
    
    ## Vérifier si le fichier est lisible
    if [ ! -r "$file" ]; then
      echo "   [AVERTISSEMENT] $file n'est pas lisible"
    fi
  else
    echo "   [ERREUR] $file n'existe pas"
    all_files_exist=false
  fi
done

if [ "$all_files_exist" = true ]; then
  echo "   Tous les fichiers système sont présents."
else
  echo "   Certains fichiers système sont manquants. Vérifiez les erreurs ci-dessus."
fi
echo

## 2. Vérifier l'espace disque
echo "2. Vérification de l'espace disque :"
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "   Utilisation de la partition racine : ${disk_usage}%"

if [ $disk_usage -ge 90 ]; then
  echo "   [CRITIQUE] L'utilisation du disque est extrêmement élevée !"
elif [ $disk_usage -ge 70 ]; then
  echo "   [AVERTISSEMENT] L'utilisation du disque augmente."
else
  echo "   [OK] L'utilisation du disque est normale."
fi
echo

## 3. Vérifier l'utilisation de la mémoire
echo "3. Vérification de l'utilisation de la mémoire :"
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))

echo "   Utilisation de la mémoire : ${mem_percentage}% (${mem_used}Mo utilisés sur ${mem_total}Mo)"

if [ $mem_percentage -ge 90 ]; then
  echo "   [CRITIQUE] L'utilisation de la mémoire est extrêmement élevée !"
elif [ $mem_percentage -ge 70 ]; then
  echo "   [AVERTISSEMENT] L'utilisation de la mémoire augmente."
else
  echo "   [OK] L'utilisation de la mémoire est normale."
fi
echo

## 4. Vérifier les processus actifs
echo "4. Vérification des processus :"
critical_processes=("sshd" "cron")
for process in "${critical_processes[@]}"; do
  if pgrep -x "$process" > /dev/null; then
    echo "   [OK] $process est en cours d'exécution"
  else
    echo "   [ERREUR] $process n'est pas en cours d'exécution"
  fi
done
echo

## 5. Vérifier la charge système
echo "5. Vérification de la charge système :"
load_1min=$(cat /proc/loadavg | awk '{print $1}')
load_5min=$(cat /proc/loadavg | awk '{print $2}')
load_15min=$(cat /proc/loadavg | awk '{print $3}')

echo "   Moyenne de la charge : $load_1min (1 min), $load_5min (5 min), $load_15min (15 min)"

## Déterminer le nombre de cœurs CPU
num_cores=$(grep -c ^processor /proc/cpuinfo)
load_threshold=$(echo "scale=2; $num_cores * 0.7" | bc)

if (( $(echo "$load_1min > $load_threshold" | bc -l) )); then
  echo "   [AVERTISSEMENT] Une charge élevée a été détectée. Le système pourrait être sous tension."
else
  echo "   [OK] La charge système est normale."
fi
echo

## 6. Vérifier les tentatives de connexion échouées récentes
echo "6. Vérification de la sécurité :"
if [ -f /var/log/auth.log ]; then
  failed_logins=$(grep "Failed password" /var/log/auth.log | wc -l)
  echo "   Tentatives de connexion échouées : $failed_logins"
  
  if [ $failed_logins -gt 10 ]; then
    echo "   [AVERTISSEMENT] Un grand nombre de tentatives de connexion échouées a été détecté."
  else
    echo "   [OK] Activité de connexion normale."
  fi
else
  echo "   [INFO] Impossible de vérifier les tentatives de connexion (auth.log non accessible)"
fi
echo

## 7. Synthèse
echo "7. Synthèse de l'état du système :"
critical_count=$(grep -c "\[CRITIQUE\]" <<< "$(cat /dev/stdin)")
warning_count=$(grep -c "\[AVERTISSEMENT\]" <<< "$(cat /dev/stdin)")
error_count=$(grep -c "\[ERREUR\]" <<< "$(cat /dev/stdin)")

if [ $critical_count -gt 0 ]; then
  echo "   [CRITIQUE] Le système présente des problèmes critiques qui nécessitent une attention immédiate !"
elif [ $warning_count -gt 0 ] || [ $error_count -gt 0 ]; then
  echo "   [AVERTISSEMENT] Le système présente quelques problèmes qui devraient être résolus bientôt."
else
  echo "   [OK] Le système fonctionne normalement. Aucun problème significatif détecté."
fi

echo
echo "========================================"
echo "    Fin du rapport de surveillance système"
echo "========================================"
EOF

## Rendre le script exécutable
chmod +x system_monitor.sh

## Exécuter le script
./system_monitor.sh

Ce script complet effectue les vérifications suivantes :

1. Vérifie si les fichiers système importants existent et sont lisibles
2. Vérifie l'utilisation de l'espace disque
3. Surveille l'utilisation de la mémoire
4. Confirme que les processus critiques sont en cours d'exécution
5. Évalue la charge système
6. Examine les journaux de sécurité pour les tentatives de connexion échouées
7. Fournit une synthèse globale de l'état du système

La sortie variera en fonction de l'état actuel de votre système, mais elle fournira un aperçu complet de la santé de votre système.

Pour rendre ce script encore plus utile, vous pourriez :

1. Le planifier pour qu'il s'exécute périodiquement à l'aide de cron
2. Le configurer pour envoyer des alertes par e-mail lorsqu'il détecte des problèmes critiques
3. Ajouter des vérifications plus spécifiques adaptées à votre système

Créons une version plus simple que vous pouvez planifier pour qu'elle s'exécute périodiquement :

## Créer un script de surveillance simplifié pour la planification
cat > daily_check.sh << 'EOF'
#!/bin/bash

## Configurer le fichier journal
LOG_FILE="/tmp/system_check_$(date +%Y%m%d).log"

## Démarrer la journalisation
echo "Vérification du système : $(date)" > $LOG_FILE
echo "--------------------------------" >> $LOG_FILE

## Vérifier l'espace disque
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "Utilisation du disque : ${disk_usage}%" >> $LOG_FILE

if [ $disk_usage -ge 90 ]; then
  echo "CRITIQUE : L'utilisation du disque est extrêmement élevée !" >> $LOG_FILE
elif [ $disk_usage -ge 70 ]; then
  echo "AVERTISSEMENT : L'utilisation du disque augmente." >> $LOG_FILE
else
  echo "OK : L'utilisation du disque est normale." >> $LOG_FILE
fi

## Vérifier la mémoire
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))
echo "Utilisation de la mémoire : ${mem_percentage}%" >> $LOG_FILE

if [ $mem_percentage -ge 90 ]; then
  echo "CRITIQUE : L'utilisation de la mémoire est extrêmement élevée !" >> $LOG_FILE
elif [ $mem_percentage -ge 70 ]; then
  echo "AVERTISSEMENT : L'utilisation de la mémoire augmente." >> $LOG_FILE
else
  echo "OK : L'utilisation de la mémoire est normale." >> $LOG_FILE
fi

## Vérifier les services critiques
for service in sshd cron; do
  if pgrep -x "$service" > /dev/null; then
    echo "$service est en cours d'exécution" >> $LOG_FILE
  else
    echo "AVERTISSEMENT : $service n'est pas en cours d'exécution" >> $LOG_FILE
  fi
done

## Fin du journal
echo "--------------------------------" >> $LOG_FILE
echo "Vérification terminée à $(date)" >> $LOG_FILE

## Afficher l'emplacement du journal
echo "Vérification du système terminée. Journal enregistré dans $LOG_FILE"
EOF

## Rendre le script exécutable
chmod +x daily_check.sh

## Exécuter le script
./daily_check.sh

Pour planifier l'exécution quotidienne de ce script, vous utiliserez généralement le système cron. Voici comment le configurer :

## Montrer comment configurer une tâche cron (ne la créez pas réellement dans cet environnement de laboratoire)
echo "Pour planifier l'exécution de ce script tous les jours à 9h, vous utiliserez :"
echo "crontab -e"
echo "Et ajoutez la ligne :"
echo "0 9 * * * /home/labex/project/daily_check.sh"

Cela démontre comment les commandes de test de conditions Linux que vous avez apprises peuvent être appliquées pour créer des outils pratiques de surveillance système.

Synthèse

Dans ce laboratoire, vous avez appris à utiliser les tests de conditions Linux pour évaluer différents types de conditions et prendre des décisions en fonction des résultats. Voici un résumé de ce que vous avez accompli :

1. Vous avez appris les bases de la commande test et comment vérifier les propriétés des fichiers telles que l'existence, la lisibilité et la taille.

2. Vous avez exploré la comparaison de chaînes de caractères en utilisant des opérateurs tels que ==, !=, -z et -n pour valider les entrées et prendre des décisions en fonction du contenu textuel.

3. Vous avez travaillé avec des comparaisons numériques en utilisant des opérateurs tels que -eq, -ne, -lt, -gt, -le et -ge pour évaluer les valeurs numériques.

4. Vous avez combiné plusieurs conditions en utilisant des opérateurs logiques (&&, ||, !) pour créer une logique de prise de décision complexe.

5. Vous avez appliqué toutes ces techniques pour créer des scripts de surveillance système complets qui peuvent vérifier divers paramètres système et fournir des rapports d'état.

Ces compétences sont fondamentales pour la programmation en shell et l'administration système sous Linux. La capacité à tester des conditions et à prendre différentes actions en fonction des résultats vous permet de créer des scripts qui peuvent automatiser des tâches, valider les entrées, gérer les erreurs et surveiller la santé du système.

Certaines applications pratiques de ce que vous avez appris incluent :

• La création de scripts de sauvegarde automatisés qui vérifient l'espace disponible avant de procéder
• Le développement de la validation des entrées pour les scripts destinés aux utilisateurs
• La construction d'outils de surveillance système qui alertent les administrateurs aux problèmes potentiels
• L'automatisation des tâches de maintenance système de routine avec une logique conditionnelle

Au fur et à mesure que vous continuerez à travailler avec Linux, vous constaterez que les tests de conditions sont une partie essentielle de presque tous les scripts shell que vous créerez ou maintiendrez.