> 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/it/sviluppo/debugging-scripts.md).

# Debug degli script

Gli script eseguiti all'interno di Universal vengono eseguiti in processi in background o runspace, il che può rendere difficile il debug di ciò che accade all'interno di uno script. È possibile utilizzare cmdlet come Write-Debug e Write-Verbose per fornire maggiori informazioni nei log di app e job.

## Visual Studio Remote Debugger

Utilizzando l'[estensione PowerShell Universal per Visual Studio Code](/powershell-universal/it/sviluppo/visual-studio-code-extension.md), è possibile connettersi direttamente agli script PowerShell in esecuzione in PowerShell Universal.

## Debugger integrato

{% hint style="warning" %}
Il debugger integrato è supportato in PowerShell 7 e negli ambienti integrati. Non è supportato in Windows PowerShell.
{% endhint %}

Il debugger integrato consente di accedere a una console di debug per gli script in esecuzione. È possibile includere la chiamata al cmdlet `Wait-Debugger` negli script, che passeranno allo stato In Breakpoint. Una volta avvenuto ciò, è possibile visualizzare il job per eseguire comandi sullo script.

### Script

PowerShell Universal si integra direttamente con il debugger di PowerShell. È possibile includere `Wait-Debugger` negli script per metterli in pausa.

Ad esempio, si supponga di avere uno script che include una chiamata a `Wait-Debugger`. La prima riga verrà eseguita e poi lo script si metterà in pausa una volta raggiunta la seconda riga.

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

Una volta che uno script è in pausa, verrà visualizzato un terminale per il debug dello script.

<figure><img src="/files/afkoaFLRTBgjsMo4FGIK" alt=""><figcaption><p>Terminale del debugger</p></figcaption></figure>

È quindi possibile utilizzare i comandi di debug integrati per eseguire lo script passo dopo passo.

<figure><img src="/files/KmlesxuJS1amaPfwpsCT" alt=""><figcaption><p>Comandi di debug</p></figcaption></figure>

### App

È possibile utilizzare `Wait-Debugger` direttamente nelle app di PowerShell Universal. È possibile includere questo comando negli event handler e nei dynamic per mettere in pausa l'esecuzione dell'app e valutare lo stato corrente dello script.

Ad esempio, è possibile includere `Wait-Debugger` in un dynamic.

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

Il risultato è che l'app visualizzerà lo skeleton di caricamento perché il debugger di PowerShell è in breakpoint.

<figure><img src="/files/3E7fa3tak5BPd8wKKC9c" alt=""><figcaption></figcaption></figure>

All'interno della console di amministrazione, è possibile fare clic sulla scheda Debugger per visualizzare i breakpoint correnti su cui l'app è in attesa. Il debugger fornisce un terminale per valutare i comandi sul runspace. È possibile utilizzare qualsiasi comando PowerShell standard. È inoltre possibile utilizzare gli strumenti di debug come l'esecuzione passo passo e la visualizzazione del codice sorgente. Nella parte superiore della console sono disponibili appositi pulsanti.

È possibile utilizzare comandi come `Get-Variable` per ottenere informazioni sullo stato delle variabili. Esegua `c` per consentire all'endpoint di continuare l'esecuzione.

## Logging degli script

Alcuni aspetti di Universal registrano automaticamente i propri script. Altre funzionalità potrebbero richiedere di effettuare il logging manualmente.

### API

È possibile utilizzare la vista Live Log nella scheda Log per visualizzare i log dell'API selezionata.

### Job

I job registrano log in modo estensivo. Verranno visualizzati l'output della console e della pipeline. Se si imposta `$DebugPreference` o `$VerbosePreference`, tali stream saranno visibili anche nell'output della console. È possibile aggiungere ulteriori messaggi di log utilizzando `Write-Debug` o `Write-Verbose`.

### App

Le app registrano nei propri log messaggi informativi, di avviso e di errore. Si consiglia di utilizzare il logging all'avvio di un'app piuttosto che tentare di collegare un debugger. È inoltre possibile utilizzare la variabile `$DebugPreference` per ottenere informazioni aggiuntive durante l'avvio dell'app.

```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'
}
```

### Autenticazione e autorizzazione

È possibile utilizzare la vista Live Log nelle pagine di autenticazione e dei ruoli per visualizzare l'output degli stream PowerShell.

## Debug degli script da una console PowerShell

È possibile eseguire il debug di qualsiasi script all'interno di Universal (o di qualsiasi processo PowerShell, in realtà) utilizzando i cmdlet di debug disponibili in PowerShell. Questi cmdlet consentono di connettersi a processi PowerShell locali, come Universal, ed eseguire gli script passo dopo passo direttamente nel terminale.

