====== Übungen Tag 4: SystemD, Dienste und Logging ======

Diese Übungen vertiefen die Themen von Tag 4 des Linux Expert Workshops.

[[agenda:agenda-expert_2|← Zurück zur Agenda]]

===== Übung 4.1: SystemD Service erstellen =====

**Ziel:** Eigenen SystemD-Service erstellen und verwalten

**Aufgaben:**
  - Erstellen Sie ein einfaches Bash-Skript /usr/local/bin/hello-service.sh:
<code bash>
#!/bin/bash
while true; do
    echo "$(date): Hello from custom service" >> /var/log/hello-service.log
    sleep 60
done
</code>
  - Machen Sie es ausführbar
  - Erstellen Sie eine Service-Unit /etc/systemd/system/hello.service
  - Starten Sie den Service
  - Prüfen Sie den Status
  - Aktivieren Sie Autostart beim Boot
  - Stoppen und deaktivieren Sie den Service wieder

<hidden Lösung>
<code bash>
# Skript erstellen
sudo nano /usr/local/bin/hello-service.sh
# Inhalt einfügen
sudo chmod +x /usr/local/bin/hello-service.sh

# Service-Unit erstellen
sudo nano /etc/systemd/system/hello.service
</code>

<code ini>
[Unit]
Description=Hello Service Demo
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/hello-service.sh
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
</code>

<code bash>
# SystemD neu laden
sudo systemctl daemon-reload

# Service starten
sudo systemctl start hello.service
sudo systemctl status hello.service

# Autostart aktivieren
sudo systemctl enable hello.service

# Logs prüfen
sudo journalctl -u hello.service -f

# Aufräumen
sudo systemctl stop hello.service
sudo systemctl disable hello.service
</code>
</hidden> \\

===== Übung 4.2: SystemD Timer =====

**Ziel:** Backup-Automatisierung mit systemd-timer

**Aufgaben:**
  - Erstellen Sie ein Backup-Skript /usr/local/bin/backup.sh:
    * Erstellt ein Tar-Archiv von /home
    * Speichert es in /backup mit Zeitstempel
    * Löscht Backups älter als 7 Tage
  - Erstellen Sie einen Service /etc/systemd/system/backup.service
  - Erstellen Sie einen Timer /etc/systemd/system/backup.timer (täglich um 02:00 Uhr)
  - Aktivieren und testen Sie den Timer

<hidden Lösung>
<code bash>
# Backup-Skript
sudo nano /usr/local/bin/backup.sh
</code>

<code bash>
#!/bin/bash
BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR
tar -czf $BACKUP_DIR/home_backup_$DATE.tar.gz /home 2>/dev/null

# Alte Backups löschen
find $BACKUP_DIR -name "home_backup_*.tar.gz" -mtime +7 -delete

echo "$(date): Backup completed - $BACKUP_DIR/home_backup_$DATE.tar.gz"
</code>

<code bash>
sudo chmod +x /usr/local/bin/backup.sh
</code>

**backup.service:**
<code ini>
[Unit]
Description=Daily Backup Service
Wants=backup.timer

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

[Install]
WantedBy=multi-user.target
</code>

**backup.timer:**
<code ini>
[Unit]
Description=Daily Backup Timer
Requires=backup.service

[Timer]
OnCalendar=daily
OnCalendar=*-*-* 02:00:00
Persistent=true

[Install]
WantedBy=timers.target
</code>

<code bash>
sudo systemctl daemon-reload
sudo systemctl enable backup.timer
sudo systemctl start backup.timer
sudo systemctl list-timers --all
# Test
sudo systemctl start backup.service
</code>
</hidden> \\

===== Übung 4.3: journalctl Mastery =====

**Ziel:** Logs effektiv durchsuchen und analysieren

**Aufgaben:**
  - Zeigen Sie Logs der letzten Stunde
  - Filtern Sie nur Kernel-Meldungen
  - Zeigen Sie Logs eines bestimmten Services (ssh)
  - Finden Sie alle ERROR-Meldungen seit gestern
  - Folgen Sie Logs in Echtzeit
  - Exportieren Sie Logs als JSON
  - Zeigen Sie Boot-Logs

<hidden Lösung>
<code bash>
# Letzte Stunde
sudo journalctl --since "1 hour ago"

# Kernel-Meldungen
sudo journalctl -k

# Bestimmter Service
sudo journalctl -u ssh.service

# Errors seit gestern
sudo journalctl --since yesterday -p err

# Echtzeit folgen
sudo journalctl -f

# Als JSON
sudo journalctl -o json-pretty -n 10

# Boot-Logs
sudo journalctl --list-boots
sudo journalctl -b 0  # Aktueller Boot
sudo journalctl -b -1 # Vorheriger Boot

# Kombiniert: SSH-Fehler heute
sudo journalctl -u ssh.service --since today -p err

# Speicher-Statistik
sudo journalctl --disk-usage
</code>
</hidden> \\

