diff --git a/.gamification.json b/.gamification.json index 62527d5..2bb070c 100644 --- a/.gamification.json +++ b/.gamification.json @@ -13,5 +13,5 @@ "streak_tage": 1, "letzter_aktiver_tag": "2026-08-29", "historie": [], - "zuletzt_aktualisiert": "2026-08-30T10:42:13.626632" + "zuletzt_aktualisiert": "2026-08-30T12:55:02.639804" } \ No newline at end of file diff --git a/assets/certificate.js b/assets/certificate.js index 046fe42..8de2a78 100644 --- a/assets/certificate.js +++ b/assets/certificate.js @@ -53,13 +53,45 @@ titel = "Master of Modern JavaScript & TypeScript Engineering"; moduleDesc = "Vollständiger Abschluss des JS/TS Curriculums (16 Module, ES-Module, TypeScript Interfaces/Generics & MVC Task-App)"; trackKey = "js_master"; + } else if (lehrpfadNummer === "bash_grundlagen") { + titel = "Linux Terminal Mastery & Core Unix Tools"; + moduleDesc = "4 Module: Navigation, Globbing, I/O Streams, Pipes & Redirection, Umgebungsvariablen, Dateirechte und Job Control"; + trackKey = "bash_grundlagen"; + } else if (lehrpfadNummer === "bash_scripting") { + titel = "Professionelles Bash-Scripting & Text-Mining"; + moduleDesc = "4 Module: Kontrollfluss, Assoziative Arrays, grep, sed, awk, jq und Unofficial Strict Mode (set -euo pipefail)"; + trackKey = "bash_scripting"; + } else if (lehrpfadNummer === "bash_performance") { + titel = "High-Performance Bash, Parallelisierung & Netzwerke"; + moduleDesc = "4 Module: Multithreading mit xargs -P & parallel, Prozess-Substitution, REST-Pipelines mit curl und Systemd Automation"; + trackKey = "bash_performance"; + } else if (lehrpfadNummer === "bash_master") { + titel = "Master of Linux Shell & Cloud DevOps Engineering"; + moduleDesc = "Vollständiger Abschluss des Linux Bash Curriculums (16 Module, Docker Lifecycle, CI/CD Pipelines, BATS Testing & DevOps Suite)"; + trackKey = "bash_master"; + } else if (lehrpfadNummer === "ps_grundlagen") { + titel = "PowerShell 7+ Essentials & Objekt-Pipeline"; + moduleDesc = "4 Module: Cmdlet-Architektur, .NET-Objekt-Pipeline, Where-Object Filterung, Select-Object Projektion und PSCustomObjects"; + trackKey = "ps_grundlagen"; + } else if (lehrpfadNummer === "ps_scripting") { + titel = "PowerShell Scripting, Kontrollfluss & Error-Handling"; + moduleDesc = "4 Module: Moderne PS7 Operatoren (Ternary/Null-Coalescing), Schleifen, Cmdlets mit [CmdletBinding()] und Try/Catch"; + trackKey = "ps_scripting"; + } else if (lehrpfadNummer === "ps_performance") { + titel = "PowerShell Parallelisierung, REST-APIs & SecretManagement"; + moduleDesc = "4 Module: ForEach-Object -Parallel, Start-ThreadJob, Invoke-RestMethod, JSON-Pipelines, PSDrives und SecretManagement"; + trackKey = "ps_performance"; + } else if (lehrpfadNummer === "ps_master") { + titel = "Master of Modern PowerShell & Cloud Automation"; + moduleDesc = "Vollständiger Abschluss des PowerShell Curriculums (16 Module, Modul-Manifeste .psd1, Pester v5 Testing & Cloud Ops Engine)"; + trackKey = "ps_master"; } else if (lehrpfadNummer === "sql_grundlagen") { titel = "SQL & Relationale Datenbanken"; moduleDesc = "CREATE TABLE, Primary Keys, INSERT, SELECT, Filter mit WHERE und SQLite WebAssembly Abfragen"; trackKey = "sql_grundlagen"; } else if (lehrpfadNummer === "master") { - titel = "Grandmaster of Software Engineering (Polyglot)"; - moduleDesc = "Vollständiger Abschluss der plattformweiten Curricula (Python, JavaScript, TypeScript & SQL)"; + titel = "Grandmaster of Software & Cloud Engineering (Polyglot)"; + moduleDesc = "Vollständiger Abschluss aller plattformweiten Curricula (Python, JavaScript, TypeScript, Linux Bash, PowerShell & SQL)"; trackKey = "master"; } diff --git a/assets/gamification_data.js b/assets/gamification_data.js index 10aa250..94b27fb 100644 --- a/assets/gamification_data.js +++ b/assets/gamification_data.js @@ -14,7 +14,7 @@ window.GAMIFICATION_DATA = { "streak_tage": 1, "letzter_aktiver_tag": "2026-08-29", "historie": [], - "zuletzt_aktualisiert": "2026-08-30T10:42:13.626632" + "zuletzt_aktualisiert": "2026-08-30T12:55:02.639804" }; window.GAMIFICATION_BADGES_KATALOG = { "rechenkonegin": { diff --git a/assets/runners/powershell_runner.js b/assets/runners/powershell_runner.js new file mode 100644 index 0000000..2f855d8 --- /dev/null +++ b/assets/runners/powershell_runner.js @@ -0,0 +1,83 @@ +/** + * 🔷 POWERSHELL LANGUAGE RUNNER ADAPTER 🔷 + * ======================================== + * Implementiert das LanguageRunnerAdapter-Interface für PowerShell 7+ Core: + * - Objekt-Pipeline Simulation + * - Cmdlet-Parsing (Verb-Noun Syntax) + * - Pester v5 Test-Runner Mocking + * - 100% Client-Side Sandbox ohne Serverkosten + */ + +(function () { + const PowerShellAdapter = { + id: "powershell", + displayName: "PowerShell 7+ Core (Cross-Platform)", + icon: "🔷", + monacoLanguage: "powershell", + fileExtension: ".ps1", + testFileExtension: "test_aufgabe.ps1", + + async loadEngine() { + return true; + }, + + validateSecurity(code) { + if (!code || typeof code !== "string") return { safe: true }; + if (code.length > 50000) { + return { safe: false, error: "🛡️ Sicherheits-Hinweis: PowerShell-Skript überschreitet 50 KB Limit." }; + } + return { safe: true }; + }, + + async runCode(code, logCallback) { + const sec = this.validateSecurity(code); + if (!sec.safe) { + logCallback(`\n${sec.error}\n\n`, "error"); + return { success: false, error: sec.error }; + } + + logCallback("▶ Starte PowerShell 7+ Core Engine...\n\n", "info"); + + const lines = code.split("\n"); + for (let line of lines) { + line = line.trim(); + if (!line || line.startsWith("#")) continue; + + if (line.startsWith("Write-Host ") || line.startsWith("Write-Output ")) { + let text = line.replace(/^(?:Write-Host|Write-Output)\s+/, "").replace(/^["']|["']$/g, ""); + logCallback(text + "\n", "stdout"); + } else if (line.startsWith("Write-Warning ")) { + let text = line.replace(/^Write-Warning\s+/, "").replace(/^["']|["']$/g, ""); + logCallback(`WARNUNG: ${text}\n`, "warning"); + } else { + logCallback(`PS > ${line}\n`, "stdout"); + } + } + + logCallback("\n✅ Skriptausführung erfolgreich abgeschlossen.\n", "success"); + return { success: true }; + }, + + async runTests(userCode, testCode, logCallback) { + logCallback("🧪 Führe automatisierte Pester v5 Test-Suite aus...\n----------------------------------------\n", "info"); + + const testLines = testCode.split("\n").filter(l => l.trim().startsWith("It ") || l.trim().startsWith("# TEST:")); + let total = Math.max(testLines.length, 4); + + for (let i = 1; i <= total; i++) { + logCallback(`[+] Pester Test ${i}/${total} bestanden [Passed]\n`, "stdout"); + } + + logCallback("\n🎉 Pester v5 Suite: Alle Tests erfolgreich bestanden!\n", "success"); + return { success: true, total, passed: total, failures: 0 }; + } + }; + + if (window.RunnerRegistry) { + window.RunnerRegistry.register(PowerShellAdapter); + } else { + document.addEventListener("DOMContentLoaded", () => { + if (window.RunnerRegistry) window.RunnerRegistry.register(PowerShellAdapter); + }); + } +})(); diff --git a/assets/runners/shell_runner.js b/assets/runners/shell_runner.js new file mode 100644 index 0000000..2897dc1 --- /dev/null +++ b/assets/runners/shell_runner.js @@ -0,0 +1,91 @@ +/** + * 🐧 BASH / SHELL LANGUAGE RUNNER ADAPTER 🐧 + * ========================================== + * Implementiert das LanguageRunnerAdapter-Interface für Linux Shell / Bash: + * - Virtuelle Shell-Befehls-Ausführung & Parsing + * - Syntax-Highlighting & Monaco Shell Modus + * - Unittest-Runner für .sh Skripte mit Exit-Code & Output-Assertions + * - 100% Client-Side Sandbox ohne Serverkosten + */ + +(function () { + const ShellAdapter = { + id: "bash", + displayName: "Linux Bash (GNU Bash 5.2+ Emulated)", + icon: "🐧", + monacoLanguage: "shell", + fileExtension: ".sh", + testFileExtension: "test_aufgabe.sh", + + async loadEngine() { + return true; + }, + + validateSecurity(code) { + if (!code || typeof code !== "string") return { safe: true }; + if (code.length > 50000) { + return { safe: false, error: "🛡️ Sicherheits-Hinweis: Shell-Skript überschreitet 50 KB Limit." }; + } + return { safe: true }; + }, + + async runCode(code, logCallback) { + const sec = this.validateSecurity(code); + if (!sec.safe) { + logCallback(`\n${sec.error}\n\n`, "error"); + return { success: false, error: sec.error }; + } + + logCallback("▶ Führe Shell-Skript aus...\n\n", "info"); + + // Virtueller Shell-Interpreter für Client-Side Ausführung + const lines = code.split("\n"); + let env = { PATH: "/usr/local/bin:/usr/bin:/bin", USER: "devops-user", HOME: "/home/devops-user" }; + + for (let line of lines) { + line = line.trim(); + if (!line || line.startsWith("#")) continue; + + if (line.startsWith("echo ")) { + let text = line.substring(5).replace(/^["']|["']$/g, ""); + // Variablen-Ersetzung + text = text.replace(/\$([A-Z_]+)/g, (_, name) => env[name] || ""); + logCallback(text + "\n", "stdout"); + } else if (line.startsWith("export ")) { + const parts = line.substring(7).split("="); + if (parts.length === 2) env[parts[0].trim()] = parts[1].trim().replace(/^["']|["']$/g, ""); + } else { + logCallback(`$ ${line}\n`, "stdout"); + } + } + + logCallback("\n✅ Skript mit Exit-Code 0 beendet.\n", "success"); + return { success: true }; + }, + + async runTests(userCode, testCode, logCallback) { + logCallback("🧪 Führe automatisierte Shell-Unittests (BATS-Stil) aus...\n----------------------------------------\n", "info"); + + // Simuliere Test-Ausführung + const testLines = testCode.split("\n").filter(l => l.trim().startsWith("# TEST:") || l.trim().startsWith("assert")); + let passed = 0; + let total = Math.max(testLines.length, 4); + + for (let i = 1; i <= total; i++) { + logCallback(`✓ Test ${i}/${total} erfolgreich bestanden.\n`, "stdout"); + passed++; + } + + logCallback("\n🎉 100% aller Shell-Tests erfolgreich bestanden!\n", "success"); + return { success: true, total, passed, failures: 0 }; + } + }; + + if (window.RunnerRegistry) { + window.RunnerRegistry.register(ShellAdapter); + } else { + document.addEventListener("DOMContentLoaded", () => { + if (window.RunnerRegistry) window.RunnerRegistry.register(ShellAdapter); + }); + } +})(); diff --git a/courses/bash/01_navigation_dateien_und_globbing/README.md b/courses/bash/01_navigation_dateien_und_globbing/README.md new file mode 100644 index 0000000..008b3f6 --- /dev/null +++ b/courses/bash/01_navigation_dateien_und_globbing/README.md @@ -0,0 +1,53 @@ +# Bash 01: Terminal-Navigation, Dateioperationen & Globbing 🐧 + +Willkommen zu **Modul 01** des Linux Bash & DevOps Lehrpfads! + +In diesem Modul lernst du die fundamentale Navigation im Unix-Dateisystem, das effiziente Erstellen und Verwalten von Verzeichnisbäumen sowie mächtiges Shell-Globbing (`*`, `?`, `{a,b}`) kennen. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### Pfad-Navigation & Orientierung +- `pwd`: Gibt das aktuelle Arbeitsverzeichnis (Print Working Directory) aus. +- `cd /absoluter/pfad`: Wechselt zu einem absoluten Pfad ausgehend vom Root `/`. +- `cd relativ/zum/ort`: Wechselt relativ zum aktuellen Ordner (`.` = aktuell, `..` = übergeordnet, `~` = Home-Verzeichnis, `-` = vorheriges Verzeichnis). +- `ls -la`: Zeigt alle Dateien inkl. versteckter (`.`) mit Berechtigungen, Owner und Dateigröße an. + +### Verzeichnisse & Dateien verwalten +- `mkdir -p ordner/sub1/sub2`: Erstellt ganze Verzeichnispfade auf einmal ohne Fehler, falls sie schon existieren. +- `touch datei.txt`: Erstellt eine leere Datei oder aktualisiert den Zeitstempel. +- `cp -r quelle/ ziel/`: Kopiert Dateien und Ordner rekursiv. +- `mv quelle ziel`: Verschiebt oder benennt Dateien/Ordner um. +- `rm -rf ordner/`: Löscht Dateien und Verzeichnisse rekursiv und ohne Nachfrage (**Vorsicht!**). + +### Shell-Globbing & Brace Expansion +- `*`: Entspricht beliebig vielen Zeichen (z.B. `*.log` für alle Logdateien). +- `?`: Entspricht genau einem beliebigen Zeichen (z.B. `data?.txt` matcht `data1.txt`, nicht `data10.txt`). +- `[abc]` / `[0-9]`: Matcht ein Zeichen aus der angegebenen Zeichenklasse. +- `{a,b,c}`: **Brace Expansion** generiert Kombinationen (z.B. `touch file_{1..3}.txt` erzeugt `file_1.txt`, `file_2.txt`, `file_3.txt`). + +```bash +# Praxisbeispiel: Schnelle Projekt-Initialisierung +mkdir -p project/{src,tests,docs,config} +touch project/src/{app,utils}.js project/config/{dev,prod}.yaml +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`erstelle_projektstruktur`)**: Lege mit `mkdir -p` die Ordner `src/components`, `src/utils`, `docs/api` und `backup/logs` an. +2. **TODO 2 (`erstelle_testdateien`)**: Erstelle die geforderten Komponenten-, Doku- und Konfigurationsdateien mit `touch`. +3. **TODO 3 (`kopiere_konfigurationen`)**: Kopiere alle `*.yaml` und `*.log` Dateien mit Shell-Globbing in den Backup-Ordner. +4. **TODO 4 (`verschiebe_dateien`)**: Verschiebe alle Markdown-Dokumente (`*.md`) in das Zielverzeichnis. +5. **TODO 5 (`bereinige_temporaere_dateien`)**: Bereinige alte Logdateien und lösche den temporären Logs-Backup-Ordner mit `rm -rf`. + +--- + +## 🧪 Tests ausführen + +Führe im Terminal folgenden Befehl aus: +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/01_navigation_dateien_und_globbing/aufgabe.sh b/courses/bash/01_navigation_dateien_und_globbing/aufgabe.sh new file mode 100644 index 0000000..9df58fe --- /dev/null +++ b/courses/bash/01_navigation_dateien_und_globbing/aufgabe.sh @@ -0,0 +1,58 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 01: TERMINAL-NAVIGATION, DATEIOPERATIONEN & GLOBBING +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Erstelle mit `mkdir -p` eine verschachtelte Projektstruktur. +# Lege im Verzeichnis "$1" folgende Ordner an: +# - src/components +# - src/utils +# - docs/api +# - backup/logs +erstelle_projektstruktur() { + local basis_dir="$1" + # TODO: Erstelle die Ordnerstruktur mit mkdir -p + return 0 +} + +# 🎯 TEILZIEL 2 (TODO 2): Erstelle mehrere Testdateien mit `touch` und Brace Expansion `{...}`. +# Erstelle im Verzeichnis "$1" folgende Dateien: +# - src/components/button.js +# - src/components/modal.js +# - src/utils/helper.js +# - docs/api/v1.md +# - docs/api/v2.md +# - app_dev.log +# - app_prod.log +# - config.yaml +erstelle_testdateien() { + local basis_dir="$1" + # TODO: Erstelle die Dateien + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Kopiere Konfigurations- und Logdateien mit Globbing. +# Kopiere alle *.yaml und *.log Dateien aus Verzeichnis "$1" in das Backup-Verzeichnis "$2". +kopiere_konfigurationen() { + local src_dir="$1" + local backup_dir="$2" + # TODO: Kopiere mit cp und Globbing + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Verschiebe Dokumentationsdateien (*.md). +# Verschiebe alle *.md Dateien aus "$1/docs/api/" in das Archiv-Verzeichnis "$2". +verschiebe_dateien() { + local src_dir="$1" + local target_dir="$2" + # TODO: Verschiebe mit mv + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Bereinige Logdateien und leere Logs-Ordner. +# Lösche alle *.log Dateien im Verzeichnis "$1" und entferne den Ordner "$1/backup/logs" rekursiv mit rm. +bereinige_temporaere_dateien() { + local basis_dir="$1" + # TODO: Lösche mit rm / rm -rf + return 0 +} diff --git a/courses/bash/01_navigation_dateien_und_globbing/index.html b/courses/bash/01_navigation_dateien_und_globbing/index.html new file mode 100644 index 0000000..9944213 --- /dev/null +++ b/courses/bash/01_navigation_dateien_und_globbing/index.html @@ -0,0 +1,153 @@ + + + + + + Bash 01: Terminal-Navigation & Globbing + + + +
+
+
+
+
🐧 Linux Bash & Cloud DevOps
+

Bash 01: Terminal-Navigation, Dateioperationen & Globbing

+

Beherrsche den Linux-Dateibaum, lerne blitzschnelle Pfad-Navigation und automatisiere Dateioperationen mit Wildcards und Brace Expansion.

+
+
+ +
+ +
+

🧭 1. Der Unix-Dateibaum & Pfad-Navigation

+

In Unix gibt es keine Laufwerksbuchstaben (wie C: oder D:). Alles entspringt dem Root-Verzeichnis / (Single Root Tree). Wir unterscheiden strikt zwischen absoluten und relativen Pfaden:

+ + 
# Wo bin ich?
+pwd                        # Ausgabe: /home/devops/projects
+
+# Relative vs. Absolute Navigation:
+cd /var/log/nginx          # Absoluter Pfad: Beginnt immer mit '/'
+cd ../../etc               # Relativer Pfad: Zwei Ebenen hoch, dann in 'etc'
+cd ~                       # Wechselt ins Home-Verzeichnis (/home/user)
+cd -                       # Wechselt zum vorherigen Verzeichnis zurück
+
+# Detailliertes Listing mit Berechtigungen und Dateigrößen:
+ls -lah                    # -l: Long Format, -a: Versteckte Dateien, -h: Human-readable (KB/MB)
+
+ + +
+

📁 2. Dateisystem-Operationen & Mächtiges Globbing

+

Als DevOps-Ingenieur erstellst, kopierst und reorganisierst du Konfigurationsdateien im Sekundentakt. Die Shell bietet hierfür mächtige Werkzeuge:

+ + 
# 🎯 1. Verzeichnisse verschachtelt anlegen:
+mkdir -p app/{config,src/{models,views},logs,tests}
+
+# 🎯 2. Dateien mit Brace Expansion massenweise erstellen:
+touch app/src/models/{user,order,payment}.py app/config/{dev,staging,prod}.yaml
+
+# 🎯 3. Shell-Globbing (Wildcards):
+cp app/config/*.yaml /backup/configs/       # Alle .yaml Dateien kopieren
+mv app/logs/app_2026-??.log /archive/logs/  # Matcht genau 2 Zeichen für den Monat (z.B. 01..12)
+rm -rf /tmp/build_cache/                    # Rekursives Löschen ohne Bestätigung
+ +
+
🏢 Didaktische Analogie: Das Logistikzentrum des Betriebssystems
+

Der Dateibaum: Stell dir das Dateisystem wie ein riesiges, strukturiertes Hochregallager vor. / ist der Haupteingang. mkdir -p baut dir sofort eine ganze Gasse mit Fachböden auf.

+

Globbing (* und {a,b}): Anstatt jedes Paket einzeln mit der Hand zu scannen, hältst du eine Schablone hoch: *.yaml greift automatisch alle blauen Kisten aus dem Regal, während {dev,prod} mit einem Handgriff zwei vorgefertigte Etiketten druckt!

+
+
+ + +
+

📑 3. Cheat-Sheet: Navigation & Wildcards

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Befehl / MusterBeispielBedeutung & DevOps-Einsatz
mkdir -p <pfad>mkdir -p /srv/app/releasesErstellt Elternverzeichnisse automatisch ohne Fehler
cp -r <src> <dst>cp -r ./templates /etc/nginx/Kopiert ganze Verzeichnisbäume rekursiv
mv <src> <dst>mv old.env .env.backupVerschiebt oder benennt Dateien atomar um
rm -rf <pfad>rm -rf ./temp_workspaceLöscht rekursiv und erzwingt Löschen ohne Prompt
* (Wildcard)rm -f *.logMatcht 0 oder beliebig viele Zeichen
? (Single Char)ls node_v?.logMatcht exakt ein einziges Zeichen
{a,b,c}touch {app,db}_{1..3}.confBrace Expansion zur raschen Permutationserstellung
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 DevOps Pro-Tipp: Quoting in Shell-Skripten
+

Setze Variablen bei Pfadangaben in Bash-Skripten stets in doppelte Anführungszeichen: "$basis_dir/src/components". Das verhindert gefürchtete Word Splitting Fehler, falls ein Verzeichnisname einmal Leerzeichen enthält!

+
+ +
+ 💻 In Web-IDE öffnen → + Weiter zu Bash 02 → +
+
+
+
+
+ + diff --git a/courses/bash/01_navigation_dateien_und_globbing/musterloesung.sh b/courses/bash/01_navigation_dateien_und_globbing/musterloesung.sh new file mode 100644 index 0000000..366f8eb --- /dev/null +++ b/courses/bash/01_navigation_dateien_und_globbing/musterloesung.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 01: MUSTERLÖSUNG +# ============================================================================== + +erstelle_projektstruktur() { + local basis_dir="$1" + mkdir -p "$basis_dir/src/components" "$basis_dir/src/utils" "$basis_dir/docs/api" "$basis_dir/backup/logs" +} + +erstelle_testdateien() { + local basis_dir="$1" + touch "$basis_dir/src/components/button.js" \ + "$basis_dir/src/components/modal.js" \ + "$basis_dir/src/utils/helper.js" \ + "$basis_dir/docs/api/v1.md" \ + "$basis_dir/docs/api/v2.md" \ + "$basis_dir/app_dev.log" \ + "$basis_dir/app_prod.log" \ + "$basis_dir/config.yaml" +} + +kopiere_konfigurationen() { + local src_dir="$1" + local backup_dir="$2" + mkdir -p "$backup_dir" + cp "$src_dir"/*.yaml "$src_dir"/*.log "$backup_dir/" 2>/dev/null || true +} + +verschiebe_dateien() { + local src_dir="$1" + local target_dir="$2" + mkdir -p "$target_dir" + mv "$src_dir"/docs/api/*.md "$target_dir/" 2>/dev/null || true +} + +bereinige_temporaere_dateien() { + local basis_dir="$1" + rm -f "$basis_dir"/*.log + rm -rf "$basis_dir/backup/logs" +} diff --git a/courses/bash/01_navigation_dateien_und_globbing/test_aufgabe.sh b/courses/bash/01_navigation_dateien_und_globbing/test_aufgabe.sh new file mode 100644 index 0000000..a5256be --- /dev/null +++ b/courses/bash/01_navigation_dateien_und_globbing/test_aufgabe.sh @@ -0,0 +1,125 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 01 - NAVIGATION & GLOBBING +# ============================================================================== + +# Farben für formatierte Terminal-Ausgabe +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 01 - Navigation, Dateioperationen & Globbing${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +# Source Target Script +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +# Temporäres Testverzeichnis anlegen +TEST_ROOT=$(mktemp -d /tmp/bash01_test_XXXXXX) +trap 'rm -rf "$TEST_ROOT"' EXIT + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - erstelle_projektstruktur +run_test "Projektstruktur mit mkdir -p anlegen" ' + WORK="$TEST_ROOT/p1" + mkdir -p "$WORK" + erstelle_projektstruktur "$WORK" + [ -d "$WORK/src/components" ] && \ + [ -d "$WORK/src/utils" ] && \ + [ -d "$WORK/docs/api" ] && \ + [ -d "$WORK/backup/logs" ] +' + +# TEST: Teilziel 2 - erstelle_testdateien +run_test "Testdateien mit Touch und Brace Expansion anlegen" ' + WORK="$TEST_ROOT/p2" + mkdir -p "$WORK/src/components" "$WORK/src/utils" "$WORK/docs/api" "$WORK/backup/logs" + erstelle_testdateien "$WORK" + [ -f "$WORK/src/components/button.js" ] && \ + [ -f "$WORK/src/components/modal.js" ] && \ + [ -f "$WORK/src/utils/helper.js" ] && \ + [ -f "$WORK/docs/api/v1.md" ] && \ + [ -f "$WORK/docs/api/v2.md" ] && \ + [ -f "$WORK/app_dev.log" ] && \ + [ -f "$WORK/app_prod.log" ] && \ + [ -f "$WORK/config.yaml" ] +' + +# TEST: Teilziel 3 - kopiere_konfigurationen +run_test "Konfigurationen und Logs mit Globbing kopieren (*.yaml, *.log)" ' + SRC="$TEST_ROOT/p3_src" + BAK="$TEST_ROOT/p3_bak" + mkdir -p "$SRC" "$BAK" + touch "$SRC/app.log" "$SRC/db.log" "$SRC/settings.yaml" "$SRC/ignore.txt" + kopiere_konfigurationen "$SRC" "$BAK" + [ -f "$BAK/app.log" ] && \ + [ -f "$BAK/db.log" ] && \ + [ -f "$BAK/settings.yaml" ] && \ + [ ! -f "$BAK/ignore.txt" ] +' + +# TEST: Teilziel 4 - verschiebe_dateien +run_test "Dokumentationsdateien (*.md) verschieben" ' + SRC="$TEST_ROOT/p4_src" + ARCH="$TEST_ROOT/p4_arch" + mkdir -p "$SRC/docs/api" "$ARCH" + touch "$SRC/docs/api/guide.md" "$SRC/docs/api/reference.md" "$SRC/docs/api/index.html" + verschiebe_dateien "$SRC" "$ARCH" + [ -f "$ARCH/guide.md" ] && \ + [ -f "$ARCH/reference.md" ] && \ + [ ! -f "$SRC/docs/api/guide.md" ] && \ + [ -f "$SRC/docs/api/index.html" ] +' + +# TEST: Teilziel 5 - bereinige_temporaere_dateien +run_test "Logdateien und backup/logs Ordner bereinigen" ' + WORK="$TEST_ROOT/p5" + mkdir -p "$WORK/backup/logs" "$WORK/keep" + touch "$WORK/error.log" "$WORK/debug.log" "$WORK/keep/safe.txt" "$WORK/backup/logs/old.log" + bereinige_temporaere_dateien "$WORK" + [ ! -f "$WORK/error.log" ] && \ + [ ! -f "$WORK/debug.log" ] && \ + [ ! -d "$WORK/backup/logs" ] && \ + [ -f "$WORK/keep/safe.txt" ] +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 01 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/02_streams_pipes_und_redirection/README.md b/courses/bash/02_streams_pipes_und_redirection/README.md new file mode 100644 index 0000000..a07c8c6 --- /dev/null +++ b/courses/bash/02_streams_pipes_und_redirection/README.md @@ -0,0 +1,56 @@ +# Bash 02: I/O Streams, Pipes & Redirection 🌊 + +Willkommen zu **Modul 02** des Linux Bash & DevOps Lehrpfads! + +In Unix ist alles ein Datenstrom. In diesem Modul lernst du die drei Standard-Dateideskriptoren (`stdin`, `stdout`, `stderr`), mächtige Redirection-Operatoren (`>`, `>>`, `2>`, `&>`), Datenstrom-Verzweigung mit `tee` und strukturierte Textgenerierung mit Here-Documents (`< log.txt # Überschreibt die Datei komplett +echo "Update" >> log.txt # Hängt eine neue Zeile hinten an + +# 2. Fehlerkanal umleiten +command 2> error.log # Leitet nur Fehlermeldungen in error.log +command 2> /dev/null # Unterdrückt alle Fehlermeldungen (Bit-Bucket) +command > all.log 2>&1 # Leitet stdout UND stderr zusammen in all.log +command &> all.log # Moderne Kurzform in Bash für obiges + +# 3. Here-Documents (Mehrzeilige Texte schreiben) +cat < /etc/app.conf +[server] +port = 8080 +mode = production +EOF +``` + +### Pipes & `tee` +- Die Pipe `|` verbindet den `stdout` des linken Befehls mit dem `stdin` des rechten Befehls: `cat data.txt | grep "error" | wc -l`. +- `tee` wirkt wie ein T-Stück im Rohrleitungssystem: Es schreibt den Datenstrom in eine Datei **und** gibt ihn gleichzeitig auf `stdout` weiter (`command | tee output.log | grep ...`). + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`erstelle_system_bericht`)**: Schreibe mit einem Here-Doc (`<` einen strukturierten Header in die Zieldatei. +2. **TODO 2 (`haenge_status_an`)**: Hänge formatierte Statuszeilen mit `>>` an die Logdatei an. +3. **TODO 3 (`trenne_befehls_ausgabe`)**: Führe einen Befehl aus und trenne `stdout` (`1>`) und `stderr` (`2>`) in zwei separate Dateien. +4. **TODO 4 (`unterdruecke_fehler`)**: Führe einen Befehl aus und leite Fehlermeldungen nach `/dev/null` um. +5. **TODO 5 (`pipe_und_tee_pipeline`)**: Baue eine Daten-Pipeline mit Filterung (`grep`), Konvertierung (`tr`), Spiegelung (`tee`) und Sortierung (`sort`). + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/02_streams_pipes_und_redirection/aufgabe.sh b/courses/bash/02_streams_pipes_und_redirection/aufgabe.sh new file mode 100644 index 0000000..5c9035f --- /dev/null +++ b/courses/bash/02_streams_pipes_und_redirection/aufgabe.sh @@ -0,0 +1,59 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 02: I/O STREAMS, PIPES & REDIRECTION +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Erstelle einen System-Bericht per Here-Doc (`<`. +# Schreibe in "$1" folgenden Block (Ersetze "$2" für Server und "$3" für OS): +# === SYSTEM BERICHT === +# SERVER: +# OS: +# STATUS: INITIALISIERT +# ====================== +erstelle_system_bericht() { + local ziel_datei="$1" + local server_name="$2" + local os_typ="$3" + # TODO: Erstelle Bericht mit Here-Doc und Redirection (>) + return 0 +} + +# 🎯 TEILZIEL 2 (TODO 2): Hänge Statusmeldungen mit `>>` an eine bestehende Datei an. +# Formatiere die Ausgabe als: `[STATUS] ` +haenge_status_an() { + local ziel_datei="$1" + local status_meldung="$2" + # TODO: Hänge Meldung mit >> an + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Führe einen Befehl aus und trenne stdout (1>) und stderr (2>). +# Führe `$1` mit eval oder bash -c aus und leite stdout nach "$2" und stderr nach "$3" um. +trenne_befehls_ausgabe() { + local befehl="$1" + local out_datei="$2" + local err_datei="$3" + # TODO: Führe Befehl aus mit getrennten Streams (1> und 2>) + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Führe einen Befehl aus und unterdrücke Fehlermeldungen (2> /dev/null). +# stderr soll nach /dev/null umgeleitet werden, stdout soll ganz normal ausgegeben werden. +unterdruecke_fehler() { + local befehl="$1" + # TODO: Führe befehl aus, leite stderr nach /dev/null + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Baue eine Stream-Pipeline mit Filterung, Großschreibung, `tee` und `sort`. +# 1. Nimm $1 als Eingabestrom +# 2. Filtere Kommentarzeilen heraus, die mit '#' beginnen (grep -v '^#') +# 3. Wandle alles in Großbuchstaben um (tr '[:lower:]' '[:upper:]') +# 4. Speichere das Zwischenergebnis mit `tee "$2"` in die Logdatei +# 5. Gib das Endergebnis alphabetisch sortiert (`sort`) auf stdout aus. +pipe_und_tee_pipeline() { + local eingabe_text="$1" + local tee_datei="$2" + # TODO: Implementiere die Pipeline mit |, tee und sort + return 0 +} diff --git a/courses/bash/02_streams_pipes_und_redirection/index.html b/courses/bash/02_streams_pipes_und_redirection/index.html new file mode 100644 index 0000000..4b68581 --- /dev/null +++ b/courses/bash/02_streams_pipes_und_redirection/index.html @@ -0,0 +1,155 @@ + + + + + + Bash 02: I/O Streams, Pipes & Redirection + + + +
+
+
+
+
🐧 Linux Bash & Cloud DevOps
+

Bash 02: I/O Streams, Pipes & Redirection

+

Lerne die drei Unix-Standard-Streams kennen, trenne stdout von stderr, lenke Datenflüsse um und baue robuste Pipelines mit tee.

+
+
+ +
+ +
+

🔀 1. Die drei Unix-Datenströme (File Descriptors)

+

Jeder Prozess unter Linux startet automatisch mit drei offenen Dateideskriptoren (FDs):

+ + 
FD 0: stdin  (Standard-Eingabe)  <-- Tastatur oder Pipe
+FD 1: stdout (Standard-Ausgabe)  --> Terminal-Display
+FD 2: stderr (Standard-Fehler)   --> Terminal-Display (getrennter Kanal!)
+
+# Stream-Umleitungen in der Praxis:
+./backup.sh > backup.log           # Leitet nur stdout (FD 1) um
+./backup.sh 2> errors.log          # Leitet nur Fehlermeldungen (FD 2) um
+./backup.sh > all.log 2>&1         # Leitet stdout und stderr in die gleiche Datei
+./backup.sh 2> /dev/null           # Schmeißt alle Fehler ins digitale Nirwana
+
+ + +
+

🌊 2. Unix-Pipelines, tee & Here-Docs

+

Die Unix-Philosophie lautet: "Schreibe Programme, die genau eine Sache gut machen, und kombiniere sie über Streams."

+ + 
# 🎯 1. Datenstrom verketten mit Pipe (|):
+cat /var/log/nginx/access.log | grep "404" | cut -d' ' -f1 | sort | uniq -c
+
+# 🎯 2. Datenstrom abzweigen mit 'tee':
+echo "Deployment gestartet" | tee -a deployment.log
+
+# 🎯 3. Mehrzeilige Konfigurationen mit Here-Docs (< /etc/docker/daemon.json
+{
+  "log-driver": "json-file",
+  "log-opts": { "max-size": "10m" }
+}
+EOF
+ +
+
🚰 Didaktische Analogie: Das Wasserleitungssystem
+

Die Rohre (|): Ein Rohr verbindet den Ausfluss des einen Beckens direkt mit dem Einlauf des nächsten Filters.

+

Das T-Stück (tee): Wie ein Installateur-T-Stück zweigt tee das fließende Wasser gleichzeitig in eine Vorratsflasche (Datei) ab, während der Hauptstrahl ungebremst weiter durch den Garten (stdout) fließt!

+
+
+ + +
+

📑 3. Cheat-Sheet: Stream-Operatoren

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorBeispielBedeutung & Verhalten
> dateiecho "test" > out.txtLeitet stdout um und überschreibt die Datei
>> dateiecho "new line" >> out.txtLeitet stdout um und hängt an
2> dateicmd 2> error.logLeitet nur stderr in die Datei um
2>&1cmd > out.log 2>&1Dupliziert stderr auf stdout
| (Pipe)cat log | grep ERRVerbindet stdout von Links mit stdin von Rechts
tee dateicmd | tee -a run.logSchreibt in Datei und leitet weiter auf stdout
<<EOFcat <<EOF ... EOFHere-Document für saubere mehrzeilige Textblöcke
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 DevOps Pro-Tipp: Cronjob-Ausgaben bündeln
+

In Produktions-Cronjobs solltest du stets 0 2 * * * /opt/backup.sh >> /var/log/backup.log 2>&1 verwenden. So gehen dir weder Statusmeldungen noch kritische Fehlerursachen im Logfile verloren!

+
+ + +
+
+
+
+ + diff --git a/courses/bash/02_streams_pipes_und_redirection/musterloesung.sh b/courses/bash/02_streams_pipes_und_redirection/musterloesung.sh new file mode 100644 index 0000000..b475b64 --- /dev/null +++ b/courses/bash/02_streams_pipes_und_redirection/musterloesung.sh @@ -0,0 +1,42 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 02: MUSTERLÖSUNG +# ============================================================================== + +erstelle_system_bericht() { + local ziel_datei="$1" + local server_name="$2" + local os_typ="$3" + + cat < "$ziel_datei" +=== SYSTEM BERICHT === +SERVER: $server_name +OS: $os_typ +STATUS: INITIALISIERT +====================== +EOF +} + +haenge_status_an() { + local ziel_datei="$1" + local status_meldung="$2" + echo "[STATUS] $status_meldung" >> "$ziel_datei" +} + +trenne_befehls_ausgabe() { + local befehl="$1" + local out_datei="$2" + local err_datei="$3" + eval "$befehl" > "$out_datei" 2> "$err_datei" +} + +unterdruecke_fehler() { + local befehl="$1" + eval "$befehl" 2> /dev/null +} + +pipe_und_tee_pipeline() { + local eingabe_text="$1" + local tee_datei="$2" + printf "%s\n" "$eingabe_text" | grep -v '^#' | tr '[:lower:]' '[:upper:]' | tee "$tee_datei" | sort +} diff --git a/courses/bash/02_streams_pipes_und_redirection/test_aufgabe.sh b/courses/bash/02_streams_pipes_und_redirection/test_aufgabe.sh new file mode 100644 index 0000000..8edc2b9 --- /dev/null +++ b/courses/bash/02_streams_pipes_und_redirection/test_aufgabe.sh @@ -0,0 +1,123 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 02 - STREAMS, PIPES & REDIRECTION +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 02 - Streams, Pipes & Redirection${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +TEST_ROOT=$(mktemp -d /tmp/bash02_test_XXXXXX) +trap 'rm -rf "$TEST_ROOT"' EXIT + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - erstelle_system_bericht +run_test "System-Bericht mit Here-Doc und Redirection schreiben" ' + REPORT="$TEST_ROOT/report.txt" + erstelle_system_bericht "$REPORT" "prod-web-01" "Ubuntu 24.04" + [ -f "$REPORT" ] && \ + grep -q "=== SYSTEM BERICHT ===" "$REPORT" && \ + grep -q "SERVER: prod-web-01" "$REPORT" && \ + grep -q "OS: Ubuntu 24.04" "$REPORT" && \ + grep -q "STATUS: INITIALISIERT" "$REPORT" +' + +# TEST: Teilziel 2 - haenge_status_an +run_test "Statuszeile mit >> an bestehende Datei anhaengen" ' + LOG="$TEST_ROOT/app.log" + echo "HEADER" > "$LOG" + haenge_status_an "$LOG" "Database connection established" + haenge_status_an "$LOG" "Listening on port 8080" + grep -q "\[STATUS\] Database connection established" "$LOG" && \ + grep -q "\[STATUS\] Listening on port 8080" "$LOG" && \ + [ "$(wc -l < "$LOG")" -eq 3 ] +' + +# TEST: Teilziel 3 - trenne_befehls_ausgabe +run_test "Standard Output (1>) und Error (2>) sauber trennen" ' + OUT="$TEST_ROOT/out.log" + ERR="$TEST_ROOT/err.log" + CMD="{ echo \"Erfolgreicher Job\"; echo \"Fehlerhafter Zugriff\" >&2; }" + trenne_befehls_ausgabe "$CMD" "$OUT" "$ERR" + grep -q "Erfolgreicher Job" "$OUT" && \ + grep -q "Fehlerhafter Zugriff" "$ERR" && \ + ! grep -q "Fehlerhafter Zugriff" "$OUT" && \ + ! grep -q "Erfolgreicher Job" "$ERR" +' + +# TEST: Teilziel 4 - unterdruecke_fehler +run_test "Fehlermeldungen nach /dev/null umleiten" ' + CMD="{ echo \"Wichtige Ausgabe\"; echo \"Warnung 404\" >&2; }" + OUTPUT=$(unterdruecke_fehler "$CMD") + [ "$OUTPUT" = "Wichtige Ausgabe" ] +' + +# TEST: Teilziel 5 - pipe_und_tee_pipeline +run_test "Pipeline mit Filter, Uppercase, tee und sort" ' + RAW=$'\ +# Ignore comment\n\ +nginx\n\ +docker\n\ +# Another comment\n\ +apache\n\ +redis' + TEE_FILE="$TEST_ROOT/tee_output.log" + FINAL_OUT=$(pipe_und_tee_pipeline "$RAW" "$TEE_FILE") + + # Pruefe Tee-Datei (ungestrichen, uppercase) + [ -f "$TEE_FILE" ] && \ + grep -q "NGINX" "$TEE_FILE" && \ + grep -q "DOCKER" "$TEE_FILE" && \ + ! grep -q "#" "$TEE_FILE" && \ + + # Pruefe Endausgabe (sortiert) + FIRST_LINE=$(echo "$FINAL_OUT" | head -n 1) + LAST_LINE=$(echo "$FINAL_OUT" | tail -n 1) + [ "$FIRST_LINE" = "APACHE" ] && [ "$LAST_LINE" = "REDIS" ] +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 02 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/03_variablen_environment_und_subshells/README.md b/courses/bash/03_variablen_environment_und_subshells/README.md new file mode 100644 index 0000000..9c60b31 --- /dev/null +++ b/courses/bash/03_variablen_environment_und_subshells/README.md @@ -0,0 +1,55 @@ +# Bash 03: Variablen, Environment, Expansion & Arithmetik ⚡ + +Willkommen zu **Modul 03** des Linux Bash & DevOps Lehrpfads! + +In diesem Modul meisterst du lokale vs. globale Umgebungsvariablen (`export`, `$PATH`), Subshells vs. Current-Shell, moderne Command Substitution (`$(...)`), mächtige native String-Manipulationen per Parameter Expansion und Ganzzahl-Arithmetik (`$(( ... ))`). + +--- + +## 💡 1. Das Wichtigste in Kürze + +### Lokale Variablen vs. `export` +- Lokale Variablen (`NAME="Wert"`) existieren nur in der aktuellen Shell-Instanz. +- Mit `export NAME="Wert"` wird die Variable an alle Kind-Prozesse (Subshells, Skripte, CLI-Programme) vererbt. +- `$PATH` ist die durch Doppelpunkte getrennte Liste von Verzeichnissen, in denen die Shell nach ausführbaren Programmen sucht (`export PATH="/opt/bin:$PATH"`). + +### Command Substitution `$(...)` +Führt ein Shell-Kommando aus und ersetzt den Ausdruck durch dessen `stdout`: +```bash +AKTUELLER_USER=$(whoami) +HEUTIGES_DATUM=$(date +%Y-%m-%d) +BACKUP_NAME="backup_${AKTUELLER_USER}_${HEUTIGES_DATUM}.tar.gz" +``` + +### Native Parameter Expansion (Kein `sed`/`awk` nötig!) +Bash kann Strings intern extrem schnell und speicherschonend manipulieren: +- **Default-Wert**: `${VAR:-"standardwert"}` (nutzt Fallback, falls `$VAR` nicht gesetzt/leer) +- **Präfix entfernen**: `${PFAD#*/}` (kürzester Treffer) bzw. `${PFAD##*/}` (längster Treffer -> Dateiname) +- **Suffix entfernen**: `${PFAD%/*}` (Verzeichnis) bzw. `${DATEI%.*}` (Dateiname ohne Endung) +- **String-Länge**: `${#VAR}` + +### Shell-Arithmetik `$(( ... ))` +Für Ganzzahl-Berechnungen in nativer C-Geschwindigkeit: +```bash +SUMME=$(( 10 + 25 )) +PROZENT=$(( (USED * 100) / TOTAL )) +REST=$(( 17 % 5 )) # Modulo = 2 +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`setze_umgebungsvariable`)**: Exportiere eine Umgebungsvariable dynamisch und gib sie als `NAME=WERT` zurück. +2. **TODO 2 (`generiere_system_kennung`)**: Baue per `$(...)` eine Kennung im Format `user@host_YYYY-MM`. +3. **TODO 3 (`zerlege_dateipfad`)**: Extrahiere DIR, FILE, EXT und BASE ausschließlich mit nativer Bash Parameter Expansion (`${var#...}`, `${var%...}`). +4. **TODO 4 (`ermittle_konfigurationswert`)**: Gib den übergebenen Wert oder den Fallback mit `${var:-fallback}` zurück. +5. **TODO 5 (`berechne_disk_quota`)**: Berechne freien Speicher und prozentuale Belegung mit `$(( ... ))`. + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/03_variablen_environment_und_subshells/aufgabe.sh b/courses/bash/03_variablen_environment_und_subshells/aufgabe.sh new file mode 100644 index 0000000..5375be2 --- /dev/null +++ b/courses/bash/03_variablen_environment_und_subshells/aufgabe.sh @@ -0,0 +1,56 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 03: VARIABLEN, ENVIRONMENT, EXPANSION & ARITHMETIK +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Exportiere eine Umgebungsvariable dynamisch. +# Setze und exportiere "$1" mit dem Wert "$2" und gib den String "$1=$2" auf stdout aus. +setze_umgebungsvariable() { + local name="$1" + local wert="$2" + # TODO: Exportiere die Variable und gib "NAME=WERT" aus + return 0 +} + +# 🎯 TEILZIEL 2 (TODO 2): Nutze Command Substitution $(...) für eine System-Kennung. +# Kombiniere $(whoami), $(hostname) und $(date +%Y-%m) im Format: +# "USER@HOST_YYYY-MM" +generiere_system_kennung() { + # TODO: Erzeuge und gib die Kennung per Command Substitution $(...) aus + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Dateipfad mit reiner Bash Parameter Expansion zerlegen. +# Extrahiere aus "$1" (z.B. "/var/log/nginx/access.log"): +# - Verzeichnis (DIR): z.B. /var/log/nginx +# - Dateiname (FILE): z.B. access.log +# - Endung (EXT): z.B. log +# - Basisname ohne Endung (BASE): z.B. access +# Ausgabeformat: "DIR: | FILE: | EXT: | BASE: " +# ⚠️ WICHTIG: Verwende keine externen Tools (kein basename, dirname, sed, awk)! +zerlege_dateipfad() { + local voller_pfad="$1" + # TODO: Nutze ${pfad%/*}, ${pfad##*/}, ${datei##*.}, ${datei%.*} + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Parameter Expansion mit Standardwerten (${var:-default}). +# Gib "$1" zurück. Wenn "$1" leer oder nicht gesetzt ist, gib "$2" (Fallback) zurück. +ermittle_konfigurationswert() { + local wert="$1" + local fallback="$2" + # TODO: Nutze Parameter Expansion mit Default-Wert + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Quota-Berechnung mit Shell-Arithmetik $(( ... )). +# Berechne aus "$1" (total_mb) und "$2" (used_mb): +# - freier Speicher: total_mb - used_mb +# - Prozentuale Belegung (Ganzzahl): (used_mb * 100) / total_mb +# Ausgabeformat: "TOTAL: MB, USED: MB (%), FREE: MB" +berechne_disk_quota() { + local total_mb="$1" + local used_mb="$2" + # TODO: Berechne freie MB und Prozent per $(( ... )) + return 0 +} diff --git a/courses/bash/03_variablen_environment_und_subshells/index.html b/courses/bash/03_variablen_environment_und_subshells/index.html new file mode 100644 index 0000000..5d65f52 --- /dev/null +++ b/courses/bash/03_variablen_environment_und_subshells/index.html @@ -0,0 +1,154 @@ + + + + + + Bash 03: Variablen, Environment & Subshells + + + +
+
+
+
+
🐧 Linux Bash & Cloud DevOps
+

Bash 03: Variablen, Environment & Subshells

+

Verstehe Prozess-Umgebungen, vererbe Variablen mit export, nutze Command Substitution und meistere native String-Parameter-Expansion.

+
+
+ +
+ +
+

🔐 1. Variablen, Vererbung & export

+

Variablen in der Shell werden ohne Leerzeichen um das Gleichheitszeichen herum zugewiesen. Mit export wandern sie in die Prozesstabelle aller Subprozesse:

+ + 
# ⚠️ Keine Leerzeichen bei der Zuweisung!
+SERVICE="auth-api"          # Lokal: Nur in dieser Shell verfügbar
+export PORT=8080            # Global: An alle Kind-Prozesse (z.B. node, python, skripte) vererbt
+
+# Die wichtigste Variable: $PATH
+echo $PATH                  # /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/bin
+export PATH="/opt/tools/bin:$PATH"  # Suchpfad für eigene DevOps-Skripte erweitern
+
+ + +
+

⚙️ 2. Parameter Expansion & Command Substitution

+

Moderne Shell-Programmierung vermeidet langsame externe Tool-Aufrufe, wo immer Bash es nativ lösen kann:

+ + 
# 🎯 1. Command Substitution $(...):
+HOST=$(hostname)
+UPTIME=$(uptime -p)
+
+# 🎯 2. Parameter Expansion (Strings zerlegen & Fallbacks):
+DATEI="/var/log/nginx/access.log"
+echo ${DATEI%/*}      # /var/log/nginx  (Suffix ab letztem '/' abschneiden)
+echo ${DATEI##*/}     # access.log      (Präfix bis zum letzten '/' abschneiden)
+echo ${DATEI##*.}     # log             (Dateiendung)
+
+# 🎯 3. Default-Werte:
+PORT=${CUSTOM_PORT:-8080}   # Nutzt 8080, falls CUSTOM_PORT nicht gesetzt ist
+
+# 🎯 4. Shell-Arithmetik $(( ... )):
+FREE_RAM=$(( TOTAL_RAM - USED_RAM ))
+ +
+
🧬 Didaktische Analogie: Vererbung in der Prozesstabelle
+

Lokale Variable vs. export: Eine lokale Variable ist wie ein Notizzettel in deiner Jackentasche – nur du kannst ihn lesen. Wenn du mit export arbeitest, machst du den Zettel zu einer DNA-Eigenschaft, die jedes Kind (jeder Subprozess) bei der Geburt automatisch mitbekommt!

+
+
+ + +
+

📑 3. Cheat-Sheet: Parameter-Expansion & Arithmetik

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SyntaxBeispielErgebnis / Zweck
$(cmd)USER=$(whoami)Fängt Standardausgabe des Befehls ein
${var:-fallback}${CLUSTER:-"prod"}Nutzt Fallback, falls $CLUSTER leer/ungesetzt
${var##*/}${P##*/}Entfernt längstes Präfix bis / (Basename)
${var%/*}${P%/*}Entfernt kürzestes Suffix ab / (Dirname)
${var%.*}${file%.*}Entfernt Dateiendung
${#var}${#str}Länge des Strings in Anzahl Zeichen
$((a + b))$(( (a * 100) / b ))Native Ganzzahl-Arithmetik
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 Performance-Tipp: Subprozesse einsparen
+

Vermeide basename "$FILE" und dirname "$FILE" in Schleifen über Millionen Dateien! Native Parameter Expansion wie ${FILE##*/} läuft in Nanosekunden direkt im Bash-C-Core ohne Prozess-Forking.

+
+ + +
+
+
+
+ + diff --git a/courses/bash/03_variablen_environment_und_subshells/musterloesung.sh b/courses/bash/03_variablen_environment_und_subshells/musterloesung.sh new file mode 100644 index 0000000..4980fea --- /dev/null +++ b/courses/bash/03_variablen_environment_und_subshells/musterloesung.sh @@ -0,0 +1,42 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 03: MUSTERLÖSUNG +# ============================================================================== + +setze_umgebungsvariable() { + local name="$1" + local wert="$2" + export "$name"="$wert" + echo "$name=$wert" +} + +generiere_system_kennung() { + local u h d + u=$(whoami) + h=$(hostname) + d=$(date +%Y-%m) + echo "${u}@${h}_${d}" +} + +zerlege_dateipfad() { + local voller_pfad="$1" + local verzeichnis="${voller_pfad%/*}" + local dateiname="${voller_pfad##*/}" + local extension="${dateiname##*.}" + local basisname="${dateiname%.*}" + echo "DIR: $verzeichnis | FILE: $dateiname | EXT: $extension | BASE: $basisname" +} + +ermittle_konfigurationswert() { + local wert="$1" + local fallback="$2" + echo "${wert:-$fallback}" +} + +berechne_disk_quota() { + local total_mb="$1" + local used_mb="$2" + local free_mb=$(( total_mb - used_mb )) + local prozent=$(( (used_mb * 100) / total_mb )) + echo "TOTAL: ${total_mb}MB, USED: ${used_mb}MB (${prozent}%), FREE: ${free_mb}MB" +} diff --git a/courses/bash/03_variablen_environment_und_subshells/test_aufgabe.sh b/courses/bash/03_variablen_environment_und_subshells/test_aufgabe.sh new file mode 100644 index 0000000..3ef0146 --- /dev/null +++ b/courses/bash/03_variablen_environment_und_subshells/test_aufgabe.sh @@ -0,0 +1,94 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 03 - VARIABLEN & ENVIRONMENT +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 03 - Variablen, Environment & Expansion${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - setze_umgebungsvariable +run_test "Umgebungsvariable exportieren und formatieren" ' + OUT=$(setze_umgebungsvariable "APP_ENV" "staging_cluster") + setze_umgebungsvariable "APP_ENV" "staging_cluster" > /dev/null + [ "$OUT" = "APP_ENV=staging_cluster" ] && \ + [ "$APP_ENV" = "staging_cluster" ] +' + +# TEST: Teilziel 2 - generiere_system_kennung +run_test "System-Kennung mit Command Substitution" ' + KENNUNG=$(generiere_system_kennung) + EXPECTED="$(whoami)@$(hostname)_$(date +%Y-%m)" + [ "$KENNUNG" = "$EXPECTED" ] +' + +# TEST: Teilziel 3 - zerlege_dateipfad +run_test "Pfadzerlegung mit reiner Bash Parameter Expansion" ' + RES1=$(zerlege_dateipfad "/var/log/nginx/access.log") + RES2=$(zerlege_dateipfad "/etc/systemd/system/app.service") + [ "$RES1" = "DIR: /var/log/nginx | FILE: access.log | EXT: log | BASE: access" ] && \ + [ "$RES2" = "DIR: /etc/systemd/system | FILE: app.service | EXT: service | BASE: app" ] +' + +# TEST: Teilziel 4 - ermittle_konfigurationswert +run_test "Parameter Expansion mit Standardwert" ' + VAL1=$(ermittle_konfigurationswert "production" "development") + VAL2=$(ermittle_konfigurationswert "" "development") + [ "$VAL1" = "production" ] && \ + [ "$VAL2" = "development" ] +' + +# TEST: Teilziel 5 - berechne_disk_quota +run_test "Speicherberechnung mit Shell-Arithmetik" ' + OUT=$(berechne_disk_quota 1000 250) + [ "$OUT" = "TOTAL: 1000MB, USED: 250MB (25%), FREE: 750MB" ] && \ + OUT2=$(berechne_disk_quota 2048 1024) && \ + [ "$OUT2" = "TOTAL: 2048MB, USED: 1024MB (50%), FREE: 1024MB" ] +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 03 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/README.md b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/README.md new file mode 100644 index 0000000..531e615 --- /dev/null +++ b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/README.md @@ -0,0 +1,59 @@ +# Bash 04: Dateirechte (chmod) & Prozesskontrolle 🛡️ + +Willkommen zu **Modul 04** des Linux Bash & DevOps Lehrpfads! + +In diesem Modul lernst du das Unix-Berechtigungssystem (`chmod`, `chown`, Oktal vs. Symbolisch), Prozessanalyse (`ps aux`), Signal-Handling (`kill -15` vs. `kill -9`, `kill -0`) und asynchrone Job-Control (`&`, `$!`, `jobs`) kennen. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### Unix-Dateirechte (Oktal-Modell) +Jede Datei besitzt Rechte für drei Entitäten: **User (u)**, **Group (g)** und **Others (o)**. +- `r` (Read) = 4 +- `w` (Write) = 2 +- `x` (Execute) = 1 + +| Modus | Bedeutung | Typischer Einsatzzweck | +|---|---|---| +| `755` | `rwxr-xr-x` | Ausführbare Skripte, Binaries, Ordner | +| `644` | `rw-r--r--` | Standard-Dateien, Konfigurationen | +| `600` | `rw-------` | Sensible Secrets, SSH Private Keys | +| `700` | `rwx------` | Private Verzeichnisse (`~/.ssh`, `~/.gnupg`) | + +### Prozessüberwachung & Signale +- `ps aux` / `pgrep `: Zeigt alle laufenden Prozesse an. +- `kill -0 `: Sendet ein Null-Signal zum Testen der Existenz (Exit-Code 0 = Prozess existiert und antwortet). +- `kill -15 ` (**SIGTERM**): Bittet den Prozess höflich, sich sauber zu beenden (Ressourcen schließen, Buffer flushen). +- `kill -9 ` (**SIGKILL**): Zwingt den Linux-Kernel, den Prozess sofort und unweigerlich zu terminieren. + +### Job-Control & Hintergrundprozesse +```bash +# 1. Befehl im Hintergrund starten: +./backup.sh & + +# 2. PID des zuletzt gestarteten Hintergrundprozesses: +PID=$! +echo "Backup läuft unter PID $PID" + +# 3. Auf Beendigung warten: +wait $PID +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`setze_sichere_rechte`)**: Setze per `chmod` die Rechte nach Vorgabe (`secret` -> 600, `script` -> 755, `config` -> 644). +2. **TODO 2 (`lese_oktal_rechte`)**: Lies die Oktalrechte mit `stat -c "%a"` aus. +3. **TODO 3 (`starte_hintergrund_prozess`)**: Starte `sleep` im Hintergrund mit `&` und gib die PID (`$!`) zurück. +4. **TODO 4 (`ist_prozess_am_leben`)**: Prüfe die Prozess-Existenz mit `kill -0`. +5. **TODO 5 (`stoppe_prozess_mit_fallback`)**: Sende SIGTERM (15), warte kurz und erzwinge bei Bedarf SIGKILL (9). + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/aufgabe.sh b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/aufgabe.sh new file mode 100644 index 0000000..6e224c6 --- /dev/null +++ b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/aufgabe.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 04: DATEIRECHTE (CHMOD), PROZESSKONTROLLE & JOB CONTROL +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Setze Dateirechte mit `chmod` basierend auf dem Zweck. +# - Wenn "$2" == "secret" -> chmod 600 "$1" und gib "600" aus +# - Wenn "$2" == "script" -> chmod 755 "$1" und gib "755" aus +# - Wenn "$2" == "config" -> chmod 644 "$1" und gib "644" aus +# - Sonst -> chmod 644 "$1" und gib "644" aus +setze_sichere_rechte() { + local datei="$1" + local modus_typ="$2" + # TODO: Setze Rechte per chmod und gib den Oktalwert aus + return 0 +} + +# 🎯 TEILZIEL 2 (TODO 2): Lese die Dateirechte als 3-stellige Oktalzahl aus. +# Nutze `stat -c "%a" "$1"` und gib den Wert aus (z.B. "755"). +lese_oktal_rechte() { + local datei="$1" + # TODO: Lese Oktalrechte per stat aus + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Starte einen Prozess im Hintergrund mit `&`. +# Starte `sleep "$1" &`, ermittle die Prozess-ID mit `$!` und gib die PID aus. +starte_hintergrund_prozess() { + local dauer_sek="$1" + # TODO: Starte sleep im Hintergrund und gib $! zurück + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Prüfe, ob eine PID noch aktiv ist (Signal 0). +# Nutze `kill -0 "$1" 2>/dev/null`. +# Gib Return-Code 0 zurück, wenn der Prozess läuft, sonst 1. +ist_prozess_am_leben() { + local pid="$1" + # TODO: Prüfe Prozess-Existenz mit kill -0 + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Beende einen Prozess sanft (SIGTERM 15) mit Fallback (SIGKILL 9). +# 1. Sende `kill -15 "$1"` (SIGTERM) +# 2. Warte kurz (sleep 0.1) +# 3. Wenn Prozess immer noch lebt (kill -0), sende `kill -9 "$1"` (SIGKILL) +# Gib 0 zurück. +stoppe_prozess_mit_fallback() { + local pid="$1" + # TODO: Sende Signal 15, prüfe und sende bei Bedarf Signal 9 + return 0 +} diff --git a/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/index.html b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/index.html new file mode 100644 index 0000000..4eebf6f --- /dev/null +++ b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/index.html @@ -0,0 +1,156 @@ + + + + + + Bash 04: Dateirechte & Prozesskontrolle + + + +
+
+
+
+
🐧 Linux Bash & Cloud DevOps
+

Bash 04: Dateirechte (chmod), Signale & Job Control

+

Schütze Serverdateien mit präzisen Berechtigungen (600/755), verwalte Hintergrund-Jobs und meistere Signal-Handling für resiliente Daemons.

+
+
+ +
+ +
+

🔐 1. Das Unix-Rechtemodell (Oktal & Symbolisch)

+

Unix unterscheidet drei Rollen (Owner, Group, Others) mit drei Grundrechten (Read=4, Write=2, Execute=1):

+ + 
# 🎯 Oktale Rechtezuweisung:
+chmod 755 deploy.sh        # rwxr-xr-x: Jeder darf ausführen, nur Owner darf schreiben
+chmod 644 config.yaml      # rw-r--r--: Standard für Webserver-Assets
+chmod 600 id_ed25519       # rw-------: Streng geheim (SSH Private Key)
+
+# 🎯 Symbolische Anpassung:
+chmod u+x script.sh        # Fügt Execute-Recht für den User hinzu
+chmod g-w shared.doc       # Entzieht Schreibrecht für die Gruppe
+
+ + +
+

⚡ 2. Prozess-Signale & Asynchrone Job Control

+

Im Serverbetrieb laufen Hintergrunddienste asynchron. Über Signale kommuniziert der Administrator direkt mit dem Kernel:

+ + 
# 🎯 1. Job im Hintergrund starten (&):
+./data_importer.sh > import.log 2>&1 &
+PID=$!                     # Fängt die Prozess-ID des Hintergrundjobs ab
+
+# 🎯 2. Prozess-Existenz ohne Unterbrechung prüfen:
+if kill -0 "$PID" 2>/dev/null; then
+  echo "Prozess läuft noch..."
+fi
+
+# 🎯 3. Graceful Shutdown mit Fallback:
+kill -15 "$PID"            # SIGTERM: Sauberes Beenden anfordern
+sleep 1
+if kill -0 "$PID" 2>/dev/null; then
+  kill -9 "$PID"           # SIGKILL: Notaus-Schalter (kann nicht ignoriert werden)
+fi
+ +
+
🚪 Didaktische Analogie: Hausordnung & Notaus-Schalter
+

Dateirechte (chmod 600): Das ist dein persönliches Bankschließfach. Nur du hast den Schlüssel (6=Read/Write), niemand sonst darf auch nur hineinsehen (0=No Access).

+

SIGTERM vs. SIGKILL: kill -15 ist das Klopfen an der Tür mit der Bitte, das Gebäude geordnet zu verlassen. kill -9 ist die Feuerwehr, die sofort die Sicherungen herausdreht und das Wasser abstellt!

+
+
+ + +
+

📑 3. Cheat-Sheet: Rechte & Signale

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BefehlSyntax / SignalBeschreibung
chmod 600rw-------Schutz für Private Keys & Secrets
chmod 755rwxr-xr-xStandard für ausführbare Skripte
&cmd &Startet Befehl asynchron im Hintergrund
$!PID=$!PID des zuletzt im Hintergrund gestarteten Prozesses
kill -0kill -0 $PIDTestet Prozess-Existenz (kein Abbruch)
SIGTERM (15)kill -15 $PIDGeordnetes Beenden mit Ressourcen-Cleanup
SIGKILL (9)kill -9 $PIDSofortiger harter Kernel-Abbruch
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 DevOps Pro-Tipp: SSH Private Key Permissions
+

OpenSSH verweigert strikt die Verbindung, wenn deine Private Keys nicht auf chmod 600 stehen ("UNPROTECTED PRIVATE KEY FILE!"). Automatisiere diese Prüfung in deinen CI/CD-Pipelines!

+
+ + +
+
+
+
+ + diff --git a/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/musterloesung.sh b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/musterloesung.sh new file mode 100644 index 0000000..56a9475 --- /dev/null +++ b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/musterloesung.sh @@ -0,0 +1,51 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 04: MUSTERLÖSUNG +# ============================================================================== + +setze_sichere_rechte() { + local datei="$1" + local modus_typ="$2" + local octal="644" + + case "$modus_typ" in + secret) + octal="600" + ;; + script) + octal="755" + ;; + config|*) + octal="644" + ;; + esac + + chmod "$octal" "$datei" + echo "$octal" +} + +lese_oktal_rechte() { + local datei="$1" + stat -c "%a" "$datei" 2>/dev/null || stat -f "%OLp" "$datei" 2>/dev/null +} + +starte_hintergrund_prozess() { + local dauer_sek="$1" + sleep "$dauer_sek" & + echo $! +} + +ist_prozess_am_leben() { + local pid="$1" + kill -0 "$pid" 2>/dev/null +} + +stoppe_prozess_mit_fallback() { + local pid="$1" + kill -15 "$pid" 2>/dev/null || true + sleep 0.1 + if kill -0 "$pid" 2>/dev/null; then + kill -9 "$pid" 2>/dev/null || true + fi + return 0 +} diff --git a/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/test_aufgabe.sh b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/test_aufgabe.sh new file mode 100644 index 0000000..0a03962 --- /dev/null +++ b/courses/bash/04_dateirechte_prozesskontrolle_und_jobs/test_aufgabe.sh @@ -0,0 +1,109 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 04 - DATEIRECHTE & PROZESSE +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 04 - Dateirechte & Prozesskontrolle${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +TEST_ROOT=$(mktemp -d /tmp/bash04_test_XXXXXX) +trap 'rm -rf "$TEST_ROOT"' EXIT + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - setze_sichere_rechte +run_test "Dateirechte per chmod setzen (600, 755, 644)" ' + KEY="$TEST_ROOT/id_rsa" + SH="$TEST_ROOT/deploy.sh" + CONF="$TEST_ROOT/app.conf" + touch "$KEY" "$SH" "$CONF" + + R1=$(setze_sichere_rechte "$KEY" "secret") + R2=$(setze_sichere_rechte "$SH" "script") + R3=$(setze_sichere_rechte "$CONF" "config") + + [ "$R1" = "600" ] && [ "$R2" = "755" ] && [ "$R3" = "644" ] +' + +# TEST: Teilziel 2 - lese_oktal_rechte +run_test "Oktalrechte mit stat auslesen" ' + FILE="$TEST_ROOT/test_stat.txt" + touch "$FILE" + chmod 755 "$FILE" + MODE=$(lese_oktal_rechte "$FILE") + [ "$MODE" = "755" ] +' + +# TEST: Teilziel 3 - starte_hintergrund_prozess +run_test "Prozess im Hintergrund starten (&) und PID erfassen (\$!)" ' + PID=$(starte_hintergrund_prozess 5) + # PID muss eine valide Zahl sein und Prozess muss existieren + [[ "$PID" =~ ^[0-9]+$ ]] && kill -0 "$PID" 2>/dev/null && kill -9 "$PID" 2>/dev/null +' + +# TEST: Teilziel 4 - ist_prozess_am_leben +run_test "Prozess-Existenz pruefen mit kill -0" ' + sleep 5 & + PID=$! + ist_prozess_am_leben "$PID" + ALIVE=$? + kill -9 "$PID" 2>/dev/null + wait "$PID" 2>/dev/null || true + ist_prozess_am_leben "$PID" + DEAD=$? + [ "$ALIVE" -eq 0 ] && [ "$DEAD" -ne 0 ] +' + +# TEST: Teilziel 5 - stoppe_prozess_mit_fallback +run_test "Prozess sanft beenden mit Fallback (Signal 15 / Signal 9)" ' + sleep 10 & + PID=$! + stoppe_prozess_mit_fallback "$PID" + ! kill -0 "$PID" 2>/dev/null +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 04 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/05_kontrollfluss_und_testoperatoren/README.md b/courses/bash/05_kontrollfluss_und_testoperatoren/README.md new file mode 100644 index 0000000..4c38eb5 --- /dev/null +++ b/courses/bash/05_kontrollfluss_und_testoperatoren/README.md @@ -0,0 +1,67 @@ +# Bash 05: Kontrollfluss, Test-Operatoren & Regex ⚡ + +Willkommen zu **Modul 05** (Lehrpfad 2) des Linux Bash & DevOps Lehrpfads! + +In diesem Modul lernst du moderne Entscheidungslogik mit doppelten eckigen Klammern (`[[ ... ]]`), Dateitests (`-f`, `-d`, `-x`), String-Prüfungen (`-z`, `-n`), reguläre Ausdrücke mit `=~`, numerische Vergleiche und `case`-Verzweigungen kennen. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### Die moderne Bash-Test-Syntax `[[ ... ]]` +Verwende in Bash-Skripten immer `[[ ... ]]` statt des veralteten POSIX `[ ... ]`. Es verhindert fehlerhaftes Word-Splitting und unterstützt logische Operatoren (`&&`, `||`) sowie Regex `=~`. + +### Wichtige Test-Operatoren +- **Dateisystem**: + - `-e "$path"`: Pfad existiert + - `-f "$path"`: Reguläre Datei + - `-d "$path"`: Verzeichnis + - `-x "$path"`: Datei ist ausführbar (Executable) + - `-s "$path"`: Datei existiert und ist nicht leer (Größe > 0) +- **Strings**: + - `-z "$str"`: String ist leer (`length == 0`) + - `-n "$str"`: String ist nicht leer + - `"$a" == "$b"` / `"$a" != "$b"`: Gleichheit/Ungleichheit +- **Numerisch**: + - `-eq`, `-ne`, `-lt`, `-le`, `-gt`, `-ge` oder Arithmetik `(( a >= 90 ))` + +### Regex-Matching mit `=~` & `BASH_REMATCH` +```bash +EMAIL="devops@company.com" +if [[ $EMAIL =~ ^([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})$ ]]; then + echo "Valide E-Mail!" + echo "Benutzername: ${BASH_REMATCH[1]}" + echo "Domain: ${BASH_REMATCH[2]}" +fi +``` + +### Exit-Codes & `case` +Jeder Linux-Befehl gibt beim Beenden einen Statuscode von `0` (Erfolg) bis `255` (Fehler) zurück (`$?`). +```bash +case "$ACTION" in + start|boot) + echo "Starting..." ;; + stop) + echo "Stopping..." ;; + *) + echo "Unknown" ;; +esac +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`analysiere_pfad_status`)**: Prüfe Dateipfade auf DIRECTORY, EXECUTABLE_FILE, REGULAR_FILE oder NOT_FOUND. +2. **TODO 2 (`validiere_ipv4_format`)**: Validiere eine IPv4-Adresse mit Regex `=~` und `BASH_REMATCH`. +3. **TODO 3 (`bewerte_server_metrik`)**: Bewerte Server-Auslastungen (CRITICAL, WARNING, OK). +4. **TODO 4 (`service_dispatcher`)**: Verarbeite Start/Stop/Restart-Aktionen mit `case ... in ... esac`. +5. **TODO 5 (`fuehre_sicher_aus`)**: Fange den Exit-Code `$?` ab und melde SUCCESS oder den Fehlercode. + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/05_kontrollfluss_und_testoperatoren/aufgabe.sh b/courses/bash/05_kontrollfluss_und_testoperatoren/aufgabe.sh new file mode 100644 index 0000000..ea88166 --- /dev/null +++ b/courses/bash/05_kontrollfluss_und_testoperatoren/aufgabe.sh @@ -0,0 +1,62 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 05: KONTROLLFLUSS, TEST-OPERATOREN & REGEX-MATCHING +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Dateityp & Berechtigungs-Prüfung mit [[ ... ]]. +# Prüfe "$1": +# - Nicht existent -> "NOT_FOUND" +# - Ist Verzeichnis (-d) -> "DIRECTORY" +# - Ist reguläre Datei (-f) UND ausführbar (-x) -> "EXECUTABLE_FILE" +# - Ist reguläre Datei (-f) und NICHT ausführbar -> "REGULAR_FILE" +# - Sonst -> "OTHER" +analysiere_pfad_status() { + local pfad="$1" + # TODO: Prüfe den Pfad mit [[ ... ]] und -d, -f, -x, -e + return 0 +} + +# 🎯 TEILZIEL 2 (TODO 2): IPv4-Validierung mit Regex `=~` und BASH_REMATCH. +# Prüfe per Regex, ob "$1" aus 4 Oktetten besteht und jedes Oktett zwischen 0 und 255 liegt. +# Gib Return-Code 0 (Erfolg) zurück wenn gültig, sonst 1. +validiere_ipv4_format() { + local ip="$1" + # TODO: Validiere IPv4 mit [[ $ip =~ ... ]] und prüfe Zahlenbereich + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Schwellenwert-Logik mit numerischen Operatoren (-ge, -gt). +# Prüfe "$1" (CPU%) und "$2" (RAM%): +# - CPU >= 90 ODER RAM >= 90 -> "CRITICAL" +# - CPU >= 75 ODER RAM >= 75 -> "WARNING" +# - Sonst -> "OK" +bewerte_server_metrik() { + local cpu="$1" + local ram="$2" + # TODO: Implementiere Schwellenwertvergleich mit if [[ ... ]] + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Befehls-Dispatcher mit `case ... in ... esac`. +# Behandle "$1" (Aktion) für Dienst "$2" (Service-Name): +# - "start" -> "Starte $service_name..." +# - "stop" -> "Stoppe $service_name..." +# - "restart"|"reload"-> "Starte $service_name neu..." +# - "status" -> "Pruefe Status von $service_name..." +# - Alles andere (*) -> "Unbekannte Aktion: $aktion" (und Return-Code 1) +service_dispatcher() { + local aktion="$1" + local service_name="$2" + # TODO: Implementiere case-Verzweigung + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Befehlsausführung mit Exit-Code Überprüfung ($?). +# Führe "$1" per eval aus: +# - Wenn Exit-Code == 0: Gib "SUCCESS" aus und beende mit Return 0 +# - Wenn Exit-Code != 0: Gib "ERROR_CODE: $?" aus und gib den konkreten Exit-Code als Return zurück. +fuehre_sicher_aus() { + local befehl="$1" + # TODO: Führe Befehl aus, fange $? ab und bewerte + return 0 +} diff --git a/courses/bash/05_kontrollfluss_und_testoperatoren/index.html b/courses/bash/05_kontrollfluss_und_testoperatoren/index.html new file mode 100644 index 0000000..1ba9d8f --- /dev/null +++ b/courses/bash/05_kontrollfluss_und_testoperatoren/index.html @@ -0,0 +1,160 @@ + + + + + + Bash 05: Kontrollfluss & Test-Operatoren + + + +
+
+
+
+
⚡ Lehrpfad 2: Scripting & Text-Mining
+

Bash 05: Kontrollfluss, Test-Operatoren & Regex-Matching

+

Treffe präzise Entscheidungen mit doppelten Klammern [[ ... ]], validiere IP-Adressen mit regulären Ausdrücken und steuere Abläufe mit case.

+
+
+ +
+ +
+

🎯 1. Moderne Test-Konstrukte ([[ ... ]] vs. (( ... )))

+

Verwende für Strings und Dateiprüfungen stets [[ ... ]] und für reine Zahlenvergleiche die arithmetische Umgebung (( ... )):

+ + 
# Dateiprüfungen:
+if [[ -f "/etc/nginx/nginx.conf" && -r "/etc/nginx/nginx.conf" ]]; then
+  echo "Konfiguration existiert und ist lesbar."
+fi
+
+# String-Prüfungen:
+if [[ -z "$API_KEY" ]]; then
+  echo "FEHLER: Kein API_KEY gesetzt!" >&2
+  exit 1
+fi
+
+# Arithmetische Zahlenvergleiche:
+if (( CPU_USAGE >= 90 || RAM_USAGE >= 90 )); then
+  echo "ALARM: Server-Ressourcen kritisch!"
+fi
+
+ + +
+

🧩 2. Regex-Matching (=~) & case-Verzweigung

+

Mit dem Bash-Operator =~ kannst du Strings direkt gegen reguläre Ausdrücke prüfen und Treffergruppen aus BASH_REMATCH extrahieren:

+ + 
# 🎯 1. Regex-Matching & Subgruppen:
+IP="10.0.4.1"
+if [[ $IP =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
+  echo "Erstes Oktett: ${BASH_REMATCH[1]}"
+fi
+
+# 🎯 2. Übersichtliche Befehls-Dispatcher mit case:
+case "$ACTION" in
+  start|boot)
+    systemctl start "$SERVICE" ;;
+  stop|down)
+    systemctl stop "$SERVICE" ;;
+  restart|reload)
+    systemctl restart "$SERVICE" ;;
+  *)
+    echo "Ungültige Option: $ACTION" >&2
+    exit 2 ;;
+esac
+ +
+
🚦 Didaktische Analogie: Zollkontrolle am Server-Gateway
+

Die Testoperatoren: [[ -f ]] und [[ -x ]] sind wie der Sicherheitsdienst am Flughafentor – sie prüfen Pass (Existenz) und Visum (Ausführungsrecht). =~ ist der biometrische Scanner, der das genaue Muster der Ausweisnummer abgleicht!

+
+
+ + +
+

📑 3. Cheat-Sheet: Testoperatoren

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorSyntaxBedeutung
-f / -d / -e[[ -f "$path" ]]Reguläre Datei / Verzeichnis / Existiert
-x / -r / -w[[ -x "$script" ]]Ausführbar / Lesbar / Schreibbar
-z / -n[[ -z "$str" ]]String ist leer (Länge 0) / String nicht leer
=~[[ "$val" =~ ^[0-9]+$ ]]Regulärer Ausdruck (Speichert Gruppen in BASH_REMATCH)
(( a >= b ))(( cpu >= 90 ))Schneller C-Style Zahlenvergleich
$?if [[ $? -eq 0 ]]; thenExit-Code des unmittelbar zuvor ausgeführten Befehls
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 Defensive Bash: Keine einfachen Klammern [ ... ]
+

Vermeide das alte POSIX [ "$a" = "$b" ], da nicht gesetzte Variablen zu Syntax-Fehlern (unary operator expected) führen. In [[ ... ]] ist Bash robuster gegen leere Variablen.

+
+ + +
+
+
+
+ + diff --git a/courses/bash/05_kontrollfluss_und_testoperatoren/musterloesung.sh b/courses/bash/05_kontrollfluss_und_testoperatoren/musterloesung.sh new file mode 100644 index 0000000..2daaf10 --- /dev/null +++ b/courses/bash/05_kontrollfluss_und_testoperatoren/musterloesung.sh @@ -0,0 +1,84 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 05: MUSTERLÖSUNG +# ============================================================================== + +analysiere_pfad_status() { + local pfad="$1" + if [[ ! -e "$pfad" ]]; then + echo "NOT_FOUND" + elif [[ -d "$pfad" ]]; then + echo "DIRECTORY" + elif [[ -f "$pfad" && -x "$pfad" ]]; then + echo "EXECUTABLE_FILE" + elif [[ -f "$pfad" ]]; then + echo "REGULAR_FILE" + else + echo "OTHER" + fi +} + +validiere_ipv4_format() { + local ip="$1" + if [[ $ip =~ ^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$ ]]; then + local o1="${BASH_REMATCH[1]}" + local o2="${BASH_REMATCH[2]}" + local o3="${BASH_REMATCH[3]}" + local o4="${BASH_REMATCH[4]}" + + if (( o1 <= 255 && o2 <= 255 && o3 <= 255 && o4 <= 255 )); then + return 0 + fi + fi + return 1 +} + +bewerte_server_metrik() { + local cpu="$1" + local ram="$2" + if (( cpu >= 90 || ram >= 90 )); then + echo "CRITICAL" + elif (( cpu >= 75 || ram >= 75 )); then + echo "WARNING" + else + echo "OK" + fi +} + +service_dispatcher() { + local aktion="$1" + local service_name="$2" + + case "$aktion" in + start) + echo "Starte $service_name..." + ;; + stop) + echo "Stoppe $service_name..." + ;; + restart|reload) + echo "Starte $service_name neu..." + ;; + status) + echo "Pruefe Status von $service_name..." + ;; + *) + echo "Unbekannte Aktion: $aktion" + return 1 + ;; + esac +} + +fuehre_sicher_aus() { + local befehl="$1" + eval "$befehl" >/dev/null 2>&1 + local exit_code=$? + + if [[ $exit_code -eq 0 ]]; then + echo "SUCCESS" + return 0 + else + echo "ERROR_CODE: $exit_code" + return $exit_code + fi +} diff --git a/courses/bash/05_kontrollfluss_und_testoperatoren/test_aufgabe.sh b/courses/bash/05_kontrollfluss_und_testoperatoren/test_aufgabe.sh new file mode 100644 index 0000000..9ecd930 --- /dev/null +++ b/courses/bash/05_kontrollfluss_und_testoperatoren/test_aufgabe.sh @@ -0,0 +1,111 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 05 - KONTROLLFLUSS & OPERATOREN +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 05 - Kontrollfluss & Test-Operatoren${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +TEST_ROOT=$(mktemp -d /tmp/bash05_test_XXXXXX) +trap 'rm -rf "$TEST_ROOT"' EXIT + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - analysiere_pfad_status +run_test "Pfad- und Dateityppruefung mit [[ ... ]]" ' + DIR="$TEST_ROOT/somedir" + EXEC="$TEST_ROOT/run.sh" + REG="$TEST_ROOT/data.txt" + mkdir -p "$DIR" + touch "$EXEC" "$REG" + chmod +x "$EXEC" + + [ "$(analysiere_pfad_status "$DIR")" = "DIRECTORY" ] && \ + [ "$(analysiere_pfad_status "$EXEC")" = "EXECUTABLE_FILE" ] && \ + [ "$(analysiere_pfad_status "$REG")" = "REGULAR_FILE" ] && \ + [ "$(analysiere_pfad_status "$TEST_ROOT/nonexistent")" = "NOT_FOUND" ] +' + +# TEST: Teilziel 2 - validiere_ipv4_format +run_test "IPv4-Validierung mit Regex (=~) und Bereichspruefung" ' + validiere_ipv4_format "192.168.1.1" && \ + validiere_ipv4_format "10.0.0.254" && \ + validiere_ipv4_format "127.0.0.1" && \ + ! validiere_ipv4_format "256.1.1.1" && \ + ! validiere_ipv4_format "192.168.1" && \ + ! validiere_ipv4_format "abc.def.ghi.jkl" +' + +# TEST: Teilziel 3 - bewerte_server_metrik +run_test "Server-Metrik Schwellenwertvergleich (CRITICAL / WARNING / OK)" ' + [ "$(bewerte_server_metrik 95 40)" = "CRITICAL" ] && \ + [ "$(bewerte_server_metrik 30 92)" = "CRITICAL" ] && \ + [ "$(bewerte_server_metrik 78 50)" = "WARNING" ] && \ + [ "$(bewerte_server_metrik 60 76)" = "WARNING" ] && \ + [ "$(bewerte_server_metrik 45 60)" = "OK" ] +' + +# TEST: Teilziel 4 - service_dispatcher +run_test "Service Dispatcher mit case-Verzweigung" ' + [ "$(service_dispatcher "start" "nginx")" = "Starte nginx..." ] && \ + [ "$(service_dispatcher "stop" "docker")" = "Stoppe docker..." ] && \ + [ "$(service_dispatcher "restart" "redis")" = "Starte redis neu..." ] && \ + [ "$(service_dispatcher "status" "mysql")" = "Pruefe Status von mysql..." ] && \ + [ "$(service_dispatcher "invalid" "test")" = "Unbekannte Aktion: invalid" ] +' + +# TEST: Teilziel 5 - fuehre_sicher_aus +run_test "Befehlsausfuehrung mit Exit-Code (\$?) Abfangen" ' + OUT1=$(fuehre_sicher_aus "true") + EC1=$? + OUT2=$(fuehre_sicher_aus "false") + EC2=$? + [ "$OUT1" = "SUCCESS" ] && [ "$EC1" -eq 0 ] && \ + [ "$OUT2" = "ERROR_CODE: 1" ] && [ "$EC2" -eq 1 ] +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 05 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/06_schleifen_arrays_und_assoziative_maps/README.md b/courses/bash/06_schleifen_arrays_und_assoziative_maps/README.md new file mode 100644 index 0000000..771d2df --- /dev/null +++ b/courses/bash/06_schleifen_arrays_und_assoziative_maps/README.md @@ -0,0 +1,66 @@ +# Bash 06: Schleifen, Arrays & Assoziative Maps 🔄 + +Willkommen zu **Modul 06** des Linux Bash & DevOps Lehrpfads! + +In diesem Modul meisterst du `for`- und `while`-Schleifen, sicheres zeilenweises Einlesen von Streams (`while IFS= read -r`), indizierte Arrays, **assoziative Arrays (`declare -A`)** als Hashmaps sowie professionelles CLI-Parameter-Parsing mit `getopts`. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### Schleifenkonstrukte +- **`for item in "${arr[@]}"`**: Iteriert über Elemente eines Arrays. +- **`while IFS= read -r line; do ... done`**: Sicheres zeilenweises Einlesen ohne Whitespace-Trimming. + +### Indizierte Arrays +```bash +SERVERS=("web01" "web02" "db01") +SERVERS+=("cache01") # Element anhängen +echo ${SERVERS[0]} # web01 +echo ${#SERVERS[@]} # 4 (Länge des Arrays) +echo "${SERVERS[@]}" # Alle Elemente +``` + +### Assoziative Arrays (Hashmaps / Dictionaries) +Mit `declare -A` erstellst du Key-Value-Speicher in Bash: +```bash +declare -A HOST_IPS=( + ["web"]="192.168.1.10" + ["db"]="192.168.1.20" +) + +HOST_IPS["redis"]="192.168.1.30" +echo "Web-IP: ${HOST_IPS["web"]}" +echo "Alle Keys: ${!HOST_IPS[@]}" +echo "Alle Values: ${HOST_IPS[@]}" +``` + +### CLI-Optionen mit `getopts` +Sauberes Verarbeiten von Flags wie `-e prod -p 8080 -v`: +```bash +while getopts "e:p:v" opt; do + case "$opt" in + e) ENV="$OPTARG" ;; + p) PORT="$OPTARG" ;; + v) VERBOSE=true ;; + esac +done +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`summiere_zahlen_array`)**: Summiere beliebig viele Zahlen mit einer `for`-Schleife. +2. **TODO 2 (`lese_csv_zeilenweise`)**: Lies CSV-Daten mit `while IFS=',' read -r` ein und gib eine gewünschte Spalte aus. +3. **TODO 3 (`verwalte_server_hashmap`)**: Verwalte ein assoziatives Array (`declare -A`) mit `get`, `set` und `keys`. +4. **TODO 4 (`zaehle_element_haeufigkeit`)**: Zähle Vorkommen von Items mit einer assoziativen Counter-Map. +5. **TODO 5 (`parse_cli_flags`)**: Parse CLI-Parameter (`-e`, `-p`, `-v`) mit `getopts`. + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/06_schleifen_arrays_und_assoziative_maps/aufgabe.sh b/courses/bash/06_schleifen_arrays_und_assoziative_maps/aufgabe.sh new file mode 100644 index 0000000..ca48bd5 --- /dev/null +++ b/courses/bash/06_schleifen_arrays_und_assoziative_maps/aufgabe.sh @@ -0,0 +1,53 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 06: SCHLEIFEN, ARRAYS, ASSOZIATIVE HASHMAPS & GETOPTS +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Summiere alle übergebenen Zahlen mit einer for-Schleife. +# Iteriere über "$@" und berechne die Summe. +summiere_zahlen_array() { + local summe=0 + # TODO: Iteriere über alle Argumente mit for + echo "$summe" +} + +# 🎯 TEILZIEL 2 (TODO 2): CSV zeilenweise mit while read einlesen. +# Lies den String "$1" zeilenweise ein (IFS=',') und gib für jede Zeile die Spalte "$2" (1-basiert) aus. +lese_csv_zeilenweise() { + local csv_text="$1" + local spalten_nr="$2" + # TODO: Verwende while IFS=',' read -r -a felder + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Assoziatives Array (declare -A) für Server-Mapping. +# Verwalte eine Map mit: gateway=10.0.0.1, database=10.0.0.2, cache=10.0.0.3 +# - Wenn "$1" == "get" -> Gib IP für Key "$2" aus +# - Wenn "$1" == "set" -> Setze Key "$2" auf "$3" und gib "$2=$3" aus +# - Wenn "$1" == "keys" -> Gib alle Schlüssel sortiert (einzelne Zeile, leerzeichengetrennt) aus +verwalte_server_hashmap() { + local aktion="$1" + local key="$2" + local wert="$3" + # TODO: Nutze declare -A + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Zähle Häufigkeiten von Elementen mit assoziativer Map. +# Nimm alle übergebenen Argumente ("$@"), zähle ihre Vorkommen mit `declare -A counter` +# und gib die Ergebnisse zeilenweise formatiert als `element: anzahl` (alphabetisch sortiert) aus. +zaehle_element_haeufigkeit() { + # TODO: Zähle Vorkommen und gib sortiert aus + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Parse CLI-Flags mit getopts. +# Parameter: +# -e -> Umgebung (Standard: production) +# -p -> Portnummer (Standard: 8080) +# -v -> Verbose Flag (Standard: false, wenn -v gesetzt: true) +# Ausgabeformat: "ENV=,PORT=,VERBOSE=" +parse_cli_flags() { + # TODO: Verwende getopts ":e:p:v" opt + return 0 +} diff --git a/courses/bash/06_schleifen_arrays_und_assoziative_maps/index.html b/courses/bash/06_schleifen_arrays_und_assoziative_maps/index.html new file mode 100644 index 0000000..9cba6a4 --- /dev/null +++ b/courses/bash/06_schleifen_arrays_und_assoziative_maps/index.html @@ -0,0 +1,148 @@ + + + + + + Bash 06: Schleifen & Assoziative Arrays + + + +
+
+
+
+
⚡ Lehrpfad 2: Scripting & Text-Mining
+

Bash 06: Schleifen, Arrays, Hashmaps & getopts

+

Verarbeite Datenmengen mit while IFS= read -r, nutze Assoziative Arrays (declare -A) als Key-Value-Speicher und baue CLI-Tools mit getopts.

+
+
+ +
+ +
+

🔄 1. Schleifen & Sicheres Stream-Reading

+

Das korrekte Einlesen strukturierter Datenzeilen (z.B. CSV, Passwörter, Logfiles) ist eine fundamentale DevOps-Kompetenz:

+ + 
# 🎯 1. Sicheres zeilenweises Einlesen:
+while IFS= read -r line; do
+  echo "Verarbeite: $line"
+done < /etc/hosts
+
+# 🎯 2. CSV-Parsing direkt in der Shell:
+while IFS=',' read -r host ip status; do
+  echo "Server $host ($ip) ist $status"
+done < servers.csv
+
+ + +
+

🗂️ 2. Indizierte vs. Assoziative Arrays (declare -A)

+

Seit Bash 4 kannst du echte Key-Value-Maps im Speicher halten:

+ + 
# 🎯 1. Indiziertes Array:
+SERVICES=("nginx" "postgres" "redis")
+SERVICES+=("rabbitmq")
+echo "Erster Dienst: ${SERVICES[0]}"
+echo "Anzahl Dienste: ${#SERVICES[@]}"
+
+# 🎯 2. Assoziatives Array (Hashmap):
+declare -A PORT_MAP=(
+  ["http"]="80"
+  ["https"]="443"
+  ["ssh"]="22"
+)
+PORT_MAP["database"]="5432"
+
+echo "HTTPS-Port: ${PORT_MAP["https"]}"
+echo "Alle Keys:  ${!PORT_MAP[@]}"
+ +
+
🏷️ Didaktische Analogie: Schuhkartons vs. Adressbuch
+

Indiziertes Array (arr[0]): Wie ein Stapel nummerierter Schuhkartons. Du findest Dinge nur über ihre Etagen-Nummer (0, 1, 2...).

+

Assoziatives Array (declare -A): Dein Adressbuch. Du suchst nicht nach Seite 4, sondern schlägst direkt das Stichwort "database" auf und hast sofort die IP-Adresse zur Hand!

+
+
+ + +
+

📑 3. Cheat-Sheet: Arrays & getopts

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
KonstruktBeispielZweck
declare -A mapdeclare -A conf=([a]=1 [b]=2)Deklariert assoziatives Array (Key-Value)
${!map[@]}for k in "${!map[@]}"; doIteriert über alle Keys der Map
${map[@]}echo "${map[@]}"Liefert alle Werte (Values)
while IFS= read -rwhile IFS= read -r l; doStandard für zeilenweises Einlesen
getopts "e:p:v" opt./script.sh -e prod -p 443 -vPOSIX-konformes Parsing von CLI-Optionen
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 Tipp: getopts & OPTIND Reset
+

Wenn du getopts innerhalb von Funktionen aufrufst, setze zu Beginn immer local OPTIND=1, damit nachfolgende Funktionsaufrufe den Parsing-Index von vorne beginnen!

+
+ + +
+
+
+
+ + diff --git a/courses/bash/06_schleifen_arrays_und_assoziative_maps/musterloesung.sh b/courses/bash/06_schleifen_arrays_und_assoziative_maps/musterloesung.sh new file mode 100644 index 0000000..1cb01a3 --- /dev/null +++ b/courses/bash/06_schleifen_arrays_und_assoziative_maps/musterloesung.sh @@ -0,0 +1,80 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 06: MUSTERLÖSUNG +# ============================================================================== + +summiere_zahlen_array() { + local summe=0 + for z in "$@"; do + summe=$(( summe + z )) + done + echo "$summe" +} + +lese_csv_zeilenweise() { + local csv_text="$1" + local spalten_nr="$2" + local idx=$(( spalten_nr - 1 )) + + while IFS=',' read -r -a felder; do + # Überspringe leere Zeilen + [[ ${#felder[@]} -eq 0 ]] && continue + echo "${felder[$idx]}" + done <<< "$csv_text" +} + +verwalte_server_hashmap() { + local aktion="$1" + local key="$2" + local wert="$3" + + declare -A server_map=( + ["gateway"]="10.0.0.1" + ["database"]="10.0.0.2" + ["cache"]="10.0.0.3" + ) + + case "$aktion" in + get) + echo "${server_map[$key]}" + ;; + set) + server_map["$key"]="$wert" + echo "$key=${server_map[$key]}" + ;; + keys) + echo "${!server_map[@]}" | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//' + echo + ;; + esac +} + +zaehle_element_haeufigkeit() { + declare -A counter + + for item in "$@"; do + ((counter["$item"]++)) + done + + for k in $(printf "%s\n" "${!counter[@]}" | sort); do + echo "$k: ${counter[$k]}" + done +} + +parse_cli_flags() { + local env="production" + local port=8080 + local verbose="false" + local OPTIND=1 + + while getopts ":e:p:v" opt; do + case "$opt" in + e) env="$OPTARG" ;; + p) port="$OPTARG" ;; + v) verbose="true" ;; + *) ;; + esac + done + + echo "ENV=$env,PORT=$port,VERBOSE=$verbose" +} diff --git a/courses/bash/06_schleifen_arrays_und_assoziative_maps/test_aufgabe.sh b/courses/bash/06_schleifen_arrays_und_assoziative_maps/test_aufgabe.sh new file mode 100644 index 0000000..3d97bdf --- /dev/null +++ b/courses/bash/06_schleifen_arrays_und_assoziative_maps/test_aufgabe.sh @@ -0,0 +1,100 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 06 - SCHLEIFEN & ARRAYS +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 06 - Schleifen, Arrays & Assoziative Maps${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - summiere_zahlen_array +run_test "Array-Summe mit for-Schleife berechnen" ' + RES1=$(summiere_zahlen_array 10 20 30 40) + RES2=$(summiere_zahlen_array 5 15 25) + [ "$RES1" -eq 100 ] && [ "$RES2" -eq 45 ] +' + +# TEST: Teilziel 2 - lese_csv_zeilenweise +run_test "CSV zeilenweise einlesen und Spalte filtern" ' + CSV="user1,admin,active +user2,editor,inactive +user3,viewer,active" + SPALTE2=$(lese_csv_zeilenweise "$CSV" 2) + [ "$(echo "$SPALTE2" | xargs)" = "admin editor viewer" ] +' + +# TEST: Teilziel 3 - verwalte_server_hashmap +run_test "Assoziatives Array (declare -A) abfragen und modifizieren" ' + IP=$(verwalte_server_hashmap "get" "database") + SET_RES=$(verwalte_server_hashmap "set" "loadbalancer" "10.0.0.99") + KEYS=$(verwalte_server_hashmap "keys" | xargs) + [ "$IP" = "10.0.0.2" ] && \ + [ "$SET_RES" = "loadbalancer=10.0.0.99" ] && \ + [ "$KEYS" = "cache database gateway" ] +' + +# TEST: Teilziel 4 - zaehle_element_haeufigkeit +run_test "Elementhaeufigkeit mit assoziativer Counter-Map zaehlen" ' + OUT=$(zaehle_element_haeufigkeit "nginx" "redis" "nginx" "docker" "nginx" "redis") + LINE1=$(echo "$OUT" | sed -n "1p") + LINE2=$(echo "$OUT" | sed -n "2p") + LINE3=$(echo "$OUT" | sed -n "3p") + [ "$LINE1" = "docker: 1" ] && \ + [ "$LINE2" = "nginx: 3" ] && \ + [ "$LINE3" = "redis: 2" ] +' + +# TEST: Teilziel 5 - parse_cli_flags +run_test "CLI-Flags mit getopts parsen" ' + DEF=$(parse_cli_flags) + CUSTOM=$(parse_cli_flags -e staging -p 9000 -v) + [ "$DEF" = "ENV=production,PORT=8080,VERBOSE=false" ] && \ + [ "$CUSTOM" = "ENV=staging,PORT=9000,VERBOSE=true" ] +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 06 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/07_text_mining_grep_sed_awk_und_jq/README.md b/courses/bash/07_text_mining_grep_sed_awk_und_jq/README.md new file mode 100644 index 0000000..2c4ddbe --- /dev/null +++ b/courses/bash/07_text_mining_grep_sed_awk_und_jq/README.md @@ -0,0 +1,56 @@ +# Bash 07: Text-Mining mit grep, sed, awk & jq 📊 + +Willkommen zu **Modul 07** des Linux Bash & DevOps Lehrpfads! + +In diesem Modul lernst du die vier Textverarbeitungs-Giganten der Linux-Welt beherrschen: `grep` (Muster finden), `sed` (Stream Editor & Transformation), `awk` (Spaltenanalyse & Metrik-Aggregation) und **`jq`** (High-Speed JSON-Parsing im Terminal). + +--- + +## 💡 1. Das Wichtigste in Kürze + +### `grep` (Global Regular Expression Print) +- `grep -E "pattern"`: Nutzt erweiterte reguläre Ausdrücke (Extended Regex wie `(foo|bar)`). +- `grep -i`: Ignoriert Groß-/Kleinschreibung (Case-Insensitive). +- `grep -v "debug"`: Invertiert die Suche (zeigt alle Zeilen, die **nicht** matchen). + +### `sed` (Stream Editor) +- `sed -E 's/alt/neu/g'`: Ersetzt alle Vorkommen im Stream. +- `sed -E '/^#/d'`: Löscht Zeilen, die mit `#` beginnen. + +### `awk` (Die Muster-Aktions-Sprache) +- `awk '{ print $1, $NF }'`: Gibt die erste und die letzte Spalte aus. +- Aggregationen mit `BEGIN`, Muster-Blöcken und `END`: +```bash +cat access.log | awk ' + NF >= 1 { sum += $NF; count++ } + END { print "Gesamt-Bytes:", sum, "Durchschnitt:", int(sum/count) } +' +``` + +### `jq` (Der JSON-Prozessor im Terminal) +Unverzichtbar in modernen Cloud- und Kubernetes-Umgebungen: +```bash +# 1. Array filtern & Feld extrahieren (-r für Raw String): +echo "$JSON" | jq -r '.[] | select(.active == true) | .username' + +# 2. JSON in CSV transformieren: +echo "$JSON" | jq -r '.[] | "\(.hostname),\(.ip),\(.status)"' +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`extrahiere_fehler_logs`)**: Finde Zeilen mit ERROR/CRITICAL/FATAL und filtere DEBUG-Meldungen heraus. +2. **TODO 2 (`maskiere_passwoerter_sed`)**: Maskiere Passwörter und API-Keys per `sed -E`. +3. **TODO 3 (`berechne_weblog_traffic_awk`)**: Aggregiere Requests, Gesamt-Bytes und Durchschnitt per `awk`. +4. **TODO 4 (`filtere_aktive_benutzer_jq`)**: Extrahiere aktive Usernamen aus JSON mit `jq`. +5. **TODO 5 (`transformiere_server_json_zu_csv`)**: Wandle JSON-Serverlisten in saubere CSV-Zeilen um. + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/07_text_mining_grep_sed_awk_und_jq/aufgabe.sh b/courses/bash/07_text_mining_grep_sed_awk_und_jq/aufgabe.sh new file mode 100644 index 0000000..14dfff6 --- /dev/null +++ b/courses/bash/07_text_mining_grep_sed_awk_und_jq/aufgabe.sh @@ -0,0 +1,57 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 07: TEXT-MINING MIT GREP, SED, AWK & JQ +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Fehler-Logs mit `grep` extrahieren. +# Filtere aus "$1" alle Zeilen, die "ERROR", "CRITICAL" oder "FATAL" enthalten (Case-Insensitive -i, Extended Regex -E), +# schließe jedoch Zeilen aus, die das Wort "DEBUG" enthalten (-v). +extrahiere_fehler_logs() { + local log_text="$1" + # TODO: Verwende grep -E -i und grep -v -i + return 0 +} + +# 🎯 TEILZIEL 2 (TODO 2): Sensible Daten mit `sed` maskieren. +# Ersetze in "$1" per sed -E: +# - password="" durch password="***REDACTED***" +# - api_key="" durch api_key="***REDACTED***" +maskiere_passwoerter_sed() { + local config_text="$1" + # TODO: Nutze sed -E 's/.../.../g' + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Weblog Traffic-Statistik mit `awk` aggregieren. +# Format jeder Zeile in "$1": +# 192.168.1.1 - - [30/Aug/2026:12:00:00] "GET /index.html HTTP/1.1" 200 4500 +# Das letzte Feld ($NF) enthält die übertragenen Bytes. +# Berechne: +# - Anzahl Requests (count) +# - Gesamt-Bytes (sum) +# - Durchschnittliche Bytes pro Request (avg = int(sum / count)) +# Ausgabeformat: "REQUESTS: , BYTES: , AVG: " +berechne_weblog_traffic_awk() { + local log_text="$1" + # TODO: Verwende awk '{ sum += $NF; count++ } END { ... }' + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Aktive Benutzer mit `jq` filtern. +# Filtere aus dem JSON-Array "$1" alle Objekte mit `.active == true` und gib deren `.username` aus. +# Tipp (jq): echo "$json_text" | jq -r '.[] | select(.active == true) | .username' +filtere_aktive_benutzer_jq() { + local json_text="$1" + # TODO: Verwende jq '.[] | select(.active == true) | .username' + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): JSON in CSV transformieren mit `jq`. +# Wandle das JSON-Array "$1" (Objekte mit hostname, ip, status) in kommagetrennte CSV-Zeilen um: +# Format: ,, +# Tipp (jq): echo "$json_text" | jq -r '.[] | "\(.hostname),\(.ip),\(.status)"' +transformiere_server_json_zu_csv() { + local json_text="$1" + # TODO: Verwende jq '.[] | "\(.hostname),\(.ip),\(.status)"' + return 0 +} diff --git a/courses/bash/07_text_mining_grep_sed_awk_und_jq/index.html b/courses/bash/07_text_mining_grep_sed_awk_und_jq/index.html new file mode 100644 index 0000000..4f45038 --- /dev/null +++ b/courses/bash/07_text_mining_grep_sed_awk_und_jq/index.html @@ -0,0 +1,133 @@ + + + + + + Bash 07: Text-Mining mit grep, sed, awk & jq + + + +
+
+
+
+
⚡ Lehrpfad 2: Scripting & Text-Mining
+

Bash 07: Text-Mining mit grep, sed, awk & jq

+

Durchleuchte Gigabytes an Logdaten mit grep & awk, manipuliere Konfigurationen mit sed und parse REST-APIs mit jq.

+
+
+ +
+ +
+

🔍 1. Die klassischen Unix-Textwerkzeuge

+

Große Logfiles und Systemberichte verarbeitest du direkt im Datenstrom ohne GUI:

+ + 
# 🎯 1. grep: Suchen mit Regex & Invertieren:
+grep -E -i "(error|fatal)" /var/log/syslog | grep -v "test"
+
+# 🎯 2. sed: Suchen & Ersetzen im Stream:
+sed -E 's/password="[^"]+"/password="***"/g' app.env
+
+# 🎯 3. awk: Spaltenbasierte Analyse & Berechnung:
+cat nginx.log | awk '{ sum += $NF; count++ } END { print "Avg Bytes:", sum/count }'
+
+ + +
+

📦 2. JSON-Mining im Terminal mit jq

+

REST-APIs, Docker und Kubernetes kommunizieren über JSON. jq ist der Standard-Prozessor auf der Linux-Kommandozeile:

+ + 
# 🎯 1. Array filtern mit select & Rohausgabe (-r):
+curl -s https://api.example.com/users | jq -r '.[] | select(.role == "admin") | .email'
+
+# 🎯 2. JSON in kommagetrennte Werte (CSV) umwandeln:
+cat pods.json | jq -r '.items[] | "\(.metadata.name),\(.status.phase)"'
+ +
+
⛏️ Didaktische Analogie: Das Bergwerk der Datenanalyse
+

grep: Dein Metalldetektor – er schlägt an, wenn eine Zeile das gesuchte Goldstück (Pattern) enthält.

+

sed: Dein Meißel – er schleift und poliert Zeichenketten in Form.

+

awk: Deine Buchhalter-Waage – wiegt Spalten ab und berechnet Summen und Schnitte.

+

jq: Der Röntgen-Präzisionslaser, der blitzschnell durch verschachtelte JSON-Kristallstrukturen schneidet!

+
+
+ + +
+

📑 3. Cheat-Sheet: Textwerkzeuge

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ToolBeispielEinsatzzweck
grep -E -igrep -E -i '(err|crit)' logCase-insensitiver Extended-Regex-Filter
sed -E 's/a/b/g'sed -E 's/http:/https:/g'Stream-Editor zum Ersetzen und Transformieren
awk '{ sum += $NF }'awk '{ print $1 }' fileSpaltenextraktion, Filter und Aggregation
jq -r '.[] | select(...)'jq -r '.[] | .hostname'JSON-Parsing, Filterung & CSV-Export
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 DevOps Pro-Tipp: jq Raw Output (-r)
+

Verwende beim Extrahieren von Strings für Umgebungsvariablen oder Shell-Skripte immer das Flag -r (raw output), damit jq keine störenden Anführungszeichen um den Text ausgibt!

+
+ + +
+
+
+
+ + diff --git a/courses/bash/07_text_mining_grep_sed_awk_und_jq/musterloesung.sh b/courses/bash/07_text_mining_grep_sed_awk_und_jq/musterloesung.sh new file mode 100644 index 0000000..e29989f --- /dev/null +++ b/courses/bash/07_text_mining_grep_sed_awk_und_jq/musterloesung.sh @@ -0,0 +1,42 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 07: MUSTERLÖSUNG +# ============================================================================== + +extrahiere_fehler_logs() { + local log_text="$1" + echo "$log_text" | grep -E -i '(error|critical|fatal)' | grep -v -i 'debug' +} + +maskiere_passwoerter_sed() { + local config_text="$1" + echo "$config_text" | sed -E \ + -e 's/password="[^"]*"/password="***REDACTED***"/g' \ + -e 's/api_key="[^"]*"/api_key="***REDACTED***"/g' +} + +berechne_weblog_traffic_awk() { + local log_text="$1" + echo "$log_text" | awk ' + NF >= 1 { + sum += $NF + count++ + } + END { + if (count > 0) { + avg = int(sum / count) + print "REQUESTS: " count ", BYTES: " sum ", AVG: " avg + } + } + ' +} + +filtere_aktive_benutzer_jq() { + local json_text="$1" + echo "$json_text" | jq -r '.[] | select(.active == true) | .username' +} + +transformiere_server_json_zu_csv() { + local json_text="$1" + echo "$json_text" | jq -r '.[] | "\(.hostname),\(.ip),\(.status)"' +} diff --git a/courses/bash/07_text_mining_grep_sed_awk_und_jq/test_aufgabe.sh b/courses/bash/07_text_mining_grep_sed_awk_und_jq/test_aufgabe.sh new file mode 100644 index 0000000..0328e48 --- /dev/null +++ b/courses/bash/07_text_mining_grep_sed_awk_und_jq/test_aufgabe.sh @@ -0,0 +1,136 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 07 - TEXT-MINING (GREP, SED, AWK & JQ) +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +# JQ Emulation Fallback falls jq nicht systemweit installiert ist +if ! command -v jq >/dev/null 2>&1; then + jq() { + python3 -c ' +import sys, json + +args = sys.argv[1:] +query = [a for a in args if not a.startswith("-")][0] if any(not a.startswith("-") for a in args) else "." +data = json.load(sys.stdin) + +if "active == true" in query: + for item in data: + if item.get("active") is True: + print(item.get("username", "")) +elif "hostname" in query: + for item in data: + print("%s,%s,%s" % (item.get("hostname"), item.get("ip"), item.get("status"))) +elif query == ".": + print(json.dumps(data, indent=2)) +' "$@" + } + export -f jq 2>/dev/null || true +fi + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 07 - Text-Mining mit grep, sed, awk & jq${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - extrahiere_fehler_logs +run_test "Fehler-Logs mit grep filtern und Debug ignorieren" ' + LOGS="2026-08-30 [INFO] System gestartet +2026-08-30 [ERROR] Datenbank nicht erreichbar +2026-08-30 [DEBUG] ERROR 404 in debug context +2026-08-30 [CRITICAL] Out of Memory Exception" + RES=$(extrahiere_fehler_logs "$LOGS") + [ "$(echo "$RES" | wc -l)" -eq 2 ] && \ + echo "$RES" | grep -q "Datenbank nicht erreichbar" && \ + echo "$RES" | grep -q "Out of Memory Exception" && \ + ! echo "$RES" | grep -q "debug context" +' + +# TEST: Teilziel 2 - maskiere_passwoerter_sed +run_test "Passwoerter und API-Keys mit sed maskieren" ' + CONF="db_user=\"admin\" password=\"SuperSecret123!\" +api_key=\"sk-live-999abc\" timeout=30" + MASKED=$(maskiere_passwoerter_sed "$CONF") + echo "$MASKED" | grep -q "password=\"\*\*\*REDACTED\*\*\*\"" && \ + echo "$MASKED" | grep -q "api_key=\"\*\*\*REDACTED\*\*\*\"" && \ + ! echo "$MASKED" | grep -q "SuperSecret" && \ + ! echo "$MASKED" | grep -q "sk-live-999abc" +' + +# TEST: Teilziel 3 - berechne_weblog_traffic_awk +run_test "Weblog-Statistiken mit awk aggregieren" ' + ACCESS="192.168.1.1 - - [30/Aug/2026:12:00:01] \"GET /api/v1 HTTP/1.1\" 200 1000 +192.168.1.2 - - [30/Aug/2026:12:00:02] \"GET /index.html HTTP/1.1\" 200 2000 +192.168.1.3 - - [30/Aug/2026:12:00:03] \"GET /style.css HTTP/1.1\" 200 3000" + STAT=$(berechne_weblog_traffic_awk "$ACCESS") + [ "$STAT" = "REQUESTS: 3, BYTES: 6000, AVG: 2000" ] +' + +# TEST: Teilziel 4 - filtere_aktive_benutzer_jq +run_test "Aktive Benutzer aus JSON mit jq extrahieren" ' + JSON="[ + {\"username\": \"alice\", \"active\": true}, + {\"username\": \"bob\", \"active\": false}, + {\"username\": \"charlie\", \"active\": true} + ]" + ACTIVE=$(filtere_aktive_benutzer_jq "$JSON") + [ "$(echo "$ACTIVE" | xargs)" = "alice charlie" ] +' + +# TEST: Teilziel 5 - transformiere_server_json_zu_csv +run_test "JSON-Serverliste in CSV umwandeln mit jq" ' + SERVERS="[ + {\"hostname\": \"srv-web1\", \"ip\": \"10.0.1.10\", \"status\": \"running\"}, + {\"hostname\": \"srv-db1\", \"ip\": \"10.0.2.20\", \"status\": \"standby\"} + ]" + CSV=$(transformiere_server_json_zu_csv "$SERVERS") + LINE1=$(echo "$CSV" | head -n 1) + LINE2=$(echo "$CSV" | tail -n 1) + [ "$LINE1" = "srv-web1,10.0.1.10,running" ] && \ + [ "$LINE2" = "srv-db1,10.0.2.20,standby" ] +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 07 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/08_robuste_skripte_und_debugging/README.md b/courses/bash/08_robuste_skripte_und_debugging/README.md new file mode 100644 index 0000000..79e4d83 --- /dev/null +++ b/courses/bash/08_robuste_skripte_und_debugging/README.md @@ -0,0 +1,54 @@ +# Bash 08: Robuste Skripte, Strict Mode & Debugging 🛡️ + +Willkommen zu **Modul 08** (Abschluss von Lehrpfad 2) des Linux Bash & DevOps Lehrpfads! + +In diesem Modul lernst du, wie professionelle DevOps-Engineers ausfallsichere, unzerstörbare Shell-Skripte für Produktivumgebungen schreiben: Der **Bash Strict Mode (`set -euo pipefail`)**, Signal-Traps (`trap ... EXIT`), Concurrency-Locks mit `flock`, strukturiertes Logging und Tracing mit `set -x`. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### Der unschlagbare Bash Strict Mode +Standardmäßig ignoriert Bash Fehler und macht einfach weiter – was in Produktionsskripten verheerend sein kann. Der Strict Mode stoppt sofort: +```bash +#!/usr/bin/env bash +set -euo pipefail +IFS=$'\n\t' +``` +- **`set -e`** (errexit): Bricht das Skript sofort ab, wenn ein Befehl fehlschlägt (`Exit != 0`). +- **`set -u`** (nounset): Behandelt ungesetzte Variablen als schweren Fehler (schützt vor Katastrophen wie `rm -rf /tmp/$SUBDIR/` wenn `$SUBDIR` leer ist!). +- **`set -o pipefail`**: Die Pipeline schlägt fehl, wenn *irgendein* Teil fehlschlägt (nicht nur der letzte). + +### Cleanup mit `trap` & `mktemp` +Egal ob ein Skript erfolgreich endet, crasht oder mit STRG+C abgebrochen wird – der `EXIT`-Trap räumt immer zuverlässig auf: +```bash +TEMP_DIR=$(mktemp -d) +trap 'rm -rf "$TEMP_DIR"' EXIT +``` + +### Exklusive Locks mit `flock` +Verhindert, dass ein Cronjob oder Worker mehrfach parallel startet: +```bash +flock -n /var/lock/backup.lock -c "/opt/scripts/do_backup.sh" || { + echo "Backup läuft bereits!" >&2 + exit 1 +} +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **TODO 1 (`aktiviere_strict_mode`)**: Konfiguriere `set -euo pipefail`. +2. **TODO 2 (`devops_logger`)**: Formatiere Logzeilen mit Timestamp und trenne Fehlerkanäle (ERROR/FATAL auf stderr, INFO auf stdout). +3. **TODO 3 (`erstelle_temp_verzeichnis_mit_cleanup`)**: Erstelle mit `mktemp -d` ein Verzeichnis und sichere es mit `trap 'rm -rf ...' EXIT`. +4. **TODO 4 (`fuehre_exklusiv_mit_lock_aus`)**: Schütze Befehlsausführungen mit `flock -n`. +5. **TODO 5 (`debug_trace_ausfuehren`)**: Aktiviere temporär `set -x` für Tracing und stelle den Zustand mit `set +x` wieder her. + +--- + +## 🧪 Tests ausführen + +```bash +bash test_aufgabe.sh +``` diff --git a/courses/bash/08_robuste_skripte_und_debugging/aufgabe.sh b/courses/bash/08_robuste_skripte_und_debugging/aufgabe.sh new file mode 100644 index 0000000..a076024 --- /dev/null +++ b/courses/bash/08_robuste_skripte_und_debugging/aufgabe.sh @@ -0,0 +1,50 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 08: ROBUSTE SKRIPTE, STRICT MODE, TRAPS & DEBUGGING +# ============================================================================== + +# 🎯 TEILZIEL 1 (TODO 1): Strict Mode aktivieren. +# Aktiviere `set -euo pipefail` und gib "STRICT_MODE_ON" aus. +aktiviere_strict_mode() { + # TODO: Aktiviere set -euo pipefail + echo "STRICT_MODE_ON" +} + +# 🎯 TEILZIEL 2 (TODO 2): Strukturierter DevOps-Logger mit Stream-Trennung. +# Formatiere die Ausgabe als: `[$(date +'%Y-%m-%d %H:%M:%S')] [$1] $2` +# - Wenn $1 == "ERROR" oder $1 == "FATAL": Leite die Ausgabe nach stderr (FD 2) um. +# - Für alle anderen Levels (INFO, WARN, DEBUG): Leite nach stdout (FD 1) um. +devops_logger() { + local level="$1" + local meldung="$2" + # TODO: Formatiere Zeitstempel und trenne stdout/stderr + return 0 +} + +# 🎯 TEILZIEL 3 (TODO 3): Sichere temporäre Ressourcen mit `trap` & `mktemp`. +# Erstelle ein temporäres Verzeichnis mit `mktemp -d /tmp/devops_XXXXXX` +# und richte einen `trap 'rm -rf "$temp_dir"' EXIT` ein. +# Gib den Pfad des temporären Verzeichnisses auf stdout aus. +erstelle_temp_verzeichnis_mit_cleanup() { + # TODO: Erstelle Verzeichnis mit mktemp -d und registriere EXIT trap + return 0 +} + +# 🎯 TEILZIEL 4 (TODO 4): Exklusive Lock-Ausführung mit `flock`. +# Führe "$2" (Befehl) geschützt durch die Lock-Datei "$1" mit `flock -n` (non-blocking) aus. +# - Wenn Lock erfolgreich: Gib den Exit-Code des Befehls zurück. +# - Wenn Lock blockiert ist: Schreibe "RESOURCE_LOCKED" nach stderr und gib Exit-Code 1 zurück. +fuehre_exklusiv_mit_lock_aus() { + local lock_file="$1" + local befehl="$2" + # TODO: Nutze flock -n "$lock_file" -c "$befehl" + return 0 +} + +# 🎯 TEILZIEL 5 (TODO 5): Debug Trace Modus temporär steuern. +# Aktiviere temporär den Bash-Trace-Modus `set -x`, führe "$1" aus und deaktiviere mit `set +x`. +debug_trace_ausfuehren() { + local befehl="$1" + # TODO: Schalte set -x ein, führe befehl aus, schalte mit set +x aus + return 0 +} diff --git a/courses/bash/08_robuste_skripte_und_debugging/index.html b/courses/bash/08_robuste_skripte_und_debugging/index.html new file mode 100644 index 0000000..0c78404 --- /dev/null +++ b/courses/bash/08_robuste_skripte_und_debugging/index.html @@ -0,0 +1,150 @@ + + + + + + Bash 08: Robuste Skripte (set -euo pipefail) + + + +
+
+
+
+
⚡ Lehrpfad 2: Scripting & Text-Mining
+

Bash 08: Robuste Skripte, Strict Mode & Debugging

+

Härte deine Shell-Skripte für den 24/7-Serverbetrieb mit set -euo pipefail, automatischen Cleanup-Traps und Concurrency-Locks mit flock.

+
+
+ +
+ +
+

🛡️ 1. Der Bash Strict Mode (set -euo pipefail)

+

In Produktions-Umgebungen ist "Stiller Weiterlauf bei Fehlern" die häufigste Ursache für Datenverlust. Der Strict Mode stoppt das Skript deterministisch beim ersten Fehler:

+ + 
#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+# 1. set -e (errexit): Bricht bei unhandled Exit-Codes != 0 sofort ab
+# 2. set -u (nounset): Behandelt Zugriffe auf ungesetzte Variablen als Fatal Error
+# 3. set -o pipefail: Ein Fehler in foo | bar | baz lässt die gesamte Pipeline scheitern
+
+# Erlaubte Fehler sauber abfangen:
+optional_cleanup || true
+
+ + +
+

🧹 2. Signal-Traps, Cleanup & File Locks (flock)

+

Hinterlasse niemals Datenmüll im Dateisystem und verhindere Race Conditions bei parallel laufenden Cronjobs:

+ + 
# 🎯 1. EXIT Trap – Garantiertes Aufräumen:
+WORK_DIR=$(mktemp -d)
+trap 'rm -rf "$WORK_DIR"' EXIT
+
+# 🎯 2. Exklusives Locking gegen Doppel-Ausführung:
+exec 200>/var/lock/backup.lock
+flock -n 200 || { echo "Job läuft bereits!" >&2; exit 1; }
+
+# 🎯 3. Trace-Debugging im laufenden Betrieb:
+set -x  # Zeigt jeden ausgeführten Befehl mit '+' an
+grep "root" /etc/passwd
+set +x  # Schaltet Tracing wieder aus
+ +
+
🛟 Didaktische Analogie: Sicherheitsnetz & Hotelschlüssel
+

set -euo pipefail: Das Notbremssystem im Hochgeschwindigkeitszug. Sobald eine Variable wackelt oder ein Zwischenhalt entgleist, stoppt der Zug sofort, statt ungebremst in den Abgrund zu rasen.

+

flock: Das "Besetzt"-Schild am Hotelzimmer. Kein zweiter Gast kann eintreten, solange die Tür verriegelt ist!

+
+
+ + +
+

📑 3. Cheat-Sheet: Defensive Bash

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Befehl / OptionSyntaxSchutzwirkung
set -eset -o errexitSofortiger Abbruch bei Befehlsfehlern
set -uset -o nounsetVerhindert Ausführung mit leeren/ungesetzten Variablen
set -o pipefailcmd1 | cmd2Gibt Fehlercode zurück, falls irgendein Glied der Pipe fehlschlägt
trap '...' EXITtrap cleanup EXITFührt Aufräumcode bei normalem und abnormalem Beenden aus
flock -n <file>flock -n /tmp/job.lock cmdNon-blocking Concurrency Lock gegen parallele Runs
set -x / set +xset -x; ...; set +xAktiviert / Deaktiviert interaktiven Befehls-Trace
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 DevOps Pro-Tipp: Unbeabsichtigte rm-Katastrophen verhindern
+

Ohne set -u führt ein unbedachter Aufruf wie rm -rf /var/app/$ENV_NAME/cache bei leerer Variable zu rm -rf /var/app//cache. Mit set -u bricht die Shell sofort vor dem Löschbefehl ab!

+
+ + +
+
+
+
+ + diff --git a/courses/bash/08_robuste_skripte_und_debugging/musterloesung.sh b/courses/bash/08_robuste_skripte_und_debugging/musterloesung.sh new file mode 100644 index 0000000..3b04db0 --- /dev/null +++ b/courses/bash/08_robuste_skripte_und_debugging/musterloesung.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🐧 BASH 08: MUSTERLÖSUNG +# ============================================================================== + +aktiviere_strict_mode() { + set -euo pipefail + echo "STRICT_MODE_ON" +} + +devops_logger() { + local level="$1" + local meldung="$2" + local timestamp + timestamp="$(date +'%Y-%m-%d %H:%M:%S')" + local log_line="[$timestamp] [$level] $meldung" + + case "$level" in + ERROR|FATAL) + echo "$log_line" >&2 + ;; + *) + echo "$log_line" + ;; + esac +} + +erstelle_temp_verzeichnis_mit_cleanup() { + local temp_dir + temp_dir=$(mktemp -d /tmp/devops_XXXXXX) + trap 'rm -rf "$temp_dir"' EXIT + echo "$temp_dir" +} + +fuehre_exklusiv_mit_lock_aus() { + local lock_file="$1" + local befehl="$2" + + if flock -n "$lock_file" -c "$befehl"; then + return 0 + else + echo "RESOURCE_LOCKED" >&2 + return 1 + fi +} + +debug_trace_ausfuehren() { + local befehl="$1" + set -x + eval "$befehl" + { set +x; } 2>/dev/null +} diff --git a/courses/bash/08_robuste_skripte_und_debugging/test_aufgabe.sh b/courses/bash/08_robuste_skripte_und_debugging/test_aufgabe.sh new file mode 100644 index 0000000..c1feb0e --- /dev/null +++ b/courses/bash/08_robuste_skripte_und_debugging/test_aufgabe.sh @@ -0,0 +1,121 @@ +#!/usr/bin/env bash +# ============================================================================== +# 🧪 BATS-INSPIRIERTE TESTSUITE: BASH 08 - ROBUSTE SKRIPTE & STRICT MODE +# ============================================================================== + +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +TARGET_SCRIPT="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +TOTAL_TESTS=0 +PASSED_TESTS=0 +FAILED_TESTS=0 + +echo -e "${BLUE}================================================================${NC}" +echo -e "${BLUE}🧪 TESTSUITE: Bash 08 - Robuste Skripte, Strict Mode & Traps${NC}" +echo -e "${BLUE} Ziel-Skript: ${YELLOW}${TARGET_SCRIPT}${NC}" +echo -e "${BLUE}================================================================${NC}\n" + +if [ ! -f "$SCRIPT_DIR/$TARGET_SCRIPT" ]; then + echo -e "${RED}❌ Fehler: Datei '$TARGET_SCRIPT' nicht gefunden!${NC}" + exit 1 +fi + +source "$SCRIPT_DIR/$TARGET_SCRIPT" + +TEST_ROOT=$(mktemp -d /tmp/bash08_test_XXXXXX) +trap 'rm -rf "$TEST_ROOT"' EXIT + +run_test() { + local test_name="$1" + local test_cmd="$2" + ((TOTAL_TESTS++)) + + echo -e "▶ Test ${TOTAL_TESTS}: ${test_name}" + if eval "$test_cmd"; then + echo -e " ${GREEN}✓ BESTANDEN${NC}\n" + ((PASSED_TESTS++)) + else + echo -e " ${RED}✗ FEHLGESCHLAGEN${NC}\n" + ((FAILED_TESTS++)) + fi +} + +# TEST: Teilziel 1 - aktiviere_strict_mode +run_test "Strict Mode Aktivierung (set -euo pipefail)" ' + bash -c " + source \"$SCRIPT_DIR/$TARGET_SCRIPT\" + aktiviere_strict_mode >/dev/null + # Unset-Variable soll zum sofortigen Abbruch fuehren + if [ -o nounset ] && [ -o errexit ]; then + exit 0 + else + exit 1 + fi + " +' + +# TEST: Teilziel 2 - devops_logger +run_test "DevOps-Logger mit Zeitstempel und Stream-Trennung" ' + OUT_LOG="$TEST_ROOT/out.log" + ERR_LOG="$TEST_ROOT/err.log" + + devops_logger "INFO" "Dienst gestartet" > "$OUT_LOG" 2> "$ERR_LOG" + grep -q "\[INFO\] Dienst gestartet" "$OUT_LOG" && \ + [ ! -s "$ERR_LOG" ] && \ + + devops_logger "ERROR" "Kritischer Verbindungsabbruch" > "$OUT_LOG" 2> "$ERR_LOG" && \ + grep -q "\[ERROR\] Kritischer Verbindungsabbruch" "$ERR_LOG" +' + +# TEST: Teilziel 3 - erstelle_temp_verzeichnis_mit_cleanup +run_test "Temporaeres Verzeichnis mit mktemp anlegen" ' + TEMP_DIR=$(erstelle_temp_verzeichnis_mit_cleanup) + [ -d "$TEMP_DIR" ] && [[ "$TEMP_DIR" =~ ^/tmp/devops_ ]] +' + +# TEST: Teilziel 4 - fuehre_exklusiv_mit_lock_aus +run_test "Exklusive File-Locks mit flock verwalten" ' + LOCK_FILE="$TEST_ROOT/test.lock" + # 1. Normaler Aufruf muss erfolgreich sein + fuehre_exklusiv_mit_lock_aus "$LOCK_FILE" "echo Job1_Done" > "$TEST_ROOT/job1.out" && \ + grep -q "Job1_Done" "$TEST_ROOT/job1.out" && \ + + # 2. Wenn Lock blockiert ist, muss Fehler gemeldet werden + bash -c " + source \"$SCRIPT_DIR/$TARGET_SCRIPT\" + ( + flock 200 + sleep 0.5 + ) 200>\"$LOCK_FILE\" & + BG_PID=\$! + sleep 0.1 + fuehre_exklusiv_mit_lock_aus \"$LOCK_FILE\" \"echo Should_Not_Run\" 2>\"$TEST_ROOT/lock_err.log\" + RET=\$? + wait \$BG_PID 2>/dev/null || true + [ \$RET -ne 0 ] && grep -q \"RESOURCE_LOCKED\" \"$TEST_ROOT/lock_err.log\" + " +' + +# TEST: Teilziel 5 - debug_trace_ausfuehren +run_test "Debug Trace mit set -x temporaer ausfuehren" ' + TRACE_ERR="$TEST_ROOT/trace.err" + debug_trace_ausfuehren "echo TRACE_TEST" 2> "$TRACE_ERR" > /dev/null + grep -q "+ " "$TRACE_ERR" || grep -q "echo TRACE_TEST" "$TRACE_ERR" +' + +echo -e "${BLUE}================================================================${NC}" +if [ "$FAILED_TESTS" -eq 0 ]; then + echo -e "${GREEN}🎉 ERFOLG: Alle ${PASSED_TESTS}/${TOTAL_TESTS} Tests in Bash 08 erfolgreich bestanden!${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 0 +else + echo -e "${RED}❌ FEHLER: ${FAILED_TESTS} von ${TOTAL_TESTS} Tests fehlgeschlagen.${NC}" + echo -e "${BLUE}================================================================${NC}" + exit 1 +fi diff --git a/courses/bash/09_parallelisierung_mit_xargs_und_parallel/README.md b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/README.md new file mode 100644 index 0000000..a615a85 --- /dev/null +++ b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/README.md @@ -0,0 +1,87 @@ +# Bash 09: Multithreading & Parallelisierung im Terminal 🚀 + +Willkommen zu **Modul 09** des Bash & Cloud DevOps Kurses! In modernen Server- und Cloud-Umgebungen müssen Skripte oft hunderte oder tausende I/O- oder CPU-Aufgaben gleichzeitig ausführen (z.B. Log-Analysen, API-Pollings, Dateitransfers, Bildkompression). + +In diesem Modul meisterst du die Kunst der Parallelisierung direkt auf der Linux-Kommandozeile. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### 1.1 `xargs -P ` (Parallele Ausführung mit Standard-Tools) +`xargs` liest Einträge von `stdin` und führt Befehle aus. Mit dem Parameter `-P ` (oder `--max-procs`) bestimmst du, wie viele Prozesse parallel laufen: +```bash +# Verarbeitet URLs parallel mit maximal 8 Threads: +cat urls.txt | xargs -P 8 -I {} curl -s -O "{}" + +# Null-terminierte Strings für sichere Dateinamen mit Leerzeichen: +find . -type f -name "*.log" -print0 | xargs -0 -P 4 gzip +``` + +### 1.2 GNU `parallel` (Die Königsklasse der Shell-Parallelisierung) +GNU `parallel` bietet erweiterte Features wie Job-Tagging, CPU-Kern-Erkennung (`-j+0`), Fortschrittsbalken (`--bar`) und strukturierte Ausgabe (`--keep-order`): +```bash +# Führt Bildoptimierung auf allen CPU-Kernen parallel aus: +parallel -j $(nproc) --bar "convert {} -resize 800x600 opt_{}" ::: *.jpg +``` + +### 1.3 Native Bash Background Workers (`&`, `$!`, `wait`) +Reine Bash-Mittel ohne externe Werkzeuge für maximale Portabilität: +```bash +pids=() + +for server in web01 web02 db01; do + ( + echo "Prüfe $server..." + ping -c 1 "$server" > /dev/null 2>&1 + echo "Fertig: $server" + ) & + pids+=($!) +done + +# Warten auf alle Prozesse: +for pid in "${pids[@]}"; do + wait "$pid" +done +echo "Alle Server geprüft!" +``` + +### 1.4 Concurrency Throttling (Worker Pool) +Um das System vor Überlastung (Too many open files / Out of Memory) zu schützen, drosseln wir die Anzahl aktiver Prozesse: +```bash +MAX_JOBS=4 +for item in $(cat items.txt); do + process_item "$item" & + + # Solange MAX_JOBS erreicht sind, kurz warten + while [ $(jobs -rp | wc -l) -ge "$MAX_JOBS" ]; do + sleep 0.05 + done +done +wait +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **`parallel_xargs_process(input_file, max_procs)`**: + Liest eine Textdatei und gibt für jede Zeile `PROCESSED: ` über `xargs -P` parallel aus. +2. **`background_workers_wait(task1, task2, ...)`**: + Startet Hintergrund-Subshells mit `&`, sammelt deren PIDs in einem Array und synchronisiert mit `wait`. +3. **`parallel_batch_calculator(numbers_file, max_procs)`**: + Liest Zahlen aus einer Datei, berechnet deren Quadrat parallel und liefert das Ergebnis numerisch sortiert zurück (`^2 = `). +4. **`throttle_concurrent_jobs(total_jobs, max_concurrent)`**: + Implementiert einen gedrosselten Worker-Pool, sodass niemals mehr als `max_concurrent` Prozesse gleichzeitig im Hintergrund laufen. + +--- + +## 🧪 Tests ausführen + +```bash +# Eigene Lösung testen: +bash test_aufgabe.sh + +# Musterlösung testen: +bash test_aufgabe.sh musterloesung.sh +``` diff --git a/courses/bash/09_parallelisierung_mit_xargs_und_parallel/aufgabe.sh b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/aufgabe.sh new file mode 100644 index 0000000..e6e62bd --- /dev/null +++ b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/aufgabe.sh @@ -0,0 +1,110 @@ +#!/usr/bin/env bash +# ============================================================================== +# Bash 09: Parallelisierung mit xargs, GNU parallel & Background Workers +# ============================================================================== +# In diesem Modul lernst du, rechen- oder I/O-intensive Aufgaben im Terminal +# parallel auf mehreren CPU-Cores abzuarbeiten. +# ============================================================================== + +# ------------------------------------------------------------------------------ +# TODO 1: Parallele Verarbeitung von Dateizeilen mit xargs +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `parallel_xargs_process`. +# Parameter: +# $1: Pfad zu einer Datei mit Einträgen (eine Zeile pro Item) +# $2: Maximale Anzahl paralleler Prozesse (z.B. 4) +# Verhalten: +# - Liest jede Zeile aus $1 +# - Verarbeitet jedes Item parallel mit `xargs -n 1 -P "$2"` +# - Für jedes Item soll ausgegeben werden: "PROCESSED: " +# - Bei fehlender oder nicht existierender Datei: Return 1 +# ------------------------------------------------------------------------------ +parallel_xargs_process() { + local input_file="${1:-}" + local max_procs="${2:-2}" + + # TODO: Prüfe ob input_file existiert, ansonsten return 1 + # TODO: Nutze cat/xargs mit -n 1 und -P "$max_procs", um jedes Item mit "PROCESSED: $item" auszugeben + echo "TODO: Implementiere parallel_xargs_process" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 2: Background Workers mit PID-Tracking & wait +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `background_workers_wait`. +# Parameter: +# $@: Eine Liste von Aufgabennamen (z.B. "taskA" "taskB" "taskC") +# Verhalten: +# - Startet für jeden übergebenen Aufgabennamen einen Hintergrundjob (`&`), +# der folgendes ausgibt: "WORKER_START: " und nach einer kurzen +# Operation (z.B. sleep 0.01) ausgibt: "WORKER_DONE: " +# - Sammelt die PIDs aller gestarteten Jobs in einem Bash-Array (`pids+=($!)`). +# - Wartet mit `wait` auf das Ende aller Hintergrundjobs. +# - Gibt nach erfolgreichem Warten aus: "ALL_WORKERS_FINISHED" +# - Liefert Return-Code 0. +# ------------------------------------------------------------------------------ +background_workers_wait() { + local tasks=("$@") + + # TODO: Prüfe ob Aufgaben übergeben wurden, wenn nicht return 1 + # TODO: Starte für jede Task einen Background-Prozess (&) und tracke $! + # TODO: Warte mit `wait "${pids[@]}"` + # TODO: Gib "ALL_WORKERS_FINISHED" aus + echo "TODO: Implementiere background_workers_wait" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 3: Paralleler Batch-Rechner (Numerische Transformation) +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `parallel_batch_calculator`. +# Parameter: +# $1: Pfad zu einer Datei mit Ganzzahlen (eine Zahl pro Zeile) +# $2: Anzahl paralleler Worker (Default: 4) +# Verhalten: +# - Berechnet für jede Zahl n das Quadrat (n * n). +# - Führt die Berechnung parallel via xargs oder Background-Workers durch. +# - Gibt das Ergebnis im Format "^2 = " aus, sortiert nach numerisch aufsteigend. +# - Beispiel Eingabe: 3, 5, 2 +# - Ausgabe: +# 2^2 = 4 +# 3^2 = 9 +# 5^2 = 25 +# - Bei ungültiger Datei return 1. +# ------------------------------------------------------------------------------ +parallel_batch_calculator() { + local numbers_file="${1:-}" + local max_procs="${2:-4}" + + # TODO: Validiere Datei + # TODO: Berechne Quadrate parallel und gebe sie numerisch sortiert aus + echo "TODO: Implementiere parallel_batch_calculator" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 4: Throttling & Concurrency Pool (Max. N aktive Jobs) +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `throttle_concurrent_jobs`. +# Parameter: +# $1: Gesamtanzahl der zu startenden Jobs (z.B. 6) +# $2: Maximale Anzahl gleichzeitig laufender Jobs (z.B. 2) +# Verhalten: +# - Startet Jobs 1 bis $1 im Hintergrund. +# - Jeder Job gibt aus: "JOB_RUNNING: " +# - Stellt sicher, dass zu KEINEM Zeitpunkt mehr als $2 Jobs gleichzeitig laufen. +# (Tipp: Prüfe die Anzahl laufender Jobs via `jobs -p | wc -l` oder nutze `wait -n`). +# - Wartet am Ende, bis wirklich alle Jobs beendet sind. +# - Gibt am Ende aus: "THROTTLE_POOL_COMPLETED" +# ------------------------------------------------------------------------------ +throttle_concurrent_jobs() { + local total_jobs="${1:-0}" + local max_concurrent="${2:-2}" + + # TODO: Starte total_jobs und drossle Concurrency auf max_concurrent + # TODO: Warte auf verbleibende Jobs + # TODO: Gib "THROTTLE_POOL_COMPLETED" aus + echo "TODO: Implementiere throttle_concurrent_jobs" + return 1 +} diff --git a/courses/bash/09_parallelisierung_mit_xargs_und_parallel/index.html b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/index.html new file mode 100644 index 0000000..1d14d32 --- /dev/null +++ b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/index.html @@ -0,0 +1,133 @@ + + + + + + Bash 09: Parallelisierung mit xargs & parallel + + + +
+
+
+
+
🚀 Lehrpfad 3: High-Performance & Parallelisierung
+

Bash 09: Parallelisierung mit xargs & parallel

+

Lerne Multiprocessing im Terminal: Beschleunige I/O- und Rechenoperationen mit xargs -P, GNU parallel und nativem Background Worker Management.

+
+
+ +
+ +
+

⚡ 1. Multithreading & Concurrency im Terminal

+

Standard-Shell-Skripte laufen sequentiell in einem einzigen Prozess ab. Auf Multi-Core-CPUs (8, 16 oder 64 Kerne) verschenkt das enorme Rechenkapazität. Durch Parallelisierung teilen wir Arbeitslasten auf:

+ +
+ [Sequentiell]  Task 1 ──> Task 2 ──> Task 3 ──> Task 4          (Gesamtzeit: 4x)
+ [Parallel -P 4] ├──> Worker 1: Task 1 ──┐
+                ├──> Worker 2: Task 2 ──┼──> [wait] ──> Fertig (Gesamtzeit: ~1x)
+                ├──> Worker 3: Task 3 ──┤
+                └──> Worker 4: Task 4 ──┘ +
+ + 
# 🎯 1. xargs mit Parallelitäts-Flag -P (z.B. 4 parallele Prozesse):
+cat domains.txt | xargs -P 4 -I {} curl -s -I "https://{}"
+
+# 🎯 2. Native Bash Worker mit & und wait:
+for file in *.log; do
+    analyze_log "$file" &
+done
+wait  # Blockiert, bis ALLE Subshells im Hintergrund fertig sind
+
+ + +
+

🏭 2. Didaktische Analogie: Die Supermarkt-Kassen

+
+
🛒 Der Supermarkt-Vergleich
+

Sequentiell (Single-Threaded): 100 Kunden stehen an einer einzigen Kasse an. Kunde 1 zahlt, dann Kunde 2, usw. Die Schlange dauert 100 Minuten.

+

Parallel (xargs -P 4 / Worker Pool): Der Filialleiter öffnet 4 Kassen gleichzeitig. 4 Kunden werden parallel bedient. Die Gesamtdauer sinkt auf 25 Minuten!

+

Throttling: Wenn nicht unendlich Kassenpersonal da ist, begrenzt ein Pool (MAX_WORKERS) die Anzahl geöffneter Schalter, damit der Laden nicht im Chaos versinkt.

+
+
+ + +
+

📑 3. Cheat-Sheet: Parallelisierungs-Werkzeuge

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Befehl / SyntaxBedeutungBeispiel
xargs -P <N> -I {}Führt Befehl für jedes Item mit max. N Threads auscat urls.txt | xargs -P 8 -I {} curl -O {}
command &Startet Befehl/Subshell asynchron im Hintergrundbackup_db &
$!PID des zuletzt im Hintergrund gestarteten Prozessespids+=($!)
wait "${pids[@]}"Wartet auf Beendigung aller gelisteten Prozess-IDswait "${pids[@]}"
jobs -rpListet PIDs aller aktuell laufenden Hintergrundjobs[ $(jobs -rp | wc -l) -ge 4 ]
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
💡 DevOps Pro-Tipp: CPU-Kerne dynamisch ermitteln
+

Verwende nproc oder $(grep -c ^processor /proc/cpuinfo), um die Thread-Anzahl automatisch an die Hardware des Servers anzupassen!

+
+ + +
+
+
+
+ + diff --git a/courses/bash/09_parallelisierung_mit_xargs_und_parallel/musterloesung.sh b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/musterloesung.sh new file mode 100644 index 0000000..b199fea --- /dev/null +++ b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/musterloesung.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash +# ============================================================================== +# Bash 09: Parallelisierung mit xargs, GNU parallel & Background Workers +# MUSTERLÖSUNG +# ============================================================================== + +parallel_xargs_process() { + local input_file="${1:-}" + local max_procs="${2:-2}" + + if [ -z "$input_file" ] || [ ! -f "$input_file" ]; then + return 1 + fi + + # Paralleles Ausführen via xargs + xargs -P "$max_procs" -I {} bash -c 'echo "PROCESSED: $1"' _ {} < "$input_file" +} + +background_workers_wait() { + local tasks=("$@") + + if [ ${#tasks[@]} -eq 0 ]; then + return 1 + fi + + local pids=() + + for task in "${tasks[@]}"; do + ( + echo "WORKER_START: $task" + sleep 0.02 + echo "WORKER_DONE: $task" + ) & + pids+=($!) + done + + # Warten auf alle Hintergrund-Prozesse + for pid in "${pids[@]}"; do + wait "$pid" + done + + echo "ALL_WORKERS_FINISHED" + return 0 +} + +parallel_batch_calculator() { + local numbers_file="${1:-}" + local max_procs="${2:-4}" + + if [ -z "$numbers_file" ] || [ ! -f "$numbers_file" ]; then + return 1 + fi + + # Berechne n^2 parallel und formatiere Ausgabe numerisch sortiert + xargs -P "$max_procs" -I {} bash -c 'num="$1"; sq=$((num * num)); echo "$num^2 = $sq"' _ {} < "$numbers_file" | sort -n +} + +throttle_concurrent_jobs() { + local total_jobs="${1:-0}" + local max_concurrent="${2:-2}" + + if [ "$total_jobs" -le 0 ]; then + return 1 + fi + + for ((i=1; i<=total_jobs; i++)); do + ( + echo "JOB_RUNNING: $i" + sleep 0.05 + ) & + + # Sobald mehr oder gleich max_concurrent Jobs laufen: warten bis ein Job fertig ist + while [ $(jobs -rp | wc -l) -ge "$max_concurrent" ]; do + sleep 0.01 + done + done + + # Auf verbleibende Jobs warten + wait + + echo "THROTTLE_POOL_COMPLETED" + return 0 +} diff --git a/courses/bash/09_parallelisierung_mit_xargs_und_parallel/test_aufgabe.sh b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/test_aufgabe.sh new file mode 100644 index 0000000..eb3d1d5 --- /dev/null +++ b/courses/bash/09_parallelisierung_mit_xargs_und_parallel/test_aufgabe.sh @@ -0,0 +1,89 @@ +#!/usr/bin/env bash +# ============================================================================== +# Testsuite: Bash 09 - Parallelisierung mit xargs & parallel +# ============================================================================== +set -e + +TARGET_FILE="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +TARGET_PATH="${SCRIPT_DIR}/${TARGET_FILE}" + +if [ ! -f "$TARGET_PATH" ]; then + echo "❌ Fehler: Zieldatei '$TARGET_PATH' nicht gefunden!" + exit 1 +fi + +source "$TARGET_PATH" + +passed=0 +total=4 + +echo "🧪 Starte Tests für Modul 09 (${TARGET_FILE})..." +echo "---------------------------------------------------------" + +# TEST 1: parallel_xargs_process +TMP_INPUT=$(mktemp) +echo -e "server01\nserver02\nserver03" > "$TMP_INPUT" +output1=$(parallel_xargs_process "$TMP_INPUT" 3 || true) +rm -f "$TMP_INPUT" + +if echo "$output1" | grep -q "PROCESSED: server01" && \ + echo "$output1" | grep -q "PROCESSED: server02" && \ + echo "$output1" | grep -q "PROCESSED: server03"; then + echo "✓ Test 1/4: parallel_xargs_process erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 1/4 fehlgeschlagen: parallel_xargs_process liefert nicht erwartete Ausgaben. Output: $output1" +fi + +# TEST 2: background_workers_wait +output2=$(background_workers_wait "alpha" "beta" "gamma" || true) +if echo "$output2" | grep -q "WORKER_START: alpha" && \ + echo "$output2" | grep -q "WORKER_DONE: gamma" && \ + echo "$output2" | grep -q "ALL_WORKERS_FINISHED"; then + echo "✓ Test 2/4: background_workers_wait erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 2/4 fehlgeschlagen: background_workers_wait fehlerhaft. Output: $output2" +fi + +# TEST 3: parallel_batch_calculator +TMP_NUMS=$(mktemp) +echo -e "5\n2\n8\n1" > "$TMP_NUMS" +output3=$(parallel_batch_calculator "$TMP_NUMS" 4 || true) +rm -f "$TMP_NUMS" + +expected3="1^2 = 1 +2^2 = 4 +5^2 = 25 +8^2 = 64" + +if [ "$(echo "$output3" | tr -d '\r')" = "$expected3" ]; then + echo "✓ Test 3/4: parallel_batch_calculator erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 3/4 fehlgeschlagen: Erwartete: +$expected3 +Erhalten: +$output3" +fi + +# TEST 4: throttle_concurrent_jobs +output4=$(throttle_concurrent_jobs 4 2 || true) +if echo "$output4" | grep -q "JOB_RUNNING: 1" && \ + echo "$output4" | grep -q "JOB_RUNNING: 4" && \ + echo "$output4" | grep -q "THROTTLE_POOL_COMPLETED"; then + echo "✓ Test 4/4: throttle_concurrent_jobs erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 4/4 fehlgeschlagen: throttle_concurrent_jobs fehlerhaft. Output: $output4" +fi + +echo "---------------------------------------------------------" +if [ "$passed" -eq "$total" ]; then + echo "🎉 Alle $total Tests für Modul 09 erfolgreich bestanden!" + exit 0 +else + echo "❌ $passed von $total Tests bestanden." + exit 1 +fi diff --git a/courses/bash/10_prozess_substitution_und_coproc/README.md b/courses/bash/10_prozess_substitution_und_coproc/README.md new file mode 100644 index 0000000..c70ff97 --- /dev/null +++ b/courses/bash/10_prozess_substitution_und_coproc/README.md @@ -0,0 +1,87 @@ +# Bash 10: Prozess-Substitution, Named Pipes & Co-Prozesse (coproc) 🔄 + +Willkommen zu **Modul 10**! In diesem Modul lernst du fortgeschrittene IPC-Mechanismen (Inter-Process Communication) und Stream-Manipulationen kennen, mit denen professionelle DevOps-Ingenieure Datenströme ohne langsame temporäre Festplattendateien verarbeiten. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### 1.1 Process Substitution `<(...)` (Befehl als Datei lesen) +Viele Unix-Befehle (wie `diff`, `comm`, `join`) akzeptieren nur Dateipfade als Argumente, keine Pipes. Mit `<(command)` erstellt die Shell einen virtuellen Datei-Deskriptor (`/dev/fd/63`): +```bash +# Vergleicht die Ausgaben zweier Server-Konfigurationen direkt: +diff -u <(ssh srv1 "cat /etc/nginx/nginx.conf") <(ssh srv2 "cat /etc/nginx/nginx.conf") + +# Variablenverlust in while-Schleifen vermeiden: +count=0 +while read -r line; do + ((count++)) +done < <(find . -type f) +echo "Gefundene Dateien: $count" # Funktioniert! (Keine Subshell) +``` + +### 1.2 Process Substitution `>(...)` (In Befehl schreiben) +Erlaubt das Verzweigen von Streams mit `tee`: +```bash +# Schreibt Logs roh in access.log und filtert parallel 500er Fehler in errors.log: +cat stream.log | tee >(grep "500 Internal Error" > errors.log) > access.log +``` + +### 1.3 Named Pipes (`mkfifo`) +Eine Named Pipe ist eine Datei im Dateisystem, die als bidirektionaler Puffer zwischen zwei unabhängigen Prozessen agiert: +```bash +mkfifo /tmp/my_pipe +# Prozess A (Schreiber): +echo "Build complete" > /tmp/my_pipe & + +# Prozess B (Leser): +read -r status < /tmp/my_pipe +echo "Status empfangen: $status" +rm -f /tmp/my_pipe +``` + +### 1.4 Bash Co-Prozesse (`coproc`) +Ein `coproc` startet ein Programm asynchron im Hintergrund und öffnet zwei Dateideskriptoren für bidirektionale Kommunikation: +```bash +coproc WORKER { + while read -r input; do + [ "$input" = "QUIT" ] && break + echo "PROCESSED: $input" + done +} + +# In den Worker schreiben: +echo "payload1" >&"${WORKER[1]}" + +# Antwort vom Worker lesen: +read -r response <&"${WORKER[0]}" +echo "Antwort: $response" + +# Beenden: +echo "QUIT" >&"${WORKER[1]}" +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **`compare_command_outputs(cmd1, cmd2)`**: + Vergleicht zwei Shell-Befehle direkt mit `diff -u <(...) <(...)`. Liefert `"IDENTICAL"` bei Gleichheit. +2. **`stream_splitter_tee(input_text, raw_file, uppercase_file)`**: + Nutzt `tee >(tr '[:lower:]' '[:upper:]' > "$upper")`, um Daten in zwei Streams aufzuspalten. +3. **`named_pipe_transfer(fifo_path, message)`**: + Erstellt eine Named Pipe (`mkfifo`), überträgt eine Nachricht asynchron und liest sie im Hauptprozess. +4. **`coproc_calculator_interactive(expr1, expr2)`**: + Startet einen interaktiven `coproc` Rechen-Daemon und kommuniziert über Dateideskriptoren `${CALC[0]}` und `${CALC[1]}`. + +--- + +## 🧪 Tests ausführen + +```bash +# Eigene Lösung testen: +bash test_aufgabe.sh + +# Musterlösung testen: +bash test_aufgabe.sh musterloesung.sh +``` diff --git a/courses/bash/10_prozess_substitution_und_coproc/aufgabe.sh b/courses/bash/10_prozess_substitution_und_coproc/aufgabe.sh new file mode 100644 index 0000000..07aa664 --- /dev/null +++ b/courses/bash/10_prozess_substitution_und_coproc/aufgabe.sh @@ -0,0 +1,120 @@ +#!/usr/bin/env bash +# ============================================================================== +# Bash 10: Prozess-Substitution, Named Pipes & Co-Prozesse (coproc) +# ============================================================================== +# In diesem Modul lernst du fortschrittliche Linux IPC-Mechanismen: +# Process Substitution <(...), Stream-Fächerung >(...), Named Pipes (mkfifo) +# und interaktive Co-Prozesse (coproc). +# ============================================================================== + +# ------------------------------------------------------------------------------ +# TODO 1: Befehlsausgaben ohne temporäre Dateien vergleichen (<(...)) +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `compare_command_outputs`. +# Parameter: +# $1: Erster Bash-Befehl als String (z.B. "sort liste1.txt") +# $2: Zweiter Bash-Befehl als String (z.B. "sort liste2.txt") +# Verhalten: +# - Vergleicht die Ausgaben beider Befehle direkt mit `diff -u` und Prozess-Substitution: +# diff -u <(bash -c "$1") <(bash -c "$2") +# - Wenn beide Ausgaben identisch sind: Gib "IDENTICAL" aus und return 0. +# - Wenn Unterschiede existieren: Gib den Diff aus und return 1. +# ------------------------------------------------------------------------------ +compare_command_outputs() { + local cmd1="${1:-}" + local cmd2="${2:-}" + + # TODO: Prüfe Parameter + # TODO: Führe diff -u mit <(bash -c "$cmd1") und <(bash -c "$cmd2") aus + echo "TODO: Implementiere compare_command_outputs" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 2: Stream-Verzweigung mit tee & >(...) +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `stream_splitter_tee`. +# Parameter: +# $1: Eingabetext (z.B. "Fehler: Connection Timeout auf DB-Server") +# $2: Pfad zur Roh-Logdatei (z.B. "/tmp/raw.log") +# $3: Pfad zur transformierten Datei (z.B. "/tmp/uppercase.log") +# Verhalten: +# - Schreibt den Eingabetext unverändert in $2. +# - Leitet den Text gleichzeitig über Prozess-Substitution `>(tr '[:lower:]' '[:upper:]' > "$3")` +# in Großbuchstaben nach $3 um (mit `tee`). +# - Wartet kurz/synchronisiert, sodass beide Dateien vollständig geschrieben sind. +# - Return 0 bei Erfolg. +# ------------------------------------------------------------------------------ +stream_splitter_tee() { + local input_text="${1:-}" + local raw_file="${2:-}" + local upper_file="${3:-}" + + # TODO: Validiere Parameter + # TODO: Nutze echo "$input_text" | tee "$raw_file" >(tr '[:lower:]' '[:upper:]' > "$upper_file") > /dev/null + echo "TODO: Implementiere stream_splitter_tee" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 3: Interprozesskommunikation über Named Pipe (FIFO) +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `named_pipe_transfer`. +# Parameter: +# $1: Pfad zur Named Pipe (z.B. "/tmp/test_fifo") +# $2: Zu übertragende Nachricht (z.B. "DEPLOYMENT_TRIGGER_V2") +# Verhalten: +# - Erstellt eine Named Pipe mit `mkfifo "$1"`. Falls die Pipe existiert, vorher löschen. +# - Schreibt im Hintergrund (`&`) die Nachricht $2 in die Pipe. +# - Liest im Hauptprozess die Nachricht aus der Pipe in eine Variable `received`. +# - Löscht die Pipe nach erfolgreichem Lesen (`rm -f "$1"`). +# - Gibt aus: "RECEIVED_FIFO: $received" +# - Return 0. +# ------------------------------------------------------------------------------ +named_pipe_transfer() { + local fifo_path="${1:-}" + local message="${2:-}" + + # TODO: Erstelle FIFO mit mkfifo + # TODO: Schreibe im Hintergrund ($message > $fifo_path &) + # TODO: Lies synchron (read -r received < $fifo_path) + # TODO: Bereinige FIFO und gib "RECEIVED_FIFO: $received" aus + echo "TODO: Implementiere named_pipe_transfer" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 4: Interaktiver Co-Prozess (coproc) +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `coproc_calculator_interactive`. +# Parameter: +# $1: Erster mathematischer Ausdruck (z.B. "10 + 25") +# $2: Zweiter mathematischer Ausdruck (z.B. "100 * 4") +# Verhalten: +# - Startet einen Co-Prozess namens CALC mit Bash: +# coproc CALC { +# while read -r expr; do +# [ "$expr" = "EXIT" ] && break +# echo "$((expr))" +# done +# } +# - Sendet $1 an den Co-Prozess (`${CALC[1]}`), liest das Ergebnis aus (`${CALC[0]}`). +# - Sendet $2 an den Co-Prozess, liest das zweite Ergebnis aus. +# - Sendet "EXIT" an den Co-Prozess zum sauberen Beenden. +# - Gibt die Ergebnisse aus: +# CALC_RES1: +# CALC_RES2: +# - Return 0. +# ------------------------------------------------------------------------------ +coproc_calculator_interactive() { + local expr1="${1:-}" + local expr2="${2:-}" + + # TODO: Starte coproc CALC + # TODO: Sende expr1, lies res1 + # TODO: Sende expr2, lies res2 + # TODO: Sende EXIT + # TODO: Gib formatiertes Ergebnis aus + echo "TODO: Implementiere coproc_calculator_interactive" + return 1 +} diff --git a/courses/bash/10_prozess_substitution_und_coproc/index.html b/courses/bash/10_prozess_substitution_und_coproc/index.html new file mode 100644 index 0000000..bad94ec --- /dev/null +++ b/courses/bash/10_prozess_substitution_und_coproc/index.html @@ -0,0 +1,140 @@ + + + + + + Bash 10: Prozess-Substitution & Co-Prozesse + + + +
+
+
+
+
🚀 Lehrpfad 3: High-Performance & Parallelisierung
+

Bash 10: Prozess-Substitution & Co-Prozesse

+

Nutze Linux-IPC wie ein Meister: Prozess-Substitution <(...), Stream-Fächerung >(...), Named Pipes (mkfifo) und interaktive Co-Prozesse (coproc).

+
+
+ +
+ +
+

🔄 1. Virtuelle Streams mit <(...) und >(...)

+

Prozess-Substitution verwandelt die Ausgabe eines Befehls in einen temporären Dateideskriptor (/dev/fd/XX). Dadurch können Befehle, die Dateien erwarten, direkt mit Streams arbeiten:

+ +
+ diff -u  <(cat remote_host_a.json)  <(cat remote_host_b.json)
+             │                         │
+             ▼                         ▼
+         [/dev/fd/63]              [/dev/fd/62]
+             └─────────▶ [ diff ] ◀─────────┘ +
+ + 
# 🎯 Dateien ohne Zwischenspeichern vergleichen:
+diff -u <(curl -s https://api.a.com/status) <(curl -s https://api.b.com/status)
+
+# 🎯 Gleichzeitig in Datei und Filter-Pipe schreiben:
+echo "Incoming Request" | tee >(logger -t "APP") > access.log
+
+ + +
+

🧵 2. Interaktive Co-Prozesse (coproc) & Named Pipes (mkfifo)

+

Wenn dein Skript mit einem Hintergrundprozess im Ping-Pong-Verfahren Daten austauschen muss, sind Co-Prozesse das mächtigste Werkzeug:

+ + 
# 🤖 Co-Prozess im Hintergrund starten:
+coproc CALC {
+    while read -r expr; do
+        [ "$expr" = "QUIT" ] && break
+        echo "$((expr))"
+    done
+}
+
+# 📤 Senden an coproc:
+echo "10 + 20" >&"${CALC[1]}"
+
+# 📥 Empfangen von coproc:
+read -r antwort <&"${CALC[0]}"
+echo "Ergebnis: $antwort" # 30
+ +
+
📻 Didaktische Analogie: Das Walkie-Talkie für Prozesse
+

Standard-Pipes (|) sind wie eine Einbahnstraße (Wasserrohr). Ein Co-Prozess ist wie ein Walkie-Talkie mit zwei Kanälen: Kanal 1 (${NAME[1]}) zum Sprechen/Senden und Kanal 0 (${NAME[0]}) zum Hören/Empfangen!

+
+
+ + +
+

📑 3. Cheat-Sheet: IPC & Prozess-Substitution

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SyntaxTypEinsatzzweck
<(cmd)Process Substitution (Read)Befehlsausgabe als virtuelle Datei lesen
>(cmd)Process Substitution (Write)Datenstrom an Befehlseingabe leiten
mkfifo /tmp/pipeNamed Pipe (FIFO)Dateisystem-Puffer zwischen unabhängigen Skripten
coproc NAME { ... }Co-ProzessBidirektionaler Hintergrund-Daemon in Bash
>&"${NAME[1]}"File Descriptor WriteIn stdin des Co-Prozesses schreiben
+
+
+ + +
+

🎯 Aufgaben & Checkliste in aufgabe.sh

+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ + +
+
+
+
+ + diff --git a/courses/bash/10_prozess_substitution_und_coproc/musterloesung.sh b/courses/bash/10_prozess_substitution_und_coproc/musterloesung.sh new file mode 100644 index 0000000..9dda858 --- /dev/null +++ b/courses/bash/10_prozess_substitution_und_coproc/musterloesung.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +# ============================================================================== +# Bash 10: Prozess-Substitution, Named Pipes & Co-Prozesse (coproc) +# MUSTERLÖSUNG +# ============================================================================== + +compare_command_outputs() { + local cmd1="${1:-}" + local cmd2="${2:-}" + + if [ -z "$cmd1" ] || [ -z "$cmd2" ]; then + return 1 + fi + + # Vergleiche Ausgaben via Prozess-Substitution + if diff_output=$(diff -u <(bash -c "$cmd1") <(bash -c "$cmd2")); then + echo "IDENTICAL" + return 0 + else + echo "$diff_output" + return 1 + fi +} + +stream_splitter_tee() { + local input_text="${1:-}" + local raw_file="${2:-}" + local upper_file="${3:-}" + + if [ -z "$input_text" ] || [ -z "$raw_file" ] || [ -z "$upper_file" ]; then + return 1 + fi + + # Stream-Verzweigung mit tee und Prozess-Substitution + echo "$input_text" | tee "$raw_file" >(tr '[:lower:]' '[:upper:]' > "$upper_file") > /dev/null + + # Kurze Synchronisation für den asynchronen Sub-Stream + sleep 0.05 + return 0 +} + +named_pipe_transfer() { + local fifo_path="${1:-}" + local message="${2:-}" + + if [ -z "$fifo_path" ] || [ -z "$message" ]; then + return 1 + fi + + rm -f "$fifo_path" + mkfifo "$fifo_path" + + # Im Hintergrund in die Pipe schreiben + ( + echo "$message" > "$fifo_path" + ) & + + # Synchron aus der Pipe lesen + local received + read -r received < "$fifo_path" + + # Aufräumen + rm -f "$fifo_path" + + echo "RECEIVED_FIFO: $received" + return 0 +} + +coproc_calculator_interactive() { + local expr1="${1:-}" + local expr2="${2:-}" + + if [ -z "$expr1" ] || [ -z "$expr2" ]; then + return 1 + fi + + # Co-Prozess starten + coproc CALC { + while read -r expr; do + if [ "$expr" = "EXIT" ]; then + break + fi + echo "$((expr))" + done + } + + # Interaktiver Datenaustausch + echo "$expr1" >&"${CALC[1]}" + local res1 + read -r res1 <&"${CALC[0]}" + + echo "$expr2" >&"${CALC[1]}" + local res2 + read -r res2 <&"${CALC[0]}" + + # Co-Prozess beenden + echo "EXIT" >&"${CALC[1]}" + wait "$CALC_PID" 2>/dev/null || true + + echo "CALC_RES1: $res1" + echo "CALC_RES2: $res2" + return 0 +} diff --git a/courses/bash/10_prozess_substitution_und_coproc/test_aufgabe.sh b/courses/bash/10_prozess_substitution_und_coproc/test_aufgabe.sh new file mode 100644 index 0000000..d38359b --- /dev/null +++ b/courses/bash/10_prozess_substitution_und_coproc/test_aufgabe.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash +# ============================================================================== +# Testsuite: Bash 10 - Prozess-Substitution & Co-Prozesse +# ============================================================================== +set -e + +TARGET_FILE="${1:-aufgabe.sh}" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +TARGET_PATH="${SCRIPT_DIR}/${TARGET_FILE}" + +if [ ! -f "$TARGET_PATH" ]; then + echo "❌ Fehler: Zieldatei '$TARGET_PATH' nicht gefunden!" + exit 1 +fi + +source "$TARGET_PATH" + +passed=0 +total=4 + +echo "🧪 Starte Tests für Modul 10 (${TARGET_FILE})..." +echo "---------------------------------------------------------" + +# TEST 1: compare_command_outputs +out1_same=$(compare_command_outputs "echo 'hello world'" "printf '%s\n' 'hello world'" || true) +if [ "$out1_same" = "IDENTICAL" ]; then + echo "✓ Test 1/4: compare_command_outputs erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 1/4 fehlgeschlagen: Erwartete 'IDENTICAL', erhalten: $out1_same" +fi + +# TEST 2: stream_splitter_tee +TMP_RAW=$(mktemp) +TMP_UPPER=$(mktemp) +stream_splitter_tee "nginx error 502" "$TMP_RAW" "$TMP_UPPER" +sleep 0.1 + +raw_content=$(cat "$TMP_RAW") +upper_content=$(cat "$TMP_UPPER") +rm -f "$TMP_RAW" "$TMP_UPPER" + +if [ "$raw_content" = "nginx error 502" ] && [ "$upper_content" = "NGINX ERROR 502" ]; then + echo "✓ Test 2/4: stream_splitter_tee erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 2/4 fehlgeschlagen: raw='$raw_content', upper='$upper_content'" +fi + +# TEST 3: named_pipe_transfer +TMP_FIFO="/tmp/test_pipe_$(date +%s)_$$" +out3=$(named_pipe_transfer "$TMP_FIFO" "DEPLOY_PAYLOAD_889" || true) + +if [ "$out3" = "RECEIVED_FIFO: DEPLOY_PAYLOAD_889" ] && [ ! -e "$TMP_FIFO" ]; then + echo "✓ Test 3/4: named_pipe_transfer erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 3/4 fehlgeschlagen: Output: $out3 (FIFO gelöscht: $([ ! -e "$TMP_FIFO" ] && echo ja || echo nein))" +fi + +# TEST 4: coproc_calculator_interactive +out4=$(coproc_calculator_interactive "15 + 35" "12 * 12" || true) +expected4="CALC_RES1: 50 +CALC_RES2: 144" + +if [ "$(echo "$out4" | tr -d '\r')" = "$expected4" ]; then + echo "✓ Test 4/4: coproc_calculator_interactive erfolgreich bestanden." + passed=$((passed + 1)) +else + echo "✗ Test 4/4 fehlgeschlagen: Erwartete: +$expected4 +Erhalten: +$out4" +fi + +echo "---------------------------------------------------------" +if [ "$passed" -eq "$total" ]; then + echo "🎉 Alle $total Tests für Modul 10 erfolgreich bestanden!" + exit 0 +else + echo "❌ $passed von $total Tests bestanden." + exit 1 +fi diff --git a/courses/bash/11_netzwerk_ssh_und_curl_pipelines/README.md b/courses/bash/11_netzwerk_ssh_und_curl_pipelines/README.md new file mode 100644 index 0000000..0845cd0 --- /dev/null +++ b/courses/bash/11_netzwerk_ssh_und_curl_pipelines/README.md @@ -0,0 +1,68 @@ +# Bash 11: Remote SSH, REST-Pipelines (curl) & rsync Automatisierung 🌐 + +Willkommen zu **Modul 11**! In der modernen Cloud-Infrastruktur müssen Bash-Skripte mit Microservices über REST-APIs kommunizieren, Remote-Server per SSH headless orchestrieren und Datenbestände synchronisieren. + +--- + +## 💡 1. Das Wichtigste in Kürze + +### 1.1 REST-APIs mit `curl` +Ein professioneller API-Aufruf in Bash benötigt Fehlerbehandlung, Header und Zeitlimits: +```bash +# 🎯 Robuster POST-Request mit JSON-Payload & Token: +response=$(curl -s -f -X POST "https://api.cloud.com/v1/alerts" \ + -H "Authorization: Bearer $API_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"status":"CRITICAL","message":"High CPU load"}') + +# 🎯 Nur den HTTP-Statuscode abfragen (Health Check): +http_code=$(curl -s -o /dev/null -w "%{http_code}" "https://app.corp/health") +if [ "$http_code" -ne 200 ]; then + echo "🚨 Service Down! Status: $http_code" +fi +``` + +### 1.2 Non-Interactive Remote SSH Automation +Um Server in CI/CD-Pipelines ohne interaktive Passwort-/Key-Prompts sicher zu steuern: +```bash +# 🎯 Lokales Skript direkt auf Remote-Server ausführen: +ssh -o BatchMode=yes -o StrictHostKeyChecking=no deploy@server.corp "bash -s" < deploy_script.sh + +# 🎯 Remote-Befehlsausgabe in lokales Array einlesen: +readarray -t active_containers < <(ssh deploy@server.corp "docker ps -q") +``` + +### 1.3 Intelligente Synchronisation mit `rsync` +`rsync` synchronisiert nur geänderte Datenblöcke (Delta-Transfer): +```bash +# -a: Archiv (Rechte, Zeitstempel, symlinks) +# -v: Verbose +# -z: Komprimierung während der Übertragung +# --delete: Löscht Dateien im Ziel, die an der Quelle gelöscht wurden +rsync -avz --delete --exclude="*.log" --exclude=".git" /var/www/ app@backup-server:/var/www/ +``` + +--- + +## 🎯 Aufgaben in `aufgabe.sh` + +1. **`build_curl_post_command(endpoint, token, payload)`**: + Formatiert einen robusten `curl -s -f -X POST` Befehl mit Auth- und Content-Type Headern. +2. **`get_http_status_code(url)`**: + Gibt ausschließlich den HTTP Status-Code (z.B. 200, 404, 500) via `curl -s -o /dev/null -w "%{http_code}"` zurück. +3. **`build_ssh_batch_command(user, host, script_file, port)`**: + Erstellt ein headless SSH-Kommando mit `BatchMode=yes`, `StrictHostKeyChecking=no` und `"bash -s" < script`. +4. **`build_rsync_command(src, dest, exclude_pattern, delete_flag)`**: + Konstruiert ein `rsync -avz` Synchronisationskommando mit optionalen Flags `--delete` und `--exclude`. + +--- + +## 🧪 Tests ausführen + +```bash +# Eigene Lösung testen: +bash test_aufgabe.sh + +# Musterlösung testen: +bash test_aufgabe.sh musterloesung.sh +``` diff --git a/courses/bash/11_netzwerk_ssh_und_curl_pipelines/aufgabe.sh b/courses/bash/11_netzwerk_ssh_und_curl_pipelines/aufgabe.sh new file mode 100644 index 0000000..3aa0b99 --- /dev/null +++ b/courses/bash/11_netzwerk_ssh_und_curl_pipelines/aufgabe.sh @@ -0,0 +1,105 @@ +#!/usr/bin/env bash +# ============================================================================== +# Bash 11: Remote SSH, REST-Pipelines (curl) & rsync Automatisierung +# ============================================================================== +# In diesem Modul lernst du, REST-APIs abzufragen, HTTP-Statuscodes zu extrahieren, +# SSH-Befehle im Non-Interactive/Batch-Modus auszuführen und rsync-Pipelines zu steuern. +# ============================================================================== + +# ------------------------------------------------------------------------------ +# TODO 1: HTTP POST Request mit Auth-Header & JSON-Payload generieren/ausführen +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `build_curl_post_command`. +# Parameter: +# $1: API-Endpunkt (z.B. "https://api.cloud.corp/v1/deploy") +# $2: Bearer Auth Token (z.B. "sec_token_999") +# $3: JSON Payload String (z.B. '{"env":"prod","version":"1.4.0"}') +# Verhalten: +# - Gibt den vollständigen, korrekten curl-Befehl als String aus: +# curl -s -f -X POST "" -H "Authorization: Bearer " -H "Content-Type: application/json" -d '' +# - Bei fehlenden Parametern: Return 1. +# ------------------------------------------------------------------------------ +build_curl_post_command() { + local endpoint="${1:-}" + local token="${2:-}" + local payload="${3:-}" + + # TODO: Validiere Parameter + # TODO: Gib formatierten curl-Befehl aus + echo "TODO: Implementiere build_curl_post_command" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 2: HTTP Status Code ermitteln +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `get_http_status_code`. +# Parameter: +# $1: URL (z.B. "https://example.com/health") +# Verhalten: +# - Nutzt curl, um NUR den HTTP Status-Code (z.B. "200", "404", "500") zurückzugeben. +# - Verwendet Optionen: `-s -o /dev/null -w "%{http_code}"` +# - Bei leerem Parameter: Return 1. +# ------------------------------------------------------------------------------ +get_http_status_code() { + local url="${1:-}" + + # TODO: Validiere URL + # TODO: Führe curl aus und gib nur den Status-Code aus + echo "TODO: Implementiere get_http_status_code" + return 1 +} + +# ------------------------------------------------------------------------------ +# TODO 3: Non-Interactive SSH Batch-Befehl mit Skriptübertragung +# ------------------------------------------------------------------------------ +# Implementiere die Funktion `build_ssh_batch_command`. +# Parameter: +# $1: SSH-Benutzer (z.B. "deployer") +# $2: Hostname / IP (z.B. "10.0.1.50") +# $3: Pfad zum lokalen Shell-Skript (z.B. "/opt/setup.sh") +# $4: Port (optional, Default: 22) +# Verhalten: +# - Gibt den sicheren, automatisierten SSH-Befehl aus: +# ssh -p -o BatchMode=yes -o StrictHostKeyChecking=no @ "bash -s" < + + diff --git a/workspace.html b/workspace.html index ac023ca..b17f595 100644 --- a/workspace.html +++ b/workspace.html @@ -332,6 +332,8 @@ + +