> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/de/entwicklung/debugging-scripts.md).

# Debuggen von Skripten

Skripte, die innerhalb von Universal ausgeführt werden, laufen in Hintergrundprozessen oder Runspaces, was es schwierig machen kann, zu debuggen, was innerhalb eines Skripts geschieht. Sie können Cmdlets wie Write-Debug und Write-Verbose verwenden, um mehr Informationen in den Protokollen für Apps und Jobs bereitzustellen.

## Visual Studio Remote Debugger

Mit der PowerShell [Universal Visual Studio Code-Erweiterung](/powershell-universal/de/entwicklung/visual-studio-code-extension.md) können Sie sich direkt mit Ihren PowerShell-Skripten verbinden, die PowerShell Universal ausführen.

## Integrierter Debugger

{% hint style="warning" %}
Der integrierte Debugger wird in PowerShell 7 und integrierten Umgebungen unterstützt. Er wird in Windows PowerShell nicht unterstützt.
{% endhint %}

Der integrierte Debugger ermöglicht den Zugriff auf eine Debug-Konsole für laufende Skripte. Sie können den Aufruf des Cmdlets `Wait-Debugger` in Ihre Skripte einbinden, und sie wechseln in den Zustand In Breakpoint. Sobald dies geschieht, können Sie den Job anzeigen, um Befehle gegen das Skript auszuführen.

### Skripte

PowerShell Universal integriert sich direkt in den PowerShell-Debugger. Sie können `Wait-Debugger` in Ihre Skripte einbinden, um sie anzuhalten.

Nehmen wir zum Beispiel an, Sie haben ein Skript mit einem enthaltenen `Wait-Debugger`-Aufruf. Die erste Zeile wird ausgeführt und dann hält es an, sobald es die zweite Zeile erreicht.

<pre class="language-powershell"><code class="lang-powershell"><strong>$Processes = Get-Process
</strong><strong>Wait-Debugger
</strong></code></pre>

Sobald ein Skript angehalten ist, sehen Sie ein Terminal zum Debuggen des Skripts.

<figure><img src="/files/rVyVzUujGBSealSKiKx6" alt=""><figcaption><p>Debugger-Terminal</p></figcaption></figure>

Sie können dann die integrierten Debugging-Befehle verwenden, um durch das Skript zu schrittweise durchzugehen.

<figure><img src="/files/FHCGGJw5ebuMTHfVZQsV" alt=""><figcaption><p>Debugging-Befehle</p></figcaption></figure>

### Apps

Sie können `Wait-Debugger` direkt in Ihren PowerShell Universal-Apps verwenden. Sie können diesen Befehl in Event-Handler und Dynamics einbinden, um die App-Ausführung anzuhalten und den aktuellen Zustand des Skripts auszuwerten.

Sie können `Wait-Debugger` zum Beispiel in ein Dynamic einbinden.

```powershell
New-UDApp -Title 'PowerShell Universal' -Content {
     New-UDDynamic -Id 'dynamic' -Content {
        Wait-Debugger
        New-UDTypography "Loaded"
    } -LoadingComponent {
        New-UDSkeleton
    }
}
```

Das Ergebnis ist, dass die App das Lade-Skeleton anzeigt, weil der PowerShell-Debugger sich in einem Breakpoint befindet.

<figure><img src="/files/Nls4lYKCnQ4WBI0G35Lv" alt=""><figcaption></figcaption></figure>

Innerhalb der Admin-Konsole können Sie auf die Registerkarte Debugger klicken, um die aktuellen Breakpoints anzuzeigen, auf die die App wartet. Der Debugger stellt ein Terminal zur Auswertung von Befehlen gegen den Runspace bereit. Sie können jeden Standard-PowerShell-Befehl verwenden. Sie können auch die Debugging-Werkzeuge wie Stepping und die Auflistung des Quellcodes verwenden. Am oberen Rand der Konsole sind Schaltflächen verfügbar.

