Einführung
In diesem Lab lernen Sie, Bash-Skripte für die RHEL-Systemadministration zu erstellen und auszuführen. Sie beginnen mit der Erstellung einfacher Skripte und erweitern diese dann mit Systembefehlen, um sie ausführbar zu machen. Das Lab geht weiter zur Verwendung von for-Schleifen zur Automatisierung von Aufgaben wie der Erfassung von Systeminformationen und der Filterung von Befehlsausgaben mit grep und regulären Ausdrücken. Schließlich erstellen Sie ein umfassendes RHEL-Systeminformationsskript und erwerben praktische Fähigkeiten in der Automatisierung administrativer Aufgaben und der Nutzung leistungsstarker Shell-Funktionen.
Ein einfaches Bash-Skript erstellen und ausführen
In diesem Schritt lernen Sie, wie Sie ein einfaches Bash-Skript erstellen und ausführen. Bash-Skripte sind reine Textdateien, die eine Reihe von Befehlen enthalten, die die Bash-Shell ausführen kann. Sie sind leistungsstarke Werkzeuge zur Automatisierung sich wiederholender Aufgaben und zur Kombination mehrerer Befehle in einer einzigen ausführbaren Einheit.
Zuerst erstellen Sie ein neues Verzeichnis, um Ihre Skripte zu speichern. Es ist eine gute Praxis, Ihre Dateien zu organisieren, und das Ablegen von Skripten in einem dedizierten Verzeichnis hilft, Ihr Home-Verzeichnis übersichtlich zu halten.
Erstellen Sie ein Verzeichnis für Ihre Skripte. Verwenden Sie den Befehl
mkdir, um ein Verzeichnis namensscriptsinnerhalb Ihres~/project-Verzeichnisses zu erstellen. Hier werden Sie Ihre Bash-Skripte speichern.mkdir ~/project/scriptsEs gibt keine direkte Ausgabe von diesem Befehl, wenn er erfolgreich ist.
Erstellen Sie Ihre erste Bash-Skriptdatei. Navigieren Sie in das neu erstellte
scripts-Verzeichnis und verwenden Sie den Texteditornano, um eine Datei namensfirstscript.shzu erstellen. Die Erweiterung.shist eine gängige Konvention für Shell-Skripte, obwohl sie nicht zwingend erforderlich ist.cd ~/project/scripts nano firstscript.shInnerhalb des
nano-Editors sehen Sie einen leeren Bildschirm.Fügen Sie Ihrem Skript Inhalt hinzu. Jedes Bash-Skript sollte mit einer "Shebang"-Zeile,
#!/usr/bin/bash, beginnen. Diese Zeile weist das Betriebssystem an, welchen Interpreter es zur Ausführung des Skripts verwenden soll (in diesem Fall Bash). Nach dem Shebang fügen Sie einen einfachenecho-Befehl hinzu, um eine Nachricht im Terminal auszugeben.Geben Sie die folgenden Zeilen in den
nano-Editor ein:#!/usr/bin/bash echo "Hello, LabEx! This is my first Bash script."Sobald Sie den Inhalt eingegeben haben, speichern Sie die Datei, indem Sie
Ctrl+Ound dannEnterdrücken, um den Dateinamen zu bestätigen, undCtrl+X, umnanozu verlassen.Ihr Terminal sollte zur Eingabeaufforderung zurückkehren.
Führen Sie Ihr Skript mit dem
bash-Interpreter aus. Sie können ein Bash-Skript ausführen, indem Sie dembash-Interpreter explizit mitteilen, dass er es ausführen soll. Diese Methode erfordert nicht, dass das Skript über ausführbare Berechtigungen verfügt.bash firstscript.shSie sollten die Ausgabe Ihres Skripts sehen:
Hello, LabEx! This is my first Bash script.Dies bestätigt, dass Ihr Skript korrekt erstellt und erfolgreich ausgeführt wurde.
Bash-Skript mit Systembefehlen erweitern und ausführbar machen
In diesem Schritt erweitern Sie Ihr Bash-Skript, indem Sie weitere Systembefehle hinzufügen, und lernen, wie Sie das Skript direkt ausführbar machen. Wenn Sie ein Skript ausführbar machen, können Sie es wie jeden anderen Befehl ausführen, ohne den bash-Interpreter explizit aufzurufen.
Navigieren Sie zu Ihrem Skriptverzeichnis. Stellen Sie sicher, dass Sie sich im Verzeichnis
~/project/scriptsbefinden, in dem Siefirstscript.shim vorherigen Schritt erstellt haben.cd ~/project/scriptsBearbeiten Sie
firstscript.sh, um weitere Systembefehle einzufügen. Sie fügen Ihrem Skript jetzt Befehle hinzu, die Systeminformationen anzeigen, wie z. B. Blockgeräte und freier Speicherplatz im Dateisystem. Dies zeigt, wie Skripte die Erfassung von Systemdaten automatisieren können.Öffnen Sie
firstscript.shmitnano:nano firstscript.shÄndern Sie den Inhalt der Datei so, dass er mit folgendem übereinstimmt. Dieses Skript wird nun:
- Eine Kopfzeile für Blockgeräteinformationen ausgeben.
lsblkausführen, um Blockgeräte aufzulisten.- Eine Kopfzeile für den freien Speicherplatz im Dateisystem ausgeben.
df -hausführen, um die Festplattenauslastung in einem für Menschen lesbaren Format anzuzeigen.
#!/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 -hSpeichern Sie die Datei, indem Sie
Ctrl+Ound dannEnterdrücken undCtrl+X, umnanozu verlassen.Machen Sie das Skript ausführbar. Um ein Skript direkt auszuführen (z. B.
./firstscript.sh), müssen Sie ihm ausführbare Berechtigungen erteilen. Der Befehlchmodwird verwendet, um Dateiberechtigungen zu ändern.+xfügt die Ausführungsberechtigung für alle Benutzer hinzu.chmod +x firstscript.shEs gibt keine direkte Ausgabe von diesem Befehl, wenn er erfolgreich ist.
Führen Sie das Skript direkt aus. Da das Skript jetzt ausführbar ist, können Sie es ausführen, indem Sie seinen Pfad angeben. Da es sich in Ihrem aktuellen Verzeichnis befindet, verwenden Sie
./gefolgt vom Skriptnamen../firstscript.shSie sollten eine Ausgabe ähnlich dieser sehen, die Ihre ursprüngliche Nachricht mit der Ausgabe von
lsblkunddf -hkombiniert: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/firmwareDie genaue Ausgabe für
lsblkunddf -hkann je nach Umgebung leicht variieren, aber die Struktur und das Vorhandensein der Ausgabe der Befehle sollten ähnlich sein.
For-Schleifen zur Automatisierung der Hostnamen-Abfrage auf RHEL-Servern verwenden
In diesem Schritt lernen Sie for-Schleifen in Bash kennen und wie Sie sie verwenden können, um Aufgaben auf mehreren Servern zu automatisieren. for-Schleifen sind grundlegende Kontrollflussanweisungen, mit denen Sie einen Codeblock wiederholt für jedes Element in einer Liste ausführen können. Dies ist besonders nützlich für die effiziente Verwaltung mehrerer Systeme.
Für diese Übung werden wir das Konzept mithilfe von localhost mit verschiedenen Ansätzen demonstrieren, um die Arbeit mit mehreren Servern zu simulieren.
Abrufen des Hostnamens mithilfe lokaler Befehle. Bevor wir eine Schleife verwenden, wollen wir sehen, wie Sie den Hostnamen typischerweise vom lokalen System abrufen würden. Wir verwenden verschiedene Methoden, um das Konzept zu demonstrieren.
hostname hostname -fSie sollten eine Ausgabe ähnlich dieser sehen:
684791f71c0e35fea6cc1243 684791f71c0e35fea6cc1243Dies zeigt, dass Sie Hostnameninformationen erfolgreich mit verschiedenen Optionen abrufen können. Beachten Sie, dass in dieser Containerumgebung alle Hostnamenoptionen dieselbe Container-ID zurückgeben.
Erstellen Sie eine
for-Schleife, um den Hostnamen-Abruf mit verschiedenen Optionen zu automatisieren. Verwenden wir nun einefor-Schleife, um verschiedene Hostnamenbefehle effizienter auszuführen. Diefor-Schleife iteriert über eine Liste von Hostnamenoptionen und führt den Befehlhostnamemit jeder Option aus.for OPTION in "" "-f" "-s"; do echo "hostname ${OPTION}:" hostname ${OPTION} echo "" doneLassen Sie uns diesen Befehl aufschlüsseln:
for OPTION in "" "-f" "-s";: Dieser Teil initialisiert die Schleife.OPTIONist eine Variable, die während jeder Iteration den Wert jedes Elements in der Liste (leere Zeichenkette,-f,-s) annimmt.do: Markiert den Beginn der Befehle, die in der Schleife ausgeführt werden sollen.echo "hostname ${OPTION}:";: Dies zeigt an, welche Option verwendet wird.hostname ${OPTION};: Dies ist der Befehl, der in jeder Iteration ausgeführt wird.${OPTION}wird zum aktuellen Wert der VariableOPTIONerweitert.echo "";: Fügt eine Leerzeile für eine bessere Lesbarkeit hinzu.done: Markiert das Ende der Schleife.
Sie sollten eine Ausgabe ähnlich dieser sehen:
hostname : 684791f71c0e35fea6cc1243 hostname -f: 684791f71c0e35fea6cc1243 hostname -s: 684791f71c0e35fea6cc1243Dies demonstriert die Leistungsfähigkeit von
for-Schleifen bei der Automatisierung sich wiederholender Aufgaben mit verschiedenen Parametern.
Erstellen und Ausführen eines Bash-Skripts mit For-Schleife für RHEL-Server
In diesem Schritt kapseln Sie die for-Schleife, die Sie im vorherigen Schritt gelernt haben, in ein Bash-Skript. Auf diese Weise können Sie die Automatisierungslogik speichern und einfach wiederverwenden. Sie lernen auch die Umgebungsvariable PATH kennen und wie Sie Ihre Skripte von jedem Verzeichnis aus zugänglich machen können.
Navigieren Sie zu Ihrem Skriptverzeichnis. Stellen Sie sicher, dass Sie sich im Verzeichnis
~/project/scriptsbefinden.cd ~/project/scriptsErstellen Sie ein neues Skript für den Hostnamen-Abruf. Sie erstellen ein Skript namens
get_hostnames.sh, das diefor-Schleife enthält, um Hostnameninformationen mit verschiedenen Optionen abzurufen.Öffnen Sie
get_hostnames.shmitnano:nano get_hostnames.shFügen Sie der Datei den folgenden Inhalt hinzu:
#!/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 0Speichern Sie die Datei, indem Sie
Ctrl+Ound dannEnterdrücken undCtrl+X, umnanozu verlassen.Lassen Sie uns die neuen Elemente aufschlüsseln:
## This script...: Zeilen, die mit#beginnen, sind Kommentare. Sie werden von der Shell ignoriert, sind aber nützlich, um Ihr Skript zu dokumentieren.echo "Getting hostname with option: ${OPTION}": Diese Zeile gibt während der Skriptausführung Feedback und zeigt an, welche Option gerade verwendet wird.exit 0: Dieser Befehl beendet das Skript explizit mit einem Statuscode von0, was konventionell Erfolg anzeigt.
Machen Sie das Skript ausführbar. Genau wie im vorherigen Schritt müssen Sie Ihrem neuen Skript ausführbare Berechtigungen erteilen.
chmod +x get_hostnames.shEs gibt keine direkte Ausgabe von diesem Befehl, wenn er erfolgreich ist.
Führen Sie das Skript aus seinem aktuellen Verzeichnis aus. Führen Sie das Skript aus, um seine Funktionalität zu überprüfen.
./get_hostnames.shSie sollten eine Ausgabe ähnlich dieser sehen:
Getting hostname with option: 684791f71c0e35fea6cc1243 ------------------------ Getting hostname with option: -f 684791f71c0e35fea6cc1243 ------------------------ Getting hostname with option: -s 684791f71c0e35fea6cc1243 ------------------------Verstehen Sie die Umgebungsvariable
PATH. Die UmgebungsvariablePATHist eine Liste von Verzeichnissen, die die Shell nach ausführbaren Befehlen durchsucht. Wenn Sie einen Befehl wielsodergrepeingeben, sucht die Shell in den imPATHaufgeführten Verzeichnissen nach der entsprechenden ausführbaren Datei.Zeigen Sie Ihre aktuelle
PATH-Variable an:echo $PATHSie sehen eine durch Doppelpunkte getrennte Liste von Verzeichnissen. Zum Beispiel:
/home/labex/.local/bin:/home/labex/bin:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbinBeachten Sie, dass
~/project/scripts(oder/home/labex/project/scripts) typischerweise nicht im Standard-PATHenthalten ist. Aus diesem Grund mussten Sie./get_hostnames.shverwenden, um Ihr Skript auszuführen.Fügen Sie Ihr Skriptverzeichnis zum
PATHhinzu (Optional, für zukünftige Referenz). Obwohl dies für diesen Laborschritt nicht unbedingt erforderlich ist, ist es gängige Praxis, ein persönlichesbin- oderscripts-Verzeichnis zu IhremPATHhinzuzufügen, damit Sie Ihre benutzerdefinierten Skripte von jedem Ort aus ausführen können. Sie können dies tun, indem Sie eine Zeile wieexport PATH=$PATH:~/project/scriptszu Ihrer Datei~/.bashrcoder~/.zshrchinzufügen. Für dieses Labor werden wir weiterhin Skripte ausführen, indem wir ihren Pfad angeben.
Filtern der Befehlsausgabe mit Grep und regulären Ausdrücken unter RHEL
In diesem Schritt lernen Sie, wie Sie den Befehl grep mit regulären Ausdrücken verwenden, um effizient spezifische Informationen aus der Befehlsausgabe und aus Dateien zu filtern und zu extrahieren. grep ist ein leistungsstarkes Dienstprogramm zum Suchen in Plain-Text-Datensätzen nach Zeilen, die einem regulären Ausdruck entsprechen. Reguläre Ausdrücke (Regex) sind Zeichenfolgen, die ein Suchmuster definieren.
Suchen nach spezifischen Benutzer- und Gruppeninformationen in Systemdateien. Sie verwenden
grep, um Informationen über den Benutzer und die Gruppelabexaus den Dateien/etc/passwdund/etc/groupzu finden. Diese Dateien speichern Benutzer- bzw. Gruppenkontoinformationen.Zuerst suchen wir nach dem Eintrag für den Benutzer
labexin/etc/passwd:grep "labex" /etc/passwdErwartete Ausgabe:
labex:x:1000:1000::/home/labex:/bin/bashAls Nächstes suchen Sie den Gruppeneintrag
labexin/etc/group:grep "labex" /etc/groupErwartete Ausgabe:
labex:x:1000:Diese Befehle demonstrieren die grundlegende
grep-Verwendung, um exakte Zeichenkettenübereinstimmungen zu finden.Filtern der
lscpu-Ausgabe mitgrepund regulären Ausdrücken. Der Befehllscpuzeigt CPU-Architekturinformationen an. Oft benötigen Sie nur bestimmte Zeilen aus seiner umfangreichen Ausgabe. Sie könnengrepmit einem regulären Ausdruck verwenden, um nach Zeilen zu filtern, die mit "CPU" beginnen.lscpu | grep '^CPU'Lassen Sie uns diesen Befehl aufschlüsseln:
lscpu: Generiert die CPU-Informationen.|: Dies ist ein Pipe, die die Standardausgabe vonlscpunimmt und sie als Standardeingabe an den Befehlgrepweiterleitet.grep '^CPU': Sucht nach Zeilen, die mit der wörtlichen Zeichenkette "CPU" beginnen. Das^(Zirkumflex) ist ein regulärer Ausdrucksanker, der den Anfang einer Zeile abgleicht.
Erwartete Ausgabe (kann je nach Umgebung leicht variieren):
CPU op-mode(s): 32-bit, 64-bit CPU(s): 4 CPU family: 6Filtern von Konfigurationsdateien, wobei Kommentare und leere Zeilen ignoriert werden. Konfigurationsdateien enthalten oft Kommentare (Zeilen, die mit
#beginnen) und leere Zeilen, die für die eigentliche Konfiguration nicht relevant sind. Sie könnengrepmit mehreren Mustern verwenden, um diese Zeilen auszuschließen. Demonstrieren wir dies mit der Datei/etc/passwd.grep -v '^#' /etc/passwd | head -5Lassen Sie uns diesen Befehl aufschlüsseln:
grep -v '^#' /etc/passwd: Die Option-vkehrt die Übereinstimmung um, was bedeutet, dass Zeilen ausgewählt werden, die nicht mit dem Muster übereinstimmen.^#gleicht Zeilen ab, die mit einem#beginnen. Dieser Teil filtert also Kommentarzeilen heraus.|: Leitet die Ausgabe des erstengrep-Befehls an den nächsten Befehl weiter.head -5: Zeigt nur die ersten 5 Zeilen der Ausgabe an.
Erwartete Ausgabe (zeigt Benutzereinträge ohne Kommentare):
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/nologinSuchen nach bestimmten Mustern in Systemdateien. Sie können
grepverwenden, um nach bestimmten Mustern in verschiedenen Systemdateien zu suchen. Suchen wir nach shellbezogenen Einträgen in der Datei/etc/passwd.grep "bash" /etc/passwdErwartete Ausgabe (zeigt Benutzer mit Bash-Shell):
root:x:0:0:root:/root:/bin/bash labex:x:1000:1000::/home/labex:/bin/bashDieser Befehl hilft Ihnen, Benutzer zu identifizieren, die Bash als ihre Standardshell haben.
Erstellen eines umfassenden RHEL-Systeminformationsskripts
In diesem letzten Schritt kombinieren Sie alle bisher gelernten Konzepte – Bash-Skripting, for-Schleifen, ssh für die Remote-Ausführung und grep mit regulären Ausdrücken zum Filtern – um ein umfassendes Skript zu erstellen, das Systeminformationen von mehreren RHEL-Servern sammelt. Das Skript speichert die gesammelten Daten in separaten Ausgabedateien für jeden Server.
Navigieren Sie zu Ihrem Skriptverzeichnis. Stellen Sie sicher, dass Sie sich im Verzeichnis
~/project/scriptsbefinden.cd ~/project/scriptsErstellen Sie ein neues Skript namens
system_info.sh. Dieses Skript sammelt Systeminformationen mit verschiedenen Ansätzen, um die Konzepte zu demonstrieren, und leitet die Ausgabe an separate Dateien in Ihrem Verzeichnis~/projectum.Öffnen Sie
system_info.shmitnano:nano system_info.shFügen Sie der Datei den folgenden Inhalt hinzu:
#!/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."Speichern Sie die Datei, indem Sie
Ctrl+Ound dannEnterdrücken undCtrl+X, umnanozu verlassen.Wichtige Elemente dieses Skripts:
OUT_DIR='/home/labex/project': Variable wird verwendet, um das Skript flexibler und lesbarer zu machen.OUTPUT_FILE="${OUT_DIR}/output-${APPROACH}.txt": Konstruiert den Ausgabedateinamen dynamisch für jeden Ansatz.> "${OUTPUT_FILE}": Dies leitet die Ausgabe eines leeren Befehls in die Datei um und löscht effektiv ihren Inhalt, falls er existiert, oder erstellt ihn, falls er nicht existiert. Dies stellt eine neue Datei für jeden Lauf sicher.>> "${OUTPUT_FILE}": Dies fügt die Ausgabe des Befehls an die angegebene Datei an.if [ "${APPROACH}" = "basic" ]; then ... else ... fi: Bedingte Anweisungen, die verschiedene Befehle ausführen, basierend auf dem verwendeten Ansatz.echo "#### Section Header ###": Fügt klare Überschriften zur Ausgabedatei hinzu, um die Organisation zu verbessern.
Machen Sie das Skript ausführbar.
chmod +x system_info.shEs gibt keine direkte Ausgabe von diesem Befehl, wenn er erfolgreich ist.
Führen Sie das Skript
system_info.shaus. Führen Sie Ihr umfassendes Skript aus. Es sammelt Systeminformationen mit verschiedenen Ansätzen und speichert die Ergebnisse in separaten Dateien../system_info.shSie sollten eine Ausgabe in Ihrem Terminal sehen, die den Fortschritt des Skripts anzeigt:
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.Überprüfen Sie die generierten Ausgabedateien. Überprüfen Sie den Inhalt der Dateien
output-basic.txtundoutput-detailed.txtin Ihrem Verzeichnis~/project, um zu verifizieren, dass das Skript die Informationen wie erwartet gesammelt hat.cat ~/project/output-basic.txt cat ~/project/output-detailed.txtDer Inhalt jeder Datei sollte ähnlich wie dieser sein (die tatsächlichen Werte variieren):
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/LinuxDieses endgültige Skript zeigt, wie Sie verschiedene Bash-Funktionen und Linux-Befehle kombinieren können, um leistungsstarke Automatisierungswerkzeuge für Systemadministrationsaufgaben zu erstellen.
Zusammenfassung
In diesem Lab haben Sie die grundlegenden Schritte zum Erstellen und Ausführen von Bash-Skripten für die RHEL-Systemadministration gelernt. Sie begannen mit der Einrichtung eines dedizierten Verzeichnisses für Skripte und erstellten dann ein einfaches Bash-Skript, wobei Sie die Bedeutung der Shebang-Zeile verstanden und den Befehl echo verwendeten. Sie haben verschiedene Methoden zur Ausführung von Skripten erkundet, einschließlich der direkten Ausführung mit dem bash-Interpreter und durch das Ausführen der Skripte.
Darüber hinaus haben Sie Ihre Skripting-Fähigkeiten erweitert, indem Sie Systembefehle integrierten und Aufgaben mithilfe von for-Schleifen automatisierten, um Systeminformationen mit verschiedenen Ansätzen zu sammeln. Sie haben auch gelernt, wie Sie die Befehlsausgabe effektiv mithilfe von grep und regulären Ausdrücken filtern können, eine entscheidende Fähigkeit zum Parsen von Systeminformationen. Schließlich haben Sie diese Konzepte angewendet, um ein umfassendes RHEL-Systeminformationsskript zu erstellen, das zeigt, wie man verschiedene Befehle und Skripting-Konstrukte kombiniert, um wertvolle Systemdaten zu sammeln und zu präsentieren.
