15 Netzwerkprogrammierung mit Bash

# Grundlegende Verwendung
ping example.com

# Begrenzung auf eine bestimmte Anzahl von Anfragen
ping -c 4 192.168.1.1

# Intervall zwischen Ping-Anfragen festlegen (in Sekunden)
ping -i 2 example.com

# Standardverwendung
traceroute example.com

# Verwendung mit UDP-Paketen
traceroute -U example.com

# Alternative mit weniger Privilegien
tracepath example.com

# Alle offenen Ports anzeigen
netstat -tuln

# Verbindungen mit PID und Programmnamen
netstat -tulnp

# Mit ss (Socket Statistics)
ss -tuln

# Netzwerkschnittstellen anzeigen
ip addr show

# Routing-Tabelle anzeigen
ip route show

# ARP-Tabelle anzeigen
ip neigh show

# Detaillierte DNS-Informationen abfragen
dig example.com

# Einfachere Alternative
nslookup example.com

# Kompakte Ausgabe
host example.com

# Reverse-DNS-Lookup
dig -x 8.8.8.8

#!/bin/bash

# Datei mit Hostnamen oder IP-Adressen
HOSTS_FILE="/path/to/hosts.txt"
LOG_FILE="/var/log/host_monitor.log"
MAX_TIMEOUT=2  # Timeout in Sekunden

if [[ ! -f "$HOSTS_FILE" ]]; then
    echo "Fehler: Hosts-Datei nicht gefunden: $HOSTS_FILE" >&2
    exit 1
fi

date_str=$(date "+%Y-%m-%d %H:%M:%S")
echo "=== Netzwerk-Check gestartet: $date_str ===" >> "$LOG_FILE"

