Créer et Exécuter des Scripts Bash sous RHEL

Red Hat Enterprise LinuxRed Hat Enterprise LinuxBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à créer et à exécuter des scripts Bash pour l'administration système RHEL. Vous commencerez par élaborer des scripts simples, puis vous les améliorerez avec des commandes système et les rendrez exécutables. Le laboratoire progresse vers l'utilisation de boucles for pour automatiser des tâches telles que la collecte d'informations système et le filtrage de la sortie de commandes avec grep et les expressions régulières. Enfin, vous construirez un script complet d'informations système RHEL, acquérant des compétences pratiques en matière d'automatisation des tâches administratives et en tirant parti des puissantes fonctionnalités du shell.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 86%. Il a reçu un taux d'avis positifs de 91% de la part des apprenants.

Créer et exécuter un script Bash simple

Dans cette étape, vous apprendrez à créer un script Bash de base et à l'exécuter. Les scripts Bash sont des fichiers texte brut contenant une série de commandes que le shell Bash peut exécuter. Ce sont des outils puissants pour automatiser les tâches répétitives et combiner plusieurs commandes en une seule unité exécutable.

Tout d'abord, vous créerez un nouveau répertoire pour stocker vos scripts. C'est une bonne pratique d'organiser vos fichiers, et placer les scripts dans un répertoire dédié permet de garder votre répertoire personnel bien rangé.

  1. Créer un répertoire pour vos scripts.
    Utilisez la commande mkdir pour créer un répertoire nommé scripts dans votre répertoire ~/project. C'est là que vous stockerez vos scripts Bash.

    mkdir ~/project/scripts

    Il n'y aura pas de sortie directe de cette commande en cas de succès.

  2. Créer votre premier fichier de script Bash.
    Naviguez dans le répertoire scripts nouvellement créé et utilisez l'éditeur de texte nano pour créer un fichier nommé firstscript.sh. L'extension .sh est une convention courante pour les scripts shell, bien que non strictement obligatoire.

    cd ~/project/scripts
    nano firstscript.sh

    À l'intérieur de l'éditeur nano, vous verrez un écran vide.

  3. Ajouter du contenu à votre script.
    Chaque script Bash doit commencer par une ligne "shebang", #!/usr/bin/bash. Cette ligne indique au système d'exploitation quel interpréteur utiliser pour exécuter le script (dans ce cas, Bash). Après le shebang, vous ajouterez une simple commande echo pour afficher un message dans le terminal.

    Tapez les lignes suivantes dans l'éditeur nano :

    #!/usr/bin/bash
    echo "Hello, LabEx! This is my first Bash script."

    Une fois que vous avez saisi le contenu, enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée pour confirmer le nom du fichier, et sur Ctrl+X pour quitter nano.

    Votre terminal devrait revenir à l'invite de commande.

  4. Exécuter votre script en utilisant l'interpréteur bash.
    Vous pouvez exécuter un script Bash en indiquant explicitement à l'interpréteur bash de l'exécuter. Cette méthode ne nécessite pas que le script ait des permissions d'exécution.

    bash firstscript.sh

    Vous devriez voir la sortie de votre script :

    Hello, LabEx! This is my first Bash script.

    Cela confirme que votre script a été créé correctement et exécuté avec succès.

Améliorer un script Bash avec des commandes système et le rendre exécutable

