Linux-Bedingungsprüfung

Einführung

In diesem Lab lernen Sie, wie Sie die Linux-Bedingungsprüfung (condition testing) nutzen können, um Systemprüfungen und -validierungen zu automatisieren. Linux bietet den leistungsstarken test-Befehl, mit dem Sie Bedingungen auswerten und Aktionen basierend auf den Ergebnissen ausführen können. Das Verständnis der Verwendung dieses Befehls ist unerlässlich für das Schreiben von Shell-Skripten, die Entscheidungen treffen und auf verschiedene Bedingungen reagieren können.

Während dieses Labs werden Sie mit verschiedenen Aspekten des test-Befehls arbeiten, einschließlich Dateiprüfung, Zeichenkettenvergleich und numerischer Auswertung. Am Ende dieser Sitzung können Sie Skripts schreiben, die automatisierte Prüfungen auf Ihrem System durchführen und dazu beitragen, seine Integrität aufrechtzuerhalten.

Grundlagen des 'test'-Befehls verstehen

Der test-Befehl in Linux ist ein wichtiges Werkzeug zur Auswertung von Bedingungen in Shell-Skripten. Er ermöglicht es Ihnen, Dateieigenschaften zu prüfen, Zeichenketten zu vergleichen, numerische Werte auszuwerten und vieles mehr. Wenn die getestete Bedingung wahr ist, gibt test einen Exit-Status von Null zurück; andernfalls gibt es einen nicht-null Exit-Status zurück.

Beginnen wir mit den Grundlagen. Navigieren Sie zunächst in Ihr Projektverzeichnis:

cd ~/project

Der test-Befehl kann auf zwei Arten geschrieben werden:

Mit dem Wort test gefolgt von der Bedingung
Mit eckigen Klammern [ ] um die Bedingung

Probieren wir beide Methoden aus, um zu prüfen, ob ein Verzeichnis existiert:

## Methode 1: Verwendung des Wortes 'test'
test -d ~/project && echo "Das Projektverzeichnis existiert."

## Methode 2: Verwendung von eckigen Klammern
[ -d ~/project ] && echo "Das Projektverzeichnis existiert."

Für beide Befehle sollten Sie die folgende Ausgabe sehen:

Das Projektverzeichnis existiert.

Die Option -d prüft, ob ein Verzeichnis existiert. Der Operator && wird verwendet, um den echo-Befehl nur auszuführen, wenn die Testbedingung wahr ist.

Einige häufige Dateiprüfoptionen sind:

-d Datei: Wahr, wenn die Datei existiert und ein Verzeichnis ist
-e Datei: Wahr, wenn die Datei existiert
-f Datei: Wahr, wenn die Datei existiert und eine normale Datei ist
-r Datei: Wahr, wenn die Datei existiert und lesbar ist
-w Datei: Wahr, wenn die Datei existiert und beschreibbar ist
-x Datei: Wahr, wenn die Datei existiert und ausführbar ist
-s Datei: Wahr, wenn die Datei existiert und eine Größe größer als Null hat

Erstellen wir eine Testdatei und prüfen ihre Eigenschaften:

## Erstellen einer Testdatei
echo "Hello, Linux condition testing!" > test_file.txt

## Prüfen, ob die Datei existiert
test -e test_file.txt && echo "Die Datei existiert."

## Prüfen, ob die Datei lesbar ist
[ -r test_file.txt ] && echo "Die Datei ist lesbar."

## Prüfen, ob die Datei leer ist
[ -s test_file.txt ] && echo "Die Datei ist nicht leer."

Diese Befehle sollten die folgende Ausgabe erzeugen:

Die Datei existiert.
Die Datei ist lesbar.
Die Datei ist nicht leer.

Jetzt erstellen wir ein einfaches Shell-Skript, das den test-Befehl verwendet, um zu prüfen, ob eine Datei existiert, und wenn nicht, sie zu erstellen:

## Erstellen einer Skriptdatei
cat > check_file.sh << 'EOF'
#!/bin/bash

FILENAME="status.txt"

if [ ! -e "$FILENAME" ]; then
  echo "Datei $FILENAME existiert nicht. Erstelle sie jetzt."
  echo "This is a status file." > "$FILENAME"
else
  echo "Datei $FILENAME existiert bereits."
fi

## Anzeigen des Dateiinhalts
echo "Inhalt von $FILENAME:"
cat "$FILENAME"
EOF

## Macht das Skript ausführbar
chmod +x check_file.sh

