LPIC-1: Streams, Pipes und Umleitungen

# Das 'cat' Programm liest von stdin und schreibt nach stdout
cat
Hier tippe ich etwas ein
Hier tippe ich etwas ein
^D  # Strg+D beendet die Eingabe

# Das 'cat' Programm liest von stdin und schreibt nach stdout
cat
Hier tippe ich etwas ein
Hier tippe ich etwas ein
^D  # Strg+D beendet die Eingabe

# Explizite Verwendung der File Descriptors
command 1>output.txt 2>errors.txt 0<input.txt

# Explizite Verwendung der File Descriptors
command 1>output.txt 2>errors.txt 0<input.txt

# stdout und stderr gehen beide auf das Terminal
ls /existiert /existiert-nicht
ls: cannot access '/existiert-nicht': No such file or directory  # stderr
/existiert:  # stdout (falls Verzeichnis existiert)

# Aber sie können getrennt umgeleitet werden
ls /existiert /existiert-nicht >ausgabe.txt 2>fehler.txt

# stdout und stderr gehen beide auf das Terminal
ls /existiert /existiert-nicht
ls: cannot access '/existiert-nicht': No such file or directory  # stderr
/existiert:  # stdout (falls Verzeichnis existiert)

# Aber sie können getrennt umgeleitet werden
ls /existiert /existiert-nicht >ausgabe.txt 2>fehler.txt

sort
zebra
apple
banana
^D
apple
banana
zebra

sort
zebra
apple
banana
^D
apple
banana
zebra

sort < unsortierte_liste.txt

sort < unsortierte_liste.txt

ls | sort

ls | sort

# Interaktiv - zeigt Prompts
mysql -u root -p
Enter password: 

# Nicht-interaktiv - keine Prompts
mysql -u root -p < backup.sql

# Interaktiv - zeigt Prompts
mysql -u root -p
Enter password: 

# Nicht-interaktiv - keine Prompts
mysql -u root -p < backup.sql

# Berechne Durchschnitt von Zahlen
cat zahlen.txt | awk '{sum += $1} END {print sum/NR}'

# Filtere und sortiere Benutzerliste
cut -d: -f1 /etc/passwd | sort | head -10

# Berechne Durchschnitt von Zahlen
cat zahlen.txt | awk '{sum += $1} END {print sum/NR}'

# Filtere und sortiere Benutzerliste
cut -d: -f1 /etc/passwd | sort | head -10

cat << EOF > konfiguration.txt
# Automatisch generierte Konfiguration
ServerName example.com
DocumentRoot /var/www/html
EOF

cat << EOF > konfiguration.txt
# Automatisch generierte Konfiguration
ServerName example.com
DocumentRoot /var/www/html
EOF

# Mehrere MySQL-Befehle ausführen
mysql -u root -p database << 'SQL'
SELECT COUNT(*) FROM users;
SHOW TABLES;
SQL

# Mehrere MySQL-Befehle ausführen
mysql -u root -p database << 'SQL'
SELECT COUNT(*) FROM users;
SHOW TABLES;
SQL

ls -la                    	# Dateiliste
ps aux                    	# Prozessliste
cat datei.txt             	# Dateiinhalt
grep "pattern" *.txt      	# Suchergebnisse
awk '{print $1}' data.csv 	# Extrahierte Daten

ls -la                    	# Dateiliste
ps aux                    	# Prozessliste
cat datei.txt             	# Dateiinhalt
grep "pattern" *.txt      	# Suchergebnisse
awk '{print $1}' data.csv 	# Extrahierte Daten

# Gutes Beispiel: Programm unterscheidet korrekt
find /etc -name "*.conf" 2>/dev/null | head -5

# Suchergebnisse gehen nach stdout, Fehlermeldungen nach stderr

# Schlechtes Beispiel: Alles vermischt
some_bad_program 2>&1 | grep -v "WARNING"  # Muss Warnungen herausfiltern

# Gutes Beispiel: Programm unterscheidet korrekt
find /etc -name "*.conf" 2>/dev/null | head -5

# Suchergebnisse gehen nach stdout, Fehlermeldungen nach stderr

# Schlechtes Beispiel: Alles vermischt
some_bad_program 2>&1 | grep -v "WARNING"  # Muss Warnungen herausfiltern

# Extrahiere Systemstatistiken
ps aux | awk '{print 3}' | awk '{sum += 1} END {print "Durchschnittliche CPU:", sum/NR "%"}'

# Analysiere Logdateien
grep "ERROR" /var/log/application.log | cut -d' ' -f1-3 > fehler_zeitstempel.txt

# Extrahiere Systemstatistiken
ps aux | awk '{print 3}' | awk '{sum += 1} END {print "Durchschnittliche CPU:", sum/NR "%"}'

# Analysiere Logdateien
grep "ERROR" /var/log/application.log | cut -d' ' -f1-3 > fehler_zeitstempel.txt

# Überwache Speicherverbrauch
free -h | grep "Mem:" | awk '{print 3 "/" 2}' > memory_usage.txt

# Verfolge Netzwerkverbindungen
netstat -an | grep ESTABLISHED | wc -l > aktive_verbindungen.txt

# Überwache Speicherverbrauch
free -h | grep "Mem:" | awk '{print 3 "/" 2}' > memory_usage.txt

# Verfolge Netzwerkverbindungen
netstat -an | grep ESTABLISHED | wc -l > aktive_verbindungen.txt

# Täglicher Systemreport
{
    echo "=== Systemreport (date) ==="
    echo "Festplattenbelegung:"
    df -h | grep -v tmpfs
    echo "Top 5 Prozesse:"
    ps aux | sort -k3 -nr | head -5
} > daily_report.txt

# Täglicher Systemreport
{
    echo "=== Systemreport (date) ==="
    echo "Festplattenbelegung:"
    df -h | grep -v tmpfs
    echo "Top 5 Prozesse:"
    ps aux | sort -k3 -nr | head -5
} > daily_report.txt

# Fehlermeldungen gehen nach stderr
cat nicht_existierende_datei.txt
cat: nicht_existierende_datei.txt: No such file or directory

# Warnungen in stderr
cp datei.txt /schreibgeschütztes_verzeichnis/
cp: cannot create regular file '/schreibgeschütztes_verzeichnis/datei.txt': Permission denied

# Fortschrittsinformationen
rsync -av --progress source/ destination/

# Fortschritt geht nach stderr, Dateiliste nach stdout

# Fehlermeldungen gehen nach stderr
cat nicht_existierende_datei.txt
cat: nicht_existierende_datei.txt: No such file or directory

# Warnungen in stderr
cp datei.txt /schreibgeschütztes_verzeichnis/
cp: cannot create regular file '/schreibgeschütztes_verzeichnis/datei.txt': Permission denied

# Fortschrittsinformationen
rsync -av --progress source/ destination/

# Fortschritt geht nach stderr, Dateiliste nach stdout

# Nur die eigentlichen Daten werden weitergegeben
find /etc -name "*.conf" 2>/dev/null | wc -l
# Fehlermeldungen stören nicht die Zählung

# Nur die eigentlichen Daten werden weitergegeben
find /etc -name "*.conf" 2>/dev/null | wc -l
# Fehlermeldungen stören nicht die Zählung

# Normale Ausgabe und Fehler getrennt speichern
backup_script.sh >backup.log 2>backup_errors.log

# Normale Ausgabe und Fehler getrennt speichern
backup_script.sh >backup.log 2>backup_errors.log

# Fehlermeldungen bleiben sichtbar, auch wenn Ausgabe umgeleitet wird
long_running_command >results.txt
# Fehler erscheinen weiterhin auf dem Terminal

# Fehlermeldungen bleiben sichtbar, auch wenn Ausgabe umgeleitet wird
long_running_command >results.txt
# Fehler erscheinen weiterhin auf dem Terminal

# Skripte können Fehler erkennen, ohne die Ausgabe zu parsen
if ! command >output.txt 2>errors.txt; then
    echo "Befehl fehlgeschlagen, siehe errors.txt"
    exit 1
fi

# Skripte können Fehler erkennen, ohne die Ausgabe zu parsen
if ! command >output.txt 2>errors.txt; then
    echo "Befehl fehlgeschlagen, siehe errors.txt"
    exit 1
fi

#!/bin/bash
# Beispiel für gutes Logging-Verhalten

log_info() {
    echo "INFO: *" >&2  # Informationen nach stderr
}

log_error() {
    echo "ERROR: *" >&2  # Fehler nach stderr
}

# Hauptfunktion gibt Daten nach stdout aus
process_data() {
    log_info "Starte Datenverarbeitung..."

    if [ ! -f "1" ]; then
        log_error "Datei 1 nicht gefunden"
        return 1
    fi

    log_info "Verarbeite 1..."
    # Eigentliche Daten nach stdout
    awk '{print 1}' "1"

    log_info "Verarbeitung abgeschlossen"
}

#!/bin/bash
# Beispiel für gutes Logging-Verhalten

log_info() {
    echo "INFO: *" >&2  # Informationen nach stderr
}

log_error() {
    echo "ERROR: *" >&2  # Fehler nach stderr
}

# Hauptfunktion gibt Daten nach stdout aus
process_data() {
    log_info "Starte Datenverarbeitung..."

    if [ ! -f "1" ]; then
        log_error "Datei 1 nicht gefunden"
        return 1
    fi

    log_info "Verarbeite 1..."
    # Eigentliche Daten nach stdout
    awk '{print 1}' "1"

    log_info "Verarbeitung abgeschlossen"
}

# Debug-Informationen nach stderr, damit sie stdout nicht stören
debug() {
    [ "DEBUG" = "1" ] && echo "DEBUG: *" >&2
}

# Verwendung in Skripten
DEBUG=1 ./mein_skript.sh >daten.txt
# Debug-Ausgaben erscheinen auf Terminal, Daten in Datei

# Debug-Informationen nach stderr, damit sie stdout nicht stören
debug() {
    [ "DEBUG" = "1" ] && echo "DEBUG: *" >&2
}

# Verwendung in Skripten
DEBUG=1 ./mein_skript.sh >daten.txt
# Debug-Ausgaben erscheinen auf Terminal, Daten in Datei

# Fehler in der Pipeline abfangen
command1 2>errors1.log | command2 2>errors2.log | command3 2>errors3.log >final_output.txt

# Alle Fehler in eine Datei
(command1 | command2 | command3 >output.txt) 2>all_errors.log

# Fehler in der Pipeline abfangen
command1 2>errors1.log | command2 2>errors2.log | command3 2>errors3.log >final_output.txt