Dans cette étape, vous améliorerez votre script Bash en ajoutant davantage de commandes système et apprendrez à rendre le script directement exécutable. Rendre un script exécutable vous permet de l'exécuter comme n'importe quelle autre commande, sans appeler explicitement l'interpréteur bash.

  1. Naviguer vers votre répertoire de scripts.
    Assurez-vous d'être dans le répertoire ~/project/scripts où vous avez créé firstscript.sh à l'étape précédente.

    cd ~/project/scripts
  2. Modifier firstscript.sh pour inclure davantage de commandes système.
    Vous allez maintenant ajouter des commandes à votre script qui affichent des informations système, telles que les périphériques de blocs et l'espace libre du système de fichiers. Cela démontre comment les scripts peuvent automatiser la collecte de données système.

    Ouvrez firstscript.sh en utilisant nano :

    nano firstscript.sh

    Modifiez le contenu du fichier pour qu'il corresponde à ce qui suit. Ce script va maintenant :

    • Afficher un en-tête pour les informations sur les périphériques de blocs.
    • Exécuter lsblk pour lister les périphériques de blocs.
    • Afficher un en-tête pour l'espace libre du système de fichiers.
    • Exécuter df -h pour afficher l'utilisation de l'espace disque dans un format lisible par l'homme.
    #!/usr/bin/bash
    echo "Hello, LabEx! This is my first Bash script."
    echo "#####################################################"
    echo "LIST BLOCK DEVICES"
    echo "#####################################################"
    lsblk
    echo "#####################################################"
    echo "FILESYSTEM FREE SPACE STATUS"
    echo "#####################################################"
    df -h

    Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et Ctrl+X pour quitter nano.

  3. Rendre le script exécutable.
    Pour exécuter un script directement (par exemple, ./firstscript.sh), vous devez lui accorder des permissions d'exécution. La commande chmod est utilisée pour modifier les permissions des fichiers. +x ajoute la permission d'exécution pour tous les utilisateurs.

    chmod +x firstscript.sh

    Il n'y aura pas de sortie directe de cette commande en cas de succès.

  4. Exécuter le script directement.
    Maintenant que le script est exécutable, vous pouvez l'exécuter en spécifiant son chemin. Puisqu'il se trouve dans votre répertoire actuel, vous utilisez ./ suivi du nom du script.

    ./firstscript.sh

    Vous devriez voir une sortie similaire à celle-ci, combinant votre message initial avec la sortie de lsblk et df -h :

    Hello, LabEx! This is my first Bash script.
    #####################################################
    LIST BLOCK DEVICES
    #####################################################
    NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
    loop0         7:0    0 10.2G  1 loop /
    loop1         7:1    0  200M  1 loop /usr/local/bin
    loop2         7:2    0  200M  1 loop /usr/local/go
    loop3         7:3    0  200M  1 loop /usr/local/java
    loop4         7:4    0  200M  1 loop /usr/local/node
    loop5         7:5    0  200M  1 loop /usr/local/python
    #####################################################
    FILESYSTEM FREE SPACE STATUS
    #####################################################
    Filesystem      Size  Used Avail Use% Mounted on
    overlay          10G  4.0G  6.1G  40% /
    tmpfs            64M     0   64M   0% /dev
    tmpfs           7.8G     0  7.8G   0% /sys/fs/cgroup
    shm              64M     0   64M   0% /dev/shm
    /dev/loop0       10G  4.0G  6.1G  40% /
    tmpfs           7.8G     0  7.8G   0% /proc/asound
    tmpfs           7.8G     0  7.8G   0% /proc/acpi
    tmpfs           7.8G     0  7.8G   0% /proc/scsi
    tmpfs           7.8G     0  7.8G   0% /sys/firmware

    La sortie exacte pour lsblk et df -h peut varier légèrement en fonction de l'environnement spécifique, mais la structure et la présence de la sortie des commandes devraient être similaires.

Utiliser les boucles For pour automatiser la récupération du nom d'hôte sur les serveurs RHEL

Dans cette étape, vous découvrirez les boucles for en Bash et comment les utiliser pour automatiser des tâches sur plusieurs serveurs. Les boucles for sont des instructions fondamentales de contrôle de flux qui vous permettent d'exécuter un bloc de code de manière répétée pour chaque élément d'une liste. Ceci est particulièrement utile pour gérer efficacement plusieurs systèmes.