while read -r host; do
    # Kommentare und leere Zeilen überspringen
    [[ "$host" =~ ^# ]] || [[ -z "$host" ]] && continue
    
    echo "Prüfe Host: $host" >> "$LOG_FILE"
    
    # Ping mit einem Timeout und nur einem Paket
    if ping -c 1 -W "$MAX_TIMEOUT" "$host" &>/dev/null; then
        echo "  Status: ERREICHBAR" >> "$LOG_FILE"
    else
        echo "  Status: NICHT ERREICHBAR" >> "$LOG_FILE"
        # Optional: Alarmierung per E-Mail oder andere Aktionen
    fi
done < "$HOSTS_FILE"

echo "=== Netzwerk-Check beendet ===" >> "$LOG_FILE"

#!/bin/bash

# HTTP-Anfrage an einen Webserver senden
exec 3<>/dev/tcp/example.com/80
echo -e "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n" >&3
cat <&3
exec 3>&-  # Socket schließen

#!/bin/bash

HOST="192.168.1.1"
START_PORT=1
END_PORT=1024
TIMEOUT=1

echo "Scanne Ports $START_PORT bis $END_PORT auf $HOST..."

for port in $(seq $START_PORT $END_PORT); do
    (timeout $TIMEOUT bash -c "echo > /dev/tcp/$HOST/$port" 2>/dev/null && 
        echo "Port $port ist offen") &
    
    # Begrenze die Anzahl der gleichzeitigen Prozesse
    if [[ $(jobs -r | wc -l) -ge 20 ]]; then
        wait -n
    fi
done

wait  # Warte auf alle Hintergrundprozesse
echo "Scan abgeschlossen."

#!/bin/bash

INTERFACE="eth0"
LOG_FILE="/var/log/network_stats.log"
INTERVAL=300  # Sekunden

# Prüfe, ob das Interface existiert
if ! ip link show "$INTERFACE" &>/dev/null; then
    echo "Fehler: Interface $INTERFACE nicht gefunden" >&2
    exit 1
fi

while true; do
    timestamp=$(date "+%Y-%m-%d %H:%M:%S")
    
    # Netzwerkstatistiken aus /proc/net/dev erfassen
    stats=$(grep "$INTERFACE:" /proc/net/dev | awk '{print $2, $10}')
    rx_bytes=$(echo "$stats" | awk '{print $1}')
    tx_bytes=$(echo "$stats" | awk '{print $2}')
    
    echo "$timestamp,$INTERFACE,$rx_bytes,$tx_bytes" >> "$LOG_FILE"
    
    sleep "$INTERVAL"
done

#!/bin/bash

# Grundlegende GET-Anfrage
curl -s https://api.example.com/status

# POST-Anfrage mit JSON-Daten
curl -X POST \
     -H "Content-Type: application/json" \
     -d '{"key": "value"}' \
     https://api.example.com/update

# Datei herunterladen mit Fortschrittsanzeige
wget --progress=bar https://example.com/large-file.tar.gz

# Website-Zustand überwachen
check_website() {
    local url="$1"
    local expected_status="$2"
    
    # HTTP-Statuscode abrufen
    status=$(curl -s -o /dev/null -w "%{http_code}" "$url")
    
    if [[ "$status" == "$expected_status" ]]; then
        echo "OK: $url returned status $status"
        return 0
    else
        echo "FEHLER: $url returned status $status (expected $expected_status)"
        return 1
    fi
}

# Verwendung
check_website "https://example.com" "200"

#!/bin/bash

LOG_FILE="/var/log/auth.log"
THRESHOLD=5  # Schwellenwert für fehlgeschlagene Anmeldeversuche
BAN_SCRIPT="/usr/local/bin/ban_ip.sh"

# Fehlgeschlagene SSH-Anmeldeversuche zählen
failed_attempts=$(grep "Failed password" "$LOG_FILE" | awk '{print $11}' | sort | uniq -c)

echo "$failed_attempts" | while read count ip; do
    if [[ $count -ge $THRESHOLD ]]; then
        echo "IP $ip hat $count fehlgeschlagene Anmeldeversuche"
        
        # Optional: IP-Adresse blockieren
        if [[ -x "$BAN_SCRIPT" ]]; then
            "$BAN_SCRIPT" "$ip"
            echo "IP $ip wurde blockiert"
        fi
    fi
done

# Grundlegende Anfrage - Ausgabe auf stdout
curl https://example.com

# Stille Ausgabe (nur Inhalt, keine Fortschrittsanzeige)
curl -s https://example.com

# Ausgabe in eine Datei umleiten
curl -o output.html https://example.com

# Datei mit Originalname speichern
curl -O https://example.com/document.pdf

# Header einer Anfrage anzeigen
curl -I https://example.com

# Benutzerdefinierte Header senden
curl -H "User-Agent: MeinScript/1.0" \
     -H "Accept: application/json" \
     https://api.example.com
     
# Nur Response-Header anzeigen
curl --head https://example.com

# POST-Anfrage mit Formular-Daten
curl -X POST \
     -d "username=benutzer&password=geheim" \
     https://example.com/login

# POST mit JSON-Daten
curl -X POST \
     -H "Content-Type: application/json" \
     -d '{"username":"benutzer","password":"geheim"}' \
     https://api.example.com/login
     
# PUT-Anfrage zum Aktualisieren von Ressourcen
curl -X PUT \
     -H "Content-Type: application/json" \
     -d '{"status":"active"}' \
     https://api.example.com/users/123

# DELETE-Anfrage
curl -X DELETE https://api.example.com/users/123

# Basic Authentication
curl -u username:password https://example.com/secured

# OAuth2 Bearer Token
curl -H "Authorization: Bearer mein_access_token" \
     https://api.example.com/protected-resource

# Cookies speichern
curl -c cookies.txt https://example.com/login

# Gespeicherte Cookies verwenden
curl -b cookies.txt https://example.com/dashboard

# Cookies in derselben Session verwenden
curl -b cookies.txt -c cookies.txt https://example.com/next-page

# Maximale Übertragungszeit festlegen
curl --max-time 10 https://example.com

# HTTP-Weiterleitungen folgen
curl -L https://example.com/redirect

# Proxy verwenden
curl -x http://proxy.example.com:8080 https://target.com

# Zertifikatsprüfung überspringen (nur zu Testzwecken!)
curl -k https://self-signed.example.com

# Ausgabe mit detaillierten Informationen
curl -v https://example.com

# Nur bestimmte HTTP-Statuscode akzeptieren
curl --write-out "%{http_code}\n" --silent --output /dev/null https://example.com

# Grundlegende Verwendung
wget https://example.com/file.zip

# Ausgabedatei umbenennen
wget -O neuername.zip https://example.com/file.zip

# Im Hintergrund ausführen
wget -b https://example.com/large-file.iso

# Website spiegeln (mit Einschränkungen)
wget -m -p -k https://example.com

# Rekursiv mit Tiefenbegrenzung
wget -r -l 2 https://example.com

# Bandbreitenbegrenzung (auf 100KB/s)
wget --limit-rate=100k https://example.com/large-file.iso

# Fortsetzung unterbrochener Downloads
wget -c https://example.com/large-file.iso

# Retry bei Fehler
wget -t 5 https://unreliable-server.com/file.zip

# Basic Auth
wget --user=username --password=password https://example.com/secure

# Verwenden von .netrc für Anmeldedaten
wget --use-askpass https://example.com/secure

#!/bin/bash

API_KEY="your_api_key"
CITY="Berlin"
OUTPUT_FILE="/tmp/weather_report.json"

# OpenWeatherMap API abfragen
curl -s "https://api.openweathermap.org/data/2.5/weather?q=${CITY}&appid=${API_KEY}&units=metric" > "$OUTPUT_FILE"

# Daten extrahieren mit jq (wenn verfügbar)
if command -v jq &>/dev/null; then
    temperature=$(jq '.main.temp' "$OUTPUT_FILE")
    description=$(jq -r '.weather[0].description' "$OUTPUT_FILE")
    echo "Wetter in $CITY: $description, $temperature°C"
else
    # Alternativ mit grep und awk
    temperature=$(grep -o '"temp":[^,]*' "$OUTPUT_FILE" | awk -F: '{print $2}')
    echo "Temperatur in $CITY: $temperature°C"
fi

#!/bin/bash

# Zu überwachende Websites
SITES=("https://example.com" "https://example.org" "https://example.net")
LOG_FILE="/var/log/website_monitor.log"
ALERT_SCRIPT="/path/to/alert.sh"

check_website() {
    local url="$1"
    local start_time=$(date +%s.%N)
    
    # HTTP-Statuscode und Antwortzeit messen
    local response=$(curl -s -w "%{http_code},%{time_total}" -o /dev/null "$url")
    local status_code=$(echo "$response" | cut -d, -f1)
    local response_time=$(echo "$response" | cut -d, -f2)
    
    local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
    
    if [ "$status_code" -eq 200 ]; then
        echo "$timestamp - $url - OK (Status: $status_code, Zeit: ${response_time}s)" >> "$LOG_FILE"
        return 0
    else
        echo "$timestamp - $url - FEHLER (Status: $status_code, Zeit: ${response_time}s)" >> "$LOG_FILE"
        
        # Alarmierung, wenn Status nicht 200 ist
        if [ -x "$ALERT_SCRIPT" ]; then
            "$ALERT_SCRIPT" "$url" "$status_code" "$response_time"
        fi
        return 1
    fi
}

# Jede Website prüfen
for site in "${SITES[@]}"; do
    check_website "$site"
done

#!/bin/bash

DOWNLOAD_URL="https://example.com/daily-report.csv"
DOWNLOAD_DIR="/var/data/reports"
ARCHIVE_DIR="/var/data/archive"
LOG_FILE="/var/log/download.log"

# Sicherstellen, dass die Verzeichnisse existieren
mkdir -p "$DOWNLOAD_DIR" "$ARCHIVE_DIR"

# Aktuelles Datum für Dateinamen
DATE=$(date +%Y-%m-%d)
FILENAME="report-$DATE.csv"

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

# Download mit wget
log "Starte Download von $DOWNLOAD_URL"
if wget -q --tries=3 --timeout=15 -O "$DOWNLOAD_DIR/$FILENAME" "$DOWNLOAD_URL"; then
    log "Download erfolgreich: $FILENAME"
    
    # Datei verarbeiten
    RECORD_COUNT=$(wc -l < "$DOWNLOAD_DIR/$FILENAME")
    log "Anzahl der Datensätze: $RECORD_COUNT"
    
    # Archivierung
    gzip -c "$DOWNLOAD_DIR/$FILENAME" > "$ARCHIVE_DIR/$FILENAME.gz"
    log "Datei archiviert: $ARCHIVE_DIR/$FILENAME.gz"
    
    # Weitere Verarbeitung hier...
else
    log "Download fehlgeschlagen mit Fehlercode $?"
    exit 1
fi

#!/bin/bash

API_BASE="https://api.example.com/v1"
TOKEN="your_access_token"
CONFIG_FILE=".api_config"

# Konfigurationsdatei laden, falls vorhanden
if [[ -f "$CONFIG_FILE" ]]; then
    source "$CONFIG_FILE"
fi

# API-Anfrage-Funktion mit curl
api_request() {
    local method="$1"
    local endpoint="$2"
    local data="$3"
    
    # Header für alle Anfragen
    local headers=(
        -H "Authorization: Bearer $TOKEN"
        -H "Content-Type: application/json"
        -H "Accept: application/json"
    )
    
    # Anfrage ausführen
    if [[ -n "$data" ]]; then
        curl -s -X "$method" "${headers[@]}" -d "$data" "${API_BASE}${endpoint}"
    else
        curl -s -X "$method" "${headers[@]}" "${API_BASE}${endpoint}"
    fi
}

# Verschiedene API-Funktionen
get_resource() {
    local resource_id="$1"
    api_request "GET" "/resources/$resource_id"
}

create_resource() {
    local resource_data="$1"
    api_request "POST" "/resources" "$resource_data"
}

update_resource() {
    local resource_id="$1"
    local resource_data="$2"
    api_request "PUT" "/resources/$resource_id" "$resource_data"
}

delete_resource() {
    local resource_id="$1"
    api_request "DELETE" "/resources/$resource_id"
}

# Beispielverwendung
case "$1" in
    "list")
        api_request "GET" "/resources" | jq '.'
        ;;
    "get")
        get_resource "$2" | jq '.'
        ;;
    "create")
        create_resource "$2" | jq '.'
        ;;
    "update")
        update_resource "$2" "$3" | jq '.'
        ;;
    "delete")
        delete_resource "$2"
        ;;
    *)
        echo "Verwendung: $0 {list|get|create|update|delete} [id] [json_data]"
        exit 1
        ;;