# Alle Fehler in eine Datei
(command1 | command2 | command3 >output.txt) 2>all_errors.log

# SCHLECHT: Meldungen in stdout
echo "Verarbeite Datei filename"  # Stört die Datenausgabe
cat "filename"

# BESSER: Meldungen nach stderr
echo "Verarbeite Datei filename" >&2
cat "filename"

# SCHLECHT: Meldungen in stdout
echo "Verarbeite Datei filename"  # Stört die Datenausgabe
cat "filename"

# BESSER: Meldungen nach stderr
echo "Verarbeite Datei filename" >&2
cat "filename"

# GEFÄHRLICH: Fehler werden übersehen
result=(command 2>/dev/null)

# BESSER: Fehler behandeln
if ! result=(command 2>error_log); then
    echo "Befehl fehlgeschlagen, siehe error_log" >&2
    exit 1
fi

# GEFÄHRLICH: Fehler werden übersehen
result=(command 2>/dev/null)

# BESSER: Fehler behandeln
if ! result=(command 2>error_log); then
    echo "Befehl fehlgeschlagen, siehe error_log" >&2
    exit 1
fi

# Ohne Umleitung: Ausgabe geht auf Terminal
echo "Hello World"
Hello World

# Mit Umleitung: Ausgabe geht in Datei
echo "Hello World" > greeting.txt
cat greeting.txt
Hello World

# Ohne Umleitung: Ausgabe geht auf Terminal
echo "Hello World"
Hello World

# Mit Umleitung: Ausgabe geht in Datei
echo "Hello World" > greeting.txt
cat greeting.txt
Hello World

[n]operator[datei]

[n]operator[datei]

# Aktuelle Prozessliste speichern
ps aux > prozesse_$(date +%Y%m%d).txt

# Festplattenbelegung protokollieren
df -h > festplatten_status.txt

# Netzwerkkonfiguration dokumentieren
ip addr show > netzwerk_config.txt

# Aktuelle Prozessliste speichern
ps aux > prozesse_$(date +%Y%m%d).txt

# Festplattenbelegung protokollieren
df -h > festplatten_status.txt

# Netzwerkkonfiguration dokumentieren
ip addr show > netzwerk_config.txt

# Einfache Konfigurationsdatei erstellen
echo "ServerName example.com" > apache_config.txt
echo "DocumentRoot /var/www/html" >> apache_config.txt

# SSH-Konfiguration für einen Host
cat > ~/.ssh/config << EOF
Host production
    HostName prod.example.com
    User admin
    Port 2222
EOF

# Einfache Konfigurationsdatei erstellen
echo "ServerName example.com" > apache_config.txt
echo "DocumentRoot /var/www/html" >> apache_config.txt

# SSH-Konfiguration für einen Host
cat > ~/.ssh/config << EOF
Host production
    HostName prod.example.com
    User admin
    Port 2222
EOF

# Täglicher Systembericht
{
    echo "=== Systembericht $(date) ==="
    echo "Betriebszeit:"
    uptime
    echo "Speicherverbrauch:"
    free -h
    echo "Festplattenbelegung:"
    df -h
} > daily_report_$(date +%Y%m%d).txt

# Täglicher Systembericht
{
    echo "=== Systembericht $(date) ==="
    echo "Betriebszeit:"
    uptime
    echo "Speicherverbrauch:"
    free -h
    echo "Festplattenbelegung:"
    df -h
} > daily_report_$(date +%Y%m%d).txt

echo "Erste Zeile" > neue_datei.txt
cat neue_datei.txt
Erste Zeile

echo "Erste Zeile" > neue_datei.txt
cat neue_datei.txt
Erste Zeile

echo "Zweite Zeile" > neue_datei.txt
cat neue_datei.txt
Zweite Zeile  # Die erste Zeile ist verschwunden!

echo "Zweite Zeile" > neue_datei.txt
cat neue_datei.txt
Zweite Zeile  # Die erste Zeile ist verschwunden!

# noclobber-Option aktivieren
set -o noclobber

# Jetzt schlägt Überschreiben fehl
echo "Test" > existierende_datei.txt
bash: existierende_datei.txt: cannot overwrite existing file

# Explizites Überschreiben erzwingen
echo "Test" >| existierende_datei.txt

# noclobber wieder deaktivieren
set +o noclobber

# noclobber-Option aktivieren
set -o noclobber

# Jetzt schlägt Überschreiben fehl
echo "Test" > existierende_datei.txt
bash: existierende_datei.txt: cannot overwrite existing file

# Explizites Überschreiben erzwingen
echo "Test" >| existierende_datei.txt

# noclobber wieder deaktivieren
set +o noclobber

#!/bin/bash
# Einfaches Log-Rotations-Skript

LOGFILE="/var/log/application.log"
ARCHIVE_DIR="/var/log/archive"

# Aktuelles Log archivieren
if [ -f "$LOGFILE" ]; then
    mv "$LOGFILE" "$ARCHIVE_DIR/application_$(date +%Y%m%d_%H%M%S).log"
fi

# Neues, leeres Log erstellen
touch "$LOGFILE"
echo "Log rotiert am $(date)" > "$LOGFILE"

#!/bin/bash
# Einfaches Log-Rotations-Skript

LOGFILE="/var/log/application.log"
ARCHIVE_DIR="/var/log/archive"

# Aktuelles Log archivieren
if [ -f "$LOGFILE" ]; then
    mv "$LOGFILE" "$ARCHIVE_DIR/application_$(date +%Y%m%d_%H%M%S).log"
fi

# Neues, leeres Log erstellen
touch "$LOGFILE"
echo "Log rotiert am $(date)" > "$LOGFILE"

# Wichtige Konfigurationsdateien sichern
tar -czf config_backup_$(date +%Y%m%d).tar.gz /etc/apache2/ /etc/nginx/ /etc/ssh/ 2> backup_errors.log

# Backup-Protokoll erstellen
{
    echo "Backup erstellt am: $(date)"
    echo "Backup-Datei: config_backup_$(date +%Y%m%d).tar.gz"
    echo "Größe: $(ls -lh config_backup_$(date +%Y%m%d).tar.gz | awk '{print $5}')"
} > backup_log.txt

# Wichtige Konfigurationsdateien sichern
tar -czf config_backup_$(date +%Y%m%d).tar.gz /etc/apache2/ /etc/nginx/ /etc/ssh/ 2> backup_errors.log

# Backup-Protokoll erstellen
{
    echo "Backup erstellt am: $(date)"
    echo "Backup-Datei: config_backup_$(date +%Y%m%d).tar.gz"
    echo "Größe: $(ls -lh config_backup_$(date +%Y%m%d).tar.gz | awk '{print $5}')"
} > backup_log.txt

# Wöchentlicher Sicherheitsbericht
{
    echo "=== Sicherheitsbericht Woche $(date +%V/%Y) ==="
    echo
    echo "Fehlgeschlagene SSH-Logins:"
    grep "Failed password" /var/log/auth.log | wc -l
    echo
    echo "Top 5 IP-Adressen mit fehlgeschlagenen Logins:"
    grep "Failed password" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -nr | head -5
    echo
    echo "Systemupdates verfügbar:"
    apt list --upgradable 2>/dev/null | wc -l
} > security_report_week_$(date +%V_%Y).txt

# Wöchentlicher Sicherheitsbericht
{
    echo "=== Sicherheitsbericht Woche $(date +%V/%Y) ==="
    echo
    echo "Fehlgeschlagene SSH-Logins:"
    grep "Failed password" /var/log/auth.log | wc -l
    echo
    echo "Top 5 IP-Adressen mit fehlgeschlagenen Logins:"
    grep "Failed password" /var/log/auth.log | awk '{print $11}' | sort | uniq -c | sort -nr | head -5
    echo
    echo "Systemupdates verfügbar:"
    apt list --upgradable 2>/dev/null | wc -l
} > security_report_week_$(date +%V_%Y).txt

# Datei erstellen
echo "Zeile 1" > testdatei.txt

# Mit > überschreiben
echo "Zeile 2" > testdatei.txt
cat testdatei.txt
Zeile 2

# Datei neu erstellen und mit >> erweitern
echo "Zeile 1" > testdatei.txt
echo "Zeile 2" >> testdatei.txt
echo "Zeile 3" >> testdatei.txt
cat testdatei.txt
Zeile 1
Zeile 2
Zeile 3

# Datei erstellen
echo "Zeile 1" > testdatei.txt

# Mit > überschreiben
echo "Zeile 2" > testdatei.txt
cat testdatei.txt
Zeile 2

# Datei neu erstellen und mit >> erweitern
echo "Zeile 1" > testdatei.txt
echo "Zeile 2" >> testdatei.txt
echo "Zeile 3" >> testdatei.txt
cat testdatei.txt
Zeile 1
Zeile 2
Zeile 3

# Systemüberwachung mit kontinuierlicher Protokollierung
while true; do
    echo "$(date): CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')" >> system_monitor.log
    echo "$(date): Memory: $(free | grep Mem | awk '{printf "%.1f%%", $3/$2 * 100.0}')" >> system_monitor.log
    sleep 60
done

# Systemüberwachung mit kontinuierlicher Protokollierung
while true; do
    echo "$(date): CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')" >> system_monitor.log
    echo "$(date): Memory: $(free | grep Mem | awk '{printf "%.1f%%", $3/$2 * 100.0}')" >> system_monitor.log
    sleep 60
done

#!/bin/bash
# Beispiel-Skript mit Logging

LOGFILE="/var/log/mein_skript.log"

log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOGFILE"
}

log_message "Skript gestartet"
log_message "Verarbeite Dateien..."

# Hauptlogik hier...

log_message "Skript beendet"

#!/bin/bash
# Beispiel-Skript mit Logging

LOGFILE="/var/log/mein_skript.log"

log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOGFILE"
}

log_message "Skript gestartet"
log_message "Verarbeite Dateien..."

# Hauptlogik hier...

log_message "Skript beendet"

# Sammle alle Fehler aus verschiedenen Quellen
grep -i error /var/log/syslog >> all_errors.log
grep -i warning /var/log/apache2/error.log >> all_errors.log
journalctl --since "1 hour ago" --priority=err >> all_errors.log

# Sammle alle Fehler aus verschiedenen Quellen
grep -i error /var/log/syslog >> all_errors.log
grep -i warning /var/log/apache2/error.log >> all_errors.log
journalctl --since "1 hour ago" --priority=err >> all_errors.log

#!/bin/bash
# Sichere Log-Rotation ohne Datenverlust