Pour cet exercice, nous allons démontrer le concept en utilisant localhost avec différentes approches pour simuler le travail avec plusieurs serveurs.

  1. Récupérer le nom d'hôte en utilisant des commandes locales.
    Avant d'utiliser une boucle, voyons comment vous obtiendriez généralement le nom d'hôte du système local. Nous utiliserons différentes méthodes pour démontrer le concept.

    hostname
    hostname -f

    Vous devriez voir une sortie similaire à celle-ci :

    684791f71c0e35fea6cc1243
    684791f71c0e35fea6cc1243

    Cela démontre que vous pouvez récupérer avec succès les informations du nom d'hôte en utilisant différentes options. Notez que dans cet environnement de conteneur, toutes les options de nom d'hôte renvoient le même ID de conteneur.

  2. Créer une boucle for pour automatiser la récupération du nom d'hôte avec différentes options.
    Maintenant, utilisons une boucle for pour exécuter différentes commandes de nom d'hôte plus efficacement. La boucle for itérera sur une liste d'options de nom d'hôte, en exécutant la commande hostname avec chaque option.

    for OPTION in "" "-f" "-s"; do
      echo "hostname ${OPTION}:"
      hostname ${OPTION}
      echo ""
    done

    Décomposons cette commande :

    • for OPTION in "" "-f" "-s";: Cette partie initialise la boucle. OPTION est une variable qui prendra la valeur de chaque élément de la liste (chaîne vide, -f, -s) lors de chaque itération.
    • do: Marque le début des commandes à exécuter dans la boucle.
    • echo "hostname ${OPTION}:";: Ceci affiche quelle option est utilisée.
    • hostname ${OPTION};: C'est la commande exécutée à chaque itération. ${OPTION} se développe en la valeur actuelle de la variable OPTION.
    • echo "";: Ajoute une ligne vide pour une meilleure lisibilité.
    • done: Marque la fin de la boucle.

    Vous devriez voir une sortie similaire à celle-ci :

    hostname :
    684791f71c0e35fea6cc1243
    
    hostname -f:
    684791f71c0e35fea6cc1243
    
    hostname -s:
    684791f71c0e35fea6cc1243

    Cela démontre la puissance des boucles for pour automatiser les tâches répétitives avec différents paramètres.

Créer et exécuter un script Bash avec une boucle For pour les serveurs RHEL

Dans cette étape, vous allez encapsuler la boucle for que vous avez apprise à l'étape précédente dans un script Bash. Cela vous permet d'enregistrer la logique d'automatisation et de la réutiliser facilement. Vous découvrirez également la variable d'environnement PATH et comment rendre vos scripts accessibles depuis n'importe quel répertoire.

  1. Naviguer vers votre répertoire de scripts.
    Assurez-vous d'être dans le répertoire ~/project/scripts.

    cd ~/project/scripts
  2. Créer un nouveau script pour la récupération du nom d'hôte.
    Vous allez créer un script nommé get_hostnames.sh qui contient la boucle for pour récupérer les informations du nom d'hôte en utilisant différentes options.

    Ouvrez get_hostnames.sh en utilisant nano :

    nano get_hostnames.sh

    Ajoutez le contenu suivant au fichier :

    #!/usr/bin/bash
    ## This script retrieves hostname information using different options.
    
    for OPTION in "" "-f" "-s"; do
      echo "Getting hostname with option: ${OPTION}"
      hostname ${OPTION}
      echo "------------------------"
    done
    
    exit 0

    Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et Ctrl+X pour quitter nano.

    Décomposons les nouveaux éléments :

    • ## This script...: Les lignes commençant par # sont des commentaires. Elles sont ignorées par le shell mais sont utiles pour documenter votre script.
    • echo "Getting hostname with option: ${OPTION}": Cette ligne fournit un retour d'information pendant l'exécution du script, indiquant quelle option est actuellement utilisée.
    • exit 0: Cette commande quitte explicitement le script avec un code d'état de 0, ce qui indique conventionnellement le succès.
  3. Rendre le script exécutable.
    Comme à l'étape précédente, vous devez donner à votre nouveau script des permissions d'exécution.

    chmod +x get_hostnames.sh

    Il n'y aura pas de sortie directe de cette commande en cas de succès.

  4. Exécuter le script depuis son répertoire actuel.
    Exécutez le script pour vérifier sa fonctionnalité.

    ./get_hostnames.sh

    Vous devriez voir une sortie similaire à celle-ci :

    Getting hostname with option:
    684791f71c0e35fea6cc1243
    ------------------------
    Getting hostname with option: -f
    684791f71c0e35fea6cc1243
    ------------------------
    Getting hostname with option: -s
    684791f71c0e35fea6cc1243
    ------------------------
  5. Comprendre la variable d'environnement PATH.
    La variable d'environnement PATH est une liste de répertoires que le shell recherche pour les commandes exécutables. Lorsque vous tapez une commande comme ls ou grep, le shell recherche dans les répertoires listés dans PATH pour trouver le fichier exécutable correspondant.

    Affichez votre variable PATH actuelle :

    echo $PATH

    Vous verrez une liste de répertoires séparés par des deux-points. Par exemple :

    /home/labex/.local/bin:/home/labex/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin

    Notez que ~/project/scripts (ou /home/labex/project/scripts) n'est généralement pas inclus dans le PATH par défaut. C'est pourquoi vous avez dû utiliser ./get_hostnames.sh pour exécuter votre script.

  6. Ajouter votre répertoire de scripts au PATH (Optionnel, pour référence future).
    Bien que cela ne soit pas strictement requis pour cette étape du laboratoire, il est courant d'ajouter un répertoire personnel bin ou scripts à votre PATH afin de pouvoir exécuter vos scripts personnalisés depuis n'importe quel emplacement. Vous pouvez le faire en ajoutant une ligne comme export PATH=$PATH:~/project/scripts à votre fichier ~/.bashrc ou ~/.zshrc. Pour ce laboratoire, nous continuerons à exécuter les scripts en spécifiant leur chemin.

