> 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

Debuggen Sie PowerShell Universal-Skripte mit Wait-Debugger, der integrierten Debugger-Konsole oder Visual Studio Code über Jobs, Apps und APIs hinweg.

Skripte, die in 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 [Universal Visual Studio Code-Erweiterung](/powershell-universal/de/entwicklung/visual-studio-code-extension.md) für PowerShell können Sie sich direkt mit Ihren PowerShell-Skripten verbinden, die in PowerShell Universal ausgeführt werden.

## 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 Cmdlet-Aufruf `Wait-Debugger` in Ihre Skripte einfügen, wodurch sie in den Zustand „In Breakpoint“ übergehen. Sobald dies geschieht, können Sie den Job anzeigen, um Befehle gegen das Skript auszuführen.

### Skripte

PowerShell Universal ist direkt in den PowerShell-Debugger integriert. Sie können `Wait-Debugger` in Ihre Skripte einfügen, um sie anzuhalten.

Nehmen wir zum Beispiel an, Sie haben ein Skript, das einen `Wait-Debugger`-Aufruf enthält. Die erste Zeile wird ausgeführt und dann wird das Skript angehalten, 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.

Anschließend können Sie die integrierten Debugging-Befehle verwenden, um das Skript schrittweise durchzugehen.

### Apps

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

Sie können `Wait-Debugger` zum Beispiel in eine Dynamic einfügen.

```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 sich der PowerShell-Debugger im Breakpoint befindet.

In 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 zum Auswerten von Befehlen gegen den Runspace bereit. Sie können jeden Standard-PowerShell-Befehl verwenden. Sie können auch die Debugging-Werkzeuge wie schrittweises Ausführen und Quellcode-Auflistung verwenden. Oben in der Konsole stehen Schaltflächen zur Verfügung.

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

## Skripte protokollieren

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

### APIs

Sie können die Live-Protokollansicht 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 mit `Write-Debug` oder `Write-Verbose` zusätzliche Protokollmeldungen hinzufügen.

### Apps

Apps protokollieren informative Meldungen sowie Warn- 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-Protokollansicht auf den Seiten für Authentifizierung und Rollen verwenden, um die PowerShell-Stream-Ausgabe zu sehen.

## Skripte von einer PowerShell-Konsole aus debuggen

Sie können jedes Skript in 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 Ihre Skripte direkt im Terminal schrittweise durchzugehen.

### Das Skript anhalten

Zunächst müssen Sie sicherstellen, dass das Skript wartet, bis Sie den Debugger verbunden haben, bevor es fortfährt. Das bedeutet, dass Sie irgendwo in Ihrem Skript einen `Wait-Debugger`-Befehl einfügen müssen.

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

### Ihr Skript ausführen

Nachdem Sie Ihr Skript so eingerichtet haben, dass es anhält und auf den Debugger wartet, sollten 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 stellen, den Sie testen möchten. Bei Apps sollten Sie die Seite in Ihrem Browser laden. Bei Authentifizierung und Autorisierung sollten Sie sich anmelden.

### Ihre Prozess-ID finden

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

#### Jobs

Jobs werden in ihrem eigenen isolierten Prozess innerhalb von Universal ausgeführt. 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 werden in einem einzigen PowerShell-Prozess ausgeführt. 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 werden in ihrem eigenen isolierten PowerShell-Prozess ausgeführt. Die Prozess-ID ist in der App-Tabelle in der Admin-Konsole aufgeführt.

#### Authentifizierung und Autorisierung

Authentifizierungs- und Autorisierungsskripte werden im Universal-Server ausgeführt. Sie können den Prozess `Universal.Server.exe` finden und sich an diesen anhängen.

**Integrierte Umgebung**

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

### An den Prozess anhängen und den Runspace debuggen

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 verbinden zu können.
{% endhint %}

Nachdem 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 aktuell 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 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 das Skript schrittweise durchgehen.

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 die Verbindung mit einem API-Prozess

Nachfolgend finden Sie ein Beispiel dafür, 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. Anschließend können Sie einen Debugger wie VS Code verwenden, um sich an den Prozess und den Runspace anzuhängen, um Variablen anzuzeigen, Code schrittweise durchzugehen 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.