esac

#!/bin/bash

# URLs zum Abrufen
mapfile -t URLS < urls.txt

# Maximale Anzahl gleichzeitiger Prozesse
MAX_PROCS=10
current_procs=0

for url in "${URLS[@]}"; do
    # Warten, wenn die maximale Anzahl erreicht ist
    if [[ $current_procs -ge $MAX_PROCS ]]; then
        wait -n  # Warten auf Beendigung eines Prozesses
        ((current_procs--))
    fi
    
    # Anfrage im Hintergrund starten
    (curl -s "$url" > "$(basename "$url").html") &
    ((current_procs++))
done

# Auf verbleibende Prozesse warten
wait

# GET: Daten abrufen
curl -s "https://api.example.com/users/123"

# POST: Neue Ressource erstellen
curl -s -X POST \
     -H "Content-Type: application/json" \
     -d '{"name": "Max Mustermann", "email": "max@example.com"}' \
     "https://api.example.com/users"

# PUT: Bestehende Ressource aktualisieren
curl -s -X PUT \
     -H "Content-Type: application/json" \
     -d '{"name": "Max Meier", "email": "max@example.com"}' \
     "https://api.example.com/users/123"

# PATCH: Teilweise Aktualisierung einer Ressource
curl -s -X PATCH \
     -H "Content-Type: application/json" \
     -d '{"email": "neuemail@example.com"}' \
     "https://api.example.com/users/123"

# DELETE: Ressource löschen
curl -s -X DELETE "https://api.example.com/users/123"

#!/bin/bash

API_KEY="Ihr_API_Key_hier"
API_ENDPOINT="https://api.example.com/data"

# API-Key als Query-Parameter
curl -s "${API_ENDPOINT}?api_key=${API_KEY}"

# API-Key als Header
curl -s -H "X-API-Key: ${API_KEY}" "${API_ENDPOINT}"

#!/bin/bash

# Konfiguration
CLIENT_ID="Ihre_Client_ID"
CLIENT_SECRET="Ihr_Client_Secret"
TOKEN_URL="https://auth.example.com/oauth/token"
API_ENDPOINT="https://api.example.com/protected-resource"

# Token anfordern
token_response=$(curl -s -X POST "${TOKEN_URL}" \
                      -d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}")

# Token extrahieren (erfordert jq für JSON-Verarbeitung)
access_token=$(echo "${token_response}" | jq -r '.access_token')

# API mit Bearer-Token aufrufen
curl -s -H "Authorization: Bearer ${access_token}" "${API_ENDPOINT}"

#!/bin/bash

USERNAME="benutzer"
PASSWORD="passwort"
API_ENDPOINT="https://api.example.com/secured-resource"

# Basic Auth mit curl
curl -s -u "${USERNAME}:${PASSWORD}" "${API_ENDPOINT}"

# Alternativ mit Header
auth_header=$(echo -n "${USERNAME}:${PASSWORD}" | base64)
curl -s -H "Authorization: Basic ${auth_header}" "${API_ENDPOINT}"

#!/bin/bash

# Beispiel: Abrufen von Wetterdaten
API_KEY="Ihr_Wetter_API_Key"
CITY="Berlin"
WEATHER_API="https://api.openweathermap.org/data/2.5/weather?q=${CITY}&units=metric&appid=${API_KEY}"

# API aufrufen und JSON verarbeiten
weather_data=$(curl -s "${WEATHER_API}")

# Extrahieren spezifischer Werte mit jq
temperature=$(echo "${weather_data}" | jq -r '.main.temp')
weather_desc=$(echo "${weather_data}" | jq -r '.weather[0].description')
humidity=$(echo "${weather_data}" | jq -r '.main.humidity')

echo "Wetter in ${CITY}:"
echo "Temperatur: ${temperature}°C"
echo "Beschreibung: ${weather_desc}"
echo "Luftfeuchtigkeit: ${humidity}%"

# Filtern von Arrays
echo "${weather_data}" | jq '.weather[] | {description: .description, icon: .icon}'

# Transformieren von Daten
echo "${weather_data}" | jq '{
    city: .name,
    country: .sys.country,
    temperature: .main.temp,
    conditions: .weather[0].main,
    wind_speed: .wind.speed
}'

#!/bin/bash

# API aufrufen
response=$(curl -s "https://api.example.com/data")

# Einfache Textverarbeitung für spezifische Werte
# (Hinweis: Diese Methode ist weniger robust als jq)
name=$(echo "${response}" | grep -o '"name":"[^"]*"' | cut -d'"' -f4)
id=$(echo "${response}" | grep -o '"id":[0-9]*' | cut -d':' -f2)

echo "Name: ${name}, ID: ${id}"

# Alternativ mit Python (falls verfügbar)
python_extract() {
    python3 -c "
import json, sys
data = json.loads(sys.stdin.read())
print(data$1)
"
}

echo "${response}" | python_extract "['name']"

#!/bin/bash

# XML-API aufrufen
xml_response=$(curl -s "https://api.example.com/xml-endpoint")

# Mit xmllint (aus libxml2-utils) verarbeiten
if command -v xmllint &>/dev/null; then
    # XPath-Abfrage verwenden
    value=$(echo "${xml_response}" | xmllint --xpath "//root/element/text()" -)
    echo "Extrahierter Wert: ${value}"
fi

# Mit grep und sed (einfachere Alternative)
element_value=$(echo "${xml_response}" | grep -o "<element>[^<]*</element>" | sed -e 's/<element>\(.*\)<\/element>/\1/')
echo "Element-Wert: ${element_value}"

#!/bin/bash

# Konfiguration
GITHUB_TOKEN="Ihr_GitHub_Token"  # Persönliches Access-Token
GITHUB_API="https://api.github.com"
REPO_OWNER="octocat"
REPO_NAME="hello-world"

# Funktion für GitHub API-Aufrufe
github_api() {
    local endpoint="$1"
    local method="${2:-GET}"
    local data="$3"
    
    local headers=(
        -H "Authorization: token ${GITHUB_TOKEN}"
        -H "Accept: application/vnd.github.v3+json"
    )
    
    if [[ -n "${data}" ]]; then
        curl -s -X "${method}" "${headers[@]}" -d "${data}" "${GITHUB_API}${endpoint}"
    else
        curl -s -X "${method}" "${headers[@]}" "${GITHUB_API}${endpoint}"
    fi
}

