Physical Address

304 North Cardinal St.
Dorchester Center, MA 02124

Linux Administration #5: Shell-Scripting und Automatisierung

Linux Administration #5: Shell-Scripting und Automatisierung
Navigation

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

Nachdem wir in den vorherigen Artikeln die Grundlagen, Benutzerverwaltung, Prozesse 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:

Markdown
Shell-Arten:
┌─────────── Bash (Standard) ──────┐
│ - Bourne Again Shell             │
│ - Weit verbreitet                │
│ - Viele Features                 │
├─────────── Zsh ──────────────────┤
│ - Moderne Alternative            │
│ - Bessere Auto-Completion        │
│ - Erweiterte Features            │
└──────────────────────────────────┘
Shell-Umgebung
Bash
# 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
Bash
# 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
Markdown
# 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
Markdown
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
ShellScript
#!/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
ShellScript
# 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
ShellScript
# 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
ShellScript
# 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
ShellScript
# 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:

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

# Alternative Syntax
name() {
    # Code-Block
    echo "Funktion ausführen"
}
1. Funktionen mit Parametern
ShellScript
# 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
ShellScript
# 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:

Markdown
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
ShellScript
#!/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
ShellScript
#!/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:

Markdown
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
ShellScript
#!/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
ShellScript
#!/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
ShellScript
#!/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
ShellScript
#!/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
Bash
# 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
Bash
# 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:

Markdown
Automatisierungs-Konzepte:
┌─────────── Backup-Skripte ───────┐
│ - Dateien sichern                │
│ - Logs rotieren                  │
│ - Aufräumen                      │
├─────────── Monitoring ───────────┤
│ - System überwachen              │
│ - Ressourcen prüfen              │
│ - Alerts versenden               │
└──────────────────────────────────┘
System-Wartung automatisieren
ShellScript
#!/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
ShellScript
#!/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
ShellScript
#!/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
ShellScript
#!/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
ShellScript
#!/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
ShellScript
#!/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:

Markdown
Cron-Zeitformat:
┌───────────── Minute (0-59)
│ ┌───────────── Stunde (0-23)
│ │ ┌───────────── Tag (1-31)
│ │ │ ┌───────────── Monat (1-12)
│ │ │ │ ┌───────────── Wochentag (0-7)
* * * * * Befehl/Skript
1. Cron-Konfiguration
Bash
# 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
Bash
# 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
Bash
# 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
Bash
# 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:

Markdown
Systemaufgaben:
┌─────────── Wartung ─────────────┐
│ - Log-Rotation                  │
│ - Backup-Verwaltung             │
│ - Aufräumarbeiten               │
├─────────── Updates ─────────────┤
│ - Paket-Updates                 │
│ - Sicherheitsupdates            │
│ - System-Upgrades               │
└─────────────────────────────────┘
Log-Rotation
ShellScript
#!/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
ShellScript
#!/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
Bash
# 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

Markdown
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

ShellScript
#!/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

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

Bis dahin, happy scripting!

Schlagwörter

Ähnliche Beiträge

Kommentar verfassen