## Ausführen des Skripts
./check_file.sh

Wenn Sie das Skript ausführen, sollten Sie eine Ausgabe ähnlich der folgenden sehen:

Datei status.txt existiert nicht. Erstelle sie jetzt.
Inhalt von status.txt:
This is a status file.

Wenn Sie das Skript erneut ausführen, sehen Sie:

Datei status.txt existiert bereits.
Inhalt von status.txt:
This is a status file.

Dies zeigt, wie der test-Befehl verwendet werden kann, um die Existenz einer Datei zu prüfen und unterschiedliche Aktionen basierend auf dem Ergebnis auszuführen.

Testen von Zeichenkettenbedingungen

In diesem Schritt lernen Sie, wie Sie den test-Befehl verwenden, um Zeichenketten zu vergleichen. Dies ist nützlich, wenn Sie Benutzereingaben validieren, Umgebungsvariablen prüfen oder Entscheidungen basierend auf Textinhalt treffen müssen.

Die gängigen Zeichenkettenvergleichsoperatoren sind:

==: Gleich
!=: Ungleich
-z: Wahr, wenn die Zeichenkette leer ist
-n: Wahr, wenn die Zeichenkette nicht leer ist

Beginnen wir damit, verschiedene Zeichenkettenbedingungen zu testen:

## Testen, ob zwei Zeichenketten gleich sind
str1="linux"
str2="linux"
[ "$str1" == "$str2" ] && echo "Die Zeichenketten sind gleich."

## Testen, ob zwei Zeichenketten unterschiedlich sind
str3="ubuntu"
[ "$str1" != "$str3" ] && echo "Die Zeichenketten sind unterschiedlich."

## Testen, ob eine Zeichenkette leer ist
empty_str=""
[ -z "$empty_str" ] && echo "Die Zeichenkette ist leer."

## Testen, ob eine Zeichenkette nicht leer ist
[ -n "$str1" ] && echo "Die Zeichenkette ist nicht leer."

Die Ausgabe sollte wie folgt sein:

Die Zeichenketten sind gleich.
Die Zeichenketten sind unterschiedlich.
Die Zeichenkette ist leer.
Die Zeichenkette ist nicht leer.

Jetzt erstellen wir ein Skript, das nach einem Passwort fragt und prüft, ob es bestimmten Kriterien entspricht:

## Erstellen eines Passwortvalidierungsskripts
cat > password_check.sh << 'EOF'
#!/bin/bash

echo "Geben Sie ein Passwort ein:"
read -s password

## Prüfen, ob das Passwort leer ist
if [ -z "$password" ]; then
  echo "Fehler: Das Passwort darf nicht leer sein."
  exit 1
fi

## Prüfen der Passwortlänge
if [ ${#password} -lt 8 ]; then
  echo "Fehler: Das Passwort muss mindestens 8 Zeichen lang sein."
  exit 1
fi

## Prüfen, ob das Passwort das Wort "password" enthält
if [[ "$password" == *password* ]]; then
  echo "Fehler: Das Passwort darf nicht das Wort 'password' enthalten."
  exit 1
fi

echo "Das Passwort ist gültig!"
EOF

## Macht das Skript ausführbar
chmod +x password_check.sh

## Ausführen des Skripts
echo "Sie können das Skript testen, indem Sie ausführen: ./password_check.sh"

Versuchen Sie, das Skript mit verschiedenen Passwörtern auszuführen, um zu sehen, wie es die Eingabe validiert:

## Testen mit einem kurzen Passwort
echo "short" | ./password_check.sh

## Testen mit einem Passwort, das "password" enthält
echo "mypassword123" | ./password_check.sh

## Testen mit einem gültigen Passwort
echo "SecurePass123" | ./password_check.sh

Die ersten beiden Tests sollten fehlschlagen, während der dritte erfolgreich sein sollte.

Erstellen wir ein weiteres Skript, das den Systemstatus basierend auf einer Texteingabe verarbeitet:

## Erstellen eines Systemstatus-Skripts
cat > system_status.sh << 'EOF'
#!/bin/bash

echo "Geben Sie den Systemstatus ein (normal, warning, critical):"
read status

if [ -z "$status" ]; then
  echo "Kein Status angegeben. Normaler Betrieb wird angenommen."
  status="normal"
fi

case "$status" in
  "normal")
    echo "Das System arbeitet normal. Keine Aktion erforderlich."
    ;;
  "warning")
    echo "Warnung: Das System erfordert Aufmerksamkeit. Prüfen Sie die Protokolldateien."
    ;;
  "critical")
    echo "KRITISCH: Sofortige Aktion erforderlich! Die Systemstabilität ist gefährdet."
    ;;
  *)
    echo "Unbekannter Status: $status. Verwenden Sie bitte normal, warning oder critical."
    ;;
