> 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/es/desarrollo/debugging-scripts.md).

# Depuración de scripts

Depure scripts de PowerShell Universal con Wait-Debugger, la consola del depurador integrado o Visual Studio Code en trabajos, aplicaciones y API.

Los scripts que se ejecutan en Universal lo hacen dentro de procesos en segundo plano o runspaces, lo que puede dificultar la depuración de lo que sucede dentro de un script. Puede usar cmdlets como Write-Debug y Write-Verbose para proporcionar más información en los registros de las aplicaciones y los trabajos.

## Visual Studio Remote Debugger

Usando la [extensión de Visual Studio Code de PowerShell Universal](/powershell-universal/es/desarrollo/visual-studio-code-extension.md), puede conectarse directamente a sus scripts de PowerShell que se ejecutan en PowerShell Universal.

## Depurador integrado

{% hint style="warning" %}
El depurador integrado se admite en PowerShell 7 y en entornos integrados. No se admite en Windows PowerShell.
{% endhint %}

El depurador integrado permite acceder a una consola de depuración para los scripts en ejecución. Puede incluir la llamada al cmdlet `Wait-Debugger` en sus scripts y estos pasarán a un estado In Breakpoint. Una vez que esto suceda, puede ver el trabajo para ejecutar comandos contra el script.

### Scripts

PowerShell Universal se integra directamente con el depurador de PowerShell. Puede incluir `Wait-Debugger` dentro de sus scripts para que se pausen.

Por ejemplo, suponga que tiene un script que incluye una llamada a `Wait-Debugger`. La primera línea se ejecutará y después se pausará una vez que llegue a la segunda línea.

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

Una vez que un script está pausado, verá un terminal para depurar el script.

A continuación, puede usar los comandos de depuración integrados para recorrer el script paso a paso.

### Aplicaciones

Puede usar `Wait-Debugger` directamente en sus aplicaciones de PowerShell Universal. Puede incluir este comando en controladores de eventos y dinámicas para pausar la ejecución de la aplicación y evaluar el estado actual del script.

Por ejemplo, puede incluir `Wait-Debugger` en una dinámica.

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

El resultado es que la aplicación mostrará el esqueleto de carga porque el depurador de PowerShell está en un punto de interrupción.

Dentro de la consola de administración, puede hacer clic en la pestaña Debugger para ver los puntos de interrupción actuales en los que la aplicación está esperando. El depurador proporciona un terminal para evaluar comandos contra el runspace. Puede usar cualquier comando estándar de PowerShell. También puede usar las herramientas de depuración, como la ejecución paso a paso y el listado del código fuente. Hay botones disponibles en la parte superior de la consola.

Puede usar comandos como `Get-Variable` para obtener información sobre el estado de las variables. Ejecute `c` para permitir que el endpoint continúe su ejecución.

## Registro de scripts

Ciertos aspectos de Universal registrarán sus scripts automáticamente. Otras funciones pueden requerir que usted mismo realice el registro.

### APIs

Puede usar la vista Live Log en la pestaña Log para ver los registros de la API seleccionada.

### Trabajos

Los trabajos registran de forma exhaustiva. Verá la salida de la consola y de la canalización. Si establece `$DebugPreference` o `$VerbosePreference` , también verá esos flujos en la salida de la consola. Puede añadir mensajes de registro adicionales usando `Write-Debug` o `Write-Verbose` .

### Aplicaciones

Las aplicaciones registran mensajes informativos, de advertencia y de error en su registro. Se recomienda usar el registro al iniciar una aplicación en lugar de intentar adjuntar un depurador. También puede usar la variable `$DebugPreference` para obtener información adicional durante el inicio de la aplicación.

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

### Autenticación y autorización

Puede usar la vista Live Log en las páginas de autenticación y de roles para ver la salida de los flujos de PowerShell.

## Depuración de scripts desde una consola de PowerShell

Puede depurar cualquier script dentro de Universal (o cualquier proceso de PowerShell, en realidad) usando los cmdlets de depuración disponibles en PowerShell. Estos cmdlets le permiten conectarse a procesos locales de PowerShell, como Universal, y recorrer sus scripts paso a paso directamente en el terminal.

### Pausar el script

