Powershell - Fehlerbehandlung
Kursübersicht
[Bearbeiten | Quelltext bearbeiten]Dauer: 4 Stunden
Voraussetzungen: Kurs 1-5 abgeschlossen
Lernziele:
- Du verstehst Fehlertypen in PowerShell
- Du verwendest Try-Catch-Finally effektiv
- Du steuerst Fehlerverhalten mit ErrorAction
- Du implementierst eigene Fehlerbehandlung
- Du debuggst Skripte systematisch
- Du erstellst robuste, produktionsreife Skripte
Modul 6.1: Fehlertypen verstehen
[Bearbeiten | Quelltext bearbeiten]Terminating vs. Non-Terminating Errors
[Bearbeiten | Quelltext bearbeiten]PowerShell kennt zwei Haupttypen von Fehlern:
| Typ | Verhalten | Beispiel | Try-Catch? |
|---|---|---|---|
| Terminating | Stoppt Ausführung sofort | Division durch Null | Ja |
| Non-Terminating | Fehler anzeigen, weiter | Get-Item für nicht existierende Datei | Nein (außer mit -ErrorAction Stop) |
# Terminating Error - stoppt sofort
function Test-Terminating {
Write-Host "Vor dem Fehler"
$zahl = 1 / 0 # Division durch Null
Write-Host "Nach dem Fehler" # Wird nicht ausgeführt
}
Test-Terminating
# Non-Terminating Error - läuft weiter
function Test-NonTerminating {
Write-Host "Vor dem Fehler"
Get-Item "C:\GibtEsNicht.txt" # Fehler, aber weiter
Write-Host "Nach dem Fehler" # Wird ausgeführt!
}
Test-NonTerminating
$Error Variable
[Bearbeiten | Quelltext bearbeiten]PowerShell speichert alle Fehler in der automatischen Variable $Error:
# Letzter Fehler
$Error[0]
# Alle Fehler anzeigen
$Error
# Anzahl der Fehler
$Error.Count
# Fehlerdetails
$Error[0] | Format-List *
# Fehler-Verlauf leeren
$Error.Clear()
# Fehler-Eigenschaft
$Error[0].Exception.Message
$Error[0].CategoryInfo
$Error[0].FullyQualifiedErrorId
$? und $LASTEXITCODE
[Bearbeiten | Quelltext bearbeiten]# $? - War der letzte Befehl erfolgreich?
Get-Process
$? # True
Get-Process -Name "GibtEsNicht"
$? # False
# $LASTEXITCODE - Exit-Code externer Programme
ping localhost
$LASTEXITCODE # 0 = Erfolg
ping 999.999.999.999
$LASTEXITCODE # 1 = Fehler
Modul 6.2: Try-Catch-Finally
[Bearbeiten | Quelltext bearbeiten]Grundlegende Try-Catch-Struktur
[Bearbeiten | Quelltext bearbeiten]# Einfaches Try-Catch
try {
# Code, der fehlschlagen könnte
$inhalt = Get-Content "C:\GibtEsNicht.txt" -ErrorAction Stop
Write-Host "Datei gelesen"
} catch {
# Fehlerbehandlung
Write-Host "Fehler aufgetreten: $($_.Exception.Message)" -ForegroundColor Red
}
Write-Host "Skript läuft weiter"
-ErrorAction Stop für Cmdlets.Finally-Block
[Bearbeiten | Quelltext bearbeiten]Der Finally-Block wird immer ausgeführt, egal ob Fehler oder nicht:
$datei = $null
try {
Write-Host "Öffne Datei..."
$datei = [System.IO.File]::Open("C:\test.txt", "Open", "Read")
$inhalt = $datei.ReadToEnd()
Write-Host "Datei gelesen"
} catch {
Write-Host "Fehler: $($_.Exception.Message)" -ForegroundColor Red
} finally {
# Aufräumen - wird immer ausgeführt!
if ($null -ne $datei) {
$datei.Close()
$datei.Dispose()
Write-Host "Datei geschlossen"
}
}
Fehler-Objekt analysieren
[Bearbeiten | Quelltext bearbeiten]Das automatische $_ Variable enthält im Catch-Block den Fehler:
try {
Get-Content "C:\GibtEsNicht.txt" -ErrorAction Stop
} catch {
Write-Host "=== Fehler-Details ===" -ForegroundColor Red
Write-Host "Nachricht: $($_.Exception.Message)"
Write-Host "Typ: $($_.Exception.GetType().FullName)"
Write-Host "Zeile: $($_.InvocationInfo.ScriptLineNumber)"
Write-Host "Befehl: $($_.InvocationInfo.Line.Trim())"
Write-Host "Kategorie: $($_.CategoryInfo.Category)"
}
Mehrere Catch-Blöcke
[Bearbeiten | Quelltext bearbeiten]Fange verschiedene Fehlertypen unterschiedlich ab:
try {
$zahl = [int]"keine zahl"
} catch [System.FormatException] {
Write-Host "Formatierungs-Fehler: Ungültige Zahl" -ForegroundColor Yellow
} catch [System.IO.IOException] {
Write-Host "Datei-/IO-Fehler" -ForegroundColor Red
} catch [System.UnauthorizedAccessException] {
Write-Host "Zugriff verweigert" -ForegroundColor Red
} catch {
# Alle anderen Fehler
Write-Host "Unbekannter Fehler: $($_.Exception.GetType().FullName)" -ForegroundColor Red
Write-Host $_.Exception.Message
}
Verschachtelte Try-Catch
[Bearbeiten | Quelltext bearbeiten]try {
Write-Host "Äußerer Try-Block"
try {
Write-Host "Innerer Try-Block"
Get-Content "C:\Fehler.txt" -ErrorAction Stop
} catch {
Write-Host "Innerer Catch: $($_.Exception.Message)" -ForegroundColor Yellow
throw # Fehler nach außen weitergeben
}
} catch {
Write-Host "Äußerer Catch: $($_.Exception.Message)" -ForegroundColor Red
}
Modul 6.3: ErrorAction Parameter
[Bearbeiten | Quelltext bearbeiten]ErrorAction Optionen
[Bearbeiten | Quelltext bearbeiten]Steuert, wie Cmdlets mit Fehlern umgehen:
| Wert | Verhalten | Verwendung |
|---|---|---|
| Continue | Fehler anzeigen, weiter (Standard) | Normal |
| Stop | Als Terminating Error behandeln | Für Try-Catch |
| SilentlyContinue | Fehler unterdrücken, weiter | Optionale Operationen |
| Ignore | Vollständig ignorieren | Unwichtige Fehler |
| Inquire | Benutzer fragen | Interaktive Skripte |
| Suspend | Workflow pausieren | Nur Workflows |
# Standard (Continue) - Fehler anzeigen
Get-Item "C:\GibtEsNicht.txt"
Write-Host "Läuft weiter"
# Stop - Für Try-Catch
try {
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Stop
} catch {
Write-Host "Gefangen!"
}
# SilentlyContinue - Fehler unterdrücken
$datei = Get-Item "C:\GibtEsNicht.txt" -ErrorAction SilentlyContinue
if ($null -eq $datei) {
Write-Host "Datei nicht gefunden"
}
# Ignore - Auch $Error wird nicht befüllt
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Ignore
# Inquire - Benutzer fragen
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Inquire
$ErrorActionPreference
[Bearbeiten | Quelltext bearbeiten]Globale Einstellung für ErrorAction:
# Standard-Wert anzeigen
$ErrorActionPreference # Continue
# Temporär ändern
$ErrorActionPreference = "Stop"
# Alle Fehler werden zu Terminating Errors
try {
Get-Item "C:\GibtEsNicht.txt" # Keine -ErrorAction nötig!
} catch {
Write-Host "Gefangen durch Preference!"
}
# Zurücksetzen
$ErrorActionPreference = "Continue"
-ErrorAction Stop punktuell statt $ErrorActionPreference global zu ändern!ErrorVariable
[Bearbeiten | Quelltext bearbeiten]Speichere Fehler in eigener Variable:
# Fehler in Variable sammeln
Get-ChildItem C:\Windows, C:\GibtEsNicht, C:\Temp -ErrorAction SilentlyContinue -ErrorVariable fehler
# Fehler analysieren
Write-Host "Anzahl Fehler: $($fehler.Count)"
foreach ($f in $fehler) {
Write-Host "Fehler: $($f.Exception.Message)"
}
# Mit + anhängen statt überschreiben
Get-Item "C:\Fehler1.txt" -ErrorAction SilentlyContinue -ErrorVariable fehler
Get-Item "C:\Fehler2.txt" -ErrorAction SilentlyContinue -ErrorVariable +fehler
Write-Host "Gesamt: $($fehler.Count) Fehler"
Modul 6.4: Eigene Fehler werfen
[Bearbeiten | Quelltext bearbeiten]Throw
[Bearbeiten | Quelltext bearbeiten]Wirft einen Terminating Error:
function Divide-Number {
param(
[int]$zaehler,
[int]$nenner
)
if ($nenner -eq 0) {
throw "Division durch Null ist nicht erlaubt!"
}
return $zaehler / $nenner
}
try {
Divide-Number -zaehler 10 -nenner 0
} catch {
Write-Host "Fehler gefangen: $_" -ForegroundColor Red
}
Write-Error
[Bearbeiten | Quelltext bearbeiten]Erzeugt Non-Terminating Error:
function Test-File {
param([string]$path)
if (-not (Test-Path $path)) {
Write-Error "Datei nicht gefunden: $path"
return $false
}
Write-Host "Datei existiert"
return $true
}
# Non-Terminating - läuft weiter
Test-File "C:\GibtEsNicht.txt"
Write-Host "Skript läuft weiter"
# Mit ErrorAction Stop für Try-Catch
try {
Test-File "C:\GibtEsNicht.txt" -ErrorAction Stop
} catch {
Write-Host "Gefangen!"
}
Eigene Exception-Objekte
[Bearbeiten | Quelltext bearbeiten]function Connect-Database {
param(
[string]$server,
[int]$timeout = 30
)
# Simuliere Verbindungsversuch
$erfolg = $false
if (-not $erfolg) {
# Eigene Exception erstellen
$exception = New-Object System.InvalidOperationException(
"Verbindung zu $server fehlgeschlagen nach $timeout Sekunden"
)
$errorRecord = New-Object System.Management.Automation.ErrorRecord(
$exception,
"DatabaseConnectionFailed",
[System.Management.Automation.ErrorCategory]::ConnectionError,
$server
)
throw $errorRecord
}
}
try {
Connect-Database -server "SQL01" -timeout 10
} catch {
Write-Host "Kategorie: $($_.CategoryInfo.Category)"
Write-Host "ErrorID: $($_.FullyQualifiedErrorId)"
Write-Host "Nachricht: $($_.Exception.Message)"
}
Throw vs. Write-Error - Wann was?
[Bearbeiten | Quelltext bearbeiten]function Process-Data {
param($data)
# Kritischer Fehler - Funktion kann nicht fortfahren
if ($null -eq $data) {
throw "Daten dürfen nicht null sein!"
}
# Nicht-kritischer Fehler - Warnung, aber weiter
if ($data.Length -eq 0) {
Write-Error "Daten sind leer"
# Könnte mit leeren Daten weiterarbeiten
}
# Verarbeitung...
}
Modul 6.5: Trap-Anweisung
[Bearbeiten | Quelltext bearbeiten]Was ist Trap?
[Bearbeiten | Quelltext bearbeiten]Trap ist eine ältere Fehlerbehandlung (vor Try-Catch). Funktioniert wie globaler Catch:
# Trap definieren
trap {
Write-Host "Fehler gefangen in Trap: $_" -ForegroundColor Red
continue # Oder: break
}
# Code mit potentiellen Fehlern
Write-Host "Vor Fehler"
Get-Item "C:\GibtEsNicht.txt" -ErrorAction Stop
Write-Host "Nach Fehler" # Wird ausgeführt mit 'continue'
Trap mit Typen
[Bearbeiten | Quelltext bearbeiten]# Spezifische Traps
trap [System.IO.IOException] {
Write-Host "IO-Fehler: $_" -ForegroundColor Yellow
continue
}
trap [System.UnauthorizedAccessException] {
Write-Host "Zugriff verweigert: $_" -ForegroundColor Red
break
}
trap {
Write-Host "Allgemeiner Fehler: $_"
continue
}
# Code...
Modul 6.6: Debugging
[Bearbeiten | Quelltext bearbeiten]Write-Verbose und Write-Debug
[Bearbeiten | Quelltext bearbeiten]function Get-Data {
[CmdletBinding()]
param(
[string]$name
)
Write-Verbose "Starte Datenabfrage für: $name"
Write-Debug "Debug: Name-Länge = $($name.Length)"
# Simuliere Verarbeitung
Start-Sleep -Milliseconds 500
Write-Verbose "Datenabfrage abgeschlossen"
return "Daten für $name"
}
# Verbose-Ausgabe aktivieren
Get-Data -name "Test" -Verbose
# Debug-Ausgabe aktivieren (Prompt für Fortsetzung)
Get-Data -name "Test" -Debug
# Preference-Variablen
$VerbosePreference = "Continue" # Verbose immer anzeigen
$DebugPreference = "Continue" # Debug immer anzeigen
Set-PSDebug
[Bearbeiten | Quelltext bearbeiten]Erweiterte Debug-Funktionen:
# Trace einschalten - zeigt jede Zeile
Set-PSDebug -Trace 1
# Code ausführen
$a = 10
$b = 20
$c = $a + $b
# Trace ausschalten
Set-PSDebug -Trace 0
# Strict Mode - findet uninitialisierte Variablen
Set-PSDebug -Strict
$undef # Fehler!
# Ausschalten
Set-PSDebug -Off
Set-StrictMode
[Bearbeiten | Quelltext bearbeiten]Empfohlene Alternative zu Set-PSDebug -Strict:
# Version 1.0 - Grundlegende Prüfungen
Set-StrictMode -Version 1.0
# Nicht initialisierte Variable
$test # Fehler!
# Version 2.0 - Zusätzliche Prüfungen
Set-StrictMode -Version 2.0
# Nicht existierende Eigenschaft
$obj = New-Object PSObject
$obj.NichtVorhanden # Fehler!
# Version Latest - Neueste Prüfungen
Set-StrictMode -Version Latest
# In Funktionen verwenden
function Test-StrictFunction {
Set-StrictMode -Version Latest
# Hier gelten strikte Regeln
$var # Fehler wenn nicht initialisiert
}
Breakpoints
[Bearbeiten | Quelltext bearbeiten]# Zeilen-Breakpoint
Set-PSBreakpoint -Script "C:\Scripts\Test.ps1" -Line 15
# Variable-Breakpoint - stoppt bei Änderung
Set-PSBreakpoint -Variable "count" -Mode Write
# Befehl-Breakpoint
Set-PSBreakpoint -Command "Get-Process"
# Alle Breakpoints anzeigen
Get-PSBreakpoint
# Breakpoint deaktivieren
Disable-PSBreakpoint -Id 1
# Breakpoint löschen
Remove-PSBreakpoint -Id 1
# Alle löschen
Get-PSBreakpoint | Remove-PSBreakpoint
Modul 6.7: Logging
[Bearbeiten | Quelltext bearbeiten]Einfaches Datei-Logging
[Bearbeiten | Quelltext bearbeiten]function Write-Log {
param(
[Parameter(Mandatory=$true)]
[string]$nachricht,
[ValidateSet("INFO", "WARNING", "ERROR", "DEBUG")]
[string]$level = "INFO",
[string]$logDatei = "C:\Logs\script.log"
)
# Zeitstempel
$zeitstempel = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
# Log-Eintrag
$eintrag = "[$zeitstempel] [$level] $nachricht"
# In Datei schreiben
Add-Content -Path $logDatei -Value $eintrag
# Auch in Konsole (optional, mit Farbe)
$farbe = switch ($level) {
"INFO" { "Green" }
"WARNING" { "Yellow" }
"ERROR" { "Red" }
"DEBUG" { "Cyan" }
}
Write-Host $eintrag -ForegroundColor $farbe
}
# Verwendung
Write-Log "Skript gestartet"
Write-Log "Verarbeite Daten..." -level "INFO"
Write-Log "Warnung: Datei nicht gefunden" -level "WARNING"
Write-Log "Kritischer Fehler!" -level "ERROR"
Erweiterte Log-Funktion
[Bearbeiten | Quelltext bearbeiten]function Write-EnhancedLog {
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]$nachricht,
[ValidateSet("INFO", "WARNING", "ERROR", "DEBUG", "SUCCESS")]
[string]$level = "INFO",
[string]$logDatei = "C:\Logs\enhanced.log",
[switch]$console,
[int]$maxSizeMB = 10
)
# Log-Ordner erstellen
$logDir = Split-Path $logDatei -Parent
if (-not (Test-Path $logDir)) {
New-Item -Path $logDir -ItemType Directory -Force | Out-Null
}
# Log-Rotation wenn zu groß
if (Test-Path $logDatei) {
$groesse = (Get-Item $logDatei).Length / 1MB
if ($groesse -gt $maxSizeMB) {
$archiv = "$logDatei.$(Get-Date -Format 'yyyyMMdd_HHmmss').old"
Move-Item -Path $logDatei -Destination $archiv
Write-Verbose "Log rotiert: $archiv"
}
}
# Erweiterte Info sammeln
$caller = (Get-PSCallStack)[1]
$funktion = if ($caller.Command) { $caller.Command } else { "Main" }
# Log-Eintrag mit mehr Details
$zeitstempel = Get-Date -Format "yyyy-MM-dd HH:mm:ss.fff"
$eintrag = "[$zeitstempel] [$level] [$funktion] $nachricht"
# Schreiben
try {
Add-Content -Path $logDatei -Value $eintrag -ErrorAction Stop
} catch {
Write-Warning "Konnte nicht in Log-Datei schreiben: $_"
}
# Konsolen-Ausgabe
if ($console -or $level -in @("ERROR", "WARNING")) {
$farbe = switch ($level) {
"INFO" { "White" }
"SUCCESS" { "Green" }
"WARNING" { "Yellow" }
"ERROR" { "Red" }
"DEBUG" { "Cyan" }
}
Write-Host $eintrag -ForegroundColor $farbe
}
# Bei ERROR auch Write-Error aufrufen
if ($level -eq "ERROR") {
Write-Error $nachricht
}
}
# Verwendung
Write-EnhancedLog "Anwendung gestartet" -level "SUCCESS" -console
Write-EnhancedLog "Debug-Information" -level "DEBUG"
Write-EnhancedLog "Etwas ist schief gelaufen" -level "ERROR" -console
Start-Transcript
[Bearbeiten | Quelltext bearbeiten]PowerShell's eingebautes Session-Logging:
# Transcript starten
Start-Transcript -Path "C:\Logs\session_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"
# Alle Befehle und Ausgaben werden aufgezeichnet
Get-Process | Select-Object -First 5
Write-Host "Test-Ausgabe"
1..10 | ForEach-Object { $_ * 2 }
# Transcript stoppen
Stop-Transcript
# In Skripts verwenden
function Invoke-WithTranscript {
param($scriptBlock)
$transcriptPath = "C:\Logs\transcript_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"
Start-Transcript -Path $transcriptPath
try {
& $scriptBlock
} finally {
Stop-Transcript
}
}
Praktische Übungen
[Bearbeiten | Quelltext bearbeiten]Übung 1: Robuste Datei-Verarbeitung
[Bearbeiten | Quelltext bearbeiten]Aufgabe: Erstelle eine Funktion, die:
- Eine Datei liest
- Try-Catch für Fehlerbehandlung verwendet
- Verschiedene Fehlertypen unterschiedlich behandelt
- Logging implementiert
- Finally für Cleanup verwendet
Lösung anzeigen
function Read-FileRobust {
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]$pfad,
[switch]$logging
)
$stream = $null
$erfolg = $false
try {
# Logging
if ($logging) {
Write-Log "Starte Datei-Lesen: $pfad" -level "INFO"
}
# Datei existiert?
if (-not (Test-Path $pfad)) {
throw [System.IO.FileNotFoundException]::new("Datei nicht gefunden: $pfad")
}
# Lese-Berechtigung?
try {
$acl = Get-Acl $pfad -ErrorAction Stop
} catch [System.UnauthorizedAccessException] {
throw [System.UnauthorizedAccessException]::new("Keine Berechtigung für: $pfad")
}
# Datei öffnen
Write-Verbose "Öffne Datei: $pfad"
$stream = [System.IO.File]::OpenText($pfad)
# Inhalt lesen
$inhalt = $stream.ReadToEnd()
Write-Verbose "Gelesen: $($inhalt.Length) Zeichen"
if ($logging) {
Write-Log "Datei erfolgreich gelesen: $($inhalt.Length) Zeichen" -level "SUCCESS"
}
$erfolg = $true
return $inhalt
} catch [System.IO.FileNotFoundException] {
$fehlerMsg = "Datei nicht gefunden: $pfad"
Write-Host $fehlerMsg -ForegroundColor Red
if ($logging) {
Write-Log $fehlerMsg -level "ERROR"
}
return $null
} catch [System.UnauthorizedAccessException] {
$fehlerMsg = "Zugriff verweigert: $pfad"
Write-Host $fehlerMsg -ForegroundColor Red
if ($logging) {
Write-Log $fehlerMsg -level "ERROR"
}
return $null
} catch [System.IO.IOException] {
$fehlerMsg = "IO-Fehler beim Lesen von $pfad : $($_.Exception.Message)"
Write-Host $fehlerMsg -ForegroundColor Red
if ($logging) {
Write-Log $fehlerMsg -level "ERROR"
}
return $null
} catch {
$fehlerMsg = "Unerwarteter Fehler: $($_.Exception.GetType().Name) - $($_.Exception.Message)"
Write-Host $fehlerMsg -ForegroundColor Red
if ($logging) {
Write-Log $fehlerMsg -level "ERROR"
}
return $null
} finally {
# Aufräumen - wird immer ausgeführt
if ($null -ne $stream) {
$stream.Close()
$stream.Dispose()
Write-Verbose "Datei-Stream geschlossen"
}
if ($logging) {
$status = if ($erfolg) { "erfolgreich" } else { "mit Fehler" }
Write-Log "Datei-Operation beendet: $status" -level "INFO"
}
}
}
# Test
Read-FileRobust -pfad "C:\test.txt" -Verbose -logging
Read-FileRobust -pfad "C:\GibtEsNicht.txt" -logging
Übung 2: Retry-Logik
[Bearbeiten | Quelltext bearbeiten]Aufgabe: Implementiere eine Funktion, die:
- Einen Befehl mehrfach versucht
- Bei Fehler automatisch wiederholt
- Wartezeit zwischen Versuchen hat
- Exponentielles Backoff unterstützt
- Nach max. Versuchen aufgibt
Lösung anzeigen
function Invoke-WithRetry {
<#
.SYNOPSIS
Führt einen Befehl mit Retry-Logik aus.
.DESCRIPTION
Versucht einen Befehl mehrfach auszuführen.
Bei Fehler wird automatisch wiederholt mit
konfigurierbarer Wartezeit.
.PARAMETER scriptBlock
Der auszuführende Code-Block.
.PARAMETER maxRetries
Maximale Anzahl an Versuchen (Standard: 3).
.PARAMETER retryDelaySeconds
Wartezeit zwischen Versuchen in Sekunden (Standard: 2).
.PARAMETER exponentialBackoff
Verdoppelt Wartezeit nach jedem Versuch.
.EXAMPLE
Invoke-WithRetry -scriptBlock {
Invoke-WebRequest "https://example.com/api"
} -maxRetries 5
#>
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[scriptblock]$scriptBlock,
[ValidateRange(1, 100)]
[int]$maxRetries = 3,
[ValidateRange(1, 3600)]
[int]$retryDelaySeconds = 2,
[switch]$exponentialBackoff
)
$versuch = 0
$versuch = 0
$erfolg = $false
$letzterFehler = $null
while ($versuch -lt $maxRetries -and -not $erfolg) {
$versuch++
try {
Write-Verbose "Versuch $versuch von $maxRetries..."
# Scriptblock ausführen
$ergebnis = & $scriptBlock
# Erfolg!
$erfolg = $true
Write-Host "✓ Erfolgreich im Versuch $versuch" -ForegroundColor Green
return $ergebnis
} catch {
$letzterFehler = $_
Write-Warning "Versuch $versuch fehlgeschlagen: $($_.Exception.Message)"
# Wenn nicht letzter Versuch, warten
if ($versuch -lt $maxRetries) {
# Wartezeit berechnen
if ($exponentialBackoff) {
$wartezeit = $retryDelaySeconds * [math]::Pow(2, $versuch - 1)
} else {
$wartezeit = $retryDelaySeconds
}
Write-Host "Warte $wartezeit Sekunden vor nächstem Versuch..." -ForegroundColor Yellow
Start-Sleep -Seconds $wartezeit
}
}
}
# Alle Versuche fehlgeschlagen
Write-Error "Alle $maxRetries Versuche fehlgeschlagen!"
throw $letzterFehler
}
# Test 1: Erfolgreicher Aufruf nach mehreren Versuchen
$zaehler = 0
Invoke-WithRetry -scriptBlock {
$script:zaehler++
if ($zaehler -lt 3) {
throw "Simulierter Fehler"
}
Write-Host "Erfolgreich!"
return "Daten"
} -maxRetries 5 -Verbose
# Test 2: Mit Exponential Backoff
Invoke-WithRetry -scriptBlock {
Invoke-WebRequest "https://httpstat.us/503" -ErrorAction Stop
} -maxRetries 4 -retryDelaySeconds 1 -exponentialBackoff -Verbose
Übung 3: Umfassende Fehlerbehandlung in Skript
[Bearbeiten | Quelltext bearbeiten]Aufgabe: Erstelle ein vollständiges Skript mit:
- Parameter-Validierung
- Try-Catch-Finally Struktur
- Unterschiedlichen Fehlerbehandlungen
- Logging in Datei
- Sauberes Cleanup
- Exit-Codes für Automatisierung
Lösung anzeigen
<#
.SYNOPSIS
Datei-Backup-Skript mit umfassender Fehlerbehandlung.
.DESCRIPTION
Erstellt Backups von Dateien mit vollständiger Fehlerbehandlung,
Logging und robuster Ausführung.
#>
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[ValidateScript({Test-Path $_ -PathType Container})]
[string]$quellOrdner,
[Parameter(Mandatory=$true)]
[string]$zielOrdner,
[string]$logDatei = "C:\Logs\backup.log"
)
# Strikte Fehlerprüfung
Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"
# Exit-Codes
$EXIT_SUCCESS = 0
$EXIT_ERROR_GENERAL = 1
$EXIT_ERROR_QUELLE = 2
$EXIT_ERROR_ZIEL = 3
$EXIT_ERROR_COPY = 4
# Logging-Funktion
function Write-BackupLog {
param(
[string]$nachricht,
[ValidateSet("INFO", "SUCCESS", "WARNING", "ERROR")]
[string]$level = "INFO"
)
$zeitstempel = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
$eintrag = "[$zeitstempel] [$level] $nachricht"
# In Datei
try {
Add-Content -Path $logDatei -Value $eintrag -ErrorAction Stop
} catch {
Write-Warning "Konnte nicht in Log schreiben: $_"
}
# In Konsole
$farbe = switch ($level) {
"INFO" { "White" }
"SUCCESS" { "Green" }
"WARNING" { "Yellow" }
"ERROR" { "Red" }
}
Write-Host $eintrag -ForegroundColor $farbe
}
# Hauptlogik
try {
Write-BackupLog "=== Backup-Skript gestartet ===" -level "INFO"
Write-BackupLog "Quelle: $quellOrdner" -level "INFO"
Write-BackupLog "Ziel: $zielOrdner" -level "INFO"
# Log-Ordner erstellen
$logDir = Split-Path $logDatei -Parent
if (-not (Test-Path $logDir)) {
try {
New-Item -Path $logDir -ItemType Directory -Force | Out-Null
Write-BackupLog "Log-Verzeichnis erstellt: $logDir" -level "INFO"
} catch {
Write-Error "Konnte Log-Verzeichnis nicht erstellen: $_"
exit $EXIT_ERROR_GENERAL
}
}
# Quelle prüfen
Write-BackupLog "Prüfe Quell-Ordner..." -level "INFO"
if (-not (Test-Path $quellOrdner -PathType Container)) {
Write-BackupLog "Quell-Ordner existiert nicht!" -level "ERROR"
exit $EXIT_ERROR_QUELLE
}
# Dateien in Quelle
$dateien = Get-ChildItem -Path $quellOrdner -File -Recurse -ErrorAction Stop
$dateiAnzahl = $dateien.Count
if ($dateiAnzahl -eq 0) {
Write-BackupLog "Keine Dateien zum Sichern gefunden" -level "WARNING"
exit $EXIT_SUCCESS
}
Write-BackupLog "Gefunden: $dateiAnzahl Datei(en)" -level "INFO"
# Ziel-Ordner erstellen
Write-BackupLog "Erstelle Ziel-Ordner..." -level "INFO"
try {
if (-not (Test-Path $zielOrdner)) {
New-Item -Path $zielOrdner -ItemType Directory -Force -ErrorAction Stop | Out-Null
Write-BackupLog "Ziel-Ordner erstellt: $zielOrdner" -level "SUCCESS"
}
} catch {
Write-BackupLog "Konnte Ziel-Ordner nicht erstellen: $($_.Exception.Message)" -level "ERROR"
exit $EXIT_ERROR_ZIEL
}
# Backup durchführen
Write-BackupLog "Starte Kopiervorgang..." -level "INFO"
$erfolgreich = 0
$fehlgeschlagen = 0
$fehlerListe = @()
foreach ($datei in $dateien) {
try {
# Relativer Pfad
$relativerPfad = $datei.FullName.Substring($quellOrdner.Length).TrimStart('\')
$zielPfad = Join-Path $zielOrdner $relativerPfad
$zielDir = Split-Path $zielPfad -Parent
# Ziel-Unterordner erstellen
if (-not (Test-Path $zielDir)) {
New-Item -Path $zielDir -ItemType Directory -Force -ErrorAction Stop | Out-Null
}
# Datei kopieren
Copy-Item -Path $datei.FullName -Destination $zielPfad -Force -ErrorAction Stop
$erfolgreich++
Write-Verbose "Kopiert: $relativerPfad"
} catch [System.UnauthorizedAccessException] {
$fehlgeschlagen++
$fehlerMsg = "Zugriff verweigert: $($datei.FullName)"
$fehlerListe += $fehlerMsg
Write-BackupLog $fehlerMsg -level "WARNING"
} catch [System.IO.IOException] {
$fehlgeschlagen++
$fehlerMsg = "IO-Fehler bei: $($datei.FullName) - $($_.Exception.Message)"
$fehlerListe += $fehlerMsg
Write-BackupLog $fehlerMsg -level "WARNING"
} catch {
$fehlgeschlagen++
$fehlerMsg = "Fehler bei: $($datei.FullName) - $($_.Exception.Message)"
$fehlerListe += $fehlerMsg
Write-BackupLog $fehlerMsg -level "WARNING"
}
}
# Zusammenfassung
Write-BackupLog "" -level "INFO"
Write-BackupLog "=== Backup abgeschlossen ===" -level "INFO"
Write-BackupLog "Erfolgreich: $erfolgreich" -level "SUCCESS"
if ($fehlgeschlagen -gt 0) {
Write-BackupLog "Fehlgeschlagen: $fehlgeschlagen" -level "WARNING"
Write-BackupLog "" -level "INFO"
Write-BackupLog "Fehler-Details:" -level "WARNING"
foreach ($fehler in $fehlerListe) {
Write-BackupLog " - $fehler" -level "WARNING"
}
}
# Exit-Code basierend auf Ergebnis
if ($fehlgeschlagen -eq 0) {
Write-BackupLog "Status: Vollständig erfolgreich" -level "SUCCESS"
exit $EXIT_SUCCESS
} elseif ($erfolgreich -gt 0) {
Write-BackupLog "Status: Teilweise erfolgreich" -level "WARNING"
exit $EXIT_ERROR_COPY
} else {
Write-BackupLog "Status: Vollständig fehlgeschlagen" -level "ERROR"
exit $EXIT_ERROR_COPY
}
} catch {
# Kritischer, unerwarteter Fehler
$fehlerMsg = "Kritischer Fehler: $($_.Exception.Message)"
Write-BackupLog $fehlerMsg -level "ERROR"
Write-BackupLog "Stack Trace: $($_.ScriptStackTrace)" -level "ERROR"
exit $EXIT_ERROR_GENERAL
} finally {
# Cleanup und finale Aktionen
Write-BackupLog "Skript beendet um $(Get-Date -Format 'HH:mm:ss')" -level "INFO"
Write-BackupLog "" -level "INFO"
}
Übung 4: Error-Report Generator
[Bearbeiten | Quelltext bearbeiten]Aufgabe: Erstelle eine Funktion, die:
- Alle Fehler aus $Error analysiert
- Fehler nach Typ gruppiert
- Statistiken erstellt
- HTML-Report generiert
- Optional Fehler-Verlauf löscht
Lösung anzeigen
function Export-ErrorReport {
<#
.SYNOPSIS
Erstellt einen detaillierten Fehler-Report.
.DESCRIPTION
Analysiert alle Fehler in $Error und erstellt
einen umfassenden HTML-Report mit Statistiken.
.PARAMETER outputPath
Pfad für den HTML-Report.
.PARAMETER clearErrors
Löscht $Error nach Export.
.PARAMETER maxErrors
Maximale Anzahl zu analysierender Fehler.
.EXAMPLE
Export-ErrorReport -outputPath "C:\Reports\errors.html"
#>
[CmdletBinding()]
param(
[string]$outputPath = ".\error_report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html",
[switch]$clearErrors,
[int]$maxErrors = 100
)
Write-Host "`n=== Fehler-Report Generator ===" -ForegroundColor Cyan
# Prüfen ob Fehler vorhanden
if ($Error.Count -eq 0) {
Write-Host "Keine Fehler zum Analysieren gefunden." -ForegroundColor Green
return
}
Write-Host "Analysiere $($Error.Count) Fehler..." -ForegroundColor Yellow
# Fehler begrenzen
$zuAnalysieren = if ($Error.Count -gt $maxErrors) {
Write-Warning "Analysiere nur die neuesten $maxErrors Fehler"
$Error | Select-Object -First $maxErrors
} else {
$Error
}
# Fehler-Objekte erstellen
$fehlerListe = @()
$index = 1
foreach ($err in $zuAnalysieren) {
$fehlerListe += [PSCustomObject]@{
Nr = $index++
Typ = $err.Exception.GetType().Name
Nachricht = $err.Exception.Message
Kategorie = $err.CategoryInfo.Category
Befehl = $err.InvocationInfo.MyCommand.Name
Zeile = $err.InvocationInfo.ScriptLineNumber
Skript = $err.InvocationInfo.ScriptName
Zeit = $err.TimeGenerated
}
}
# Statistiken
$stats = @{
Gesamt = $fehlerListe.Count
NachTyp = $fehlerListe | Group-Object Typ | Sort-Object Count -Descending
NachKategorie = $fehlerListe | Group-Object Kategorie | Sort-Object Count -Descending
NachBefehl = $fehlerListe | Group-Object Befehl | Sort-Object Count -Descending | Select-Object -First 10
HaeufigsteFehler = $fehlerListe | Group-Object Nachricht | Sort-Object Count -Descending | Select-Object -First 5
}
# HTML generieren
$htmlContent = @"
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>PowerShell Fehler-Report</title>
<style>
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
margin: 20px;
background-color: #f5f5f5;
}
.container {
max-width: 1400px;
margin: 0 auto;
background-color: white;
padding: 30px;
border-radius: 8px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
h1 {
color: #d9534f;
border-bottom: 3px solid #d9534f;
padding-bottom: 10px;
}
h2 {
color: #337ab7;
margin-top: 30px;
border-bottom: 2px solid #337ab7;
padding-bottom: 5px;
}
.stats {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 15px;
margin: 20px 0;
}
.stat-box {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 20px;
border-radius: 8px;
text-align: center;
}
.stat-box h3 {
margin: 0;
font-size: 36px;
font-weight: bold;
}
.stat-box p {
margin: 5px 0 0 0;
opacity: 0.9;
}
table {
width: 100%;
border-collapse: collapse;
margin: 15px 0;
background-color: white;
}
th {
background-color: #337ab7;
color: white;
padding: 12px;
text-align: left;
font-weight: 600;
}
td {
border: 1px solid #ddd;
padding: 10px;
}
tr:nth-child(even) {
background-color: #f9f9f9;
}
tr:hover {
background-color: #f0f0f0;
}
.error-msg {
color: #d9534f;
font-family: 'Courier New', monospace;
}
.meta-info {
background-color: #f8f9fa;
padding: 15px;
border-radius: 5px;
margin: 20px 0;
}
.chart {
margin: 20px 0;
}
</style>
</head>
<body>
<div class="container">
<h1>🔴 PowerShell Fehler-Report</h1>
<div class="meta-info">
<strong>Erstellt:</strong> $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')<br>
<strong>Computer:</strong> $env:COMPUTERNAME<br>
<strong>Benutzer:</strong> $env:USERNAME<br>
<strong>PowerShell Version:</strong> $($PSVersionTable.PSVersion)
</div>
<h2>📊 Übersicht</h2>
<div class="stats">
<div class="stat-box">
<h3>$($stats.Gesamt)</h3>
<p>Fehler gesamt</p>
</div>
<div class="stat-box">
<h3>$($stats.NachTyp.Count)</h3>
<p>Fehlertypen</p>
</div>
<div class="stat-box">
<h3>$($stats.NachKategorie.Count)</h3>
<p>Kategorien</p>
</div>
</div>
<h2>📈 Fehler nach Typ</h2>
$($stats.NachTyp | Select-Object Name, Count | ConvertTo-Html -Fragment)
<h2>📋 Fehler nach Kategorie</h2>
$($stats.NachKategorie | Select-Object Name, Count | ConvertTo-Html -Fragment)
<h2>⚡ Top Befehle mit Fehlern</h2>
$($stats.NachBefehl | Select-Object Name, Count | ConvertTo-Html -Fragment)
<h2>🔥 Häufigste Fehler-Nachrichten</h2>
$($stats.HaeufigsteFehler | Select-Object Name, Count | ConvertTo-Html -Fragment)
<h2>📝 Detaillierte Fehler-Liste</h2>
$($fehlerListe | Select-Object Nr, Typ, Nachricht, Kategorie, Befehl, Zeile | ConvertTo-Html -Fragment)
</div>
</body>
</html>
"@
# In Datei schreiben
try {
$htmlContent | Out-File -FilePath $outputPath -Encoding UTF8 -ErrorAction Stop
Write-Host "✓ Report erstellt: $outputPath" -ForegroundColor Green
# Datei öffnen
Invoke-Item $outputPath
} catch {
Write-Error "Konnte Report nicht schreiben: $_"
return
}
# Fehler löschen
if ($clearErrors) {
$Error.Clear()
Write-Host "✓ Fehler-Verlauf gelöscht" -ForegroundColor Green
}
# Zusammenfassung
Write-Host "`n=== Zusammenfassung ===" -ForegroundColor Cyan
Write-Host "Analysierte Fehler: $($stats.Gesamt)"
Write-Host "Häufigster Typ: $($stats.NachTyp[0].Name) ($($stats.NachTyp[0].Count)x)"
Write-Host "Report-Pfad: $outputPath"
}
# Test: Einige Fehler erzeugen und dann Report erstellen
try { Get-Item "C:\GibtEsNicht1.txt" -ErrorAction Stop } catch {}
try { [int]"keine zahl" } catch {}
try { 1/0 } catch {}
# Report erstellen
Export-ErrorReport -outputPath "C:\Reports\error_report.html" -Verbose
Fehlerbehandlungs-Entscheidungsbaum
[Bearbeiten | Quelltext bearbeiten]Fehlerbehandlung nötig?
├─ Kritischer Fehler (muss stoppen)?
│ ├─ Ja → throw verwenden
│ └─ Nein → Write-Error verwenden
│
├─ Cmdlet-Fehler abfangen?
│ ├─ Ja → Try-Catch mit -ErrorAction Stop
│ └─ Nein → ErrorAction SilentlyContinue
│
├─ Cleanup nötig?
│ ├─ Ja → Finally-Block verwenden
│ └─ Nein → Nur Try-Catch
│
├─ Instabile Operation?
│ ├─ Ja → Retry-Logik implementieren
│ └─ Nein → Normale Fehlerbehandlung
│
└─ Produktions-Skript?
├─ Ja → Logging + Try-Catch + Finally
└─ Nein → Einfaches Try-Catch reichtBest Practices
[Bearbeiten | Quelltext bearbeiten]DO:
- Verwende Try-Catch für kritische Operationen
- Implementiere Finally für Cleanup (Dateien schließen, Verbindungen trennen)
- Logge Fehler in Produktions-Skripten
- Verwende spezifische Catch-Blöcke für verschiedene Fehlertypen
- Gib aussagekräftige Fehlermeldungen
- Nutze -ErrorAction Stop für Cmdlets in Try-Catch
- Implementiere Retry-Logik für Netzwerk-Operationen
- Verwende Set-StrictMode für robusteren Code
DON'T:
- Keine leeren Catch-Blöcke (Fehler verschlucken)
- Nicht alle Fehler gleich behandeln
- Keine generischen Fehlermeldungen ("Fehler aufgetreten")
- Nicht zu viele verschachtelte Try-Catch
- Keine kritischen Fehler mit Write-Error (verwende throw)
- Nicht Finally vergessen bei Ressourcen-Cleanup
- Keine Fehler loggen ohne Kontext-Information
Cheat Sheet - Fehlerbehandlung
[Bearbeiten | Quelltext bearbeiten]# TRY-CATCH-FINALLY
try {
Get-Content "datei.txt" -ErrorAction Stop
} catch [System.IO.FileNotFoundException] {
Write-Host "Datei nicht gefunden"
} catch {
Write-Host "Anderer Fehler: $_"
} finally {
Write-Host "Cleanup"
}
# ERRORACTION
-ErrorAction Stop # Für Try-Catch
-ErrorAction SilentlyContinue # Fehler unterdrücken
-ErrorAction Ignore # Komplett ignorieren
# EIGENE FEHLER
throw "Kritischer Fehler!"
Write-Error "Warnung"
# FEHLER-VARIABLEN
$Error[0] # Letzter Fehler
$Error.Clear() # Leeren
$? # Erfolg?
$LASTEXITCODE # Exit-Code
# LOGGING
Write-Verbose "Info" -Verbose
Write-Debug "Debug" -Debug
Start-Transcript "log.txt"
# DEBUGGING
Set-PSBreakpoint -Line 10
Set-StrictMode -Version Latest
$DebugPreference = "Continue"
# RETRY-PATTERN
$versuche = 0
while ($versuche -lt 3) {
try {
# Operation
break
} catch {
$versuche++
Start-Sleep 2
}
}
Nächste Schritte
[Bearbeiten | Quelltext bearbeiten]Im nächsten Kurs lernst du:
- Mit dem Dateisystem arbeiten
- Dateien und Ordner verwalten
- Inhalte lesen und schreiben
- Pfade manipulieren
- Datei-Operationen automatisieren
Zusätzliche Ressourcen
[Bearbeiten | Quelltext bearbeiten]Häufige Fehlertypen
[Bearbeiten | Quelltext bearbeiten]| Exception | Bedeutung | Häufige Ursache |
|---|---|---|
| FileNotFoundException | Datei nicht gefunden | Falscher Pfad |
| UnauthorizedAccessException | Zugriff verweigert | Fehlende Rechte |
| IOException | Ein-/Ausgabefehler | Datei in Verwendung |
| ArgumentException | Ungültiges Argument | Falsche Parameter |
| FormatException | Formatfehler | Typkonvertierung fehlgeschlagen |
| InvalidOperationException | Ungültige Operation | Falscher Zustand |
| NullReferenceException | Null-Referenz | Variable ist $null |