esac
EOF

## Macht das Skript ausführbar
chmod +x system_status.sh

## Ausführen des Skripts
echo "Sie können das Skript testen, indem Sie ausführen: ./system_status.sh"

Versuchen Sie, das Skript mit verschiedenen Statuseingaben auszuführen:

## Testen mit Status "normal"
echo "normal" | ./system_status.sh

## Testen mit Status "warning"
echo "warning" | ./system_status.sh

## Testen mit Status "critical"
echo "critical" | ./system_status.sh

## Testen mit einem ungültigen Status
echo "unstable" | ./system_status.sh

## Testen mit leerer Eingabe
echo "" | ./system_status.sh

Jede Eingabe sollte basierend auf der bedingten Logik im Skript eine andere Ausgabe erzeugen.

Testen von numerischen Bedingungen

In diesem Schritt lernen Sie, wie Sie den test-Befehl für numerische Vergleiche verwenden. Dies ist nützlich, um die Ressourcenauslastung zu prüfen, Benutzereingaben zu validieren oder Entscheidungen basierend auf numerischen Werten zu treffen.

Die gängigen numerischen Vergleichsoperatoren sind:

-eq: Gleich
-ne: Ungleich
-lt: Kleiner als
-le: Kleiner oder gleich
-gt: Größer als
-ge: Größer oder gleich

Beginnen wir mit einigen grundlegenden numerischen Vergleichen:

## Vergleichen von zwei Zahlen
num1=10
num2=20

## Gleich
[ $num1 -eq 10 ] && echo "$num1 ist gleich 10"

## Ungleich
[ $num1 -ne $num2 ] && echo "$num1 ist nicht gleich $num2"

## Kleiner als
[ $num1 -lt $num2 ] && echo "$num1 ist kleiner als $num2"

## Größer als
[ $num2 -gt $num1 ] && echo "$num2 ist größer als $num1"

## Kleiner oder gleich
[ $num1 -le 10 ] && echo "$num1 ist kleiner oder gleich 10"

## Größer oder gleich
[ $num2 -ge 20 ] && echo "$num2 ist größer oder gleich 20"

Die Ausgabe sollte wie folgt aussehen:

10 ist gleich 10
10 ist nicht gleich 20
10 ist kleiner als 20
20 ist größer als 10
10 ist kleiner oder gleich 10
20 ist größer oder gleich 20

Jetzt erstellen wir ein Skript, das den Festplattenspeicherplatz prüft und eine Warnung ausgibt, wenn er unter einem bestimmten Schwellenwert liegt:

## Erstellen eines Skripts zur Prüfung des Festplattenspeicherplatzes
cat > disk_check.sh << 'EOF'
#!/bin/bash

## Ermitteln des Festplattennutzungsanteils (Entfernen des %-Zeichens)
DISK_USAGE=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

## Festlegen der Schwellenwerte
WARNING_THRESHOLD=70
CRITICAL_THRESHOLD=90

echo "Aktuelle Festplattennutzung: $DISK_USAGE%"

if [ $DISK_USAGE -ge $CRITICAL_THRESHOLD ]; then
  echo "KRITISCH: Die Festplattennutzung ist kritisch hoch!"
  echo "Aktion: Löschen Sie unverzichtbare Dateien sofort."
elif [ $DISK_USAGE -ge $WARNING_THRESHOLD ]; then
  echo "WARNUNG: Die Festplattennutzung wird hoch."
  echo "Aktion: Erwägen Sie, bald einige Dateien zu löschen."
else
  echo "OK: Die Festplattennutzung ist normal."
  echo "Keine Aktion erforderlich."
fi
EOF

## Macht das Skript ausführbar
chmod +x disk_check.sh

## Ausführen des Skripts
./disk_check.sh

Das Skript zeigt die aktuelle Festplattennutzung an und gibt eine andere Nachricht aus, je nachdem, wie voll die Festplatte ist.

Erstellen wir ein weiteres Skript, das ein Temperaturüberwachungssystem simuliert:

## Erstellen eines Skripts zur Temperaturüberwachung
cat > temp_monitor.sh << 'EOF'
#!/bin/bash