Sie können Befehle wie `Get-Variable` verwenden, um Informationen über den Variablenzustand zu erhalten. Führen Sie `c` aus, damit der Endpunkt die Ausführung fortsetzen kann.

## Protokollierung von Skripten

Bestimmte Aspekte von Universal protokollieren ihre Skripte automatisch. Andere Funktionen erfordern möglicherweise, dass Sie selbst protokollieren.

### APIs

Sie können die Live-Log-Ansicht auf der Registerkarte Log verwenden, um Protokolle für die ausgewählte API anzuzeigen.

### Jobs

Jobs protokollieren umfangreich. Sie sehen Konsolen- und Pipeline-Ausgaben. Wenn Sie `$DebugPreference` oder `$VerbosePreference` setzen, sehen Sie diese Streams ebenfalls in der Konsolenausgabe. Sie können zusätzliche Protokollmeldungen mit `Write-Debug` oder `Write-Verbose` hinzufügen.

### Apps

Apps protokollieren informative Meldungen, Warnungen und Fehlermeldungen in ihrem Protokoll. Es wird empfohlen, beim Starten einer App die Protokollierung zu verwenden, anstatt zu versuchen, einen Debugger anzuhängen. Sie können auch die Variable `$DebugPreference` verwenden, um während des App-Starts zusätzliche Informationen zu erhalten.

```powershell
$DebugPreference = 'Continue'

New-UDApp -Title 'Test' -Content {
    Write-Debug "My app is loading. I have am $user with $roles"

    New-UDTypography -Text 'Hello, world'
}
```

### Authentifizierung und Autorisierung

Sie können die Live-Log-Ansicht auf den Authentifizierungs- und Rollenseiten verwenden, um die PowerShell-Stream-Ausgabe zu sehen.

## Debuggen von Skripten über eine PowerShell-Konsole

Sie können jedes Skript innerhalb von Universal (oder eigentlich jeden PowerShell-Prozess) mit den in PowerShell verfügbaren Debugging-Cmdlets debuggen. Diese Cmdlets ermöglichen es Ihnen, sich mit lokalen PowerShell-Prozessen wie Universal zu verbinden und direkt im Terminal durch Ihre Skripte zu gehen.

### Anhalten des Skripts

Zuerst müssen Sie sicherstellen, dass das Skript darauf wartet, dass Sie den Debugger verbinden, bevor es fortfährt. Das bedeutet, dass Sie irgendwo in Ihrem Skript einen `Wait-Debugger`-Befehl einbinden müssen.

{% hint style="info" %}
Apps warten beim Start nur 10 Sekunden, daher funktioniert das Einfügen eines Wait-Debugger möglicherweise nicht. Sie sollten sich auf die Verwendung von $DebugPreference und Write-Debug verlassen, um Probleme beim App-Start zu diagnostizieren.
{% endhint %}

### Ausführen Ihres Skripts

Nachdem Sie Ihr Skript so eingerichtet haben, dass es anhält und auf den Debugger wartet, möchten Sie Ihr Skript ausführen. Bei Jobs starten Sie einfach den Job. Bei APIs müssen Sie eine Anfrage an die API über den Endpunkt senden, den Sie testen möchten. Bei Apps möchten Sie die Seite in Ihrem Browser laden. Bei Authentifizierung und Autorisierung möchten Sie sich anmelden.

### Ermitteln Ihrer Prozess-ID

Sobald Sie Ihren `Wait-Debugger`-Befehl in dem Skript haben, das Sie debuggen möchten, müssen Sie das Skript starten und den Prozess bestimmen, in dem es ausgeführt wird.

#### Jobs

Jobs laufen in ihrem eigenen isolierten Prozess innerhalb von Universal. Sie müssen lediglich den Job starten, und er startet den Prozess und wartet auf Ihren `Wait-Debugger`-Befehl. Sobald Ihr Job gestartet ist, können Sie das Cmdlet `Get-UAJob` verwenden, um die Prozess-ID dieses Jobs zu finden.