Filtrer la sortie de commande avec Grep et les expressions régulières sur RHEL

Dans cette étape, vous apprendrez à utiliser la commande grep avec des expressions régulières pour filtrer et extraire efficacement des informations spécifiques à partir de la sortie de commandes et de fichiers. grep est un utilitaire puissant pour rechercher dans des ensembles de données en texte brut les lignes qui correspondent à une expression régulière. Les expressions régulières (regex) sont des séquences de caractères qui définissent un motif de recherche.

  1. Rechercher des informations spécifiques sur les utilisateurs et les groupes dans les fichiers système.
    Vous utiliserez grep pour trouver des informations sur l'utilisateur et le groupe labex à partir des fichiers /etc/passwd et /etc/group. Ces fichiers stockent respectivement les informations de compte utilisateur et de groupe.

    Tout d'abord, recherchons l'entrée de l'utilisateur labex dans /etc/passwd :

    grep "labex" /etc/passwd

    Sortie attendue :

    labex:x:1000:1000::/home/labex:/bin/bash

    Ensuite, trouvez l'entrée du groupe labex dans /etc/group :

    grep "labex" /etc/group

    Sortie attendue :

    labex:x:1000:

    Ces commandes démontrent l'utilisation de base de grep pour trouver des correspondances de chaînes exactes.

  2. Filtrer la sortie de lscpu en utilisant grep et les expressions régulières.
    La commande lscpu affiche les informations sur l'architecture du processeur. Souvent, vous n'avez besoin que de lignes spécifiques de sa sortie étendue. Vous pouvez utiliser grep avec une expression régulière pour filtrer les lignes qui commencent par "CPU".

    lscpu | grep '^CPU'

    Décomposons cette commande :

    • lscpu: Génère les informations sur le processeur.
    • |: Il s'agit d'un pipe, qui prend la sortie standard de lscpu et l'alimente en entrée standard à la commande grep.
    • grep '^CPU': Recherche les lignes qui commencent par la chaîne littérale "CPU". Le ^ (caret) est une ancre d'expression régulière qui correspond au début d'une ligne.

    Sortie attendue (peut varier légèrement en fonction de l'environnement) :

    CPU op-mode(s):                     32-bit, 64-bit
    CPU(s):                             4
    CPU family:                         6
  3. Filtrer les fichiers de configuration, en ignorant les commentaires et les lignes vides.
    Les fichiers de configuration contiennent souvent des commentaires (lignes commençant par #) et des lignes vides qui ne sont pas pertinentes pour la configuration réelle. Vous pouvez utiliser grep avec plusieurs motifs pour exclure ces lignes. Démontrons cela avec le fichier /etc/passwd.

    grep -v '^#' /etc/passwd | head -5

    Décomposons cette commande :

    • grep -v '^#' /etc/passwd: L'option -v inverse la correspondance, ce qui signifie qu'elle sélectionne les lignes qui ne correspondent pas au motif. ^# correspond aux lignes qui commencent par un #. Ainsi, cette partie filtre les lignes de commentaires.
    • |: Achemine la sortie de la première commande grep vers la commande suivante.
    • head -5: Affiche uniquement les 5 premières lignes de la sortie.

    Sortie attendue (montrant les entrées de compte utilisateur sans commentaires) :

    root:x:0:0:root:/root:/bin/bash
    bin:x:1:1:bin:/bin:/sbin/nologin
    daemon:x:2:2:daemon:/sbin:/sbin/nologin
    adm:x:3:4:adm:/var/adm:/sbin/nologin
    lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
  4. Rechercher des motifs spécifiques dans les fichiers système.
    Vous pouvez utiliser grep pour rechercher des motifs spécifiques dans divers fichiers système. Recherchons les entrées liées au shell dans le fichier /etc/passwd.

    grep "bash" /etc/passwd

    Sortie attendue (montrant les utilisateurs avec le shell bash) :

    root:x:0:0:root:/root:/bin/bash
    labex:x:1000:1000::/home/labex:/bin/bash

    Cette commande vous aide à identifier les utilisateurs qui ont bash comme shell par défaut.

Construire un script complet d'informations système RHEL

Dans cette dernière étape, vous combinerez tous les concepts appris jusqu'à présent – scripts Bash, boucles for, ssh pour l'exécution à distance et grep avec des expressions régulières pour le filtrage – afin de construire un script complet qui collecte des informations système à partir de plusieurs serveurs RHEL. Le script enregistrera les données collectées dans des fichiers de sortie distincts pour chaque serveur.

  1. Naviguer vers votre répertoire de scripts.
    Assurez-vous d'être dans le répertoire ~/project/scripts.

    cd ~/project/scripts
  2. Créer un nouveau script nommé system_info.sh.
    Ce script collectera les informations système en utilisant différentes approches pour démontrer les concepts, et redirigera la sortie vers des fichiers distincts dans votre répertoire ~/project.

    Ouvrez system_info.sh en utilisant nano :

    nano system_info.sh

    Ajoutez le contenu suivant au fichier :

    #!/usr/bin/bash
    
    ## Define variables for output directory
    OUT_DIR='/home/labex/project'
    
    ## Loop through different information gathering approaches
    for APPROACH in "basic" "detailed"; do
      OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt"
    
      echo "Gathering ${APPROACH} system information..."
      ## Clear previous output file or create a new one
      > "${OUTPUT_FILE}"
    
      ## Get hostname information
      echo "#### Hostname Information ###" >> "${OUTPUT_FILE}"
      if [ "${APPROACH}" = "basic" ]; then
        hostname >> "${OUTPUT_FILE}"
      else
        hostname -f >> "${OUTPUT_FILE}"
      fi
      echo "" >> "${OUTPUT_FILE}" ## Add a blank line for readability
    
      ## Get CPU information (only lines starting with CPU)
      echo "#### CPU Information ###" >> "${OUTPUT_FILE}"
      lscpu | grep '^CPU' >> "${OUTPUT_FILE}"
      echo "" >> "${OUTPUT_FILE}"
    
      ## Get system users with bash shell
      echo "#### Users with Bash Shell ###" >> "${OUTPUT_FILE}"
      grep "bash" /etc/passwd >> "${OUTPUT_FILE}"
      echo "" >> "${OUTPUT_FILE}"
    
      ## Get system information based on approach
      if [ "${APPROACH}" = "basic" ]; then
        echo "#### Basic System Info ###" >> "${OUTPUT_FILE}"
        uname -r >> "${OUTPUT_FILE}"
      else
        echo "#### Detailed System Info ###" >> "${OUTPUT_FILE}"
        uname -a >> "${OUTPUT_FILE}"
      fi
      echo "" >> "${OUTPUT_FILE}"
    
      echo "Information saved to ${OUTPUT_FILE}"
      echo "-----------------------------------------------------"
    done
    
    echo "Script execution complete."

    Enregistrez le fichier en appuyant sur Ctrl+O, puis sur Entrée, et Ctrl+X pour quitter nano.

    Éléments clés de ce script :

    • OUT_DIR='/home/labex/project': La variable est utilisée pour rendre le script plus flexible et lisible.
    • OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt": Construit dynamiquement le nom du fichier de sortie pour chaque approche.
    • > "${OUTPUT_FILE}": Ceci redirige la sortie d'une commande vide vers le fichier, effaçant efficacement son contenu s'il existe ou le créant s'il n'existe pas. Cela garantit un fichier frais à chaque exécution.
    • >> "${OUTPUT_FILE}": Ceci ajoute la sortie de la commande au fichier spécifié.
    • if [ "${APPROACH}" = "basic" ]; then ... else ... fi: Instructions conditionnelles qui exécutent différentes commandes en fonction de l'approche utilisée.
    • echo "#### Section Header ###": Ajoute des en-têtes clairs au fichier de sortie pour une meilleure organisation.
  3. Rendre le script exécutable.

    chmod +x system_info.sh

    Il n'y aura pas de sortie directe de cette commande en cas de succès.

  4. Exécuter le script system_info.sh.
    Exécutez votre script complet. Il collectera les informations système en utilisant différentes approches et enregistrera les résultats dans des fichiers séparés.

    ./system_info.sh

    Vous devriez voir une sortie dans votre terminal indiquant la progression du script :

    Gathering basic system information...
    Information saved to /home/labex/project/output-basic.txt
    -----------------------------------------------------
    Gathering detailed system information...
    Information saved to /home/labex/project/output-detailed.txt
    -----------------------------------------------------
    Script execution complete.
  5. Examiner les fichiers de sortie générés.
    Vérifiez le contenu des fichiers output-basic.txt et output-detailed.txt dans votre répertoire ~/project pour vérifier que le script a collecté les informations comme prévu.

    cat ~/project/output-basic.txt
    cat ~/project/output-detailed.txt

    Le contenu de chaque fichier devrait être similaire à ceci (les valeurs réelles varieront) :

    output-basic.txt :

    #### Hostname Information ###
    684791f71c0e35fea6cc1243
    
    #### CPU Information ###
    CPU op-mode(s):                     32-bit, 64-bit
    CPU(s):                             4
    CPU family:                         6
    
    #### Users with Bash Shell ###
    root:x:0:0:root:/root:/bin/bash
    labex:x:1000:1000::/home/labex:/bin/bash
    
    #### Basic System Info ###
    5.4.0-162-generic

    output-detailed.txt :

    #### Hostname Information ###
    684791f71c0e35fea6cc1243
    
    #### CPU Information ###
    CPU op-mode(s):                     32-bit, 64-bit
    CPU(s):                             4
    CPU family:                         6
    
    #### Users with Bash Shell ###
    root:x:0:0:root:/root:/bin/bash
    labex:x:1000:1000::/home/labex:/bin/bash
    
    #### Detailed System Info ###
    Linux 684791f71c0e35fea6cc1243 5.4.0-162-generic #179-Ubuntu SMP Mon Aug 14 08:51:31 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux

    Ce script final démontre comment vous pouvez combiner diverses fonctionnalités Bash et commandes Linux pour créer des outils d'automatisation puissants pour les tâches d'administration système.

Résumé

Dans ce laboratoire, vous avez appris les étapes fondamentales de la création et de l'exécution de scripts Bash pour l'administration système RHEL. Vous avez commencé par configurer un répertoire dédié aux scripts, puis vous avez créé un script Bash simple, en comprenant l'importance de la ligne shebang et en utilisant la commande echo. Vous avez exploré différentes méthodes d'exécution de scripts, y compris directement avec l'interpréteur bash et en les rendant exécutables.

De plus, vous avez amélioré vos compétences en matière de scripts en incorporant des commandes système et en automatisant des tâches à l'aide de boucles for pour collecter des informations système avec différentes approches. Vous avez également appris à filtrer efficacement la sortie des commandes en utilisant grep et les expressions régulières, une compétence cruciale pour l'analyse des informations système. Enfin, vous avez appliqué ces concepts pour construire un script complet d'informations système RHEL, démontrant comment combiner diverses commandes et constructions de scripts pour collecter et présenter des données système précieuses.