## Funktion zur Generierung einer zufälligen Temperatur zwischen 15 und 35
generate_temp() {
  echo $((RANDOM % 21 + 15))
}

## Generieren einer zufälligen Temperatur
TEMP=$(generate_temp)
echo "Aktuelle Temperatur: ${TEMP}°C"

## Temperatur-Schwellenwerte
MIN_TEMP=18
MAX_TEMP=26

if [ $TEMP -lt $MIN_TEMP ]; then
  echo "Aktion: Heizung erhöhen. Die Temperatur liegt unter dem Mindestschwellenwert."
elif [ $TEMP -gt $MAX_TEMP ]; then
  echo "Aktion: Kühlung aktivieren. Die Temperatur liegt über dem Höchstschwellenwert."
else
  echo "Status: Die Temperatur liegt im akzeptablen Bereich."
fi

## Zusätzliche Prüfung auf extreme Temperaturen
if [ $TEMP -ge 30 ]; then
  echo "WARNUNG: Die Temperatur ist sehr hoch. Prüfen Sie die Kühlsysteme."
fi
if [ $TEMP -le 17 ]; then
  echo "WARNUNG: Die Temperatur ist sehr niedrig. Prüfen Sie die Heizsysteme."
fi
EOF

## Macht das Skript ausführbar
chmod +x temp_monitor.sh

## Ausführen des Skripts
./temp_monitor.sh

Jedes Mal, wenn Sie dieses Skript ausführen, wird eine zufällige Temperatur generiert und entsprechend reagiert. Versuchen Sie, es mehrmals auszuführen, um verschiedene Ergebnisse zu sehen:

## Mehrmaliges Ausführen des Temperaturüberwachungsskripts
./temp_monitor.sh
./temp_monitor.sh
./temp_monitor.sh

Diese Beispiele zeigen, wie Sie numerische Bedingungen verwenden können, um Systemparameter zu überwachen und entsprechende Aktionen basierend auf Schwellenwerten auszuführen.

Kombinieren von Bedingungen mit logischen Operatoren

In diesem Schritt lernen Sie, wie Sie mehrere Bedingungen mit logischen Operatoren kombinieren können. Dies ist essentiell für die Erstellung komplexer Entscheidungslogik in Ihren Skripten.

Die drei Hauptlogischen Operatoren sind:

&& (UND): Wahr, wenn beide Bedingungen wahr sind
|| (ODER): Wahr, wenn mindestens eine Bedingung wahr ist
! (NICHT): Wahr, wenn die Bedingung falsch ist

Beginnen wir mit einigen grundlegenden Beispielen:

## Erstellen einer Testdatei
touch test_file.txt
chmod 644 test_file.txt

## UND-Operator - beide Bedingungen müssen wahr sein
[ -f test_file.txt ] && [ -r test_file.txt ] && echo "Die Datei existiert und ist lesbar."

## ODER-Operator - mindestens eine Bedingung muss wahr sein
[ -x test_file.txt ] || [ -w test_file.txt ] && echo "Die Datei ist entweder ausführbar oder beschreibbar."

## NICHT-Operator - kehrt die Bedingung um
[ ! -x test_file.txt ] && echo "Die Datei ist nicht ausführbar."

## Kombinieren mehrerer Operatoren
[ -f test_file.txt ] && [ -r test_file.txt ] && [ ! -x test_file.txt ] && echo "Die Datei existiert, ist lesbar, aber nicht ausführbar."

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Die Datei existiert und ist lesbar.
Die Datei ist entweder ausführbar oder beschreibbar.
Die Datei ist nicht ausführbar.
Die Datei existiert, ist lesbar, aber nicht ausführbar.

Der test-Befehl ermöglicht es Ihnen auch, Bedingungen innerhalb eines einzigen Klammerpaars mit diesen Operatoren zu kombinieren:

-a (UND)
-o (ODER)

Beispiel:

## UND innerhalb eines einzelnen test-Befehls
[ -f test_file.txt -a -r test_file.txt ] && echo "Die Datei existiert und ist lesbar."

## ODER innerhalb eines einzelnen test-Befehls
[ -x test_file.txt -o -w test_file.txt ] && echo "Die Datei ist entweder ausführbar oder beschreibbar."

Erstellen wir ein komplexeres Skript, das die Systemressourcen prüft:

## Erstellen eines Skripts zur Prüfung der Systemressourcen
cat > resource_check.sh << 'EOF'
#!/bin/bash

echo "Prüfe Systemressourcen..."