Primero, tendrá que asegurarse de que el script espere a que conecte el depurador antes de continuar. Esto significa que deberá incluir un comando `Wait-Debugger` en algún lugar de su script.

{% hint style="info" %}
Las aplicaciones solo esperarán 10 segundos durante el inicio, por lo que poner un Wait-Debugger en ellas puede no funcionar. Debe basarse en el uso de $DebugPreference y Write-Debug para diagnosticar los problemas de inicio de la aplicación.
{% endhint %}

### Ejecutar su script

Ahora que tiene su script configurado para pausarse y esperar al depurador, querrá ejecutar su script. Para los trabajos, simplemente inicie el trabajo. Para las API, deberá realizar una solicitud a la API a través del endpoint que intenta probar. Para las aplicaciones, deberá cargar la página en su navegador. Para la autenticación y la autorización, deberá iniciar sesión.

### Encontrar el ID de su proceso

Una vez que tenga el comando `Wait-Debugger` en el script que desea depurar, deberá iniciar el script y determinar el proceso dentro del cual se ejecuta.

#### Trabajos

Los trabajos se ejecutan en su propio proceso aislado dentro de Universal. Todo lo que tendrá que hacer es iniciar el trabajo y este iniciará el proceso y esperará en su comando `Wait-Debugger`. Una vez que el trabajo se haya iniciado, puede usar el cmdlet `Get-UAJob` para encontrar el ID de proceso de ese trabajo.

#### APIs

Las API se ejecutan en un único proceso de PowerShell. No inicia un nuevo proceso para cada llamada a la API. Puede localizar el proceso de la API buscando el proceso pwsh o PowerShell cuya línea de comandos incluya `StartApi`.

#### Aplicaciones

Las aplicaciones se ejecutan en su propio proceso aislado de PowerShell. El ID de proceso se muestra en la tabla de aplicaciones dentro de la consola de administración.

#### Autenticación y autorización

Los scripts de autenticación y autorización se ejecutan dentro del servidor de Universal. Puede encontrar el proceso `Universal.Server.exe` y adjuntarse a él.

**Entorno integrado**

Cualquier función que se ejecute dentro del entorno integrado se ejecutará dentro del proceso `Universal.Server.exe`. Deberá adjuntarse a este proceso para poder depurarlas.

### Adjuntarse al proceso y depurar el runspace

Una vez que tenga el proceso al que desea adjuntarse, puede hacerlo usando `Enter-PSHostProcess` . Simplemente especifique el ID de proceso que encontró en el paso anterior.

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

{% hint style="info" %}
Enter-PSHostProcess usa canalizaciones con nombre y requiere que tenga permiso sobre el proceso al que está accediendo. Si ejecuta Universal como servicio, puede que necesite ejecutarlo con su cuenta local para conectarse correctamente al proceso.
{% endhint %}

Una vez que se haya adjuntado al proceso, ahora querrá encontrar el runspace donde se está ejecutando su código. Para ello, puede usar el cmdlet `Get-Runspace`. Esto devolverá una lista de los runspaces actualmente activos en su proceso. Busque el runspace marcado como `InBreakpoint`. Este es el runspace que está esperando en el comando `Wait-Debugger`.

Ahora que ha encontrado su runspace, use `Debug-Runspace` para adjuntarse al runspace. Ahora tendrá la oportunidad de emitir comandos de depuración contra ese runspace. Puede ver el estado de las variables, emitir comandos e incluso recorrer el script paso a paso.

Para obtener una lista completa de los comandos de depuración, puede consultar la [documentación de Microsoft aquí](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_debuggers?view=powershell-7#starting-and-stopping-the-debugger).

### Ejemplo de conexión a un proceso de API

El siguiente es un ejemplo de cómo conectarse a un proceso de API.

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

## Depuración con Visual Studio Code

Para depurar un script, puede usar el cmdlet Wait-Debugger dentro de su script para pausar el script hasta que se adjunte un depurador. A continuación, puede usar un depurador, como VS Code, para adjuntarse al proceso y al runspace para ver las variables, recorrer el código paso a paso y ejecutar comandos de depuración.

También puede depurar scripts usando los cmdlets integrados `Enter-PSHostProcess`, `Get-Runspace` y `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/es/desarrollo/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.