CURRENT_LOG="/var/log/application.log"
ARCHIVE_LOG="/var/log/archive/application_$(date +%Y%m%d_%H%M%S).log"

# Aktuelles Log in Archiv kopieren (nicht verschieben!)
cp "$CURRENT_LOG" "$ARCHIVE_LOG"

# Aktuelles Log leeren, aber nicht löschen
> "$CURRENT_LOG"

# Bestätigung ins neue Log schreiben
echo "$(date): Log rotiert, Archiv: $(basename "$ARCHIVE_LOG")" >> "$CURRENT_LOG"

#!/bin/bash
# Sichere Log-Rotation ohne Datenverlust

CURRENT_LOG="/var/log/application.log"
ARCHIVE_LOG="/var/log/archive/application_$(date +%Y%m%d_%H%M%S).log"

# Aktuelles Log in Archiv kopieren (nicht verschieben!)
cp "$CURRENT_LOG" "$ARCHIVE_LOG"

# Aktuelles Log leeren, aber nicht löschen
> "$CURRENT_LOG"

# Bestätigung ins neue Log schreiben
echo "$(date): Log rotiert, Archiv: $(basename "$ARCHIVE_LOG")" >> "$CURRENT_LOG"

# Backup-Skript mit sicherer Protokollierung
BACKUP_LOG="/var/log/backup.log"

{
    echo "=== Backup gestartet: $(date) ==="

    if rsync -av /home/ /backup/home/ 2>&1; then
        echo "Home-Verzeichnis erfolgreich gesichert"
    else
        echo "FEHLER beim Sichern des Home-Verzeichnisses"
    fi

    echo "=== Backup beendet: $(date) ==="
    echo
} >> "$BACKUP_LOG"

# Backup-Skript mit sicherer Protokollierung
BACKUP_LOG="/var/log/backup.log"

{
    echo "=== Backup gestartet: $(date) ==="

    if rsync -av /home/ /backup/home/ 2>&1; then
        echo "Home-Verzeichnis erfolgreich gesichert"
    else
        echo "FEHLER beim Sichern des Home-Verzeichnisses"
    fi

    echo "=== Backup beendet: $(date) ==="
    echo
} >> "$BACKUP_LOG"

# Sammle Daten aus verschiedenen Quellen sicher
DATA_FILE="/var/data/collected_data.txt"
TEMP_FILE="/tmp/data_collection.$$"

# Sammle Daten in temporärer Datei
{
    echo "Timestamp: $(date)"
    ps aux | wc -l
    df -h | grep -v tmpfs
    free -m
} > "$TEMP_FILE"

# Nur bei erfolgreichem Sammeln an Hauptdatei anhängen
if [ -s "$TEMP_FILE" ]; then
    cat "$TEMP_FILE" >> "$DATA_FILE"
    echo "--- End of Entry ---" >> "$DATA_FILE"
fi

# Temporäre Datei aufräumen
rm -f "$TEMP_FILE"

# Sammle Daten aus verschiedenen Quellen sicher
DATA_FILE="/var/data/collected_data.txt"
TEMP_FILE="/tmp/data_collection.$$"

# Sammle Daten in temporärer Datei
{
    echo "Timestamp: $(date)"
    ps aux | wc -l
    df -h | grep -v tmpfs
    free -m
} > "$TEMP_FILE"

# Nur bei erfolgreichem Sammeln an Hauptdatei anhängen
if [ -s "$TEMP_FILE" ]; then
    cat "$TEMP_FILE" >> "$DATA_FILE"
    echo "--- End of Entry ---" >> "$DATA_FILE"
fi

# Temporäre Datei aufräumen
rm -f "$TEMP_FILE"

command 2> error_file.txt        # stderr in Datei umleiten
command 2>> error_log.txt        # stderr an Datei anhängen
command > output.txt 2> errors.txt   # stdout und stderr getrennt umleiten

command 2> error_file.txt        # stderr in Datei umleiten
command 2>> error_log.txt        # stderr an Datei anhängen
command > output.txt 2> errors.txt   # stdout und stderr getrennt umleiten

# Suche nach Dateien, ignoriere Berechtigungsfehler
find /etc -name "*.conf" 2>/dev/null > config_files.txt

# Kompiliere Programm, sammle Fehler separat
gcc -o program source.c 2> compile_errors.txt

# Backup mit getrennter Fehlerprotokollierung
rsync -av /home/ /backup/ > backup_success.log 2> backup_errors.log

# Suche nach Dateien, ignoriere Berechtigungsfehler
find /etc -name "*.conf" 2>/dev/null > config_files.txt

# Kompiliere Programm, sammle Fehler separat
gcc -o program source.c 2> compile_errors.txt

# Backup mit getrennter Fehlerprotokollierung
rsync -av /home/ /backup/ > backup_success.log 2> backup_errors.log

# Befehle ausführen ohne Fehlermeldungen
command 2>/dev/null

# Cron-Jobs ohne E-Mail-Spam
0 2 * * * /usr/local/bin/backup.sh > /var/log/backup.log 2>/dev/null

# Befehle ausführen ohne Fehlermeldungen
command 2>/dev/null

# Cron-Jobs ohne E-Mail-Spam
0 2 * * * /usr/local/bin/backup.sh > /var/log/backup.log 2>/dev/null

#!/bin/bash
# Skript mit getrennter Ausgabe- und Fehlerbehandlung

OUTPUT_FILE="/var/log/script_output.log"
ERROR_FILE="/var/log/script_errors.log"

# Hauptfunktion mit getrennter Protokollierung
main() {
    echo "Starte Verarbeitung..." >&2  # Nach stderr für Logging

    # Verarbeitung mit Ausgabe nach stdout
    process_data input.txt

    echo "Verarbeitung abgeschlossen" >&2
}

# Ausführung mit Umleitung
main > "$OUTPUT_FILE" 2> "$ERROR_FILE"

# Prüfe Ergebnisse
if [ -s "$ERROR_FILE" ]; then
    echo "Fehler aufgetreten, siehe $ERROR_FILE"
    exit 1
else
    echo "Erfolgreich abgeschlossen, Ergebnisse in $OUTPUT_FILE"
fi

#!/bin/bash
# Skript mit getrennter Ausgabe- und Fehlerbehandlung

OUTPUT_FILE="/var/log/script_output.log"
ERROR_FILE="/var/log/script_errors.log"

# Hauptfunktion mit getrennter Protokollierung
main() {
    echo "Starte Verarbeitung..." >&2  # Nach stderr für Logging

    # Verarbeitung mit Ausgabe nach stdout
    process_data input.txt

    echo "Verarbeitung abgeschlossen" >&2
}

# Ausführung mit Umleitung
main > "$OUTPUT_FILE" 2> "$ERROR_FILE"

# Prüfe Ergebnisse
if [ -s "$ERROR_FILE" ]; then
    echo "Fehler aufgetreten, siehe $ERROR_FILE"
    exit 1
else
    echo "Erfolgreich abgeschlossen, Ergebnisse in $OUTPUT_FILE"
fi

# Systemwartung mit detaillierter Protokollierung
{
    echo "=== Systemwartung $(date) ==="

    # Updates installieren
    apt update && apt upgrade -y

    # Logs rotieren
    logrotate /etc/logrotate.conf

    # Temporäre Dateien aufräumen
    find /tmp -type f -mtime +7 -delete

    echo "=== Wartung abgeschlossen ==="
} > maintenance_$(date +%Y%m%d).log 2> maintenance_errors_$(date +%Y%m%d).log

# Systemwartung mit detaillierter Protokollierung
{
    echo "=== Systemwartung $(date) ==="

    # Updates installieren
    apt update && apt upgrade -y

    # Logs rotieren
    logrotate /etc/logrotate.conf

    # Temporäre Dateien aufräumen
    find /tmp -type f -mtime +7 -delete

    echo "=== Wartung abgeschlossen ==="
} > maintenance_$(date +%Y%m%d).log 2> maintenance_errors_$(date +%Y%m%d).log

# Methode 1: Beide Streams in dieselbe Datei
command > output.txt 2>&1

# Methode 2: Kurzform (bash 4.0+)
command &> output.txt

# Methode 3: Anhängend
command >> output.txt 2>&1
command &>> output.txt  # Kurzform

# Methode 1: Beide Streams in dieselbe Datei
command > output.txt 2>&1

# Methode 2: Kurzform (bash 4.0+)
command &> output.txt

# Methode 3: Anhängend
command >> output.txt 2>&1
command &>> output.txt  # Kurzform

# RICHTIG: Erst stdout umleiten, dann stderr zu stdout
command > file.txt 2>&1

# FALSCH: stderr wird zum ursprünglichen stdout umgeleitet
command 2>&1 > file.txt

# RICHTIG: Erst stdout umleiten, dann stderr zu stdout
command > file.txt 2>&1

# FALSCH: stderr wird zum ursprünglichen stdout umgeleitet
command 2>&1 > file.txt

# Alle Ausgaben eines Skripts protokollieren
./complex_script.sh &> full_log_$(date +%Y%m%d_%H%M%S).txt

# Cron-Job mit vollständiger Protokollierung
0 3 * * * /usr/local/bin/backup.sh &>> /var/log/backup_full.log

# Alle Ausgaben eines Skripts protokollieren
./complex_script.sh &> full_log_$(date +%Y%m%d_%H%M%S).txt

# Cron-Job mit vollständiger Protokollierung
0 3 * * * /usr/local/bin/backup.sh &>> /var/log/backup_full.log

# Alle Ausgaben einer Pipeline sammeln
(command1 | command2 | command3) &> pipeline_debug.log

# Mit Zeitstempel für besseres Debugging
{
    echo "=== Pipeline Start: $(date) ==="
    command1 | command2 | command3
    echo "=== Pipeline Ende: $(date) ==="
} &> pipeline_$(date +%Y%m%d_%H%M%S).log

# Alle Ausgaben einer Pipeline sammeln
(command1 | command2 | command3) &> pipeline_debug.log

# Mit Zeitstempel für besseres Debugging
{
    echo "=== Pipeline Start: $(date) ==="
    command1 | command2 | command3
    echo "=== Pipeline Ende: $(date) ==="
} &> pipeline_$(date +%Y%m%d_%H%M%S).log

# Datei als Eingabe für ein Programm verwenden
sort < unsortierte_liste.txt

# Äquivalent zu:
sort unsortierte_liste.txt
# Aber mit < wird die Datei von der Shell geöffnet, nicht vom Programm

# Datei als Eingabe für ein Programm verwenden
sort < unsortierte_liste.txt

# Äquivalent zu:
sort unsortierte_liste.txt
# Aber mit < wird die Datei von der Shell geöffnet, nicht vom Programm