## Prüfen der Speicherauslastung
MEM_THRESHOLD=80
MEM_USED=$(free | grep Mem | awk '{print int($3/$2 * 100)}')

echo "Speicherauslastung: ${MEM_USED}%"

## Prüfen des Festplattenspeicherplatzes
DISK_THRESHOLD=70
DISK_USED=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

echo "Festplattenauslastung: ${DISK_USED}%"

## Prüfen der CPU-Auslastung (1-Minuten-Durchschnitt)
LOAD_THRESHOLD=1.0
CPU_LOAD=$(cat /proc/loadavg | awk '{print $1}')

echo "CPU-Auslastungsdurchschnitt: ${CPU_LOAD}"

## Kombinierte Bedingungsprüfung
if [ $MEM_USED -gt $MEM_THRESHOLD ] && [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "KRITISCH: Sowohl der Speicher- als auch der Festplattenspeicherplatz sind hoch belegt!"
  echo "Aktion: Räumen Sie Sofort Ressourcen frei."
elif [ $MEM_USED -gt $MEM_THRESHOLD ] || [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "WARNUNG: Entweder der Speicher oder der Festplattenspeicherplatz ist hoch belegt."
  echo "Aktion: Beobachten Sie das System engmaschig."
else
  echo "OK: Die Speicher- und Festplattenauslastung liegen innerhalb der akzeptablen Grenzen."
fi

## Prüfen, ob die Auslastung numerisch ist, bevor Sie vergleichen
if [[ $CPU_LOAD =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
  ## Wir müssen bc für den Vergleich von Fließkommazahlen verwenden
  if (( $(echo "$CPU_LOAD > $LOAD_THRESHOLD" | bc -l) )); then
    echo "WARNUNG: Die CPU-Auslastung ist hoch. Prüfen Sie auf ressourcenintensive Prozesse."
  else
    echo "OK: Die CPU-Auslastung ist normal."
  fi
else
  echo "Fehler: Der CPU-Auslastungswert konnte nicht geparst werden."
fi
EOF

## Macht das Skript ausführbar
chmod +x resource_check.sh

## Ausführen des Skripts
./resource_check.sh

Dieses Skript prüft die Speicherauslastung, den Festplattenspeicherplatz und die CPU-Auslastung und gibt dann verschiedene Ausgaben basierend auf Kombinationen dieser Bedingungen aus.

Schließlich erstellen wir ein Skript, das die Benutzereingabe mit mehreren Bedingungen validiert:

## Erstellen eines Skripts zur Eingabevalidierung
cat > validate_input.sh << 'EOF'
#!/bin/bash

echo "Geben Sie einen Benutzernamen ein (nur Kleinbuchstaben, 3-8 Zeichen):"
read username

echo "Geben Sie Ihr Alter ein (muss 18 Jahre oder älter sein):"
read age

## Benutzernamenvalidierung
is_valid_username=true

## Prüfen, ob der Benutzername leer ist
if [ -z "$username" ]; then
  echo "Fehler: Der Benutzername darf nicht leer sein."
  is_valid_username=false
fi

## Prüfen der Länge des Benutzernamens
if [ ${#username} -lt 3 ] || [ ${#username} -gt 8 ]; then
  echo "Fehler: Der Benutzername muss zwischen 3 und 8 Zeichen lang sein."
  is_valid_username=false
fi

## Prüfen, ob der Benutzername nur Kleinbuchstaben enthält
if [[ ! "$username" =~ ^[a-z]+$ ]]; then
  echo "Fehler: Der Benutzername muss nur Kleinbuchstaben enthalten."
  is_valid_username=false
fi

## Altersvalidierung
is_valid_age=true

## Prüfen, ob das Alter eine Zahl ist
if [[ ! "$age" =~ ^[0-9]+$ ]]; then
  echo "Fehler: Das Alter muss eine Zahl sein."
  is_valid_age=false
fi

## Prüfen, ob das Alter mindestens 18 Jahre beträgt
if [ "$is_valid_age" = true ] && [ $age -lt 18 ]; then
  echo "Fehler: Sie müssen mindestens 18 Jahre alt sein."
  is_valid_age=false
fi

## Endgültige Validierung
if [ "$is_valid_username" = true ] && [ "$is_valid_age" = true ]; then
  echo "Registrierung erfolgreich!"
  echo "Willkommen, $username. Ihr Konto wurde erstellt."
else
  echo "Registrierung fehlgeschlagen. Bitte korrigieren Sie die Fehler und versuchen Sie es erneut."
fi
EOF

## Macht das Skript ausführbar
chmod +x validate_input.sh

## Ausführen des Skripts
echo "Sie können das Skript testen, indem Sie ausführen: ./validate_input.sh"

Versuchen Sie, das Skript mit verschiedenen Eingaben auszuführen, um zu sehen, wie die kombinierten Bedingungen zusammenwirken, um die Benutzereingabe zu validieren:

## Testen mit gültiger Eingabe
echo -e "john\n25" | ./validate_input.sh

## Testen mit ungültigem Benutzernamen (zu kurz)
echo -e "jo\n25" | ./validate_input.sh

## Testen mit ungültigem Benutzernamen (enthält Großbuchstaben)
echo -e "John\n25" | ./validate_input.sh

## Testen mit ungültigem Alter (unter 18)
echo -e "john\n17" | ./validate_input.sh

## Testen mit ungültigem Alter (keine Zahl)
echo -e "john\nabc" | ./validate_input.sh

Diese Beispiele zeigen, wie Sie mehrere Bedingungen kombinieren können, um komplexe Validierungslogik in Ihren Skripten zu erstellen.

Erstellen eines umfassenden Systemüberwachungsskripts

In diesem letzten Schritt werden Sie alles, was Sie gelernt haben, kombinieren, um ein umfassendes Systemüberwachungsskript zu erstellen. Dieses Skript wird verschiedene Systemparameter prüfen und einen zusammenfassenden Bericht liefern.

Erstellen wir ein Skript, das mehrere Aspekte des Systems überwacht:

## Erstellen eines Systemüberwachungsskripts
cat > system_monitor.sh << 'EOF'
#!/bin/bash

echo "========================================"
echo "    Systemüberwachungsbericht"
echo "    $(date)"
echo "========================================"
echo

## 1. Prüfen, ob wichtige Systemdateien existieren
echo "1. Systemdateienprüfung:"
important_files=("/etc/passwd" "/etc/hosts" "/etc/resolv.conf")
all_files_exist=true

for file in "${important_files[@]}"; do
  if [ -e "$file" ]; then
    echo "   [OK] $file existiert"
    
    ## Prüfen, ob die Datei leer ist
    if [ ! -s "$file" ]; then
      echo "   [WARNUNG] $file ist leer"
    fi
    
    ## Prüfen, ob die Datei lesbar ist
    if [ ! -r "$file" ]; then
      echo "   [WARNUNG] $file ist nicht lesbar"
    fi
  else
    echo "   [FEHLER] $file existiert nicht"
    all_files_exist=false
  fi
done

if [ "$all_files_exist" = true ]; then
  echo "   Alle Systemdateien sind vorhanden."
else
  echo "   Einige Systemdateien fehlen. Prüfen Sie die obigen Fehler."
fi
echo

## 2. Prüfen des Festplattenspeicherplatzes
echo "2. Festplattenspeicherplatzprüfung:"
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "   Verbrauch der Root-Partition: ${disk_usage}%"

if [ $disk_usage -ge 90 ]; then
  echo "   [KRITISCH] Der Festplattenspeicherplatz ist kritisch hoch belegt!"
elif [ $disk_usage -ge 70 ]; then
  echo "   [WARNUNG] Der Festplattenspeicherplatz wird hoch belegt."
else
  echo "   [OK] Der Festplattenspeicherplatz ist normal belegt."
fi
echo

## 3. Prüfen der Speicherauslastung
echo "3. Speicherauslastungsprüfung:"
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))

echo "   Speicherauslastung: ${mem_percentage}% (${mem_used}MB von ${mem_total}MB verwendet)"

if [ $mem_percentage -ge 90 ]; then
  echo "   [KRITISCH] Die Speicherauslastung ist kritisch hoch!"
elif [ $mem_percentage -ge 70 ]; then
  echo "   [WARNUNG] Die Speicherauslastung wird hoch."
else
  echo "   [OK] Die Speicherauslastung ist normal."
fi
echo

## 4. Prüfen auf aktive Prozesse
echo "4. Prozessprüfung:"
critical_processes=("sshd" "cron")
for process in "${critical_processes[@]}"; do
  if pgrep -x "$process" > /dev/null; then
    echo "   [OK] $process läuft"
  else
    echo "   [FEHLER] $process läuft nicht"
  fi
done
echo

## 5. Prüfen der Systemauslastung
echo "5. Systemauslastungsprüfung:"
load_1min=$(cat /proc/loadavg | awk '{print $1}')
load_5min=$(cat /proc/loadavg | awk '{print $2}')
load_15min=$(cat /proc/loadavg | awk '{print $3}')

echo "   Durchschnittliche Auslastung: $load_1min (1 min), $load_5min (5 min), $load_15min (15 min)"

## Bestimmen der Anzahl der CPU-Kerne
num_cores=$(grep -c ^processor /proc/cpuinfo)
load_threshold=$(echo "scale=2; $num_cores * 0.7" | bc)

if (( $(echo "$load_1min > $load_threshold" | bc -l) )); then
  echo "   [WARNUNG] Hohe Auslastung erkannt. Das System könnte unter Stress stehen."
else
  echo "   [OK] Die Systemauslastung ist normal."
fi
echo

## 6. Prüfen auf kürzlich fehlgeschlagene Anmeldeversuche
echo "6. Sicherheitsüberprüfung:"
if [ -f /var/log/auth.log ]; then
  failed_logins=$(grep "Failed password" /var/log/auth.log | wc -l)
  echo "   Fehlgeschlagene Anmeldeversuche: $failed_logins"
  
  if [ $failed_logins -gt 10 ]; then
    echo "   [WARNUNG] Eine hohe Anzahl fehlgeschlagener Anmeldeversuche wurde erkannt."
  else
    echo "   [OK] Normale Anmeldeaktivität."
  fi
else
  echo "   [INFO] Anmeldeversuche können nicht geprüft werden (auth.log nicht zugänglich)"
fi
echo

## 7. Zusammenfassung
echo "7. Systemstatuszusammenfassung:"
critical_count=$(grep -c "\[KRITISCH\]" <<< "$(cat /dev/stdin)")
warning_count=$(grep -c "\[WARNUNG\]" <<< "$(cat /dev/stdin)")
error_count=$(grep -c "\[FEHLER\]" <<< "$(cat /dev/stdin)")

if [ $critical_count -gt 0 ]; then
  echo "   [KRITISCH] Das System hat kritische Probleme, die sofort behoben werden müssen!"
elif [ $warning_count -gt 0 ] || [ $error_count -gt 0 ]; then
  echo "   [WARNUNG] Das System hat einige Probleme, die bald behoben werden sollten."
else
  echo "   [OK] Das System funktioniert normal. Keine signifikanten Probleme erkannt."
fi

echo
echo "========================================"
echo "    Ende des Systemüberwachungsberichts"
echo "========================================"
EOF

## Macht das Skript ausführbar
chmod +x system_monitor.sh

## Ausführen des Skripts
./system_monitor.sh

Dieses umfassende Skript führt die folgenden Prüfungen durch:

Überprüft, ob wichtige Systemdateien existieren und lesbar sind
Prüft den Festplattenspeicherplatzverbrauch
Überwacht die Speicherauslastung
Bestätigt, dass kritische Prozesse laufen
Bewertet die Systemauslastung
Untersucht die Sicherheitslogs auf fehlgeschlagene Anmeldeversuche
Liefert eine Gesamtübersicht über den Systemstatus

Die Ausgabe variiert je nach aktuellem Zustand Ihres Systems, aber es wird eine umfassende Übersicht über die Gesundheit Ihres Systems liefern.

Um dieses Skript noch nützlicher zu machen, könnten Sie:

Es mithilfe von cron regelmäßig ausführen lassen
Es so konfigurieren, dass es bei der Erkennung kritischer Probleme E-Mail-Warnungen sendet
Weitere spezifische Prüfungen hinzufügen, die für Ihr System relevant sind

Erstellen wir eine einfachere Version, die Sie regelmäßig ausführen lassen können:

## Erstellen eines vereinfachten Überwachungsskripts für die Planung
cat > daily_check.sh << 'EOF'
#!/bin/bash

## Einrichten der Protokolldatei
LOG_FILE="/tmp/system_check_$(date +%Y%m%d).log"

## Starten der Protokollierung
echo "Systemprüfung: $(date)" > $LOG_FILE
echo "--------------------------------" >> $LOG_FILE

## Prüfen des Festplattenspeicherplatzes
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "Festplattenspeicherplatzverbrauch: ${disk_usage}%" >> $LOG_FILE

if [ $disk_usage -ge 90 ]; then
  echo "KRITISCH: Der Festplattenspeicherplatz ist kritisch hoch belegt!" >> $LOG_FILE
elif [ $disk_usage -ge 70 ]; then
  echo "WARNUNG: Der Festplattenspeicherplatz wird hoch belegt." >> $LOG_FILE
else
  echo "OK: Der Festplattenspeicherplatz ist normal belegt." >> $LOG_FILE
fi

## Prüfen des Speichers
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))
echo "Speicherauslastung: ${mem_percentage}%" >> $LOG_FILE

if [ $mem_percentage -ge 90 ]; then
  echo "KRITISCH: Die Speicherauslastung ist kritisch hoch!" >> $LOG_FILE
elif [ $mem_percentage -ge 70 ]; then
  echo "WARNUNG: Die Speicherauslastung wird hoch." >> $LOG_FILE
else
  echo "OK: Die Speicherauslastung ist normal." >> $LOG_FILE
fi

## Prüfen auf kritische Dienste
for service in sshd cron; do
  if pgrep -x "$service" > /dev/null; then
    echo "$service läuft" >> $LOG_FILE
  else
    echo "WARNUNG: $service läuft nicht" >> $LOG_FILE
  fi
done

## Ende des Protokolls
echo "--------------------------------" >> $LOG_FILE
echo "Prüfung am $(date) abgeschlossen" >> $LOG_FILE

## Anzeigen des Speicherorts des Protokolls
echo "Systemprüfung abgeschlossen. Protokoll gespeichert in $LOG_FILE"
EOF

## Macht das Skript ausführbar
chmod +x daily_check.sh

## Ausführen des Skripts
./daily_check.sh

Um dieses Skript täglich ausführen zu lassen, würden Sie normalerweise das cron-System verwenden. So würden Sie es einrichten:

## Zeigen, wie man einen cron-Job einrichtet (erstellen Sie ihn in dieser Lab-Umgebung nicht tatsächlich)
echo "Um dieses Skript täglich um 9:00 Uhr morgens ausführen zu lassen, würden Sie folgendes verwenden:"
echo "crontab -e"
echo "Und die Zeile hinzufügen:"
echo "0 9 * * * /home/labex/project/daily_check.sh"

Dies zeigt, wie die von Ihnen gelernten Linux-Bedingungstestbefehle zur Erstellung praktischer Systemüberwachungstools angewendet werden können.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Linux-Bedingungstests verwenden können, um verschiedene Arten von Bedingungen zu bewerten und Entscheidungen auf der Grundlage der Ergebnisse zu treffen. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

Sie haben die Grundlagen des test-Befehls gelernt und wie Sie Dateieigenschaften wie Existenz, Lesbarkeit und Größe prüfen können.
Sie haben den Zeichenkettenvergleich mit Operatoren wie ==, !=, -z und -n untersucht, um Eingaben zu validieren und Entscheidungen auf der Grundlage von Textinhalt zu treffen.
Sie haben mit numerischen Vergleichen gearbeitet, indem Sie Operatoren wie -eq, -ne, -lt, -gt, -le und -ge verwendet haben, um numerische Werte zu bewerten.
Sie haben mehrere Bedingungen mit logischen Operatoren (&&, ||, !) kombiniert, um komplexe Entscheidungslogik zu erstellen.
Sie haben all diese Techniken angewendet, um umfassende Systemüberwachungsskripte zu erstellen, die verschiedene Systemparameter prüfen und Statusberichte liefern können.

Diese Fähigkeiten sind grundlegend für die Shell-Skripting und Systemadministration in Linux. Die Fähigkeit, Bedingungen zu testen und unterschiedliche Aktionen auf der Grundlage der Ergebnisse auszuführen, ermöglicht es Ihnen, Skripte zu erstellen, die Aufgaben automatisieren, Eingaben validieren, Fehler behandeln und die Systemgesundheit überwachen können.

Einige praktische Anwendungen dessen, was Sie gelernt haben, umfassen:

Das Erstellen von automatisierten Sicherungsskripten, die vor dem Fortfahren auf verfügbaren Speicherplatz prüfen
Die Entwicklung von Eingabevalidierung für Benutzer-Skripte
Das Erstellen von Systemüberwachungstools, die Administratoren auf potenzielle Probleme hinweisen
Die Automatisierung von routinemäßigen Systemwartungsaufgaben mit bedingter Logik

Wenn Sie weiterhin mit Linux arbeiten, werden Sie feststellen, dass der Bedingungstest ein wesentlicher Bestandteil fast jedes Shell-Skripts ist, das Sie erstellen oder pflegen.