Willkommen zum fünften Teil unserer technischen Wiki-Serie über Linux-Administration!

Nachdem wir in den vorherigen Artikeln die Grundlagen, die Prozessverwaltung und Netzwerkkonfiguration behandelt haben, widmen wir uns heute dem Shell-Scripting und der Automatisierung von Aufgaben.

Als Linux-Administrator verbringst du viel Zeit in der Shell. Die Fähigkeit, Aufgaben zu automatisieren, ist dabei ein wichtiger Schlüssel zur effizienten Systemverwaltung. Stell dir Shell-Scripting wie einen persönlichen Assistenten vor, der wiederkehrende Aufgaben für dich erledigt.

⚠️ Hinweis: In diesem Artikel verwenden wir Ubuntu/Debian als Beispiel-Distribution. Die grundlegenden Konzepte sind auf allen Linux-Systemen gleich, aber die Installation von Paketen und einige Konfigurationspfade können sich je nach Distribution unterscheiden. Wenn du eine andere Distribution verwendest, konsultiere bitte die entsprechende Dokumentation für die spezifischen Installationsbefehle und Pfade.

Shell-Grundlagen verstehen

Die Shell ist deine Hauptschnittstelle zum Linux-System. Lass uns die wichtigsten Konzepte durchgehen:


Shell-Arten:
┌─────────── Bash (Standard) ──────┐
│ - Bourne Again Shell             │
│ - Weit verbreitet                │
│ - Viele Features                 │
├─────────── Zsh ──────────────────┤
│ - Moderne Alternative            │
│ - Bessere Auto-Completion        │
│ - Erweiterte Features            │
└──────────────────────────────────┘

Shell-Umgebung


# Shell-Version anzeigen
echo $SHELL
echo $BASH_VERSION
# Wichtige Umgebungsvariablen
echo $PATH        # Suchpfade für Programme
echo $HOME        # Benutzer-Heimatverzeichnis
echo $USER        # Aktueller Benutzer

Shell-Konfiguration


# Konfigurationsdateien
~/.bashrc        # Persönliche Bash-Konfiguration
~/.bash_profile  # Login-Shell-Konfiguration
~/.bash_history  # Befehlsverlauf
# Aliase definieren
alias ll='ls -la'
alias update='sudo apt update && sudo apt upgrade'

Shell-Funktionen

Grundlegende Shell-Funktionen

echo # Text ausgeben

cd # Verzeichnis wechseln
ls # Dateien auflisten
pwd # Aktuelles Verzeichnis
cp # Dateien kopieren
mv # Dateien verschieben
rm # Dateien löschen
mkdir # Verzeichnis erstellen


Shell-Funktionen:
┌─────────── Ein-/Ausgabe ─────────┐
│ - echo, cat, less                │
│ - read, printf                   │
├─────────── Navigation ───────────┤
│ - cd, pwd, ls                    │
│ - find, locate                   │
├─────────── Dateioperationen ─────┤
│ - cp, mv, rm                     │
│ - mkdir, rmdir                   │
└──────────────────────────────────┘

Shell-Scripting

Nach den Shell-Grundlagen kommen wir nun zu den Details des Shell-Scriptings. Hier lernen wir, wie wir effektive Skripte schreiben:

Grundlegende Syntax


#!/bin/bash              # Shebang - definiert den Interpreter
# Dies ist ein Kommentar
# Variablen definieren
name="Anna"              # String
alter=25                 # Integer
datum=$(date +%Y-%m-%d)  # Kommando-Substitution
# Ausgabe
echo "Hallo $name"       # Variablen-Expansion
echo 'Hallo $name'       # Kein Variablen-Expansion

Variablen und Datentypen