# Repository-Informationen abrufen
repo_info=$(github_api "/repos/${REPO_OWNER}/${REPO_NAME}")
repo_name=$(echo "${repo_info}" | jq -r '.name')
repo_stars=$(echo "${repo_info}" | jq -r '.stargazers_count')
repo_forks=$(echo "${repo_info}" | jq -r '.forks_count')

echo "Repository: ${repo_name}"
echo "Stars: ${repo_stars}"
echo "Forks: ${repo_forks}"

# Offene Issues auflisten
issues=$(github_api "/repos/${REPO_OWNER}/${REPO_NAME}/issues?state=open")
echo -e "\nOffene Issues:"
echo "${issues}" | jq -r '.[] | "- #\(.number): \(.title)"'

# Einen neuen Issue erstellen
create_issue() {
    local title="$1"
    local body="$2"
    
    local issue_data=$(jq -n \
                        --arg title "${title}" \
                        --arg body "${body}" \
                        '{title: $title, body: $body}')
    
    github_api "/repos/${REPO_OWNER}/${REPO_NAME}/issues" "POST" "${issue_data}"
}

# Beispielaufruf (auskommentiert)
# new_issue=$(create_issue "API Test Issue" "Dieses Issue wurde automatisch erstellt.")
# echo "Neuer Issue erstellt: #$(echo "${new_issue}" | jq -r '.number')"

#!/bin/bash

# Konfiguration
API_ENDPOINT="https://api.example.com/resources"
API_KEY="Ihr_API_Key"
PER_PAGE=100

# Funktion zum Abrufen aller Seiten
fetch_all_pages() {
    local endpoint="$1"
    local page=1
    local all_results="[]"
    
    while true; do
        local url="${endpoint}?page=${page}&per_page=${PER_PAGE}&api_key=${API_KEY}"
        local response=$(curl -s "${url}")
        
        # Ergebnisse dieser Seite extrahieren
        local items=$(echo "${response}" | jq -r '.items')
        local count=$(echo "${items}" | jq 'length')
        
        # Keine weiteren Ergebnisse
        if [[ "${count}" -eq 0 ]]; then
            break
        fi
        
        # Ergebnisse zusammenführen
        all_results=$(echo "${all_results}" | jq --argjson new "${items}" '. + $new')
        
        # Nächste Seite
        ((page++))
    done
    
    echo "${all_results}"
}

# Alle Ressourcen abrufen
all_resources=$(fetch_all_pages "${API_ENDPOINT}")
echo "Insgesamt $(echo "${all_resources}" | jq 'length') Ressourcen gefunden."

# Verarbeiten der Ergebnisse
echo "${all_resources}" | jq -r '.[] | .name'

#!/bin/bash

# Konfiguration
API_ENDPOINT="https://api.example.com/data"
MAX_RETRIES=3
RETRY_DELAY=5  # Sekunden

# Funktion für API-Aufrufe mit Fehlerbehandlung
api_request() {
    local url="$1"
    local retry_count=0
    
    while [[ ${retry_count} -lt ${MAX_RETRIES} ]]; do
        # API aufrufen und Statuscode speichern
        response=$(curl -s -w "%{http_code}" -o /tmp/api_response.json "${url}")
        status_code=$response
        
        # Erfolg
        if [[ ${status_code} -ge 200 && ${status_code} -lt 300 ]]; then
            cat /tmp/api_response.json
            return 0
        fi
        
        # Ratenbegrenzung (429 Too Many Requests)
        if [[ ${status_code} -eq 429 ]]; then
            # Retry-After Header auslesen (falls vorhanden)
            retry_after=$(curl -s -I "${url}" | grep -i "retry-after" | awk '{print $2}' | tr -d '\r')
            
            if [[ -n "${retry_after}" ]]; then
                sleep "${retry_after}"
            else
                # Exponentielles Backoff
                sleep $((RETRY_DELAY * 2**retry_count))
            fi
        # Andere Fehler
        else
            echo "Fehler: API gab Statuscode ${status_code} zurück" >&2
            echo "Antwort: $(cat /tmp/api_response.json)" >&2
            
            # Bei bestimmten Fehlern nicht wiederholen
            if [[ ${status_code} -eq 400 || ${status_code} -eq 401 || ${status_code} -eq 403 ]]; then
                return 1
            fi
            
            sleep "${RETRY_DELAY}"
        fi
        
        ((retry_count++))
    done
    
    echo "Maximale Anzahl von Wiederholungen erreicht" >&2
    return 1
}

# Verwendung
data=$(api_request "${API_ENDPOINT}")
if [[ $? -eq 0 ]]; then
    echo "Daten erfolgreich abgerufen"
    echo "${data}" | jq .
else
    echo "Fehler beim Abrufen der Daten"
fi

#!/bin/bash

# Konfiguration
API_BASE="https://api.example.com"
API_KEY="Ihr_API_Key"
POLL_INTERVAL=5  # Sekunden
MAX_POLLS=60     # Maximal 5 Minuten warten

# Starten einer langläufigen Operation
start_job() {
    curl -s -X POST \
         -H "Authorization: Bearer ${API_KEY}" \
         -H "Content-Type: application/json" \
         -d '{"parameters": {"input": "data"}}' \
         "${API_BASE}/jobs"
}

# Status einer Operation abfragen
check_job_status() {
    local job_id="$1"
    
    curl -s -H "Authorization: Bearer ${API_KEY}" \
         "${API_BASE}/jobs/${job_id}"
}

# Job starten
job_response=$(start_job)
job_id=$(echo "${job_response}" | jq -r '.id')
echo "Job gestartet mit ID: ${job_id}"

# Polling bis zur Fertigstellung
poll_count=0
while [[ ${poll_count} -lt ${MAX_POLLS} ]]; do
    job_status=$(check_job_status "${job_id}")
    status=$(echo "${job_status}" | jq -r '.status')
    
    echo "Job-Status: ${status}"
    
    if [[ "${status}" == "completed" ]]; then
        result=$(echo "${job_status}" | jq -r '.result')
        echo "Job abgeschlossen! Ergebnis: ${result}"
        break
    elif [[ "${status}" == "failed" ]]; then
        error=$(echo "${job_status}" | jq -r '.error')
        echo "Job fehlgeschlagen: ${error}" >&2
        exit 1
    fi
    
    ((poll_count++))
    sleep "${POLL_INTERVAL}"
done

if [[ ${poll_count} -eq ${MAX_POLLS} ]]; then
    echo "Zeitüberschreitung beim Warten auf Jobabschluss" >&2
    exit 1
fi

#!/bin/bash

# Einfacher HTTP-Server auf Port 8080
echo "Starte Webhook-Empfänger auf Port 8080..."

process_webhook() {
    local request="$1"
    local body=$(echo "${request}" | awk 'BEGIN{RS="\r\n\r\n"} {print $0}' | tail -n 1)
    
    echo "Webhook empfangen: ${body}"
    
    # Verarbeitung hier...
    if echo "${body}" | jq -e '.event == "completed"' &>/dev/null; then
        echo "Job abgeschlossen!"
    fi
}