===== Übung 4.4: Log-Rotation konfigurieren =====

**Ziel:** Eigene Log-Rotation für Custom-Service

**Aufgaben:**
  - Erstellen Sie /etc/logrotate.d/hello-service
  - Konfigurieren Sie:
    * Tägliche Rotation
    * 7 Archive behalten
    * Kompression
    * Service nach Rotation neu laden
  - Testen Sie die Konfiguration

<hidden Lösung>
<code bash>
sudo nano /etc/logrotate.d/hello-service
</code>

<code>
/var/log/hello-service.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
    create 0640 root adm
    sharedscripts
    postrotate
        systemctl reload hello.service > /dev/null 2>&1 || true
    endscript
}
</code>

<code bash>
# Syntax testen
sudo logrotate -d /etc/logrotate.d/hello-service

# Manuell ausführen (Test)
sudo logrotate -f /etc/logrotate.d/hello-service
</code>
</hidden> \\

===== Übung 4.5: Automatisierung mit cron =====

**Ziel:** Wartungs-Tasks mit cron automatisieren

**Aufgaben:**
  - Erstellen Sie ein Cleanup-Skript /usr/local/bin/cleanup.sh:
    * Löscht /tmp-Dateien älter als 7 Tage
    * Leert den Package-Cache
    * Erstellt einen Report in /var/log/cleanup.log
  - Richten Sie Cron-Jobs ein:
    * Täglich um 03:00 Uhr
    * Wöchentlich Sonntags um 04:00 Uhr (vollständiger Cleanup)
  - Testen Sie das Skript

<hidden Lösung>
<code bash>
# Cleanup-Skript
sudo nano /usr/local/bin/cleanup.sh
</code>

<code bash>
#!/bin/bash
LOG="/var/log/cleanup.log"

echo "=== Cleanup started: $(date) ===" >> $LOG

# /tmp aufräumen
DELETED=$(find /tmp -type f -mtime +7 -delete -print | wc -l)
echo "Deleted $DELETED old files from /tmp" >> $LOG

# Package Cache
if [ "$1" == "full" ]; then
    apt-get clean >> $LOG 2>&1
    echo "Package cache cleaned" >> $LOG
fi

# Disk Usage
df -h / >> $LOG

echo "=== Cleanup finished: $(date) ===" >> $LOG
echo "" >> $LOG
</code>

<code bash>
sudo chmod +x /usr/local/bin/cleanup.sh

# Crontab bearbeiten
sudo crontab -e
</code>

<code>
# Täglicher Cleanup um 03:00 Uhr
0 3 * * * /usr/local/bin/cleanup.sh

# Wöchentlicher vollständiger Cleanup (Sonntag 04:00 Uhr)
0 4 * * 0 /usr/local/bin/cleanup.sh full

# Log-Rotation täglich um 05:00 Uhr
0 5 * * * /usr/sbin/logrotate /etc/logrotate.conf
</code>

<code bash>
# Cron-Jobs auflisten
sudo crontab -l

# Manuell testen
sudo /usr/local/bin/cleanup.sh
cat /var/log/cleanup.log
</code>
</hidden> \\

===== Zusatz-Challenge: Monitoring-System =====

**Erstellen Sie ein komplettes Monitoring-System:**
  - Service der CPU, RAM, Disk überwacht
  - Logs bei > 80% Auslastung
  - Timer der stündlich prüft
  - Alert-Skript bei kritischen Werten
  - Dashboard-Report in /var/www/html/status.html

<hidden Lösung>
<code bash>
#!/bin/bash
# /usr/local/bin/monitor.sh
THRESHOLD=80
ALERT_LOG="/var/log/monitor-alerts.log"

CPU=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
MEM=$(free | grep Mem | awk '{print ($3/$2) * 100.0}' | cut -d'.' -f1)
DISK=$(df / | tail -1 | awk '{print $5}' | cut -d'%' -f1)

if [ $CPU -gt $THRESHOLD ] || [ $MEM -gt $THRESHOLD ] || [ $DISK -gt $THRESHOLD ]; then
    echo "$(date): ALERT - CPU:${CPU}% MEM:${MEM}% DISK:${DISK}%" >> $ALERT_LOG
fi

# HTML-Report
cat > /var/www/html/status.html << EOF
<!DOCTYPE html>
<html>
<head><title>System Status</title></head>
<body>
<h1>System Status - $(date)</h1>
<ul>
<li>CPU: ${CPU}%</li>
<li>Memory: ${MEM}%</li>
<li>Disk: ${DISK}%</li>
</ul>
</body>
</html>
EOF
</code>
</hidden> \\

===== Siehe auch =====
  * [[sammlung:systemd|SystemD]]
  * [[sammlung:journalctl|journalctl]]
  * [[sammlung:crontab|cron]]
  * [[sammlung:systemd_timer|systemd-timer]]

{{tag>übung workshop systemd logging automatisierung}}