### Mettere in pausa lo script

Innanzitutto, è necessario assicurarsi che lo script attenda la connessione del debugger prima di continuare. Ciò significa che sarà necessario includere un comando `Wait-Debugger` da qualche parte nello script.

{% hint style="info" %}
Le app attendono solo 10 secondi durante l'avvio, quindi inserire un Wait-Debugger al loro interno potrebbe non funzionare. È consigliabile affidarsi all'uso di $DebugPreference e Write-Debug per diagnosticare i problemi di avvio delle app.
{% endhint %}

### Esecuzione dello script

Ora che lo script è configurato per mettersi in pausa e attendere il debugger, sarà necessario eseguirlo. Per i job, è sufficiente avviare il job. Per le API, sarà necessario effettuare una richiesta all'API tramite l'endpoint che si desidera testare. Per le app, sarà necessario caricare la pagina nel browser. Per l'autenticazione e l'autorizzazione, sarà necessario effettuare il login.

### Trovare l'ID del processo

Una volta inserito il comando `Wait-Debugger` nello script di cui si desidera eseguire il debug, sarà necessario avviare lo script e determinare il processo all'interno del quale viene eseguito.

#### Job

I job vengono eseguiti in un processo isolato all'interno di Universal. È sufficiente avviare il job: verrà avviato il processo che rimarrà in attesa sul comando `Wait-Debugger`. Una volta avviato il job, è possibile utilizzare il cmdlet `Get-UAJob` per trovare l'ID del processo di quel job.

#### API

Le API vengono eseguite in un unico processo PowerShell. Non viene avviato un nuovo processo per ogni chiamata API. È possibile individuare il processo delle API cercando il processo pwsh o PowerShell la cui riga di comando include `StartApi`.

#### App

Le app vengono eseguite in un processo PowerShell isolato. L'ID del processo è indicato nella tabella delle app all'interno della console di amministrazione.

#### Autenticazione e autorizzazione

Gli script di autenticazione e autorizzazione vengono eseguiti all'interno del server Universal. È possibile individuare il processo `Universal.Server.exe` e collegarsi ad esso.

**Ambiente integrato**

Qualsiasi funzionalità in esecuzione nell'ambiente integrato verrà eseguita all'interno del processo `Universal.Server.exe`. Sarà necessario collegarsi a questo processo per eseguirne il debug.

### Collegarsi al processo ed eseguire il debug del runspace

Una volta individuato il processo a cui si desidera collegarsi, è possibile farlo utilizzando `Enter-PSHostProcess`. È sufficiente specificare l'ID del processo trovato nel passaggio precedente.

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

{% hint style="info" %}
Enter-PSHostProcess utilizza named pipe e richiede di disporre dell'autorizzazione per il processo a cui si accede. Se si esegue Universal come servizio, potrebbe essere necessario eseguirlo con il proprio account locale per connettersi correttamente al processo.
{% endhint %}

Una volta collegati al processo, sarà necessario individuare il runspace in cui viene eseguito il codice. A tale scopo, è possibile utilizzare il cmdlet `Get-Runspace`. Questo restituirà un elenco dei runspace attualmente attivi nel processo. Cerchi il runspace contrassegnato come `InBreakpoint`. Si tratta del runspace in attesa sul comando `Wait-Debugger`.

Ora che ha individuato il runspace, utilizzi `Debug-Runspace` per collegarsi ad esso. Avrà quindi la possibilità di impartire comandi di debug su quel runspace. È possibile visualizzare lo stato delle variabili, impartire comandi e persino eseguire lo script passo dopo passo.

Per un elenco completo dei comandi di debug, può consultare la [documentazione Microsoft qui](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_debuggers?view=powershell-7#starting-and-stopping-the-debugger).

### Esempio di connessione a un processo API

Di seguito è riportato un esempio di come connettersi a un processo API.

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

## Debug con Visual Studio Code

Per eseguire il debug di uno script, è possibile utilizzare il cmdlet Wait-Debugger all'interno dello script per metterlo in pausa finché non viene collegato un debugger. È quindi possibile utilizzare un debugger, come VS Code, per collegarsi al processo e al runspace per visualizzare le variabili, eseguire il codice passo dopo passo ed eseguire comandi di debug.

È inoltre possibile eseguire il debug degli script utilizzando i cmdlet integrati `Enter-PSHostProcess`, `Get-Runspace` e `Debug-Runspace`.


---

# 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/it/sviluppo/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.