# CSV-Datei verarbeiten
awk -F',' '{print $1, $3}' < daten.csv

# Konfigurationsdatei validieren
while read line; do
    echo "Verarbeite: $line"
done < config.txt

# CSV-Datei verarbeiten
awk -F',' '{print $1, $3}' < daten.csv

# Konfigurationsdatei validieren
while read line; do
    echo "Verarbeite: $line"
done < config.txt

# SQL-Befehle aus Datei ausführen
mysql -u root -p database_name < backup.sql

# E-Mails aus Datei versenden
sendmail user@example.com < email_content.txt

# SQL-Befehle aus Datei ausführen
mysql -u root -p database_name < backup.sql

# E-Mails aus Datei versenden
sendmail user@example.com < email_content.txt

# Here Document Syntax
command << DELIMITER
Zeile 1
Zeile 2
Zeile 3
DELIMITER

# Here Document Syntax
command << DELIMITER
Zeile 1
Zeile 2
Zeile 3
DELIMITER

# Apache Virtual Host erstellen
cat << 'EOF' > /etc/apache2/sites-available/example.conf
<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/example
    ErrorLog ${APACHE_LOG_DIR}/example_error.log
    CustomLog ${APACHE_LOG_DIR}/example_access.log combined
</VirtualHost>
EOF

# Apache Virtual Host erstellen
cat << 'EOF' > /etc/apache2/sites-available/example.conf
<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/example
    ErrorLog ${APACHE_LOG_DIR}/example_error.log
    CustomLog ${APACHE_LOG_DIR}/example_access.log combined
</VirtualHost>
EOF

# Datenbank-Setup mit Here Document
mysql -u root -p << 'SQL'
CREATE DATABASE IF NOT EXISTS myapp;
USE myapp;
CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL
);
INSERT INTO users (username, email) VALUES
    ('admin', 'admin@example.com'),
    ('user1', 'user1@example.com');
SQL

# Datenbank-Setup mit Here Document
mysql -u root -p << 'SQL'
CREATE DATABASE IF NOT EXISTS myapp;
USE myapp;
CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL
);
INSERT INTO users (username, email) VALUES
    ('admin', 'admin@example.com'),
    ('user1', 'user1@example.com');
SQL

# Here String für kurze Eingaben
tr '[:lower:]' '[:upper:]' <<< "hello world"
HELLO WORLD

# Base64-Kodierung
base64 <<< "secret message"

# Here String für kurze Eingaben
tr '[:lower:]' '[:upper:]' <<< "hello world"
HELLO WORLD

# Base64-Kodierung
base64 <<< "secret message"

!/bin/bash
# Automatische SSH-Konfiguration

# SSH-Config für neuen Server erstellen
cat << EOF >> ~/.ssh/config
Host production-server
    HostName 192.168.1.100
    User admin
    Port 2222
    IdentityFile ~/.ssh/production_key
    StrictHostKeyChecking no
EOF

# Firewall-Regeln aus Datei laden
while read rule; do
    iptables $rule
done < firewall_rules.txt

!/bin/bash
# Automatische SSH-Konfiguration

# SSH-Config für neuen Server erstellen
cat << EOF >> ~/.ssh/config
Host production-server
    HostName 192.168.1.100
    User admin
    Port 2222
    IdentityFile ~/.ssh/production_key
    StrictHostKeyChecking no
EOF

# Firewall-Regeln aus Datei laden
while read rule; do
    iptables $rule
done < firewall_rules.txt

# CSV-Daten transformieren
awk -F',' '
BEGIN { OFS=";" }
NR > 1 {
    print $2, $1, $3
}' < input.csv > output.csv

# Log-Analyse mit Eingabeumleitung
grep "ERROR" < /var/log/application.log | \
  awk '{print $1, $2, $NF}' > error_summary.txt

# CSV-Daten transformieren
awk -F',' '
BEGIN { OFS=";" }
NR > 1 {
    print $2, $1, $3
}' < input.csv > output.csv

# Log-Analyse mit Eingabeumleitung
grep "ERROR" < /var/log/application.log | \
  awk '{print $1, $2, $NF}' > error_summary.txt

# FALSCH: Versucht, in eine Eingabedatei zu schreiben
echo "test" < output.txt

# RICHTIG: Ausgabe in Datei umleiten
echo "test" > output.txt

# FALSCH: Versucht, in eine Eingabedatei zu schreiben
echo "test" < output.txt

# RICHTIG: Ausgabe in Datei umleiten
echo "test" > output.txt

# PROBLEMATISCH: Variablen werden expandiert
cat << EOF
Current user: $USER
EOF

# SICHER: Variablen werden nicht expandiert
cat << 'EOF'
Current user: $USER
EOF

# PROBLEMATISCH: Variablen werden expandiert
cat << EOF
Current user: $USER
EOF

# SICHER: Variablen werden nicht expandiert
cat << 'EOF'
Current user: $USER
EOF

Programm1 | Programm2 | Programm3
    ↓           ↓           ↓
  stdout → stdin → stdout → stdin → stdout

Programm1 | Programm2 | Programm3
    ↓           ↓           ↓
  stdout → stdin → stdout → stdin → stdout

# Ohne Pipe: Umständlich mit temporären Dateien
ps aux > temp_processes.txt
grep apache temp_processes.txt > apache_processes.txt
wc -l apache_processes.txt
rm temp_processes.txt apache_processes.txt

# Mit Pipe: Elegant und effizient
ps aux | grep apache | wc -l

# Ohne Pipe: Umständlich mit temporären Dateien
ps aux > temp_processes.txt
grep apache temp_processes.txt > apache_processes.txt
wc -l apache_processes.txt
rm temp_processes.txt apache_processes.txt

# Mit Pipe: Elegant und effizient
ps aux | grep apache | wc -l

# Langsamer Producer, schneller Consumer
find / -name "*.log" 2>/dev/null | head -10
# find läuft weiter, auch wenn head bereits beendet ist

# Schneller Producer, langsamer Consumer  
cat große_datei.txt | sleep 10
# cat wartet, bis sleep die Daten verarbeitet hat

# Langsamer Producer, schneller Consumer
find / -name "*.log" 2>/dev/null | head -10
# find läuft weiter, auch wenn head bereits beendet ist

# Schneller Producer, langsamer Consumer  
cat große_datei.txt | sleep 10
# cat wartet, bis sleep die Daten verarbeitet hat

# Mit Dateiumleitung: Langsam, viel Speicherplatz
grep "ERROR" /var/log/huge.log > temp1.txt
sort temp1.txt > temp2.txt  
uniq temp2.txt > temp3.txt
wc -l temp3.txt
rm temp1.txt temp2.txt temp3.txt

# Mit Pipes: Schnell, wenig Speicherplatz
grep "ERROR" /var/log/huge.log | sort | uniq | wc -l

# Mit Dateiumleitung: Langsam, viel Speicherplatz
grep "ERROR" /var/log/huge.log > temp1.txt
sort temp1.txt > temp2.txt  
uniq temp2.txt > temp3.txt
wc -l temp3.txt
rm temp1.txt temp2.txt temp3.txt

# Mit Pipes: Schnell, wenig Speicherplatz
grep "ERROR" /var/log/huge.log | sort | uniq | wc -l

befehl1 | befehl2

befehl1 | befehl2

# Anzahl laufender Apache-Prozesse
ps aux | grep apache | grep -v grep | wc -l

# Anzahl eingeloggte Benutzer
who | wc -l

# Anzahl Dateien in einem Verzeichnis
ls -1 | wc -l

# Anzahl laufender Apache-Prozesse
ps aux | grep apache | grep -v grep | wc -l

# Anzahl eingeloggte Benutzer
who | wc -l

# Anzahl Dateien in einem Verzeichnis
ls -1 | wc -l

# Eindeutige Shells im System
cut -d: -f7 /etc/passwd | sort | uniq

# Häufigste Befehle in der History
history | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

# Eindeutige Shells im System
cut -d: -f7 /etc/passwd | sort | uniq

# Häufigste Befehle in der History
history | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

# Benutzerfreundliche Prozessliste
ps aux | awk '{print $2, $3, $4, $11}' | column -t