while true; do
    response="HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK"
    request=$(nc -l 8080)
    echo "${response}" | nc -l 8080 &
    
    process_webhook "${request}"
done

#!/bin/bash

# Konfiguration
WEATHER_API_KEY="Wetter_API_Key"
SLACK_WEBHOOK_URL="https://hooks.slack.com/services/XXX/YYY/ZZZ"
CITY="Berlin"

# Wetterdaten abrufen
get_weather() {
    local city="$1"
    
    curl -s "https://api.openweathermap.org/data/2.5/weather?q=${city}&units=metric&appid=${WEATHER_API_KEY}"
}

# Nachricht an Slack senden
send_slack_message() {
    local message="$1"
    
    curl -s -X POST \
         -H "Content-Type: application/json" \
         -d "{\"text\":\"${message}\"}" \
         "${SLACK_WEBHOOK_URL}"
}

# Wetterwarnung erstellen
create_weather_alert() {
    # Wetter abrufen
    weather_data=$(get_weather "${CITY}")
    
    # Daten extrahieren
    temp=$(echo "${weather_data}" | jq -r '.main.temp')
    conditions=$(echo "${weather_data}" | jq -r '.weather[0].main')
    
    # Nachricht formatieren
    message="Wetterbericht für ${CITY}: ${temp}°C, ${conditions}"
    
    # Warnungen basierend auf Bedingungen
    if (( $(echo "${temp} > 30" | bc -l) )); then
        message="${message}\n⚠️ WARNUNG: Extreme Hitze! Bitte viel trinken und Schatten suchen."
    elif (( $(echo "${temp} < 0" | bc -l) )); then
        message="${message}\n⚠️ WARNUNG: Frost! Bitte auf mögliche Glätte achten."
    fi
    
    if [[ "${conditions}" == "Thunderstorm" ]]; then
        message="${message}\n⚠️ WARNUNG: Gewitter! Bitte Aktivitäten im Freien einschränken."
    elif [[ "${conditions}" == "Rain" && $(echo "${weather_data}" | jq -r '.rain."3h"') > 10 ]]; then
        message="${message}\n⚠️ WARNUNG: Starker Regen! Mögliche Überschwemmungsgefahr."
    fi
    
    # An Slack senden
    send_slack_message "${message}"
}

# Ausführen
create_weather_alert

ssh [Optionen] [Benutzer@]Hostname [Befehl]

# Ausführen eines einzelnen Befehls auf einem entfernten Host
ssh benutzer@server "ls -la /var/log"

# Nicht-interaktiver Modus (vermeidet Hängen bei Problemen)
ssh -n benutzer@server "uptime"

# Batch-Modus (deaktiviert alle Abfragen)
ssh -n -o BatchMode=yes benutzer@server "df -h"

# Verbindungstimeout setzen
ssh -o ConnectTimeout=10 benutzer@server "uptime"

# SSH-Schlüsselpaar generieren (falls noch nicht vorhanden)
ssh-keygen -t ed25519 -C "Automatisierungsschlüssel"

# Öffentlichen Schlüssel auf den Zielserver übertragen
ssh-copy-id benutzer@server

# Alternative, wenn ssh-copy-id nicht verfügbar ist
cat ~/.ssh/id_ed25519.pub | ssh benutzer@server "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

#!/bin/bash

# Grundlegende Remote-Befehlsausführung
ssh server "hostname && uptime"

# Umgebungsvariablen festlegen
ssh server "export PATH=/usr/local/bin:\$PATH && which python3"

# Interaktive Befehle vermeiden
ssh -n server "nohup long-running-command > output.log 2>&1 &"

#!/bin/bash

# sudo-Befehl auf einem entfernten System ausführen
ssh admin@server "sudo service nginx restart"

# Mit Passwort-Übergabe (vermeiden, wenn möglich)
echo "sudo_password" | ssh admin@server "sudo -S service nginx restart"

# Besser: sudo ohne Passwort für bestimmte Befehle konfigurieren
# (erfordert vorherige Einrichtung der sudoers-Datei)
ssh admin@server "sudo service nginx restart"

#!/bin/bash

# Exit-Code vom Remote-Befehl erhalten
ssh server "test -d /var/www/html"
if [ $? -eq 0 ]; then
    echo "Verzeichnis existiert"
else
    echo "Verzeichnis existiert nicht"
fi

# Alternative mit direkter Prüfung
if ssh server "test -d /var/www/html"; then
    echo "Verzeichnis existiert"
else
    echo "Verzeichnis existiert nicht"
fi

# Fehlerbehandlung
ssh server "some-command" || {
    echo "Fehler bei der Befehlsausführung auf dem Server" >&2
    exit 1
}

#!/bin/bash

# Methode 1: Skript über die SSH-Verbindung pipen
cat local_script.sh | ssh server "bash -s"

# Methode 2: Skript mit Argumenten übergeben
cat local_script.sh | ssh server "bash -s -- arg1 arg2"

# Methode 3: Skript hochladen und ausführen
scp local_script.sh server:/tmp/
ssh server "chmod +x /tmp/local_script.sh && /tmp/local_script.sh"

#!/bin/bash

ssh server bash << 'EOT'
# Dieser Code läuft auf dem Remote-Server
LOG_DIR="/var/log"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)

# Verarbeitung auf Verzeichnisebene
cd "$LOG_DIR" || exit 1
for log_file in *.log; do
    echo "Verarbeite $log_file"
    # Komplexe Verarbeitung hier...
    gzip -c "$log_file" > "/backup/${log_file}-${TIMESTAMP}.gz"
done

# Aufräumen
find "$LOG_DIR" -name "*.log" -type f -mtime +7 -delete
echo "Bereinigung abgeschlossen"
EOT

#!/bin/bash

# Daten vom Remote-System abrufen und lokal verarbeiten
server_info=$(ssh server "hostname && uptime && df -h")

# Lokale Verarbeitung
server_name=$(echo "$server_info" | head -1)
uptime_info=$(echo "$server_info" | head -2 | tail -1)
disk_usage=$(echo "$server_info" | grep -m 1 "/dev/sda")

echo "Server: $server_name"
echo "Uptime: $uptime_info"
echo "Hauptpartition: $disk_usage"

#!/bin/bash

# Datei auf einen Remote-Server hochladen
scp local_file.txt user@server:/path/to/destination/

# Datei von einem Remote-Server herunterladen
scp user@server:/path/to/remote_file.txt local_directory/

# Verzeichnis rekursiv übertragen
scp -r local_directory/ user@server:/path/to/destination/

# Übertragungsgeschwindigkeit begrenzen (KB/s)
scp -l 1000 large_file.iso user@server:/tmp/

#!/bin/bash

# SFTP-Befehle in einem Batchmodus ausführen
sftp -b - user@server << EOF
cd /remote/directory
lcd /local/directory
get file1.txt
get file2.txt
put local_file.txt
bye
EOF

#!/bin/bash

