PowerShell is de belangrijkste command line- en scripttaal van Windows-besturingssystemen. U kunt er programma’s mee uitvoeren en systeembeheertaken vanuit de terminal afhandelen. Systeembeheerders en ontwikkelaars gebruiken PowerShell dan ook volop om hun workflows te automatiseren.
Error handling is een belangrijk onderdeel van elke vorm van scripting en automatisering. Als er iets misgaat, zouden uw PowerShell-scripts niet zomaar moeten crashen. Ze zouden moeten vaststellen dat er een fout is opgetreden en actie moeten ondernemen: de taak opnieuw proberen of u waarschuwen dat er iets mis is, zodat u de oorzaak kunt opsporen en verhelpen.
Deze gids geeft u een gedetailleerd beeld van PowerShell error handling, inclusief soorten fouten, technieken voor error handling, voorbeelden van hoe u error handling in uw scripts implementeert en beste praktijken voor het throwen, catchen, loggen en afhandelen van fouten.
Wilt u een snel overzicht? Bekijk dan deze videogids over de complete gids voor PowerShell error handling.
De soorten fouten in PowerShell
Er zijn twee soorten fouten die u verschillend moet afhandelen om uw PowerShell-scripts betrouwbaar te houden.
Terminating errors stoppen de uitvoering van uw opdracht of script zodra ze optreden. Dit zijn meestal exceptions en u kunt ze afhandelen met try/catch-blokken (verderop in dit artikel toegelicht). Terminating errors ontstaan onder meer door syntaxfouten (wanneer u een opdracht verkeerd typt of ongeldige parameters meegeeft) en door interne fouten in de applicatie of opdracht die u uitvoert.
Non-terminating errors stoppen de uitvoering van uw opdracht of script niet: uw PowerShell-script loopt gewoon door nadat de fout is opgetreden. Meestal verschijnt er bij een non-terminating error een foutmelding voordat de uitvoering wordt hervat. U moet deze fouten anders afhandelen dan terminating errors, zodat ze uw scripts niet laten vastlopen wanneer de verwachte uitvoer later alsnog nodig is. Non-terminating errors kunnen ontstaan door time-outs in het netwerk, ontbrekende bestanden of rechtenproblemen. Dat zijn op zichzelf geen kritieke exceptions of uitvoeringsfouten, maar ze leiden wel tot onbedoeld gedrag als u ze niet afhandelt.
Basisbegrippen van PowerShell error handling (try, catch, finally en $ErrorActionPreference)
Terminating errors en exceptions worden gethrowd (de fout treedt op) en gecatcht (er wordt code uitgevoerd om de fout af te handelen). Fouten die niet worden gecatcht, zorgen ervoor dat de uitvoering van uw PowerShell-script stopt. Door uw code in try-, catch- en finally-blokken te plaatsen, kunt u dit soort fouten beheersen.
Als code in een try-blok een fout throwt, wordt het codeblok in het bijbehorende catch-blok uitgevoerd om de fout af te handelen (waarna de uitvoering kan doorgaan als dat gepast is). Opruimtaken die u hoe dan ook wilt uitvoeren of er nu een fout optrad of niet, zet u in een finally-blok. Verderop op deze pagina ziet u dit in een volledig codevoorbeeld.
Non-terminating errors afhandelen gaat anders, omdat er geen fout wordt gethrowd die de uitvoering stopt en u de fout dus ook niet kunt catchen. In plaats daarvan wordt de fout opgeslagen in de variabele $Error, een array met fouten die u op elk punt in uw PowerShell-scripts kunt raadplegen om te zien of een voorgaande instructie een non-terminating error heeft gegenereerd, zoals in dit voorbeeld:
Get-ChildItem -Path "C:fake_path"
if ($Error) {
Write-Host "Error occurred: $($Error[0])" # Display the most recent error as a string
$Error.Clear() # Clear the error
}Hierboven genereert de PowerShell-opdracht Get-ChildItem een non-terminating error als het opgegeven bestandssysteempad niet bestaat (in dit geval C:fake_path). De fout wordt vastgelegd in de variabele $Error, die vervolgens wordt gecontroleerd en afgehandeld.
Wilt u de foutuitvoer van een specifieke opdracht aan een eigen variabele toewijzen, dan gebruikt u de parameter -ErrorVariable (let op: in dat geval is de foutvariabele geen array):
Get-ChildItem -Path "C:fake_path" -ErrorVariable customError
if ($customError) {
Write-Host "Error occurred: $customError" # Display the error as a string
}U kunt non-terminating errors ook omzetten in terminating errors en ze met try/catch-blokken afhandelen. Dat doet u voor elke non-terminating error in uw script door de globale variabele $ErrorActionPreference op Stop te zetten:
$ErrorActionPreference = "Stop"
Wilt u dit alleen voor de fouten van één enkele opdracht, dan stelt u de parameter -ErrorAction in:
Get-ChildItem -Path "C:fake_path" -ErrorAction Stop
Try/catch/finally-blokken implementeren in PowerShell
Hieronder ziet u een voorbeeldscript in PowerShell dat de syntax en structuur van try/catch/finally-blokken laat zien. Het toont hoe u meerdere catch-blokken voor verschillende soorten exceptions gebruikt en hoe u met een finally-blok opruimt en eventueel resterende fouten afhandelt. Eerst een enkele fout die met een try/catch-blok wordt afgehandeld:
try {
# Attempt a file operation that fails
Get-Content -Path "C:fake_pathfake_file.txt" -ErrorAction Stop
} catch {
Write-Host "Exception caught: $($_.Exception.Message)"
}U kunt ook meerdere verschillende soorten mogelijke fouten in één try-blok afhandelen, elk met een eigen catch-blok:
try {
# Each of the below commands will throw a terminating error of a different type
Get-Content -Path "C:fake_pathfake_file.txt" -ErrorAction Stop # Attempt a file operation that fails to throw a ItemNotFoundException
$null.fakeFunction() # Attempt to run a non-existent method on a null object to throw a RuntimeException
$divideZero = 1/0 # Divide by zero to throw an exception that won't be specifically caught
} catch [System.Management.Automation.ItemNotFoundException] { # Catch the specific error thrown by Get-Content
Write-Host "Item not found exception caught: $($_.Exception.Message)"
} catch [System.Management.Automation.RuntimeException] { # Catch the specific error thrown by $null.fakeFunction
Write-Host "Runtime exception caught: $($_.Exception.Message)"
} catch { # Catch all other errors
# General catch block for any other exceptions
Write-Host "General exception caught: $($_.Exception.Message)"
} finally { # The finally block is always executed whether an exception was thrown or not.
Write-Host "Executing the finally block."
$Error.Clear() # This could, for example, be used to clean up non-terminating errors.
}In de code wordt het doel van elke instructie toegelicht, zodat u de volledige context ziet van hoe try, catch en finally samenwerken. Let op: als er meerdere terminating errors in hetzelfde try-blok optreden, wordt alleen de eerste fout gecatcht en afgehandeld, waarna het finally-blok wordt uitgevoerd. Zodra die fout is verholpen, worden volgende fouten gecatcht bij de volgende uitvoering van het script.
Geavanceerde technieken en voorbeelden voor error handling
U kunt try/catch-blokken ook nesten, zodat fouten erdoorheen omhoog ‘bubbelen’. Zo handelt u specifieke fouten af in de binnenste try/catch-blokken en vangt u in de buitenste blokken alle fouten op die niet zijn gecatcht of opnieuw zijn gethrowd, ook fouten uit uw binnenste catch-blokken. U kunt bijvoorbeeld geneste blokken gebruiken om specifieke fouten af te handelen en vervolgens één buitenste blok om alle fouten te catchen en te loggen, in plaats van de logcode in elk binnenste catch-blok te herhalen.
try { # Beginning of the outer catch block
try { # Beginning of the inner catch block
# Include potentially error-causing code here
Get-Content -Path "C:fake_pathfake_file.txt" -ErrorAction Stop
} catch [System.Management.Automation.ItemNotFoundException] { # Catch statement for the inner catch block that specifically handles ItemNotFoundException
Write-Host "Inner try block file not found exception caught: $($_.Exception.Message)"
} catch { # Catch statement for the inner catch block that handles all other exceptions
Write-Host "Inner try block exception caught: $($_.Exception.Message)"
throw # Re-throw the exception so that it will bubble up to the outer try/catch block
}
} catch { # Catch statement for the outer catch block
Write-Host "Outer try block exception caught: $($_.Exception.Message)" # Handle all errors re-thrown in the inner catch blocks here for clean up, logging, and alerting tasks
}Merk in bovenstaand voorbeeld op dat de ItemNotFoundException niet opnieuw wordt gethrowd en dus niet omhoog bubbelt naar het buitenste catch-blok.
Naarmate u uw PowerShell-scripts uitbreidt voor uw eigen toepassingen, wilt u waarschijnlijk ook eigen exceptions en PowerShell-foutrecords kunnen introduceren:
try {
$customException = New-Object Exception "This is a custom error!" # Create and throw a custom error
# Create a custom Error Record
$customErrorRecord = New-Object System.Management.Automation.ErrorRecord (
$customException,
"CustomErrorID",
[System.Management.Automation.ErrorCategory]::NotSpecified, # Sets the ErrorRecord category to NotSpecified
$null # Specify no specific target object for this error
)
throw $customErrorRecord
} catch {
# Catch and handle the custom error record
Write-Host "Error Message: $($_.Exception.Message)"
Write-Host "Error ID: $($_.FullyQualifiedErrorId)"
}Hierboven ziet u dat er geen doelobject is opgegeven (het staat op $null). U kunt dit vervangen door een bestandspad of een andere verwijzing en extra details aan de tekst van de exception toevoegen om de eigen fout informatiever te maken.
Beste praktijken voor PowerShell error handling
Er zijn verschillende beste praktijken die u bij het schrijven van uw PowerShell-scripts kunt volgen om error handling effectief te maken:
- Schrijf duidelijke en voorspelbare foutmeldingen: uw foutmeldingen moeten beschrijvend zijn en voldoende details uit de Exception of het ErrorRecord-object bevatten om de specifieke oorzaak van een fout te achterhalen.
- Zorg dat uw scripts kunnen doorlopen (of netjes afsluiten) wanneer er een fout optreedt: als uw scripts nog andere taken uitvoeren, wilt u de fout misschien afhandelen terwijl die taken doorlopen. Fouten die verdere uitvoering onmogelijk maken, moeten uw script laten afsluiten met een exitcode. Log en rapporteer vervolgens het resultaat van alle fouten.
- Test uw infrastructuur voor error handling en rapportage regelmatig: uw PowerShell-automatiseringen zijn waardeloos als ze falen zonder dat u het doorhebt. Test uw scripts regelmatig door bewust fouten te introduceren, zodat u zeker weet dat uw error handling werkt, de details worden gelogd en u een melding krijgt.
Error handling is een belangrijke functie van PowerShell-scripting en helpt u terwijl u uw script- en automatiseringsvaardigheden ontwikkelt. Door error handling goed te implementeren, fouten correct te throwen, try/catch/finally-blokken te gebruiken en $ErrorActionPreference in te zetten, leert u de PowerShell-syntax beter kennen. Bovendien krijgt u meer inzicht in de problemen die uw scripts tegenkomen en kunt u ze beter beheren.
