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.
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é.
Créer un répertoire pour vos scripts. Utilisez la commande
mkdirpour créer un répertoire nomméscriptsdans votre répertoire~/project. C'est là que vous stockerez vos scripts Bash.mkdir ~/project/scriptsIl n'y aura pas de sortie directe de cette commande en cas de succès.
Créer votre premier fichier de script Bash. Naviguez dans le répertoire
scriptsnouvellement créé et utilisez l'éditeur de textenanopour créer un fichier nomméfirstscript.sh. L'extension.shest 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.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 commandeechopour 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 surEntréepour confirmer le nom du fichier, et surCtrl+Xpour quitternano.Votre terminal devrait revenir à l'invite de commande.
Exécuter votre script en utilisant l'interpréteur
bash. Vous pouvez exécuter un script Bash en indiquant explicitement à l'interpréteurbashde l'exécuter. Cette méthode ne nécessite pas que le script ait des permissions d'exécution.bash firstscript.shVous 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.
Naviguer vers votre répertoire de scripts. Assurez-vous d'être dans le répertoire
~/project/scriptsoù vous avez crééfirstscript.shà l'étape précédente.cd ~/project/scriptsModifier
firstscript.shpour 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.shen utilisantnano:nano firstscript.shModifiez 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
lsblkpour lister les périphériques de blocs. - Afficher un en-tête pour l'espace libre du système de fichiers.
- Exécuter
df -hpour 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 -hEnregistrez le fichier en appuyant sur
Ctrl+O, puis surEntrée, etCtrl+Xpour quitternano.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 commandechmodest utilisée pour modifier les permissions des fichiers.+xajoute la permission d'exécution pour tous les utilisateurs.chmod +x firstscript.shIl n'y aura pas de sortie directe de cette commande en cas de succès.
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.shVous devriez voir une sortie similaire à celle-ci, combinant votre message initial avec la sortie de
lsblketdf -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/firmwareLa sortie exacte pour
lsblketdf -hpeut 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 des 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.
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 -fVous devriez voir une sortie similaire à celle-ci :
684791f71c0e35fea6cc1243 684791f71c0e35fea6cc1243Cela 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.
Créer une boucle
forpour automatiser la récupération du nom d'hôte avec différentes options. Maintenant, utilisons une boucleforpour exécuter différentes commandes de nom d'hôte plus efficacement. La boucleforitérera sur une liste d'options de nom d'hôte, en exécutant la commandehostnameavec chaque option.for OPTION in "" "-f" "-s"; do echo "hostname ${OPTION}:" hostname ${OPTION} echo "" doneDécomposons cette commande :
for OPTION in "" "-f" "-s";: Cette partie initialise la boucle.OPTIONest 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 variableOPTION.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: 684791f71c0e35fea6cc1243Cela démontre la puissance des boucles
forpour 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.
Naviguer vers votre répertoire de scripts. Assurez-vous d'être dans le répertoire
~/project/scripts.cd ~/project/scriptsCréer un nouveau script pour la récupération du nom d'hôte. Vous allez créer un script nommé
get_hostnames.shqui contient la boucleforpour récupérer les informations du nom d'hôte en utilisant différentes options.Ouvrez
get_hostnames.shen utilisantnano:nano get_hostnames.shAjoutez 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 0Enregistrez le fichier en appuyant sur
Ctrl+O, puis surEntrée, etCtrl+Xpour quitternano.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 de0, ce qui indique conventionnellement le succès.
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.shIl n'y aura pas de sortie directe de cette commande en cas de succès.
Exécuter le script depuis son répertoire actuel. Exécutez le script pour vérifier sa fonctionnalité.
./get_hostnames.shVous devriez voir une sortie similaire à celle-ci :
Getting hostname with option: 684791f71c0e35fea6cc1243 ------------------------ Getting hostname with option: -f 684791f71c0e35fea6cc1243 ------------------------ Getting hostname with option: -s 684791f71c0e35fea6cc1243 ------------------------Comprendre la variable d'environnement
PATH. La variable d'environnementPATHest une liste de répertoires que le shell recherche pour les commandes exécutables. Lorsque vous tapez une commande commelsougrep, le shell recherche dans les répertoires listés dansPATHpour trouver le fichier exécutable correspondant.Affichez votre variable
PATHactuelle :echo $PATHVous 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/sbinNotez que
~/project/scripts(ou/home/labex/project/scripts) n'est généralement pas inclus dans lePATHpar défaut. C'est pourquoi vous avez dû utiliser./get_hostnames.shpour exécuter votre script.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 personnelbinouscriptsà votrePATHafin de pouvoir exécuter vos scripts personnalisés depuis n'importe quel emplacement. Vous pouvez le faire en ajoutant une ligne commeexport PATH=$PATH:~/project/scriptsà votre fichier~/.bashrcou~/.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.
Rechercher des informations spécifiques sur les utilisateurs et les groupes dans les fichiers système. Vous utiliserez
greppour trouver des informations sur l'utilisateur et le groupelabexà partir des fichiers/etc/passwdet/etc/group. Ces fichiers stockent respectivement les informations de compte utilisateur et de groupe.Tout d'abord, recherchons l'entrée de l'utilisateur
labexdans/etc/passwd:grep "labex" /etc/passwdSortie attendue :
labex:x:1000:1000::/home/labex:/bin/bashEnsuite, trouvez l'entrée du groupe
labexdans/etc/group:grep "labex" /etc/groupSortie attendue :
labex:x:1000:Ces commandes démontrent l'utilisation de base de
greppour trouver des correspondances de chaînes exactes.Filtrer la sortie de
lscpuen utilisantgrepet les expressions régulières. La commandelscpuaffiche les informations sur l'architecture du processeur. Souvent, vous n'avez besoin que de lignes spécifiques de sa sortie étendue. Vous pouvez utilisergrepavec 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 delscpuet l'alimente en entrée standard à la commandegrep.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: 6Filtrer 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 utilisergrepavec plusieurs motifs pour exclure ces lignes. Démontrons cela avec le fichier/etc/passwd.grep -v '^#' /etc/passwd | head -5Décomposons cette commande :
grep -v '^#' /etc/passwd: L'option-vinverse 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 commandegrepvers 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/nologinRechercher des motifs spécifiques dans les fichiers système. Vous pouvez utiliser
greppour 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/passwdSortie attendue (montrant les utilisateurs avec le shell bash) :
root:x:0:0:root:/root:/bin/bash labex:x:1000:1000::/home/labex:/bin/bashCette 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.
Naviguer vers votre répertoire de scripts. Assurez-vous d'être dans le répertoire
~/project/scripts.cd ~/project/scriptsCré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.shen utilisantnano:nano system_info.shAjoutez 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 surEntrée, etCtrl+Xpour quitternano.É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.
Rendre le script exécutable.
chmod +x system_info.shIl n'y aura pas de sortie directe de cette commande en cas de succès.
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.shVous 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.Examiner les fichiers de sortie générés. Vérifiez le contenu des fichiers
output-basic.txtetoutput-detailed.txtdans votre répertoire~/projectpour vérifier que le script a collecté les informations comme prévu.cat ~/project/output-basic.txt cat ~/project/output-detailed.txtLe 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-genericoutput-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/LinuxCe 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.