# Grundlegende Rsync-Übertragung über SSH
rsync -avz -e ssh /local/directory/ user@server:/remote/directory/

# Inkrementelles Backup mit Rsync
rsync -avz --delete -e ssh /local/directory/ user@server:/backup/directory/

# Übertragung mit Bandbreitenbegrenzung
rsync -avz --bwlimit=1000 -e ssh /local/directory/ user@server:/remote/directory/

# Ausschließen bestimmter Dateien
rsync -avz --exclude='*.tmp' --exclude='cache/' -e ssh /local/directory/ user@server:/remote/directory/

#!/bin/bash

SERVERS=("web1" "web2" "web3" "db1" "db2")
COMMAND="uptime"

for server in "${SERVERS[@]}"; do
    echo "=== Führe Befehl auf $server aus ==="
    ssh "$server" "$COMMAND"
done

#!/bin/bash

SERVERS=("web1" "web2" "web3" "db1" "db2")
COMMAND="uptime"
MAX_PARALLEL=3
running=0

for server in "${SERVERS[@]}"; do
    # Maximale Anzahl paralleler Prozesse begrenzen
    if [[ $running -ge $MAX_PARALLEL ]]; then
        wait -n  # Warten auf Beendigung eines Prozesses
        running=$((running - 1))
    fi
    
    # Befehl im Hintergrund ausführen
    (
        echo "=== Ausführung auf $server ===" 
        if ssh -o ConnectTimeout=5 "$server" "$COMMAND"; then
            echo "=== $server: Erfolgreich ==="
        else
            echo "=== $server: Fehler ($?) ===" >&2
        fi
    ) &
    
    running=$((running + 1))
done

# Auf verbleibende Prozesse warten
wait
echo "Alle Befehle abgeschlossen"

#!/bin/bash

SERVERS=("web1" "web2" "web3" "db1" "db2")
RESULTS_DIR="/tmp/server_results"
mkdir -p "$RESULTS_DIR"

# Funktion zur Ausführung auf einem Server
run_on_server() {
    local server="$1"
    local output_file="$RESULTS_DIR/$server.out"
    
    echo "Starte Ausführung auf $server..."
    
    # Mehrere Befehle auf dem Remote-Server ausführen
    ssh -o ConnectTimeout=5 "$server" << 'EOT' > "$output_file" 2>&1
        hostname
        uptime
        df -h | grep -v tmpfs
        free -m
        grep -c processor /proc/cpuinfo
EOT
    
    local status=$?
    if [[ $status -eq 0 ]]; then
        echo "Ausführung auf $server erfolgreich abgeschlossen"
    else
        echo "Fehler bei der Ausführung auf $server (Exit-Code: $status)" >&2
    fi
    
    return $status
}

# Parallel auf allen Servern ausführen
for server in "${SERVERS[@]}"; do
    run_on_server "$server" &
done

# Auf alle Hintergrundprozesse warten
wait

# Ergebnisse zusammenfassen
echo -e "\n=== Zusammenfassung ===\n"
for server in "${SERVERS[@]}"; do
    result_file="$RESULTS_DIR/$server.out"
    if [[ -f "$result_file" ]]; then
        hostname=$(head -1 "$result_file")
        disk_usage=$(grep -m 1 '/' "$result_file" | awk '{print $5}')
        load=$(grep -o 'load average:.*' "$result_file" | cut -d: -f2 | tr -d ',')
        cpu_count=$(tail -1 "$result_file")
        
        echo "$server ($hostname):"
        echo "  - Festplattenbelegung: $disk_usage"
        echo "  - Load: $load"
        echo "  - CPUs: $cpu_count"
    else
        echo "$server: Keine Ergebnisse (Verbindungsfehler?)"
    fi
done

#!/bin/bash

# Lokales Port-Forwarding einrichten
# Lokaler Port 8080 wird an den Port 80 des Remote-Servers weitergeleitet
ssh -L 8080:localhost:80 -N -f user@server

# Überprüfen, ob der Tunnel läuft
if ps aux | grep "ssh -L" | grep -v grep > /dev/null; then
    echo "SSH-Tunnel ist aktiv"
else
    echo "SSH-Tunnel konnte nicht eingerichtet werden"
fi

# Skript, das den Tunnel nutzt
curl http://localhost:8080/

# Tunnel beenden (alle passenden SSH-Prozesse)
pkill -f "ssh -L 8080:localhost:80"

#!/bin/bash

# Entferntes Port-Forwarding einrichten
# Port 8080 auf dem Remote-Server wird an den lokalen Port 80 weitergeleitet
ssh -R 8080:localhost:80 -N -f user@server

# Tunnel-Management
PID_FILE="/tmp/ssh_tunnel.pid"

# Tunnel starten
start_tunnel() {
    ssh -R 8080:localhost:80 -N -f user@server
    echo $! > "$PID_FILE"
    echo "Tunnel gestartet mit PID $(cat "$PID_FILE")"
}

# Tunnel stoppen
stop_tunnel() {
    if [[ -f "$PID_FILE" ]]; then
        kill $(cat "$PID_FILE") 2>/dev/null
        rm "$PID_FILE"
        echo "Tunnel beendet"
    else
        echo "Kein aktiver Tunnel gefunden"
    fi
}

# Tunnelstatus überprüfen
check_tunnel() {
    if [[ -f "$PID_FILE" ]] && kill -0 $(cat "$PID_FILE") 2>/dev/null; then
        echo "Tunnel läuft mit PID $(cat "$PID_FILE")"
    else
        echo "Tunnel läuft nicht"
    fi
}

#!/bin/bash

# SOCKS-Proxy auf Port 1080 einrichten
ssh -D 1080 -q -C -N -f user@server

# Überprüfen, ob der Proxy läuft
netstat -tulpn | grep 1080

# Beispiel: curl über den SOCKS-Proxy
curl --socks5 localhost:1080 http://example.com/

#!/bin/bash

KEY_TYPE="ed25519"
KEY_NAME="automation_key"
KEY_FILE="$HOME/.ssh/${KEY_NAME}"
KEY_COMMENT="Automatisch generierter Schlüssel für $(whoami)@$(hostname)"

# Prüfen, ob der Schlüssel bereits existiert
if [[ -f "${KEY_FILE}" ]]; then
    echo "Schlüssel existiert bereits: ${KEY_FILE}"
    exit 0
fi

# Schlüssel ohne Passphrase generieren
ssh-keygen -t "$KEY_TYPE" -f "$KEY_FILE" -N "" -C "$KEY_COMMENT"

# Berechtigungen korrigieren
chmod 600 "${KEY_FILE}"
chmod 644 "${KEY_FILE}.pub"

echo "Schlüssel erfolgreich generiert:"
echo "Private Key: ${KEY_FILE}"
echo "Public Key: ${KEY_FILE}.pub"

# Optional: Öffentlichen Schlüssel anzeigen
echo -e "\nÖffentlicher Schlüssel:"
cat "${KEY_FILE}.pub"

#!/bin/bash