#### APIs

APIs laufen in einem einzelnen PowerShell-Prozess. Es wird nicht für jeden API-Aufruf ein neuer Prozess gestartet. Sie können den API-Prozess finden, indem Sie den pwsh- oder PowerShell-Prozess mit der Befehlszeile suchen, die `StartApi` enthält.

#### Apps

Apps laufen in ihrem eigenen isolierten PowerShell-Prozess. Die Prozess-ID ist in der App-Tabelle innerhalb der Admin-Konsole aufgeführt.

#### Authentifizierung und Autorisierung

Authentifizierungs- und Autorisierungsskripte laufen innerhalb des Universal-Servers. Sie können den Prozess `Universal.Server.exe` finden und sich an diesen anhängen.

**Integrierte Umgebung**

Jede Funktion, die innerhalb der integrierten Umgebung ausgeführt wird, läuft innerhalb des Prozesses `Universal.Server.exe`. Sie müssen sich an diesen Prozess anhängen, um sie zu debuggen.

### Anhängen an den Prozess und Debuggen des Runspace

Sobald Sie den Prozess haben, an den Sie sich anhängen möchten, können Sie dies mit `Enter-PSHostProcess` tun. Geben Sie einfach die Prozess-ID an, die Sie im vorherigen Schritt gefunden haben.

```powershell
Enter-PSHostProcess -id 1231
```

{% hint style="info" %}
Enter-PSHostProcess verwendet Named Pipes und erfordert, dass Sie Berechtigungen für den Prozess haben, auf den Sie zugreifen. Wenn Sie Universal als Dienst ausführen, müssen Sie es möglicherweise unter Ihrem lokalen Konto ausführen, um sich ordnungsgemäß mit dem Prozess zu verbinden.
{% endhint %}

Sobald Sie sich an den Prozess angehängt haben, möchten Sie nun den Runspace finden, in dem Ihr Code ausgeführt wird. Dazu können Sie das Cmdlet `Get-Runspace` verwenden. Dieses gibt eine Liste der derzeit in Ihrem Prozess aktiven Runspaces zurück. Suchen Sie nach dem Runspace, der mit `InBreakpoint` markiert ist. Dies ist der Runspace, der auf den `Wait-Debugger`-Befehl wartet.

Nachdem Sie nun Ihren Runspace gefunden haben, verwenden Sie `Debug-Runspace`, um sich an den Runspace anzuhängen. Sie haben nun die Möglichkeit, Debugging-Befehle gegen diesen Runspace auszuführen. Sie können den Status von Variablen anzeigen, Befehle ausführen und sogar schrittweise durch das Skript gehen.

Eine vollständige Liste der Debugging-Befehle finden Sie in der [Microsoft-Dokumentation hier](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_debuggers?view=powershell-7#starting-and-stopping-the-debugger).

### Beispiel für das Verbinden mit einem API-Prozess

Im Folgenden finden Sie ein Beispiel, wie Sie sich mit einem API-Prozess verbinden.

```powershell
$Process = Get-Process pwsh | Where-Object { $_.CommandLine.Contains('StartApi') }
Enter-PSHostProcess -Id $Process.Id
Get-Runspace
Debug-Runspace -Id 2
```

## Debuggen mit Visual Studio Code

Um ein Skript zu debuggen, können Sie das Cmdlet Wait-Debugger in Ihrem Skript verwenden, um das Skript anzuhalten, bis ein Debugger angehängt ist. Sie können dann einen Debugger wie VS Code verwenden, um sich an den Prozess und den Runspace anzuhängen, um Variablen anzuzeigen, schrittweise durch den Code zu gehen und Debugging-Befehle auszuführen.

Sie können Skripte auch mit den integrierten Cmdlets `Enter-PSHostProcess`, `Get-Runspace` und `Debug-Runspace` debuggen.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/de/entwicklung/debugging-scripts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.