Bash-Skripte erstellen und ausführen in RHEL

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.

Erstellen und Ausführen eines einfachen Bash-Skripts

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 namens scripts innerhalb Ihres ~/project-Verzeichnisses zu erstellen. Hier werden Sie Ihre Bash-Skripte speichern.
```
mkdir ~/project/scripts
```
Es 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 Texteditor nano, um eine Datei namens firstscript.sh zu erstellen. Die Erweiterung .sh ist eine gängige Konvention für Shell-Skripte, obwohl sie nicht zwingend erforderlich ist.
```
cd ~/project/scripts
nano firstscript.sh
```
Innerhalb 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 einfachen echo-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+O und dann Enter drücken, um den Dateinamen zu bestätigen, und Ctrl+X, um nano zu 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 dem bash-Interpreter explizit mitteilen, dass er es ausführen soll. Diese Methode erfordert nicht, dass das Skript über ausführbare Berechtigungen verfügt.
```
bash firstscript.sh
```
Sie 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.

Erweitern des Bash-Skripts mit Systembefehlen und Ausführbarmachen

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/scripts befinden, in dem Sie firstscript.sh im vorherigen Schritt erstellt haben.
```
cd ~/project/scripts
```
Bearbeiten 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.sh mit nano:
```
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.
- lsblk ausführen, um Blockgeräte aufzulisten.
- Eine Kopfzeile für den freien Speicherplatz im Dateisystem ausgeben.
- df -h ausfü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 -h
```
Speichern Sie die Datei, indem Sie Ctrl+O und dann Enter drücken und Ctrl+X, um nano zu 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 Befehl chmod wird verwendet, um Dateiberechtigungen zu ändern. +x fügt die Ausführungsberechtigung für alle Benutzer hinzu.
```
chmod +x firstscript.sh
```
Es 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.sh

Sie sollten eine Ausgabe ähnlich dieser sehen, die Ihre ursprüngliche Nachricht mit der Ausgabe von lsblk und df -h kombiniert:

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

Die genaue Ausgabe für lsblk und df -h kann je nach Umgebung leicht variieren, aber die Struktur und das Vorhandensein der Ausgabe der Befehle sollten ähnlich sein.

Verwenden von For-Schleifen zur Automatisierung des Hostnamen-Abrufs auf RHEL-Servern

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 -f
```
Sie sollten eine Ausgabe ähnlich dieser sehen:
```
684791f71c0e35fea6cc1243
684791f71c0e35fea6cc1243
```
Dies 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 eine for-Schleife, um verschiedene Hostnamenbefehle effizienter auszuführen. Die for-Schleife iteriert über eine Liste von Hostnamenoptionen und führt den Befehl hostname mit jeder Option aus.
```
for OPTION in "" "-f" "-s"; do
  echo "hostname ${OPTION}:"
  hostname ${OPTION}
  echo ""
done
```
Lassen Sie uns diesen Befehl aufschlüsseln:
- for OPTION in "" "-f" "-s";: Dieser Teil initialisiert die Schleife. OPTION ist 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 Variable OPTION erweitert.
- 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:
684791f71c0e35fea6cc1243
```
Dies 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/scripts befinden.
```
cd ~/project/scripts
```
Erstellen Sie ein neues Skript für den Hostnamen-Abruf.
Sie erstellen ein Skript namens get_hostnames.sh, das die for-Schleife enthält, um Hostnameninformationen mit verschiedenen Optionen abzurufen.

Öffnen Sie get_hostnames.sh mit nano:
```
nano get_hostnames.sh
```
Fü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 0
```
Speichern Sie die Datei, indem Sie Ctrl+O und dann Enter drücken und Ctrl+X, um nano zu 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 von 0, 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.sh
```
Es 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.sh

Sie 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 Umgebungsvariable PATH ist eine Liste von Verzeichnissen, die die Shell nach ausführbaren Befehlen durchsucht. Wenn Sie einen Befehl wie ls oder grep eingeben, sucht die Shell in den im PATH aufgeführten Verzeichnissen nach der entsprechenden ausführbaren Datei.