KEY_FILE="$HOME/.ssh/automation_key.pub"
SERVERS=("web1" "web2" "db1" "db2")

# Prüfen, ob der öffentliche Schlüssel existiert
if [[ ! -f "$KEY_FILE" ]]; then
    echo "Fehler: Öffentlicher Schlüssel nicht gefunden: $KEY_FILE" >&2
    exit 1
fi

# Schlüssel auf jeden Server kopieren
for server in "${SERVERS[@]}"; do
    echo "Kopiere Schlüssel auf $server..."
    
    # Methode 1: Mit ssh-copy-id
    if command -v ssh-copy-id >/dev/null; then
        ssh-copy-id -i "$KEY_FILE" "user@$server"
    else
        # Methode 2: Manuelles Kopieren
        cat "$KEY_FILE" | ssh "user@$server" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"
    fi
    
    # Überprüfen, ob der Schlüssel funktioniert
    if ssh -i "${KEY_FILE%.pub}" -o BatchMode=yes "user@$server" "echo 'Schlüsseltest erfolgreich'"; then
        echo "✓ Schlüssel auf $server erfolgreich installiert"
    else
        echo "✗ Fehler beim Testen des Schlüssels auf $server" >&2
    fi
done

#!/bin/bash

# SSH-Agent starten, falls noch nicht aktiv
start_ssh_agent() {
    if [[ -z "$SSH_AUTH_SOCK" ]]; then
        eval $(ssh-agent -s)
        echo "SSH-Agent gestartet mit PID $SSH_AGENT_PID"
    else
        echo "SSH-Agent läuft bereits mit Socket $SSH_AUTH_SOCK"
    fi
}

# Schlüssel zum SSH-Agent hinzufügen
add_key_to_agent() {
    local key_file="$1"
    
    if [[ ! -f "$key_file" ]]; then
        echo "Fehler: Schlüsseldatei nicht gefunden: $key_file" >&2
        return 1
    fi
    
    # Prüfen, ob der Schlüssel bereits hinzugefügt wurde
    if ssh-add -l | grep -q "$(ssh-keygen -lf "$key_file" | awk '{print $2}')"; then
        echo "Schlüssel ist bereits im SSH-Agent"
    else
        ssh-add "$key_file"
        echo "Schlüssel hinzugefügt: $key_file"
    fi
}

# Verwendung
start_ssh_agent
add_key_to_agent "$HOME/.ssh/automation_key"

# Automatisierungsbefehle mit SSH-Agent ausführen
ssh server "uptime"

# Beispiel für einen Eintrag in ~/.ssh/authorized_keys mit Einschränkungen
# Nur bestimmte Befehle erlauben
command="uptime" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... automation@host

# IP-Beschränkungen
from="192.168.1.*" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... automation@host

# Kombination mehrerer Einschränkungen
command="df -h",from="10.0.0.*",no-port-forwarding ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... automation@host

#!/bin/bash

KEY_FILE="$HOME/.ssh/automation_key.pub"
SERVER="target-server"
ALLOWED_COMMANDS=("uptime" "df -h" "/usr/local/sbin/backup.sh")
ALLOWED_NETWORKS=("192.168.1.*" "10.0.0.*")

# Öffentlichen Schlüssel einlesen
if [[ ! -f "$KEY_FILE" ]]; then
    echo "Fehler: Öffentlicher Schlüssel nicht gefunden: $KEY_FILE" >&2
    exit 1
fi
public_key=$(cat "$KEY_FILE")

# Einschränkungen erstellen
restrictions=""

# Netzwerk-Einschränkungen
network_restriction="from=\"$(IFS=,; echo "${ALLOWED_NETWORKS[*]}")\""
restrictions="${restrictions}${network_restriction},"

