AI für Shell Scripts & Automation

AI für Shell Scripts & Automation: Bash, PowerShell und CLI-Tools mit ChatGPT & Claude erstellen. 10 Prompts für Automatisierung und Scripting.

Einleitung

Shell-Scripting und Automatisierung gehören zu den wichtigsten Developer-Skills. AI kennt die Syntax von Bash, PowerShell und Co. auswendig und erstellt robuste Scripts in Sekunden. Hier sind 10 Prompts für Shell Scripts und Automation.

Insbesondere für fortgeschrittene Projekte ist das relevant.

Dementsprechend solltest du die einzelnen Schritte sorgfältig abarbeiten.

Prompt 1: Bash Script erstellen

Zusammenfassend lässt sich sagen, dass dies ein zentraler Aspekt ist.

Erstelle ein Bash Script für:

Aufgabe: [z.B. "Alle .log Dateien älter als 30 Tage löschen"]
OS: [Linux / macOS / beides]

Anforderungen:
1. Shebang (#!/bin/bash) und set -euo pipefail
2. Argumente parsen (getopts oder benannte Parameter)
3. Help/Usage Ausgabe (-h, --help)
4. Input-Validierung (Existiert der Pfad? Sind Rechte da?)
5. Farbige Ausgabe (grün = Erfolg, rot = Fehler)
6. Logging (stdout + optionale Logdatei)
7. Error Handling (trap für Cleanup)
8. Dry-run Modus (--dry-run zeigt was passieren würde)
9. Confirmation Prompt ("Wirklich 47 Dateien löschen? [y/N]")
10. Exit Codes (0 = OK, 1 = Error, 2 = Usage Error)

Best Practices beachten:
- Variablen in Anführungszeichen: "$variable"
- shellcheck-kompatibel
- Portable (POSIX wo möglich)

Natürlich solltest du den generierten Code vor dem Einsatz testen.

Außerdem profitierst du von einem systematischen Vorgehen.

Prompt 2: Datei-Operationen

Dementsprechend solltest du die folgenden Aspekte kennen.

Erstelle Shell-Befehle für Datei-Operationen:

Aufgabe: [z.B. "CSV Dateien verarbeiten, zusammenführen, konvertieren"]

Zeige Lösungen mit:
1. **find**: Dateien suchen (Größe, Datum, Name, Typ)
2. **grep/ripgrep**: Text in Dateien suchen
3. **sed**: Text ersetzen (in-place und mit Backup)
4. **awk**: Spalten extrahieren, Berechnungen, Aggregationen
5. **sort/uniq**: Sortieren, Duplikate, Häufigkeiten
6. **xargs**: Ergebnisse an nächsten Befehl pipen
7. **jq**: JSON Dateien filtern und transformieren
8. **cut/paste**: Spalten ausschneiden, Dateien zusammenführen
9. **wc/head/tail**: Zählen, Anfang/Ende anzeigen
10. **rsync**: Dateien synchronisieren (lokal & remote)

One-Liner + erklärendes Script für jedes Beispiel.
Zeige die Pipe-Kette und erkläre jeden Schritt.

Im Grunde funktioniert dieser Ansatz mit allen gängigen AI-Tools.

Ebenfalls empfehlenswert ist eine regelmäßige Überprüfung der Ergebnisse.

Prompt 3: Cron Jobs & Scheduling

Somit kannst du direkt mit der Umsetzung beginnen.

Richte Cron Jobs / Scheduled Tasks ein:

Aufgaben:
1. [z.B. "Backup täglich um 3:00 Uhr"]
2. [z.B. "Log Rotation jeden Sonntag"]
3. [z.B. "Health Check alle 5 Minuten"]

Erstelle:
1. Crontab-Eintrag mit Erklärung der Syntax (Min H Tag Mon Wochentag)
2. Das ausgeführte Script (mit Logging!)
3. Fehlerbehandlung (was wenn Script fehlschlägt?)
4. E-Mail/Slack Benachrichtigung bei Fehler
5. Lockfile (Script nicht parallel ausführen)
6. Output Redirect (stdout + stderr in Logdatei)
7. Systemd Timer (Alternative zu Cron, empfohlen!)
8. Anacron (für Rechner die nicht 24/7 laufen)
9. Monitoring: Healthchecks.io oder Cronitor
10. Testing: Cron-Job manuell testen vor dem Einrichten

Häufige Fehler:
- PATH nicht gesetzt in Cron
- Relative Pfade funktionieren nicht
- Permissions/User-Kontext falsch

Dabei zeigt dieses Beispiel den grundlegenden Ansatz.

Folglich verbessert sich die gesamte Codequalität deutlich.

Prompt 4: Deployment Scripts

Ebenfalls relevant sind die praktischen Anwendungsbeispiele.

Erstelle ein Deployment Script:

Projekt: [z.B. "Node.js App auf Linux Server"]
Methode: [SSH / Docker / rsync / Git Pull]

Implementiere:
1. **Pre-Deploy Checks**: Tests durchlaufen? Branch korrekt? .env vorhanden?
2. **Backup**: Aktuellen Stand sichern vor Deploy
3. **Upload**: Code auf Server (rsync, scp, git pull)
4. **Dependencies**: npm install --production
5. **Build**: npm run build (falls nötig)
6. **Migrations**: Datenbank-Migrationen ausführen
7. **Restart**: Service neu starten (systemd, pm2)
8. **Health Check**: Ist die App nach Deploy erreichbar?
9. **Rollback**: Bei Fehler alten Stand wiederherstellen
10. **Notification**: Slack/Discord Nachricht bei Deploy

Bonus:
- Zero-Downtime Deployment (symlink switching)
- Version Tracking (welcher Commit ist deployed?)
- Deploy Lock (nicht parallel deployen)

Zusammenfassend bietet dieser Abschnitt praktische Handlungsempfehlungen.

Prompt 5: Backup & Restore

Grundsätzlich gibt es dabei einige Punkte zu beachten.

Erstelle ein Backup-System mit Shell Scripts:

Was sichern: [z.B. "PostgreSQL DB + /var/www Dateien + Nginx Config"]
Wohin: [z.B. "S3 Bucket + lokale Festplatte"]

Implementiere:
1. **DB Backup**: pg_dump / mysqldump mit Komprimierung
2. **Datei Backup**: tar + gzip mit Exclude-Patterns
3. **Inkrementelles Backup**: Nur geänderte Dateien (rsync, borgbackup)
4. **Verschlüsselung**: gpg oder openssl für sensible Daten
5. **Upload**: S3 (aws cli), B2 (Backblaze), oder SFTP
6. **Rotation**: Letzte 7 Tage, 4 Wochen, 12 Monate aufbewahren
7. **Verifikation**: Backup Integrität prüfen (Checksumme)
8. **Restore Script**: Wiederherstellung testen!
9. **Monitoring**: Warnung wenn Backup fehlschlägt oder ausbleibt
10. **Dokumentation**: README mit Restore-Anleitung

3-2-1 Regel: 3 Kopien, 2 Medien, 1 offsite.
Cron: Automatische Ausführung zur Nachtzeit.

Insbesondere die Struktur des Prompts ist dabei entscheidend für gute Ergebnisse.

Zudem lassen sich die Ergebnisse auch auf andere Projekte übertragen.

Prompt 6: Log-Analyse & Monitoring

Außerdem gibt es hilfreiche Tools, die dich dabei unterstützen.

Erstelle Shell Scripts für Log-Analyse:

Log-Format: [z.B. "Nginx Access Log" / "Application JSON Logs"]
Aufgabe: [z.B. "Fehler-Trends erkennen, Top IPs, langsame Requests"]

Erstelle One-Liner für:
1. Top 10 IP-Adressen (nach Requests)
2. HTTP Status Code Verteilung
3. Langsamste Requests (Response Time > 5s)
4. 404 Errors gruppiert nach URL
5. Requests pro Stunde (Traffic Pattern)
6. Error Rate der letzten 24 Stunden
7. Verdächtige Zugriffe (Rate > 100 req/min pro IP)
8. Disk Space Monitoring mit Alert
9. CPU/Memory Monitoring Script
10. Live Log Tailing mit Filter (tail -f | grep)

Bonus:
- Ergebnisse als Slack/Teams Notification senden
- Einfaches Alerting Script (wenn Threshold überschritten)
- Aggregierte Daten in CSV/JSON exportieren

Weiterhin ist es ratsam, die Ergebnisse immer kritisch zu prüfen.

Deshalb ist es wichtig, diesen Abschnitt aufmerksam zu lesen.

Prompt 7: CLI Tool bauen

Im Folgenden findest du alle wichtigen Details dazu.

Baue ein CLI Tool:

Name: [z.B. "projinit"]
Zweck: [z.B. "Neues Projekt initialisieren mit Template"]
Sprache: [Bash / Node.js (Commander.js) / Python (Click)]

Features:
1. **Subcommands**: projinit create, projinit list, projinit config
2. **Argumente**: projinit create --name myapp --template react
3. **Interaktiver Modus**: Fragen stellen wenn Argumente fehlen
4. **Config File**: ~/.projinit.yaml für Defaults
5. **Farbige Ausgabe**: chalk/rich/tput für formatierte Ausgabe
6. **Progress Bar**: Für lange Operationen
7. **Tab Completion**: Bash/Zsh Autocomplete
8. **Versionierung**: --version Flag
9. **Error Messages**: Hilfreiche Fehlermeldungen
10. **Man Page / README**: Dokumentation generieren

Distribution:
- npm publish (Node.js)
- Homebrew Formula (macOS)
- Single binary (pkg, PyInstaller)

Dementsprechend ist eine manuelle Überprüfung empfehlenswert.

Grundsätzlich empfiehlt es sich, schrittweise vorzugehen.

Prompt 8: PowerShell Scripts

Dennoch solltest du einige Besonderheiten beachten.

Erstelle PowerShell Scripts für:

Aufgabe: [z.B. "Windows Server Administration automatisieren"]

Erstelle:
1. **Service Management**: Dienste prüfen, starten, stoppen
2. **Datei-Operationen**: Bulk Rename, Move, Cleanup
3. **Registry**: Einstellungen lesen und setzen
4. **Netzwerk**: Ports prüfen, DNS Tests, Connectivity
5. **Active Directory**: User anlegen, Gruppen verwalten
6. **Scheduled Tasks**: Windows Task Scheduler konfigurieren
7. **Event Log**: Fehler im Windows Event Log filtern
8. **IIS Management**: Website erstellen, App Pool verwalten
9. **Remote Execution**: Invoke-Command auf mehreren Servern
10. **Reporting**: HTML Report generieren (ConvertTo-Html)

PowerShell Best Practices:
- Approved Verbs (Get-, Set-, New-, Remove-)
- Parameter-Validierung ([ValidateSet], [ValidateRange])
- -WhatIf und -Confirm Support
- Proper Error Handling (try/catch/finally)
- Pipeline Support (ValueFromPipeline)

Zusätzlich gibt es einige bewährte Tipps für den Alltag.

Prompt 9: Git Hooks & Workflows

Natürlich gibt es dabei verschiedene Herangehensweisen.

Erstelle Git Hooks für mein Projekt:

Projekt: [z.B. "Node.js Monorepo"]
Tools: [Husky / lefthook / native Git Hooks]

Implementiere:
1. **pre-commit**: Lint + Format (lint-staged)
2. **commit-msg**: Conventional Commits erzwingen
3. **pre-push**: Tests laufen lassen, keine Secrets pushen
4. **post-merge**: npm install wenn package.json geändert
5. **prepare-commit-msg**: Branch-Name in Commit einfügen
6. **post-checkout**: .env Datei prüfen, Dependencies updaten

Automatisierung:
7. **Release Script**: Changelog generieren, Version bumpen, Tag
8. **Branch Cleanup**: Merged Branches löschen
9. **PR Template**: Automatisch Vorlage laden
10. **Danger/GitHub Actions**: CI als "Hook" nutzen

Setup:
- Husky installieren und konfigurieren
- lint-staged für staged-only Linting
- commitlint für Commit Message Format

Deshalb empfiehlt es sich, den Prompt schrittweise zu verfeinern.

Allerdings gibt es dabei einige Punkte, die du beachten solltest.

Prompt 10: Makefile & Task Runner

Dabei spielen mehrere Faktoren eine wichtige Rolle.

Erstelle ein Makefile / Task Runner für mein Projekt:

Projekt: [z.B. "Docker-basierte Microservices"]
Alternative: [Makefile / Just / Task (taskfile.dev)]

Erstelle Tasks für:
1. **make dev**: Lokale Entwicklungsumgebung starten
2. **make build**: Projekt bauen (Docker Images)
3. **make test**: Alle Tests ausführen
4. **make lint**: Linting und Formatting
5. **make deploy**: Production Deployment
6. **make db-migrate**: Datenbank Migrationen
7. **make seed**: Testdaten einfügen
8. **make clean**: Aufräumen (Caches, Build Artifacts)
9. **make docs**: Dokumentation generieren
10. **make help**: Alle verfügbaren Commands mit Beschreibung

Makefile Features:
- .PHONY für nicht-Datei Targets
- Variablen und Umgebungsvariablen
- Abhängigkeiten zwischen Targets
- Conditional Execution
- Self-documenting (make help autogeneriert)

Somit sparst du Zeit und erhältst qualitativ hochwertigeren Output.

Dabei ist der folgende Punkt besonders wichtig.

FAQ

Bash oder Python für Scripts?

Vor allem für den praktischen Einsatz sind diese Informationen wertvoll.

Bash für einfache Datei-Operationen, Pipes und System-Tasks (< 50 Zeilen). Python sobald es komplex wird: Error Handling, APIs, Datenstrukturen, Tests. Faustregel: Wenn du ein Array brauchst, nimm Python.

Wie teste ich Shell Scripts?

Im Grunde vereinfacht dieser Ansatz den gesamten Workflow erheblich.

Nutze shellcheck für statische Analyse, bats-core für Unit Tests, und Docker für isolierte Test-Umgebungen. Immer mit –dry-run Modus entwickeln. AI kann Tests für deine Scripts schreiben.

Wie sicher ist AI-generierter Shell Code?

Darüber hinaus bietet dieser Abschnitt konkrete Beispiele und Tipps.

Vorsicht bei rm -rf, chmod, und sudo Befehlen! AI generiert funktionierenden Code, aber prüfe immer: Werden Pfade korrekt gequotet? Gibt es Race Conditions? Laufen Befehle mit zu vielen Rechten? Teste in einer Sandbox.

Vor allem in der Praxis hat sich dieser Workflow bewährt.

Verwandte Artikel:

Darüber hinaus solltest du diesen Aspekt berücksichtigen.

Zuletzt aktualisiert: März 2026