Zeigen Sie Ihre aktuelle PATH-Variable an:
```
echo $PATH
```
Sie 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/sbin
```
Beachten Sie, dass ~/project/scripts (oder /home/labex/project/scripts) typischerweise nicht im Standard-PATH enthalten ist. Aus diesem Grund mussten Sie ./get_hostnames.sh verwenden, um Ihr Skript auszuführen.
Fügen Sie Ihr Skriptverzeichnis zum PATH hinzu (Optional, für zukünftige Referenz).
Obwohl dies für diesen Laborschritt nicht unbedingt erforderlich ist, ist es gängige Praxis, ein persönliches bin- oder scripts-Verzeichnis zu Ihrem PATH hinzuzufügen, damit Sie Ihre benutzerdefinierten Skripte von jedem Ort aus ausführen können. Sie können dies tun, indem Sie eine Zeile wie export PATH=$PATH:~/project/scripts zu Ihrer Datei ~/.bashrc oder ~/.zshrc hinzufü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 auf 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 Gruppe labex aus den Dateien /etc/passwd und /etc/group zu finden. Diese Dateien speichern Benutzer- bzw. Gruppenkontoinformationen.

Zuerst suchen wir nach dem Eintrag für den Benutzer labex in /etc/passwd:
```
grep "labex" /etc/passwd
```
Erwartete Ausgabe:
```
labex:x:1000:1000::/home/labex:/bin/bash
```
Als Nächstes suchen Sie den Gruppeneintrag labex in /etc/group:
```
grep "labex" /etc/group
```
Erwartete Ausgabe:
```
labex:x:1000:
```
Diese Befehle demonstrieren die grundlegende grep-Verwendung, um exakte Zeichenkettenübereinstimmungen zu finden.
Filtern der lscpu-Ausgabe mit grep und regulären Ausdrücken.
Der Befehl lscpu zeigt CPU-Architekturinformationen an. Oft benötigen Sie nur bestimmte Zeilen aus seiner umfangreichen Ausgabe. Sie können grep mit 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 von lscpu nimmt und sie als Standardeingabe an den Befehl grep weiterleitet.
- 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:                         6
```
Filtern 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önnen grep mit mehreren Mustern verwenden, um diese Zeilen auszuschließen. Demonstrieren wir dies mit der Datei /etc/passwd.
```
grep -v '^#' /etc/passwd | head -5
```
Lassen Sie uns diesen Befehl aufschlüsseln:
- grep -v '^#' /etc/passwd: Die Option -v kehrt 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 ersten grep-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/nologin
```
Suchen nach bestimmten Mustern in Systemdateien.
Sie können grep verwenden, um nach bestimmten Mustern in verschiedenen Systemdateien zu suchen. Suchen wir nach shellbezogenen Einträgen in der Datei /etc/passwd.
```
grep "bash" /etc/passwd
```
Erwartete Ausgabe (zeigt Benutzer mit Bash-Shell):
```
root:x:0:0:root:/root:/bin/bash
labex:x:1000:1000::/home/labex:/bin/bash
```
Dieser 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/scripts befinden.
```
cd ~/project/scripts
```

Erstellen 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 ~/project um.

Öffnen Sie system_info.sh mit nano:

nano system_info.sh

Fü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+O und dann Enter drücken und Ctrl+X, um nano zu 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.sh
```
Es gibt keine direkte Ausgabe von diesem Befehl, wenn er erfolgreich ist.

Führen Sie das Skript system_info.sh aus.
Führen Sie Ihr umfassendes Skript aus. Es sammelt Systeminformationen mit verschiedenen Ansätzen und speichert die Ergebnisse in separaten Dateien.

./system_info.sh

Sie 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.txt und output-detailed.txt in Ihrem Verzeichnis ~/project, um zu verifizieren, dass das Skript die Informationen wie erwartet gesammelt hat.

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

Der 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-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

Dieses 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.