# Befehlseinschränkungen, wenn spezifiziert
if [[ ${#ALLOWED_COMMANDS[@]} -gt 0 ]]; then
    # Mehrere Befehle mit SSH-Wrapper-Skript erlauben
    ssh "user@$SERVER" "cat > /tmp/ssh-wrapper.sh << 'EOF'
#!/bin/bash
# SSH-Befehlswrapper
cmd=\$SSH_ORIGINAL_COMMAND
case \"\$cmd\" in
$(for cmd in "${ALLOWED_COMMANDS[@]}"; do echo "    \"$cmd\") $cmd ;;"; done)
    *) echo \"Befehl nicht erlaubt: \$cmd\" >&2; exit 1 ;;
esac
EOF
    chmod +x /tmp/ssh-wrapper.sh
    sudo mv /tmp/ssh-wrapper.sh /usr/local/bin/ssh-wrapper.sh"
    
    restrictions="${restrictions}command=\"/usr/local/bin/ssh-wrapper.sh\","
fi

# Weitere Einschränkungen
restrictions="${restrictions}no-port-forwarding,no-X11-forwarding,no-agent-forwarding"

# Schlüssel mit Einschränkungen hinzufügen
restricted_key="$restrictions $public_key"
echo "Installiere eingeschränkten Schlüssel auf $SERVER..."
echo "$restricted_key" | ssh "user@$SERVER" "cat >> ~/.ssh/authorized_keys"

echo "Schlüssel mit folgenden Einschränkungen installiert:"
echo "$restrictions"

#!/bin/bash

# Überwachung aktiver SSH-Sitzungen auf einem Server
SERVER="monitoring-server"

# SSH-Sitzungen abfragen
ssh_sessions=$(ssh "admin@$SERVER" "who | grep -i ssh")

echo "Aktive SSH-Sitzungen auf $SERVER:"
echo "$ssh_sessions"

# Optional: Verdächtige Aktivitäten überprüfen
ssh "admin@$SERVER" "grep 'Failed password' /var/log/auth.log | tail -10"

# Sitzungen mit ungewöhnlicher Dauer identifizieren
ssh "admin@$SERVER" "w -h | awk '{print \$1, \$2, \$3, \$4}' | sort -k 4" | while read user from login idle; do
    # Idle-Zeit in Minuten konvertieren
    if [[ "$idle" == *"days"* ]]; then
        echo "WARNUNG: Benutzer $user von $from ist seit $idle inaktiv!"
    fi
done

#!/bin/bash

SERVER="frequent-access-server"
SOCKET_DIR="/tmp/ssh_mux"
SOCKET_FILE="$SOCKET_DIR/$SERVER"

# Socket-Verzeichnis erstellen
mkdir -p "$SOCKET_DIR"
chmod 700 "$SOCKET_DIR"

# Master-Verbindung öffnen
echo "Öffne Master-Verbindung zu $SERVER..."
ssh -M -S "$SOCKET_FILE" -o ControlPersist=10m "$SERVER" "echo 'Master-Verbindung hergestellt'"

# Funktion zum Ausführen von Befehlen über die Master-Verbindung
run_ssh_command() {
    local cmd="$1"
    echo "Führe aus: $cmd"
    ssh -S "$SOCKET_FILE" "$SERVER" "$cmd"
}

# Mehrere Befehle ausführen (sehr schnell, da eine Verbindung wiederverwendet wird)
run_ssh_command "uptime"
run_ssh_command "df -h"
run_ssh_command "free -m"

# Master-Verbindung schließen
echo "Schließe Master-Verbindung..."
ssh -S "$SOCKET_FILE" -O exit "$SERVER"

#!/bin/bash

# Direkter Zugriff über einen Jumphost
ssh -J jumphost.example.com internal-server.local "uptime"

# Alternative mit SSH-Konfiguration in ~/.ssh/config:
# Host internal-server
#     HostName internal-server.local
#     User admin
#     ProxyJump jumphost.example.com

# Mehrere Jumphosts verwenden
ssh -J jumphost1.example.com,jumphost2.example.com internal-server.local

# Dateiübertragung über einen Jumphost
scp -J jumphost.example.com local_file.txt internal-server.local:/destination/path/

#!/bin/bash

# Konfiguration
APP_NAME="myapp"
APP_VERSION="1.2.3"
SERVERS=("web1" "web2" "web3")
DEPLOY_USER="deployer"
DEPLOY_PATH="/var/www/$APP_NAME"
PACKAGE_FILE="${APP_NAME}-${APP_VERSION}.tar.gz"
BACKUP_DIR="/var/backups/$APP_NAME"

# Fehlerbehandlung
set -e  # Skript bei Fehlern beenden
trap 'echo "Deployment fehlgeschlagen!"; exit 1' ERR

echo "=== Deployment von $APP_NAME v$APP_VERSION startet ==="

# Paket auf jeden Server kopieren
for server in "${SERVERS[@]}"; do
    echo "Deployment auf $server..."
    
    # SSH-Session für mehrere Befehle verwenden
    ssh "$DEPLOY_USER@$server" << EOF
    # Verzeichnis vorbereiten
    if [[ ! -d "$DEPLOY_PATH" ]]; then
        mkdir -p "$DEPLOY_PATH"
    fi
    
    # Backup erstellen
    if [[ -d "$DEPLOY_PATH/current" ]]; then
        echo "Erstelle Backup..."
        mkdir -p "$BACKUP_DIR"
        cp -a "$DEPLOY_PATH/current" "$BACKUP_DIR/$APP_NAME-$(date +%Y%m%d-%H%M%S)"
        
        # Ältere Backups bereinigen
        find "$BACKUP_DIR" -maxdepth 1 -type d -mtime +7 -exec rm -rf {} \;
    fi
    
    # Verzeichnis für neue Version erstellen
    mkdir -p "$DEPLOY_PATH/releases/$APP_VERSION"
EOF
    
    # Paket übertragen
    echo "Übertrage Paket auf $server..."
    scp "$PACKAGE_FILE" "$DEPLOY_USER@$server:/tmp/"
    
    # Paket entpacken und installieren
    ssh "$DEPLOY_USER@$server" << EOF
    # Paket entpacken
    tar -xzf "/tmp/$PACKAGE_FILE" -C "$DEPLOY_PATH/releases/$APP_VERSION"
    rm "/tmp/$PACKAGE_FILE"
    
    # Symlink aktualisieren
    if [[ -L "$DEPLOY_PATH/current" ]]; then
        rm "$DEPLOY_PATH/current"
    fi
    ln -sf "$DEPLOY_PATH/releases/$APP_VERSION" "$DEPLOY_PATH/current"
    
    # Berechtigungen anpassen
    find "$DEPLOY_PATH/current" -type f -exec chmod 644 {} \;
    find "$DEPLOY_PATH/current" -type d -exec chmod 755 {} \;
    
    # Anwendungsspezifische Aktionen
    if [[ -f "$DEPLOY_PATH/current/scripts/post-deploy.sh" ]]; then
        echo "Führe Post-Deployment-Skript aus..."
        cd "$DEPLOY_PATH/current" && ./scripts/post-deploy.sh
    fi
    
    # Service neustarten
    echo "Starte Anwendungsdienst neu..."
    sudo systemctl restart "$APP_NAME"
    
    # Status überprüfen
    sleep 2
    if sudo systemctl is-active "$APP_NAME" > /dev/null; then
        echo "Dienst erfolgreich gestartet"
    else
        echo "FEHLER: Dienst konnte nicht gestartet werden!"
        exit 1
    fi
EOF
    
    echo "Deployment auf $server abgeschlossen"
done

echo "=== Deployment erfolgreich abgeschlossen ==="

# SSH-Agent starten
eval $(ssh-agent)

# Alternativ mit Lebensdauer begrenzen (in Sekunden)
eval $(ssh-agent -t 3600)  # Agent läuft für 1 Stunde

# Schlüssel zum Agenten hinzufügen
ssh-add ~/.ssh/id_ed25519

# Passwortgeschützten Schlüssel hinzufügen (interaktive Passwortabfrage)
ssh-add ~/.ssh/secure_key

# Schlüssel mit bestimmtem Pfad hinzufügen
ssh-add /path/to/specific_key

# Alle Standardschlüssel hinzufügen
ssh-add

# Alle geladenen Schlüssel anzeigen (Fingerabdrücke)
ssh-add -l

# Detaillierte Ausgabe mit vollständigem Pfad
ssh-add -L

# Spezifischen Schlüssel entfernen
ssh-add -d ~/.ssh/specific_key

# Alle Schlüssel entfernen
ssh-add -D

# SSH-Agent beenden
ssh-agent -k

#!/bin/bash

# Funktion zur Verwaltung des SSH-Agents
setup_ssh_agent() {
    # Prüfen, ob bereits ein Agent läuft
    if [[ -z "$SSH_AUTH_SOCK" ]]; then
        echo "Starte neuen SSH-Agent..."
        eval $(ssh-agent)
        echo "SSH-Agent gestartet mit PID $SSH_AGENT_PID"
        
        # PID für späteres Beenden speichern
        echo "$SSH_AGENT_PID" > /tmp/ssh_agent_pid
    else
        echo "Verwende existierenden SSH-Agent mit Socket $SSH_AUTH_SOCK"
    fi
    
    # Schlüssel hinzufügen, falls noch nicht geladen
    if ! ssh-add -l | grep -q "$(ssh-keygen -lf ~/.ssh/automation_key | awk '{print $2}')"; then
        echo "Füge Automatisierungsschlüssel hinzu..."
        ssh-add ~/.ssh/automation_key
    fi
}

# Funktion zum Beenden des Agenten
cleanup_ssh_agent() {
    if [[ -f /tmp/ssh_agent_pid ]]; then
        local agent_pid=$(cat /tmp/ssh_agent_pid)
        echo "Beende SSH-Agent (PID $agent_pid)..."
        kill "$agent_pid"
        rm /tmp/ssh_agent_pid
    fi
}

# Agent einrichten
setup_ssh_agent

# Automatisierungsaufgaben ausführen
echo "Führe SSH-Befehle mit Agent-Unterstützung aus..."
ssh server1 "uptime"
ssh server2 "df -h"

# Bei Skript-Ende Agent beenden
trap cleanup_ssh_agent EXIT