# String-Operationen
text="Hallo Welt"
echo ${#text}              # Länge: 10
echo ${text:0:5}           # Substring: "Hallo"
echo ${text/Welt/Linux}    # Ersetzung: "Hallo Linux"
# Arrays
declare -a fruits=("Apfel" "Birne" "Orange")
echo ${fruits[0]}          # Erstes Element
echo ${fruits[@]}          # Alle Elemente
echo ${#fruits[@]}         # Array-Länge
fruits+=("Banane")         # Element hinzufügen
# Integer-Operationen
declare -i zahl=42
((zahl+=5))               # Arithmetische Operation
let "ergebnis = zahl * 2" # Alternative Berechnung
echo $((16 / 4))          # Direkte Berechnung

Kontrollstrukturen

Kontrollstrukturen sind fundamental für die Programmlogik. Lass uns die wichtigsten Strukturen im Detail betrachten:

1. If-Bedingungen


# Grundlegende Syntax
if [ Bedingung ]; then
	# Aktionen
elif [ Bedingung ]; then
	# Alternative Aktionen
else
	# Fallback Aktionen
fi
# Praktische Beispiele
# Dateiprüfung
if [ -f "/etc/hosts" ]; then
	echo "Hosts-Datei existiert"
	cat /etc/hosts
elif [ -f "/etc/hostname" ]; then
	echo "Nur Hostname-Datei gefunden"
else
	echo "Keine Systemdateien gefunden"
fi
# Numerische Vergleiche
alter=25
if [ $alter -gt 18 ]; then
	echo "Volljährig"
	if [ $alter -lt 67 ]; then
		echo "Im arbeitsfähigen Alter"
	fi
fi

2. Schleifen


# For-Schleife mit Liste
for name in Anna Bob Charlie; do
	echo "Hallo $name"
	mkdir -p /home/$name/dokumente
done
# For-Schleife mit Zahlenbereich
for i in {1..5}; do
	echo "Durchlauf $i"
	sleep 1
done
# While-Schleife mit Bedingung
count=1
while [ $count -le 3 ]; do
	echo "Zähler: $count"
	((count++))
	if [ $count -eq 2 ]; then
		echo "Hälfte geschafft!"
	fi
done

3. Case-Anweisungen


# Grundlegende Syntax
case $1 in
	start)
		echo "Starte Dienst"
		systemctl start apache2
		;;
	stop)
		echo "Stoppe Dienst"
		systemctl stop apache2
		;;
	restart)
		echo "Starte Dienst neu"
		systemctl restart apache2
		;;
	*)
		echo "Unbekannte Option"
		echo "Verwendung: $0 {start|stop|restart}"
		exit 1
		;;
esac

Funktionen

Funktionen sind wiederverwendbare Codeblöcke, die deine Skripte übersichtlicher und wartbarer machen:


# Grundlegende Funktions-Syntax
function name() {
	# Code-Block
	echo "Funktion ausführen"
}
# Alternative Syntax
name() {
	# Code-Block
	echo "Funktion ausführen"
}

1. Funktionen mit Parametern


# Parameter in Funktionen verwenden
check_user() {
	local username=$1    # Erster Parameter
	local uid=$2         # Zweiter Parameter
	# Prüfe ob Benutzer existiert
	if id "$username" &>/dev/null; then
		echo "Benutzer $username existiert"
		return 0
	else
		echo "Benutzer $username existiert nicht"
		return 1
	fi
}
# Funktion aufrufen
check_user "anna" 1001

2. Rückgabewerte und Exit-Codes


# Funktion mit Rückgabewert
get_disk_usage() {
	local directory=$1
	local usage=$(df -h "$directory" | tail -n 1 | awk '{print $5}')
	# Prozentzeichen entfernen und als Zahl zurückgeben
	echo "${usage%\%}"
	# Exit-Code setzen
	if [ "${usage%\%}" -gt 90 ]; then
		return 1    # Fehler: Über 90% voll
	fi
	return 0       # Erfolg
}
# Funktion verwenden
if ! disk_usage=$(get_disk_usage "/"); then
	echo "Warnung: Festplatte ist zu voll ($disk_usage%)"
fi

Parameter-Verarbeitung

Die Parameter-Verarbeitung ist ein wichtiger Bestandteil für flexible und wiederverwendbare Skripte:


Parameter-Arten:
┌───── Positionsparameter ─────────┐
│ $0  - Skriptname                 │
│ $1, $2, ... - Parameter          │
│ $# - Anzahl der Parameter        │
├─────────── Spezialparameter ─────┤
│ $@ - Alle Parameter als Liste    │
│ $* - Alle Parameter als String   │
│ $? - Letzter Exit-Status         │
└──────────────────────────────────┘

1. Grundlegende Parameter-Verarbeitung


#!/bin/bash
# backup.sh - Ein Backup-Skript
# Prüfe ob Parameter übergeben wurden
if [ $# -eq 0 ]; then
	echo "Verwendung: $0 <quellverzeichnis> <zielverzeichnis>"
	exit 1
fi
# Parameter verwenden
quelle="$1"
ziel="$2"
# Parameter prüfen
if [ ! -d "$quelle" ]; then
	echo "Fehler: Quellverzeichnis existiert nicht"
	exit 1
fi

2. Erweiterte Parameter-Verarbeitung


#!/bin/bash
# Parameter mit Standardwerten
ziel=${2:-"/backup"}        # Standardwert wenn $2 leer
verbose=${VERBOSE:-false}   # Umgebungsvariable oder false
# Alle Parameter durchlaufen
for param in "$@"; do
	echo "Verarbeite: $param"
done
# Parameter zählen
echo "Anzahl Parameter: $#"
# Exit-Status des letzten Befehls
if [ $? -eq 0 ]; then
	echo "Letzter Befehl erfolgreich"
fi

Fehlerbehandlung

Die Fehlerbehandlung ist essentiell für robuste Shell-Skripte. Hier sind die wichtigsten Konzepte und Techniken:


Fehlerbehandlung:
┌─────────── Exit Codes ───────────┐
│ 0     = Erfolg                   │
│ 1-255 = Verschiedene Fehler      │
├─────────── Überprüfung ──────────┤
│ $?    = Letzter Exit-Code        │
│ &&    = UND-Verknüpfung          │
│ ||    = ODER-Verknüpfung         │
└──────────────────────────────────┘

1. Exit Codes und Fehlerüberprüfung


#!/bin/bash
# Grundlegende Fehlerbehandlung
# Funktion mit Fehlerprüfung
check_file() {
	local file="$1"
	if [ ! -f "$file" ]; then
		echo "Fehler: Datei '$file' nicht gefunden!" >&2
		return 1
	fi
	return 0
}
# Beispiel mit Exit-Code-Prüfung
if ! check_file "config.txt"; then
	echo "Konfigurationsdatei fehlt!" >&2
	exit 1
fi

2. Erweiterte Fehlerbehandlung


#!/bin/bash
# Fehler abfangen und protokollieren
# Fehlerprotokollierung einrichten
log_error() {
	local message="$1"
	echo "[ERROR] $(date '+%Y-%m-%d %H:%M:%S') - $message" >&2
	echo "[ERROR] $(date '+%Y-%m-%d %H:%M:%S') - $message" >> error.log
}
# set-Optionen für bessere Fehlerbehandlung
set -e  # Beendet Skript bei Fehler
set -u  # Fehler bei undefinierten Variablen
set -o pipefail  # Fehler in Pipes beachten
# Trap für Aufräumarbeiten
trap 'echo "Skript wird beendet..."; rm -f /tmp/tempfile' EXIT


Tipp: Für eine tiefergehende Einführung in das Shell-Scripting empfehlen wir unseren Bash-Grundkurs. Dort lernst du Schritt für Schritt, wie du effektive Shell-Skripte erstellst und verwaltest.

Praktische Beispiele

Die Fehlerbehandlung ist entscheidend für robuste Shell-Skripte. Hier sind praktische Beispiele:

1. Fehlerbehandlung in Funktionen


#!/bin/bash
# Funktion mit Fehlerbehandlung
backup_files() {
	local quelle="$1"
	local ziel="$2"
	# Prüfe ob Quellverzeichnis existiert
	if [ ! -d "$quelle" ]; then
		echo "Fehler: Quellverzeichnis '$quelle' nicht gefunden!" >&2
		return 1
	fi
	# Prüfe Schreibrechte im Zielverzeichnis
	if [ ! -w "$ziel" ]; then
		echo "Fehler: Keine Schreibrechte in '$ziel'!" >&2
		return 2
	fi
	# Führe Backup durch
	cp -r "$quelle"/* "$ziel"/ || {
		echo "Fehler beim Kopieren der Dateien!" >&2
		return 3
	}
	return 0
}

2. Fehlerprotokolle und Debugging


#!/bin/bash
# Debugging aktivieren
set -x  # Zeigt ausgeführte Befehle
trap 'echo "Zeile $LINENO: Befehl fehlgeschlagen!"' ERR
# Fehlerprotokollierung
log_error() {
	local message="$1"
	echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $message" >> error.log
	return 1
}
# Beispiel für Fehlerbehandlung
if ! mkdir -p /pfad/zum/verzeichnis; then
	log_error "Konnte Verzeichnis nicht erstellen"
	exit 1
fi

3. Debugging-Techniken


# Debug-Modus aktivieren
set -x          # Zeigt jeden Befehl vor Ausführung
set -e          # Beendet Skript bei Fehlern
set -u          # Fehler bei undefinierten Variablen
set -o pipefail # Zeigt Fehler in Pipes
# Debug-Ausgaben
echo "DEBUG: Variable=$variable" >&2
logger "DEBUG: Skript erreicht Punkt A"
# Schrittweise Ausführung
bash -x ./script.sh

4. Fehlerprotokolle und Logging


# Eigene Logging-Funktion
log() {
	local level="$1"
	shift
	echo "[$(date +'%Y-%m-%d %H:%M:%S')] [$level] $*" >> script.log
}
# Verwendung
log "INFO" "Skript gestartet"
log "ERROR" "Datei nicht gefunden"

Automatisierung

Nach den Shell-Scripting Grundlagen kommen wir nun zur praktischen Automatisierung von Aufgaben. Hier lernen wir, wie wir wiederkehrende Aufgaben effizient automatisieren können:


Automatisierungs-Konzepte:
┌─────────── Backup-Skripte ───────┐
│ - Dateien sichern                │
│ - Logs rotieren                  │
│ - Aufräumen                      │
├─────────── Monitoring ───────────┤
│ - System überwachen              │
│ - Ressourcen prüfen              │
│ - Alerts versenden               │
└──────────────────────────────────┘

System-Wartung automatisieren


#!/bin/bash
# system_maintenance.sh
# Variablen definieren
LOG_DIR="/var/log"
BACKUP_DIR="/backup"
MAX_LOG_DAYS=30
# Alte Logs aufräumen
find "$LOG_DIR" -type f -name "*.log" -mtime +$MAX_LOG_DAYS -delete
# System-Updates durchführen
apt update && apt upgrade -y
# Backup erstellen
tar -czf "$BACKUP_DIR/backup_$(date +%Y%m%d).tar.gz" /home/user/data/

Weitere Automatisierungsbeispiele

Hier sind praktische Beispiele für typische Automatisierungsaufgaben:

1. Log-Rotation und Aufräumen


#!/bin/bash
# cleanup_logs.sh - Alte Logs aufräumen und komprimieren
# Variablen
LOG_DIR="/var/log"
MAX_DAYS=30
ARCHIVE_DIR="/backup/logs"
# Verzeichnis für Archive erstellen
mkdir -p "$ARCHIVE_DIR"
# Alte Logs finden und archivieren
find "$LOG_DIR" -name "*.log" -type f -mtime +$MAX_DAYS -exec gzip -c {} \; \
	-exec mv {} "$ARCHIVE_DIR/" \;
# Sehr alte Archive löschen (älter als 90 Tage)
find "$ARCHIVE_DIR" -type f -mtime +90 -delete

2. System-Monitoring


#!/bin/bash
# system_monitor.sh - Überwacht wichtige Systemressourcen
# Schwellwerte
DISK_THRESHOLD=90
MEM_THRESHOLD=80
CPU_THRESHOLD=90
# Monitoring-Funktion
check_resources() {
	# Festplattennutzung
	disk_usage=$(df -h / | tail -n1 | awk '{print $5}' | tr -d '%')
	# RAM-Nutzung
	memory_usage=$(free | grep Mem | awk '{print $3/$2 * 100}' | cut -d. -f1)
	# CPU-Last
	cpu_load=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d. -f1)
	# Warnungen versenden
	if [ "$disk_usage" -gt "$DISK_THRESHOLD" ]; then
		echo "WARNUNG: Festplatte zu ${disk_usage}% voll!" | mail -s "Disk Alert" admin@domain.com
	fi
}

3. Ressourcen-Monitoring und Alerts


#!/bin/bash
# monitor_and_alert.sh - Überwacht Systemressourcen und sendet Warnungen
# Schwellwerte
DISK_THRESHOLD=90
MEM_THRESHOLD=80
CPU_THRESHOLD=90
LOAD_THRESHOLD=4
# Alert-Funktion
send_alert() {
	local message="$1"
	local subject="$2"
	# Per Mail
	echo "$message" | mail -s "$subject" admin@domain.com
	# Per Log
	logger -p user.warning "$subject: $message"
	# Optional: Per Slack/Discord/Teams
	# curl -X POST -H 'Content-type: application/json' \
	#    --data "{\"text\":\"$message\"}" \
	#    $WEBHOOK_URL
}
# Ressourcen prüfen
check_resources() {
	# Festplattennutzung
	local disk_usage=$(df -h / | tail -n1 | awk '{print $5}' | tr -d '%')
	if [ "$disk_usage" -gt "$DISK_THRESHOLD" ]; then
		send_alert "Festplatte zu ${disk_usage}% voll!" "Disk Alert"
	fi
	# RAM-Nutzung
	local memory_usage=$(free | grep Mem | awk '{print $3/$2 * 100}' | cut -d. -f1)
	if [ "$memory_usage" -gt "$MEM_THRESHOLD" ]; then
		send_alert "RAM-Nutzung bei ${memory_usage}%!" "Memory Alert"
	fi
	# CPU-Last
	local load_average=$(uptime | awk '{print $(NF-2)}' | tr -d ',')
	if [ "$(echo "$load_average > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
		send_alert "Load Average zu hoch: ${load_average}!" "CPU Alert"
	fi
}
# Hauptprogramm
while true; do
	check_resources
	sleep 300  # Alle 5 Minuten prüfen
done

4. Prozess-Automatisierung


#!/bin/bash
# process_automation.sh
# Prozesse überwachen und neu starten
check_and_restart_process() {
	local process_name="$1"
	if ! pgrep "$process_name" >/dev/null; then
		systemctl restart "$process_name"
		logger "Prozess $process_name wurde neu gestartet"
	fi
}
# Wichtige Dienste überwachen
check_and_restart_process "nginx"
check_and_restart_process "mysql"

5. Netzwerk-Automatisierung


#!/bin/bash
# network_automation.sh
# Netzwerkverbindung prüfen
check_network() {
	if ! ping -c 1 8.8.8.8 >/dev/null; then
		systemctl restart networking
		logger "Netzwerk wurde neu gestartet"
	fi
}
# VPN-Verbindung überwachen
check_vpn() {
	if ! ip link show tun0 >/dev/null 2>&1; then
		systemctl restart openvpn
		logger "VPN wurde neu gestartet"
	fi
}

Cron-Jobs und Zeitgesteuerte Aufgaben

Die zeitgesteuerte Ausführung von Aufgaben ist ein wichtiger Teil der Automatisierung. Cron bietet eine flexible Möglichkeit, Skripte und Befehle zu bestimmten Zeiten auszuführen:


Cron-Zeitformat:
┌───────────── Minute (0-59)
│ ┌───────────── Stunde (0-23)
│ │ ┌───────────── Tag (1-31)
│ │ │ ┌───────────── Monat (1-12)
│ │ │ │ ┌───────────── Wochentag (0-7)
* * * * * Befehl/Skript

1. Cron-Konfiguration


# Crontab bearbeiten
crontab -e
# Beispiel-Einträge:
# Jede Stunde
0 * * * * /pfad/zum/stündlich.sh
# Jeden Tag um 3:30 Uhr
30 3 * * * /pfad/zum/täglich.sh
# Jeden Montag um 8 Uhr
0 8 * * 1 /pfad/zum/wöchentlich.sh

Erweiterte Cron-Funktionen

Die erweiterten Cron-Funktionen bieten noch mehr Möglichkeiten für die Automatisierung:

1. Spezielle Cron-Ausdrücke


# Spezielle Zeitangaben
@yearly   # Einmal pro Jahr (0 0 1 1 *)
@monthly  # Einmal pro Monat (0 0 1 * *)
@weekly   # Einmal pro Woche (0 0 * * 0)
@daily    # Einmal pro Tag (0 0 * * *)
@hourly   # Einmal pro Stunde (0 * * * *)
@reboot   # Nach jedem Neustart

2. Umgebungsvariablen in Cron


# In crontab -e:
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
MAILTO=admin@domain.com
# Backup mit Log
0 2 * * * /scripts/backup.sh >> /var/log/backup.log 2>&1

3. Fehlerbehandlung und Logging


# Fehler in separate Datei umleiten
30 1 * * * /scripts/cleanup.sh > /var/log/cleanup.log 2> /var/log/cleanup.error
# Ausgabe unterdrücken
0 * * * * /scripts/check.sh >/dev/null 2>&1
# Mit Zeitstempel loggen
15 * * * * echo "$(date '+\%Y-\%m-\%d \%H:\%M:\%S') - Start" >> /var/log/cron.log && /scripts/task.sh

Automatisierung von Systemaufgaben

Nach dem Shell-Scripting und der Cron-Konfiguration kommen wir zur praktischen Automatisierung von Systemaufgaben. Diese Aufgaben sind essentiell für einen reibungslosen Systembetrieb:


Systemaufgaben:
┌─────────── Wartung ─────────────┐
│ - Log-Rotation                  │
│ - Backup-Verwaltung             │
│ - Aufräumarbeiten               │
├─────────── Updates ─────────────┤
│ - Paket-Updates                 │
│ - Sicherheitsupdates            │
│ - System-Upgrades               │
└─────────────────────────────────┘

Log-Rotation


#!/bin/bash
# logrotate.sh - Automatische Log-Verwaltung
# Variablen
LOG_DIR="/var/log"
MAX_DAYS=30
ARCHIVE_DIR="/backup/logs"
# Alte Logs archivieren
find "$LOG_DIR" -name "*.log" -type f -mtime +$MAX_DAYS -exec gzip {} \;
find "$LOG_DIR" -name "*.gz" -type f -mtime +90 -delete
# Status protokollieren
logger "Log-Rotation durchgeführt: $(date)"

Update-Automatisierung

Die automatische Aktualisierung deines Systems ist wichtig für die Sicherheit und Stabilität. Hier ist ein detailliertes Beispiel:

1. System-Updates automatisieren


#!/bin/bash
# auto_update.sh - Automatische System-Updates
# Variablen
LOG_FILE="/var/log/system_updates.log"
MAIL_TO="admin@domain.com"
UPDATE_TIMEOUT=1800  # 30 Minuten Timeout
# Logging-Funktion
log_message() {
	echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}
# Updates durchführen
perform_updates() {
	log_message "Starte System-Update"
	# APT Update Cache
	if ! apt-get update; then
		log_message "FEHLER: apt-get update fehlgeschlagen"
		return 1
	fi
	# Sicherheitsupdates zuerst
	if ! DEBIAN_FRONTEND=noninteractive apt-get -y --with-new-pkgs upgrade; then
		log_message "FEHLER: Sicherheitsupdates fehlgeschlagen"
		return 2
	fi
	# Aufräumen
	apt-get clean
	apt-get autoremove -y
	log_message "System-Update erfolgreich abgeschlossen"
	return 0
}

2. Neustart-Management


# Prüfen ob Neustart erforderlich
check_reboot() {
	if [ -f /var/run/reboot-required ]; then
		log_message "System-Neustart erforderlich"
		# Nur nachts neustarten
		if [ $(date +%H) -ge 2 ] && [ $(date +%H) -le 4 ]; then
			log_message "Führe geplanten Neustart durch"
			/sbin/shutdown -r +5 "System-Neustart nach Updates"
		fi
	fi
}

Übung

In dieser Übung werden wir ein praktisches Automatisierungsskript erstellen, das verschiedene Systemaufgaben überwacht und protokolliert.

Szenario: Du bist Linux-Administrator in einem kleinen Unternehmen und sollst ein Monitoring-System aufsetzen, das wichtige Systemressourcen überwacht und bei Problemen automatisch reagiert.

Das Skript soll:

Systemressourcen (CPU, RAM, Festplatte) überwachen
Warnungen bei Überschreitung von Schwellwerten senden
Logs erstellen und rotieren
Automatisch als Cron-Job laufen

Anforderungen


Monitoring-Anforderungen:
┌─────────── Überwachung ───────────┐
│ - CPU-Auslastung > 80%            │
│ - RAM-Nutzung > 90%               │
│ - Festplatte > 85%                │
├─────────── Aktionen ──────────────┤
│ - E-Mail-Benachrichtigung         │
│ - Logging aller Ereignisse        │
│ - Automatische Log-Rotation       │
└───────────────────────────────────┘

Mögliche Lösung


#!/bin/bash
# monitor.sh - System-Monitoring-Skript
# Schwellwerte
CPU_THRESHOLD=80
MEM_THRESHOLD=90
DISK_THRESHOLD=85
# Monitoring-Funktion
check_resources() {
	# CPU-Last prüfen
	cpu_load=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d. -f1)
	# Speicherauslastung prüfen
	mem_used=$(free | grep Mem | awk '{print $3/$2 * 100}' | cut -d. -f1)
	# Festplattennutzung prüfen
	disk_used=$(df / | tail -n1 | awk '{print $5}' | tr -d '%')
	# Logging und Alerts
	if [ "$cpu_load" -gt "$CPU_THRESHOLD" ]; then
		echo "WARNUNG: CPU-Last bei ${cpu_load}%" | mail -s "CPU Alert" admin@firma.de
	fi
}

Checkliste


Implementierungs-Checkliste:
┌─────────── Grundfunktionen ───────┐
│ □ Monitoring-Funktionen           │
│ □ Alert-System                    │
│ □ Logging-Mechanismus             │
├─────────── Automatisierung ───────┤
│ □ Cron-Job einrichten             │
│ □ Log-Rotation aktivieren         │
│ □ Fehlerbehandlung                │
└───────────────────────────────────┘

Fazit

In diesem fünften Teil unserer Linux-Administrations-Serie hast du die Grundlagen des Shell-Scriptings und der Automatisierung kennengelernt. Du verstehst nun, wie du wiederkehrende Aufgaben durch Skripte automatisieren und dadurch deine Arbeit als Administrator effizienter gestalten kannst.

Die Shell ist dein wichtigstes Werkzeug für die Systemverwaltung. Mit den erlernten Konzepten kannst du nun eigene Skripte schreiben, Systemaufgaben automatisieren und Überwachungsprozesse einrichten. Besonders wichtig ist das Verständnis für die verschiedenen Automatisierungsmöglichkeiten, von einfachen Backup-Skripten bis hin zu komplexen Monitoring-Lösungen mit Cron-Jobs.

Das erworbene Wissen bildet eine solide Grundlage für fortgeschrittene Automatisierungsaufgaben. Im nächsten Artikel der Serie werden wir uns mit Datensicherung und Wiederherstellung beschäftigen. Du lernst verschiedene Backup-Strategien und Tools kennen, um deine Systeme und Daten effektiv zu sichern.