# Festplattenbelegung sortiert nach Größe
du -h /var/log/* | sort -hr

# Benutzerfreundliche Prozessliste
ps aux | awk '{print $2, $3, $4, $11}' | column -t

# Festplattenbelegung sortiert nach Größe
du -h /var/log/* | sort -hr

befehl1 | befehl2 | befehl3 | befehl4

befehl1 | befehl2 | befehl3 | befehl4

# Top 10 IP-Adressen in Apache-Logs
cat /var/log/apache2/access.log | \
  awk '{print $1}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  head -10

# Top 10 IP-Adressen in Apache-Logs
cat /var/log/apache2/access.log | \
  awk '{print $1}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  head -10

# Speicherhungrigste Prozesse
ps aux | \
  awk 'NR>1 {print $4, $11}' | \
  sort -nr | \
  head -5 | \
  column -t

# Speicherhungrigste Prozesse
ps aux | \
  awk 'NR>1 {print $4, $11}' | \
  sort -nr | \
  head -5 | \
  column -t

# Aktive Verbindungen nach Ports sortiert
netstat -an | \
  grep ESTABLISHED | \
  awk '{print $4}' | \
  sed 's/.*://' | \
  sort -n | \
  uniq -c | \
  sort -nr

# Aktive Verbindungen nach Ports sortiert
netstat -an | \
  grep ESTABLISHED | \
  awk '{print $4}' | \
  sed 's/.*://' | \
  sort -n | \
  uniq -c | \
  sort -nr

# Größte Dateien im aktuellen Verzeichnis
ls -la | awk 'NR>1 {print $5, $9}' | sort -nr | head -5

# Dateien älter als 30 Tage finden und auflisten
find . -type f -mtime +30 | head -20

# Verzeichnisse nach Anzahl der Dateien sortieren
find . -type d | while read dir; do echo "$(find "$dir" -maxdepth 1 -type f | wc -l) $dir"; done | sort -nr

# Größte Dateien im aktuellen Verzeichnis
ls -la | awk 'NR>1 {print $5, $9}' | sort -nr | head -5

# Dateien älter als 30 Tage finden und auflisten
find . -type f -mtime +30 | head -20

# Verzeichnisse nach Anzahl der Dateien sortieren
find . -type d | while read dir; do echo "$(find "$dir" -maxdepth 1 -type f | wc -l) $dir"; done | sort -nr

# Benutzer mit Bash-Shell
grep "/bin/bash$" /etc/passwd | cut -d: -f1 | sort

# Home-Verzeichnisse und ihre Größen
cut -d: -f1,6 /etc/passwd | grep "/home" | while IFS=: read user home; do
    echo "$user: $(du -sh "$home" 2>/dev/null | cut -f1)"
done

# Benutzer mit Bash-Shell
grep "/bin/bash$" /etc/passwd | cut -d: -f1 | sort

# Home-Verzeichnisse und ihre Größen
cut -d: -f1,6 /etc/passwd | grep "/home" | while IFS=: read user home; do
    echo "$user: $(du -sh "$home" 2>/dev/null | cut -f1)"
done

# CPU-Auslastung der Top-Prozesse
ps aux | awk 'NR>1 {print $3, $11}' | sort -nr | head -10

# Speicherverbrauch nach Prozessname gruppiert
ps aux | awk 'NR>1 {mem[$11] += $4} END {for (proc in mem) print mem[proc], proc}' | sort -nr | head -10

# CPU-Auslastung der Top-Prozesse
ps aux | awk 'NR>1 {print $3, $11}' | sort -nr | head -10

# Speicherverbrauch nach Prozessname gruppiert
ps aux | awk 'NR>1 {mem[$11] += $4} END {for (proc in mem) print mem[proc], proc}' | sort -nr | head -10

#!/bin/bash
# Umfassende Apache-Log-Analyse

LOGFILE="/var/log/apache2/access.log"

echo "=== Apache Log-Analyse ==="
echo "Analysiere: $LOGFILE"
echo

# Gesamtstatistiken
echo "Gesamtanzahl Requests:"
cat "$LOGFILE" | wc -l

echo -e "\nTop 10 IP-Adressen:"
cat "$LOGFILE" | \
  awk '{print $1}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  head -10 | \
  awk '{printf "%-15s %s\n", $2, $1}'

echo -e "\nHTTP Status-Codes:"
cat "$LOGFILE" | \
  awk '{print $9}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  awk '{printf "%-3s %s\n", $2, $1}'

echo -e "\nTop 10 angeforderte Seiten:"
cat "$LOGFILE" | \
  awk '{print $7}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  head -10 | \
  awk '{printf "%-50s %s\n", $2, $1}'

echo -e "\nRequests pro Stunde:"
cat "$LOGFILE" | \
  awk '{print substr($4, 14, 2)}' | \
  sort -n | \
  uniq -c | \
  awk '{printf "%02d:00 %s\n", $2, $1}'

#!/bin/bash
# Umfassende Apache-Log-Analyse

LOGFILE="/var/log/apache2/access.log"

echo "=== Apache Log-Analyse ==="
echo "Analysiere: $LOGFILE"
echo

# Gesamtstatistiken
echo "Gesamtanzahl Requests:"
cat "$LOGFILE" | wc -l

echo -e "\nTop 10 IP-Adressen:"
cat "$LOGFILE" | \
  awk '{print $1}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  head -10 | \
  awk '{printf "%-15s %s\n", $2, $1}'

echo -e "\nHTTP Status-Codes:"
cat "$LOGFILE" | \
  awk '{print $9}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  awk '{printf "%-3s %s\n", $2, $1}'

echo -e "\nTop 10 angeforderte Seiten:"
cat "$LOGFILE" | \
  awk '{print $7}' | \
  sort | \
  uniq -c | \
  sort -nr | \
  head -10 | \
  awk '{printf "%-50s %s\n", $2, $1}'

echo -e "\nRequests pro Stunde:"
cat "$LOGFILE" | \
  awk '{print substr($4, 14, 2)}' | \
  sort -n | \
  uniq -c | \
  awk '{printf "%02d:00 %s\n", $2, $1}'

# Detaillierte Speicher-Analyse
ps aux | \
  awk 'NR>1 {
    cmd=$11; 
    for(i=12;i<=NF;i++) cmd=cmd" "$i; 
    mem[cmd]+=$4; 
    count[cmd]++
  } 
  END {
    for(c in mem) 
      printf "%.1f%% (%d Prozesse) %s\n", mem[c], count[c], c
  }' | \
  sort -nr | \
  head -15
```

**3. Netzwerk-Traffic-Analyse:**
```bash
# Verbindungsanalyse mit Details
netstat -an | \
  awk '/^tcp/ {
    split($4, local, ":");
    split($5, remote, ":");
    if(local[2] != "" && remote[2] != "") {
      connections[local[2] " -> " remote[2]]++;
      states[$6]++;
    }
  }
  END {
    print "=== Verbindungen nach Ports ===";
    for(conn in connections) 
      printf "%-20s %d\n", conn, connections[conn];
    print "\n=== Verbindungsstatus ===";
    for(state in states) 
      printf "%-12s %d\n", state, states[state];
  }' | \
  sort -k2 -nr

# Detaillierte Speicher-Analyse
ps aux | \
  awk 'NR>1 {
    cmd=$11; 
    for(i=12;i<=NF;i++) cmd=cmd" "$i; 
    mem[cmd]+=$4; 
    count[cmd]++
  } 
  END {
    for(c in mem) 
      printf "%.1f%% (%d Prozesse) %s\n", mem[c], count[c], c
  }' | \
  sort -nr | \
  head -15
```

**3. Netzwerk-Traffic-Analyse:**
```bash
# Verbindungsanalyse mit Details
netstat -an | \
  awk '/^tcp/ {
    split($4, local, ":");
    split($5, remote, ":");
    if(local[2] != "" && remote[2] != "") {
      connections[local[2] " -> " remote[2]]++;
      states[$6]++;
    }
  }
  END {
    print "=== Verbindungen nach Ports ===";
    for(conn in connections) 
      printf "%-20s %d\n", conn, connections[conn];
    print "\n=== Verbindungsstatus ===";
    for(state in states) 
      printf "%-12s %d\n", state, states[state];
  }' | \
  sort -k2 -nr

# Langsame Pipeline debuggen
time (find /var -name "*.log" | head -1000 | xargs grep "ERROR" | wc -l)

# Einzelne Schritte messen
time find /var -name "*.log" | wc -l
time find /var -name "*.log" | head -1000 | wc -l

# Langsame Pipeline debuggen
time (find /var -name "*.log" | head -1000 | xargs grep "ERROR" | wc -l)

# Einzelne Schritte messen
time find /var -name "*.log" | wc -l
time find /var -name "*.log" | head -1000 | wc -l

# SCHLECHT: Große Datenmenge bis zum Ende
cat huge_file.txt | sort | uniq | grep "pattern" | head -10

# BESSER: Früh filtern
grep "pattern" huge_file.txt | sort | uniq | head -10

# SCHLECHT: Große Datenmenge bis zum Ende
cat huge_file.txt | sort | uniq | grep "pattern" | head -10

# BESSER: Früh filtern
grep "pattern" huge_file.txt | sort | uniq | head -10

# Sequenzielle Verarbeitung
find /var/log -name "*.log" | xargs grep "ERROR" | wc -l

# Parallele Verarbeitung
find /var/log -name "*.log" | parallel grep "ERROR" {} | wc -l

# Sequenzielle Verarbeitung
find /var/log -name "*.log" | xargs grep "ERROR" | wc -l

# Parallele Verarbeitung
find /var/log -name "*.log" | parallel grep "ERROR" {} | wc -l

# Schritt 1: Basis-Befehl testen
ps aux

# Schritt 2: Ersten Filter hinzufügen
ps aux | grep apache

# Schritt 3: Weiteren Filter hinzufügen
ps aux | grep apache | grep -v grep

# Schritt 4: Zählung hinzufügen
ps aux | grep apache | grep -v grep | wc -l

# Schritt 1: Basis-Befehl testen
ps aux

# Schritt 2: Ersten Filter hinzufügen
ps aux | grep apache

# Schritt 3: Weiteren Filter hinzufügen
ps aux | grep apache | grep -v grep

# Schritt 4: Zählung hinzufügen
ps aux | grep apache | grep -v grep | wc -l

# Mit tee Zwischenergebnisse speichern
ps aux | tee debug1.txt | grep apache | tee debug2.txt | wc -l

# Oder temporär unterbrechen
ps aux | grep apache | head -5  # Erste 5 Zeilen anschauen

# Mit tee Zwischenergebnisse speichern
ps aux | tee debug1.txt | grep apache | tee debug2.txt | wc -l

# Oder temporär unterbrechen
ps aux | grep apache | head -5  # Erste 5 Zeilen anschauen

# Pipeline-Status prüfen
command1 | command2 | command3
echo "Pipeline-Status: ${PIPESTATUS[@]}"

# Fehler in der Pipeline abfangen
set -o pipefail  # Pipeline schlägt fehl, wenn ein Befehl fehlschlägt
command1 | command2 | command3 || echo "Pipeline fehlgeschlagen"

# Pipeline-Status prüfen
command1 | command2 | command3
echo "Pipeline-Status: ${PIPESTATUS[@]}"

# Fehler in der Pipeline abfangen
set -o pipefail  # Pipeline schlägt fehl, wenn ein Befehl fehlschlägt
command1 | command2 | command3 || echo "Pipeline fehlgeschlagen"

# Named Pipe erstellen
mkfifo meine_pipe

# Eigenschaften anzeigen
ls -l meine_pipe
prw-rw-r-- 1 user user 0 Jul 13 10:14 meine_pipe
#^-- 'p' zeigt an, dass es eine Pipe ist

# Named Pipe erstellen
mkfifo meine_pipe

# Eigenschaften anzeigen
ls -l meine_pipe
prw-rw-r-- 1 user user 0 Jul 13 10:14 meine_pipe
#^-- 'p' zeigt an, dass es eine Pipe ist

# Terminal 1: Daten in die Pipe schreiben
echo "Hallo Welt" > meine_pipe

# Terminal 2: Daten aus der Pipe lesen
cat < meine_pipe
Hallo Welt

# Terminal 1: Daten in die Pipe schreiben
echo "Hallo Welt" > meine_pipe

# Terminal 2: Daten aus der Pipe lesen
cat < meine_pipe
Hallo Welt

# Monitoring-System mit Named Pipes
mkfifo /tmp/system_monitor

# Producer-Prozess (läuft kontinuierlich)
while true; do
    echo "$(date): CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')" > /tmp/system_monitor
    sleep 5
done &

# Consumer-Prozess
while read line; do
    echo "Empfangen: $line"
    # Hier könnte Alerting-Logik stehen
done < /tmp/system_monitor

# Monitoring-System mit Named Pipes
mkfifo /tmp/system_monitor

# Producer-Prozess (läuft kontinuierlich)
while true; do
    echo "$(date): CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}')" > /tmp/system_monitor
    sleep 5
done &

# Consumer-Prozess
while read line; do
    echo "Empfangen: $line"
    # Hier könnte Alerting-Logik stehen
done < /tmp/system_monitor

# Zentraler Log-Collector
mkfifo /tmp/app_logs

# Verschiedene Anwendungen schreiben in die Pipe
echo "App1: $(date) - Startup complete" > /tmp/app_logs &
echo "App2: $(date) - Processing request" > /tmp/app_logs &

# Log-Processor liest und verarbeitet
while read log_entry; do
    echo "$log_entry" >> /var/log/applications.log
    # Zusätzliche Verarbeitung (Alerting, Analyse, etc.)
done < /tmp/app_logs

# Zentraler Log-Collector
mkfifo /tmp/app_logs

# Verschiedene Anwendungen schreiben in die Pipe
echo "App1: $(date) - Startup complete" > /tmp/app_logs &
echo "App2: $(date) - Processing request" > /tmp/app_logs &

# Log-Processor liest und verarbeitet
while read log_entry; do
    echo "$log_entry" >> /var/log/applications.log
    # Zusätzliche Verarbeitung (Alerting, Analyse, etc.)
done < /tmp/app_logs

#!/bin/bash
# Build-System mit Named Pipes für Parallelisierung

PIPE="/tmp/build_queue"
mkfifo "$PIPE"

# Build-Worker (mehrere parallel)
build_worker() {
    local worker_id=$1
    while read task; do
        echo "Worker $worker_id: Verarbeite $task"
        # Hier würde der eigentliche Build-Prozess stehen
        sleep 2
        echo "Worker $worker_id: $task abgeschlossen"
    done < "$PIPE"
}

# Starte mehrere Worker
for i in {1..3}; do
    build_worker $i &
done

# Tasks in die Queue einreihen
for task in project1 project2 project3 project4 project5; do
    echo "$task" > "$PIPE"
done

# Aufräumen
wait
rm "$PIPE"

#!/bin/bash
# Build-System mit Named Pipes für Parallelisierung

PIPE="/tmp/build_queue"
mkfifo "$PIPE"

# Build-Worker (mehrere parallel)
build_worker() {
    local worker_id=$1
    while read task; do
        echo "Worker $worker_id: Verarbeite $task"
        # Hier würde der eigentliche Build-Prozess stehen
        sleep 2
        echo "Worker $worker_id: $task abgeschlossen"
    done < "$PIPE"
}

# Starte mehrere Worker
for i in {1..3}; do
    build_worker $i &
done

# Tasks in die Queue einreihen
for task in project1 project2 project3 project4 project5; do
    echo "$task" > "$PIPE"
done

# Aufräumen
wait
rm "$PIPE"

# PROBLEMATISCH: Kann hängen bleiben
echo "test" > meine_pipe &
cat meine_pipe

# BESSER: Non-blocking oder Timeout verwenden
timeout 5 cat meine_pipe

# PROBLEMATISCH: Kann hängen bleiben
echo "test" > meine_pipe &
cat meine_pipe

# BESSER: Non-blocking oder Timeout verwenden
timeout 5 cat meine_pipe

# Named Pipes nach Verwendung löschen
rm meine_pipe

# Oder in Skripten mit trap
trap 'rm -f /tmp/meine_pipe' EXIT

# Named Pipes nach Verwendung löschen
rm meine_pipe

# Oder in Skripten mit trap
trap 'rm -f /tmp/meine_pipe' EXIT

# Named Pipe mit spezifischen Berechtigungen erstellen
mkfifo -m 660 /tmp/secure_pipe

# Named Pipe mit spezifischen Berechtigungen erstellen
mkfifo -m 660 /tmp/secure_pipe

# Klassische Syntax - funktioniert überall
./install_script.sh > install.log 2>&1

# Moderne Syntax - nur in neueren Bash-Versionen
./install_script.sh &> install.log

# Kontinuierliche Protokollierung
./monitoring_script.sh &>> system_monitor.log

# Klassische Syntax - funktioniert überall
./install_script.sh > install.log 2>&1

# Moderne Syntax - nur in neueren Bash-Versionen
./install_script.sh &> install.log

# Kontinuierliche Protokollierung
./monitoring_script.sh &>> system_monitor.log

# Alle Ausgaben für Debugging sammeln
find /var -name "*.log" -exec grep "ERROR" {} \; &> debug_output.txt

# Backup-Operation vollständig protokollieren
rsync -av /home/ /backup/home/ &> backup_$(date +%Y%m%d_%H%M%S).log

# Alle Ausgaben für Debugging sammeln
find /var -name "*.log" -exec grep "ERROR" {} \; &> debug_output.txt

# Backup-Operation vollständig protokollieren
rsync -av /home/ /backup/home/ &> backup_$(date +%Y%m%d_%H%M%S).log

# RICHTIG: Erst stdout umleiten, dann stderr zu stdout
command > file.txt 2>&1

# RICHTIG: Erst stdout umleiten, dann stderr zu stdout
command > file.txt 2>&1

# FALSCH: Falsche Reihenfolge
command 2>&1 > file.txt

# FALSCH: Falsche Reihenfolge
command 2>&1 > file.txt

# Test-Befehl, der sowohl stdout als auch stderr produziert
ls /existiert /existiert-nicht

# Richtige Reihenfolge - alles in Datei
ls /existiert /existiert-nicht > test1.txt 2>&1
cat test1.txt
# Beide Ausgaben sind in der Datei

# Falsche Reihenfolge - nur stdout in Datei
ls /existiert /existiert-nicht 2>&1 > test2.txt
# Fehlermeldung erscheint auf Terminal
cat test2.txt
# Nur normale Ausgabe in der Datei

# Test-Befehl, der sowohl stdout als auch stderr produziert
ls /existiert /existiert-nicht

# Richtige Reihenfolge - alles in Datei
ls /existiert /existiert-nicht > test1.txt 2>&1
cat test1.txt
# Beide Ausgaben sind in der Datei

# Falsche Reihenfolge - nur stdout in Datei
ls /existiert /existiert-nicht 2>&1 > test2.txt
# Fehlermeldung erscheint auf Terminal
cat test2.txt
# Nur normale Ausgabe in der Datei

#!/bin/bash
# Umfassendes Wartungsskript mit vollständiger Protokollierung

LOGFILE="/var/log/maintenance_$(date +%Y%m%d_%H%M%S).log"

{
    echo "=== Systemwartung gestartet: $(date) ==="
    
    echo "Aktualisiere Paketlisten..."
    apt update
    
    echo "Installiere verfügbare Updates..."
    apt upgrade -y
    
    echo "Bereinige Paket-Cache..."
    apt autoremove -y
    apt autoclean
    
    echo "Rotiere Logdateien..."
    logrotate /etc/logrotate.conf
    
    echo "Bereinige temporäre Dateien..."
    find /tmp -type f -mtime +7 -delete
    
    echo "=== Systemwartung abgeschlossen: $(date) ==="
} &> "$LOGFILE"

# Ergebnis anzeigen
if [ $? -eq 0 ]; then
    echo "Wartung erfolgreich abgeschlossen. Log: $LOGFILE"
else
    echo "Wartung mit Fehlern beendet. Siehe: $LOGFILE"
fi

#!/bin/bash
# Umfassendes Wartungsskript mit vollständiger Protokollierung

LOGFILE="/var/log/maintenance_$(date +%Y%m%d_%H%M%S).log"

{
    echo "=== Systemwartung gestartet: $(date) ==="
    
    echo "Aktualisiere Paketlisten..."
    apt update
    
    echo "Installiere verfügbare Updates..."
    apt upgrade -y
    
    echo "Bereinige Paket-Cache..."
    apt autoremove -y
    apt autoclean
    
    echo "Rotiere Logdateien..."
    logrotate /etc/logrotate.conf
    
    echo "Bereinige temporäre Dateien..."
    find /tmp -type f -mtime +7 -delete
    
    echo "=== Systemwartung abgeschlossen: $(date) ==="
} &> "$LOGFILE"

# Ergebnis anzeigen
if [ $? -eq 0 ]; then
    echo "Wartung erfolgreich abgeschlossen. Log: $LOGFILE"
else
    echo "Wartung mit Fehlern beendet. Siehe: $LOGFILE"
fi

#!/bin/bash
# Backup-Skript mit getrennter Erfolgs- und Fehlerprotokollierung

BACKUP_DATE=$(date +%Y%m%d_%H%M%S)
SUCCESS_LOG="/var/log/backup_success_$BACKUP_DATE.log"
ERROR_LOG="/var/log/backup_errors_$BACKUP_DATE.log"
COMBINED_LOG="/var/log/backup_combined_$BACKUP_DATE.log"

# Backup mit getrennter Protokollierung
rsync -av --progress /home/ /backup/home/ > "$SUCCESS_LOG" 2> "$ERROR_LOG"

# Kombinierte Protokollierung für Übersicht
{
    echo "=== Backup-Bericht $BACKUP_DATE ==="
    echo "Erfolgreiche Operationen:"
    wc -l < "$SUCCESS_LOG"
    echo "Fehler aufgetreten:"
    wc -l < "$ERROR_LOG"
    
    if [ -s "$ERROR_LOG" ]; then
        echo "=== Fehlerdetails ==="
        cat "$ERROR_LOG"
    fi
} &> "$COMBINED_LOG"
```

**3. Cron-Jobs mit intelligenter Protokollierung:**
```bash
# Crontab-Eintrag für stille Ausführung mit Fehlerprotokollierung
0 2 * * * /usr/local/bin/backup.sh > /var/log/backup.log 2>&1 || echo "Backup fehlgeschlagen am $(date)" >> /var/log/backup_failures.log

# Erweiterte Cron-Protokollierung
0 3 * * * {
    echo "=== Nightly Tasks $(date) ==="
    /usr/local/bin/cleanup.sh
    /usr/local/bin/optimize.sh
    echo "=== Tasks completed $(date) ==="
} &>> /var/log/nightly_tasks.log

#!/bin/bash
# Backup-Skript mit getrennter Erfolgs- und Fehlerprotokollierung

BACKUP_DATE=$(date +%Y%m%d_%H%M%S)
SUCCESS_LOG="/var/log/backup_success_$BACKUP_DATE.log"
ERROR_LOG="/var/log/backup_errors_$BACKUP_DATE.log"
COMBINED_LOG="/var/log/backup_combined_$BACKUP_DATE.log"

# Backup mit getrennter Protokollierung
rsync -av --progress /home/ /backup/home/ > "$SUCCESS_LOG" 2> "$ERROR_LOG"

# Kombinierte Protokollierung für Übersicht
{
    echo "=== Backup-Bericht $BACKUP_DATE ==="
    echo "Erfolgreiche Operationen:"
    wc -l < "$SUCCESS_LOG"
    echo "Fehler aufgetreten:"
    wc -l < "$ERROR_LOG"
    
    if [ -s "$ERROR_LOG" ]; then
        echo "=== Fehlerdetails ==="
        cat "$ERROR_LOG"
    fi
} &> "$COMBINED_LOG"
```

**3. Cron-Jobs mit intelligenter Protokollierung:**
```bash
# Crontab-Eintrag für stille Ausführung mit Fehlerprotokollierung
0 2 * * * /usr/local/bin/backup.sh > /var/log/backup.log 2>&1 || echo "Backup fehlgeschlagen am $(date)" >> /var/log/backup_failures.log

# Erweiterte Cron-Protokollierung
0 3 * * * {
    echo "=== Nightly Tasks $(date) ==="
    /usr/local/bin/cleanup.sh
    /usr/local/bin/optimize.sh
    echo "=== Tasks completed $(date) ==="
} &>> /var/log/nightly_tasks.log

# File Descriptor 3 öffnen zum Schreiben
exec 3> logfile.txt

# In File Descriptor 3 schreiben
echo "Nachricht 1" >&3
echo "Nachricht 2" >&3

# File Descriptor 3 schließen
exec 3>&-

# File Descriptor 3 öffnen zum Schreiben
exec 3> logfile.txt

# In File Descriptor 3 schreiben
echo "Nachricht 1" >&3
echo "Nachricht 2" >&3

# File Descriptor 3 schließen
exec 3>&-

#!/bin/bash
# Skript mit mehreren gleichzeitigen Log-Ausgaben

# Verschiedene Log-Streams öffnen
exec 3> /var/log/debug.log      # Debug-Informationen
exec 4> /var/log/errors.log     # Nur Fehler
exec 5> /var/log/audit.log      # Audit-Trail

log_debug() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') DEBUG: $*" >&3
}

log_error() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') ERROR: $*" >&4
    echo "$(date '+%Y-%m-%d %H:%M:%S') ERROR: $*" >&2  # Auch nach stderr
}

log_audit() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') AUDIT: $*" >&5
}

# Verwendung
log_debug "Skript gestartet"
log_audit "Benutzer $(whoami) hat Skript gestartet"

# Hauptlogik hier...

# File Descriptors schließen
exec 3>&- 4>&- 5>&-

#!/bin/bash
# Skript mit mehreren gleichzeitigen Log-Ausgaben

# Verschiedene Log-Streams öffnen
exec 3> /var/log/debug.log      # Debug-Informationen
exec 4> /var/log/errors.log     # Nur Fehler
exec 5> /var/log/audit.log      # Audit-Trail

log_debug() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') DEBUG: $*" >&3
}

log_error() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') ERROR: $*" >&4
    echo "$(date '+%Y-%m-%d %H:%M:%S') ERROR: $*" >&2  # Auch nach stderr
}

log_audit() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') AUDIT: $*" >&5
}

# Verwendung
log_debug "Skript gestartet"
log_audit "Benutzer $(whoami) hat Skript gestartet"

# Hauptlogik hier...

# File Descriptors schließen
exec 3>&- 4>&- 5>&-

#!/bin/bash
# Temporäre Umleitung von stdout/stderr

# Aktuelle stdout/stderr sichern
exec 6>&1 7>&2

# Temporär umleiten
exec 1> temp_output.log 2> temp_errors.log

# Befehle ausführen (gehen in die temporären Dateien)
echo "Diese Nachricht geht in temp_output.log"
echo "Fehler!" >&2

# Ursprüngliche stdout/stderr wiederherstellen
exec 1>&6 2>&7

# File Descriptors schließen
exec 6>&- 7>&-

# Jetzt gehen Ausgaben wieder normal auf Terminal
echo "Diese Nachricht erscheint auf dem Terminal"

#!/bin/bash
# Temporäre Umleitung von stdout/stderr

# Aktuelle stdout/stderr sichern
exec 6>&1 7>&2

# Temporär umleiten
exec 1> temp_output.log 2> temp_errors.log

# Befehle ausführen (gehen in die temporären Dateien)
echo "Diese Nachricht geht in temp_output.log"
echo "Fehler!" >&2

# Ursprüngliche stdout/stderr wiederherstellen
exec 1>&6 2>&7

# File Descriptors schließen
exec 6>&- 7>&-

# Jetzt gehen Ausgaben wieder normal auf Terminal
echo "Diese Nachricht erscheint auf dem Terminal"

# Nur stderr unterdrücken
find /etc -name "*.conf" 2>/dev/null

# Nur stdout unterdrücken
command > /dev/null

# Alles unterdrücken
command &> /dev/null

# Stdin von /dev/null (leere Eingabe)
command < /dev/null

# Nur stderr unterdrücken
find /etc -name "*.conf" 2>/dev/null

# Nur stdout unterdrücken
command > /dev/null

# Alles unterdrücken
command &> /dev/null

# Stdin von /dev/null (leere Eingabe)
command < /dev/null

#!/bin/bash
# Stille Systemprüfungen für Monitoring

# Prüfe, ob Service läuft (ohne Ausgabe)
if systemctl is-active apache2 &> /dev/null; then
    echo "Apache läuft"
else
    echo "Apache ist gestoppt"
fi

# Prüfe Festplattenspeicher (nur bei kritischem Zustand melden)
USAGE=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
if [ "$USAGE" -gt 90 ]; then
    echo "WARNUNG: Festplatte zu ${USAGE}% voll"
fi > /dev/null 2>&1  # Normale Ausgaben unterdrücken

#!/bin/bash
# Stille Systemprüfungen für Monitoring

# Prüfe, ob Service läuft (ohne Ausgabe)
if systemctl is-active apache2 &> /dev/null; then
    echo "Apache läuft"
else
    echo "Apache ist gestoppt"
fi

# Prüfe Festplattenspeicher (nur bei kritischem Zustand melden)
USAGE=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
if [ "$USAGE" -gt 90 ]; then
    echo "WARNUNG: Festplatte zu ${USAGE}% voll"
fi > /dev/null 2>&1  # Normale Ausgaben unterdrücken

# Viele Dateien verarbeiten, nur Fehler anzeigen
for file in *.txt; do
    process_file "$file" > /dev/null || echo "Fehler bei $file"
done

# Cron-Jobs ohne E-Mail-Spam
0 * * * * /usr/local/bin/hourly_check.sh > /dev/null 2>&1

# Viele Dateien verarbeiten, nur Fehler anzeigen
for file in *.txt; do
    process_file "$file" > /dev/null || echo "Fehler bei $file"
done

# Cron-Jobs ohne E-Mail-Spam
0 * * * * /usr/local/bin/hourly_check.sh > /dev/null 2>&1

#!/bin/bash
# Komplexe Stream-Manipulation

# Funktion für temporäre Umleitung
with_logging() {
    local logfile="$1"
    shift
    
    # Aktuelle Streams sichern
    exec 8>&1 9>&2
    
    # Zu Logdatei umleiten
    exec 1>> "$logfile" 2>&1
    
    # Befehle ausführen
    "$@"
    local result=$?
    
    # Streams wiederherstellen
    exec 1>&8 2>&9
    exec 8>&- 9>&-
    
    return $result
}

# Verwendung
with_logging "/var/log/operation.log" complex_operation arg1 arg2
echo "Operation abgeschlossen (diese Nachricht geht auf Terminal)"

#!/bin/bash
# Komplexe Stream-Manipulation

# Funktion für temporäre Umleitung
with_logging() {
    local logfile="$1"
    shift
    
    # Aktuelle Streams sichern
    exec 8>&1 9>&2
    
    # Zu Logdatei umleiten
    exec 1>> "$logfile" 2>&1
    
    # Befehle ausführen
    "$@"
    local result=$?
    
    # Streams wiederherstellen
    exec 1>&8 2>&9
    exec 8>&- 9>&-
    
    return $result
}

# Verwendung
with_logging "/var/log/operation.log" complex_operation arg1 arg2
echo "Operation abgeschlossen (diese Nachricht geht auf Terminal)"

# Komplexe Log-Analyse mit Fehlerbehandlung
{
    grep "ERROR" /var/log/application.log | \
    awk '{print $1, $2, $NF}' | \
    sort | \
    uniq -c | \
    sort -nr
} > error_analysis.txt 2> analysis_errors.log
```

**2. Multi-Stage-Datenverarbeitung:**
```bash
#!/bin/bash
# Mehrstufige Datenverarbeitung mit Zwischenspeicherung

TEMP_DIR="/tmp/data_processing_$$"
mkdir -p "$TEMP_DIR"

# Stage 1: Daten sammeln
{
    echo "=== Sammle Daten $(date) ==="
    find /var/log -name "*.log" -mtime -1 | \
    xargs grep -l "ERROR" 2>/dev/null
} | tee "$TEMP_DIR/stage1.log" | \

# Stage 2: Daten analysieren
{
    echo "=== Analysiere Daten $(date) ==="
    while read logfile; do
        echo "Analysiere: $logfile"
        grep -c "ERROR" "$logfile" 2>/dev/null | \
        sed "s/^/${logfile}: /"
    done
} | tee "$TEMP_DIR/stage2.log" | \

# Stage 3: Berichten
{
    echo "=== Erstelle Bericht $(date) ==="
    sort -t: -k2 -nr | \
    head -10 | \
    awk -F: '{printf "%-50s %s Fehler\n", $1, $2}'
} > final_report.txt 2> processing_errors.log

# Aufräumen
rm -rf "$TEMP_DIR"

# Komplexe Log-Analyse mit Fehlerbehandlung
{
    grep "ERROR" /var/log/application.log | \
    awk '{print $1, $2, $NF}' | \
    sort | \
    uniq -c | \
    sort -nr
} > error_analysis.txt 2> analysis_errors.log
```

**2. Multi-Stage-Datenverarbeitung:**
```bash
#!/bin/bash
# Mehrstufige Datenverarbeitung mit Zwischenspeicherung

TEMP_DIR="/tmp/data_processing_$$"
mkdir -p "$TEMP_DIR"

# Stage 1: Daten sammeln
{
    echo "=== Sammle Daten $(date) ==="
    find /var/log -name "*.log" -mtime -1 | \
    xargs grep -l "ERROR" 2>/dev/null
} | tee "$TEMP_DIR/stage1.log" | \

# Stage 2: Daten analysieren
{
    echo "=== Analysiere Daten $(date) ==="
    while read logfile; do
        echo "Analysiere: $logfile"
        grep -c "ERROR" "$logfile" 2>/dev/null | \
        sed "s/^/${logfile}: /"
    done
} | tee "$TEMP_DIR/stage2.log" | \

# Stage 3: Berichten
{
    echo "=== Erstelle Bericht $(date) ==="
    sort -t: -k2 -nr | \
    head -10 | \
    awk -F: '{printf "%-50s %s Fehler\n", $1, $2}'
} > final_report.txt 2> processing_errors.log

# Aufräumen
rm -rf "$TEMP_DIR"

# Komplexe Analyse mit Zwischenspeicherung für Debugging
ps aux | \
  tee process_list.debug | \
  grep apache | \
  tee apache_processes.debug | \
  awk '{sum += $3} END {print "Gesamt CPU:", sum "%"}' | \
  tee cpu_summary.debug

# Komplexe Analyse mit Zwischenspeicherung für Debugging
ps aux | \
  tee process_list.debug | \
  grep apache | \
  tee apache_processes.debug | \
  awk '{sum += $3} END {print "Gesamt CPU:", sum "%"}' | \
  tee cpu_summary.debug

#!/bin/bash
# Parallele Datenverarbeitung mit umfassender Protokollierung

INPUT_DIR="/data/input"
OUTPUT_DIR="/data/output"
LOG_DIR="/var/log/processing"

# Named Pipes für parallele Verarbeitung
mkfifo /tmp/worker1_pipe /tmp/worker2_pipe

# Worker-Funktionen
worker1() {
    while read file; do
        echo "Worker1: Verarbeite $file" >&2
        process_type1 "$file" > "$OUTPUT_DIR/$(basename "$file").type1" 2>> "$LOG_DIR/worker1_errors.log"
    done < /tmp/worker1_pipe
}

worker2() {
    while read file; do
        echo "Worker2: Verarbeite $file" >&2
        process_type2 "$file" > "$OUTPUT_DIR/$(basename "$file").type2" 2>> "$LOG_DIR/worker2_errors.log"
    done < /tmp/worker2_pipe
}

# Worker starten
worker1 &
worker2 &

# Dateien auf Worker verteilen
find "$INPUT_DIR" -name "*.txt" | \
while read file; do
    if [ $((RANDOM % 2)) -eq 0 ]; then
        echo "$file" > /tmp/worker1_pipe
    else
        echo "$file" > /tmp/worker2_pipe
    fi
done

# Aufräumen
wait
rm -f /tmp/worker1_pipe /tmp/worker2_pipe

#!/bin/bash
# Parallele Datenverarbeitung mit umfassender Protokollierung

INPUT_DIR="/data/input"
OUTPUT_DIR="/data/output"
LOG_DIR="/var/log/processing"

# Named Pipes für parallele Verarbeitung
mkfifo /tmp/worker1_pipe /tmp/worker2_pipe

# Worker-Funktionen
worker1() {
    while read file; do
        echo "Worker1: Verarbeite $file" >&2
        process_type1 "$file" > "$OUTPUT_DIR/$(basename "$file").type1" 2>> "$LOG_DIR/worker1_errors.log"
    done < /tmp/worker1_pipe
}

worker2() {
    while read file; do
        echo "Worker2: Verarbeite $file" >&2
        process_type2 "$file" > "$OUTPUT_DIR/$(basename "$file").type2" 2>> "$LOG_DIR/worker2_errors.log"
    done < /tmp/worker2_pipe
}

# Worker starten
worker1 &
worker2 &

# Dateien auf Worker verteilen
find "$INPUT_DIR" -name "*.txt" | \
while read file; do
    if [ $((RANDOM % 2)) -eq 0 ]; then
        echo "$file" > /tmp/worker1_pipe
    else
        echo "$file" > /tmp/worker2_pipe
    fi
done

# Aufräumen
wait
rm -f /tmp/worker1_pipe /tmp/worker2_pipe

#!/bin/bash
# Pipeline mit umfassender Fehlerbehandlung

set -o pipefail  # Pipeline schlägt fehl, wenn ein Befehl fehlschlägt

LOGFILE="/var/log/data_processing.log"
ERRORFILE="/var/log/data_processing_errors.log"

# Funktion für sichere Pipeline-Ausführung
safe_pipeline() {
    local description="$1"
    shift
    
    echo "$(date): Starte $description" >> "$LOGFILE"
    
    if "$@" 2>> "$ERRORFILE"; then
        echo "$(date): $description erfolgreich" >> "$LOGFILE"
        return 0
    else
        local exit_code=$?
        echo "$(date): FEHLER bei $description (Exit-Code: $exit_code)" >> "$LOGFILE"
        echo "$(date): FEHLER bei $description (Exit-Code: $exit_code)" >> "$ERRORFILE"
        return $exit_code
    fi
}

# Verwendung
safe_pipeline "Datenextraktion" \
    find /var/log -name "*.log" -mtime -1 -exec grep -l "ERROR" {} \; | \
    sort | \
    uniq > extracted_data.txt

safe_pipeline "Datenanalyse" \
    cat extracted_data.txt | \
    xargs -I {} sh -c 'echo "{}:$(grep -c ERROR "{}")"' | \
    sort -t: -k2 -nr > analysis_results.txt

# Prüfe Gesamtergebnis
if [ -s analysis_results.txt ]; then
    echo "Verarbeitung erfolgreich abgeschlossen"
else
    echo "Verarbeitung fehlgeschlagen - keine Ergebnisse"
    exit 1
fic

#!/bin/bash
# Pipeline mit umfassender Fehlerbehandlung

set -o pipefail  # Pipeline schlägt fehl, wenn ein Befehl fehlschlägt

LOGFILE="/var/log/data_processing.log"
ERRORFILE="/var/log/data_processing_errors.log"

# Funktion für sichere Pipeline-Ausführung
safe_pipeline() {
    local description="$1"
    shift
    
    echo "$(date): Starte $description" >> "$LOGFILE"
    
    if "$@" 2>> "$ERRORFILE"; then
        echo "$(date): $description erfolgreich" >> "$LOGFILE"
        return 0
    else
        local exit_code=$?
        echo "$(date): FEHLER bei $description (Exit-Code: $exit_code)" >> "$LOGFILE"
        echo "$(date): FEHLER bei $description (Exit-Code: $exit_code)" >> "$ERRORFILE"
        return $exit_code
    fi
}

# Verwendung
safe_pipeline "Datenextraktion" \
    find /var/log -name "*.log" -mtime -1 -exec grep -l "ERROR" {} \; | \
    sort | \
    uniq > extracted_data.txt

safe_pipeline "Datenanalyse" \
    cat extracted_data.txt | \
    xargs -I {} sh -c 'echo "{}:$(grep -c ERROR "{}")"' | \
    sort -t: -k2 -nr > analysis_results.txt

# Prüfe Gesamtergebnis
if [ -s analysis_results.txt ]; then
    echo "Verarbeitung erfolgreich abgeschlossen"
else
    echo "Verarbeitung fehlgeschlagen - keine Ergebnisse"
    exit 1
fic

#!/bin/bash
# Erweiterte Log-Rotation mit Archivierung

LOGDIR="/var/log"
ARCHIVE_DIR="/var/log/archive"
COMPRESS_DAYS=7
DELETE_DAYS=90

rotate_log() {
    local logfile="$1"
    local basename=$(basename "$logfile")
    local timestamp=$(date +%Y%m%d_%H%M%S)
    
    if [ -f "$logfile" ] && [ -s "$logfile" ]; then
        # Log archivieren
        {
            echo "Rotiere $logfile"
            cp "$logfile" "$ARCHIVE_DIR/${basename}_${timestamp}"
            > "$logfile"  # Log-Datei leeren
            echo "Rotation abgeschlossen für $logfile"
        } >> /var/log/logrotate.log 2>&1
        
        # Signal an Dienst senden (falls nötig)
        if [[ "$basename" == *"apache"* ]]; then
            systemctl reload apache2 &>> /var/log/logrotate.log
        fi
    fi
}

# Alte Archive komprimieren
{
    echo "=== Komprimiere alte Archive $(date) ==="
    find "$ARCHIVE_DIR" -name "*.log_*" -mtime +$COMPRESS_DAYS ! -name "*.gz" | \
    while read archive; do
        echo "Komprimiere $archive"
        gzip "$archive"
    done
} &>> /var/log/logrotate.log

# Sehr alte Archive löschen
{
    echo "=== Lösche sehr alte Archive $(date) ==="
    find "$ARCHIVE_DIR" -name "*.gz" -mtime +$DELETE_DAYS | \
    while read old_archive; do
        echo "Lösche $old_archive"
        rm "$old_archive"
    done
} &>> /var/log/logrotate.log

#!/bin/bash
# Erweiterte Log-Rotation mit Archivierung

LOGDIR="/var/log"
ARCHIVE_DIR="/var/log/archive"
COMPRESS_DAYS=7
DELETE_DAYS=90

rotate_log() {
    local logfile="$1"
    local basename=$(basename "$logfile")
    local timestamp=$(date +%Y%m%d_%H%M%S)
    
    if [ -f "$logfile" ] && [ -s "$logfile" ]; then
        # Log archivieren
        {
            echo "Rotiere $logfile"
            cp "$logfile" "$ARCHIVE_DIR/${basename}_${timestamp}"
            > "$logfile"  # Log-Datei leeren
            echo "Rotation abgeschlossen für $logfile"
        } >> /var/log/logrotate.log 2>&1
        
        # Signal an Dienst senden (falls nötig)
        if [[ "$basename" == *"apache"* ]]; then
            systemctl reload apache2 &>> /var/log/logrotate.log
        fi
    fi
}

# Alte Archive komprimieren
{
    echo "=== Komprimiere alte Archive $(date) ==="
    find "$ARCHIVE_DIR" -name "*.log_*" -mtime +$COMPRESS_DAYS ! -name "*.gz" | \
    while read archive; do
        echo "Komprimiere $archive"
        gzip "$archive"
    done
} &>> /var/log/logrotate.log

# Sehr alte Archive löschen
{
    echo "=== Lösche sehr alte Archive $(date) ==="
    find "$ARCHIVE_DIR" -name "*.gz" -mtime +$DELETE_DAYS | \
    while read old_archive; do
        echo "Lösche $old_archive"
        rm "$old_archive"
    done
} &>> /var/log/logrotate.log