> 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/app/building-dashboards.md).

# App

## Creare un'app

Il primo passo consiste nel creare un'app in PowerShell Universal. Questo è il contenitore di tutte le pagine e i componenti del sito web della sua app. Consigliamo di eseguire le app in ambienti esterni, come PowerShell 7, per garantire che siano isolate dal resto del server. Per creare un'app, clicchi su Apps \ Apps e poi su Create New App.

Durante la creazione dovrà fornire un nome e un URL univoci per l'app. Tutte le altre proprietà sono facoltative. Dopo aver creato l'app, può modificarne il codice. Ad esempio, provi ad aggiungere un componente alla sua app.

```powershell
New-UDApp -Content {
   New-UDButton -Text 'Click Me' -OnClick {
       Show-UDToast "Ouch!"
   }
}
```

Una volta salvata l'app, può cliccare sull'icona del globo per visualizzare il risultato. Cliccando sul pulsante verrà visualizzato un messaggio toast nel suo browser.

## New-UDApp

Il cmdlet di primo livello per le dashboard è `New-UDApp`. Deve richiamarlo quando restituisce un'app. Può utilizzarlo con o senza pagine.

#### Contenuto

Il contenuto dell'app è una serie di componenti da visualizzare nella pagina. È un blocco di script che restituirà tutti i componenti nell'ordine in cui verranno renderizzati nella pagina. Può utilizzare il componente Grid per disporre gli elementi e visualizzare elementi come testo con tipografia.

```powershell
New-UDApp -Title 'My New Dashboard' -Content {
    New-UDTypography -Text 'Hello!'
}
```

## Personalizzazione dell'intestazione

Può personalizzare l'intestazione dell'app utilizzando diversi parametri.

### Posizione <a href="#position" id="position"></a>

Utilizzi il parametro `-HeaderPosition` per modificare il comportamento dell'intestazione.

* absolute\fixed - Rimane nella parte superiore della pagina, anche durante lo scorrimento
* relative - Rimane nella parte superiore della pagina. Non è visibile durante lo scorrimento.

```powershell
New-UDApp -HeaderPosition fixed -Content {
    New-UDElement -tag div -Attributes @{
        style = @{
            height = '150vh'
        }
    }
}
```

### Colori

Può regolare i colori dell'intestazione specificando i parametri `-HeaderColor` e `-HeaderBackgroundColor`. Questi colori sovrascriveranno i colori del tema.

```powershell
New-UDApp -Content {
} -HeaderColor 'black' -HeaderBackgroundColor 'white'
```

### Contenuto

Può definire contenuti personalizzati da includere nell'intestazione utilizzando il parametro `-HeaderContent`.

```powershell
New-UDApp -Content {

} -HeaderContent {
    New-UDButton -Icon (New-UDIcon -Icon Users) -Text 'User'
}
```

### Disattivare il selettore del tema

Può rimuovere il selettore del tema con `-DisableThemeToggle`.

```powershell
New-UDApp -Content {} -DisableThemeToggle
```

### Logo

Può modificare l'immagine del logo fornendo un URL al parametro `-Logo`.

```powershell
New-UDApp -Content {} -Logo '/logo.png'
```

### Navigazione

Per modificare il layout di navigazione, utilizzi i parametri `-Navigation` e `-NavigationLayout`.

```powershell
New-UDApp -Content {
} -Navigation (
    New-UDList -Children {
        New-UDListItem -Label "Home"
        New-UDListItem -Label "Getting Started" -Children {
            New-UDListItem -Label "Installation" -OnClick {}
            New-UDListItem -Label "Usage" -OnClick {}
            New-UDListItem -Label "FAQs" -OnClick {}
            New-UDListItem -Label "System Requirements" -OnClick {}
            New-UDListItem -Label "Purchasing" -OnClick {}
        }
    }
) -NavigationLayout permanent
```

## Componenti

I componenti sono i singoli widget che può inserire nella sua app. Esistono componenti per visualizzare dati, acquisire input dell'utente, aggiungere testo e immagini e altro ancora. I componenti possono essere scaricati come moduli PowerShell e aggiunti alla sua app.

I componenti vengono richiamati utilizzando la sintassi standard verbo-nome di qualsiasi cmdlet PowerShell.

```powershell
New-UDPage -Content {
    New-UDTextbox
}
```

Maggiori informazioni sui [componenti qui](/powershell-universal/it/app/components.md).

## Pagine

Può specificare più pagine all'interno di un'app. Ogni pagina definisce una route. A partire dalla v3, tutte le pagine sono dinamiche. PowerShell verrà eseguito a ogni caricamento della pagina per renderizzare la nuova pagina. Poiché UD è un'applicazione a pagina singola, il browser web non deve aggiornare l'intera pagina web quando si naviga tra le diverse pagine dell'app.

```powershell
$Pages = @()
$Pages += New-UDPage -Name 'My Home Page' -Content {}
$Pages += New-UDPage -Name 'Diagnostics' -Content {}
New-UDApp -Pages $Pages -Title 'Dashboard'
```

Maggiori informazioni sulle [pagine qui](/powershell-universal/it/app/components/pages.md).

## Modulo

Le app avranno automaticamente accesso a tutti i comandi disponibili all'interno del PSModulePath, così come ai moduli che carica direttamente nell'app stessa. Detto questo, può anche definire funzioni all'interno dell'app stessa. Queste funzioni verranno incluse in un modulo che viene archiviato insieme al codice della sua app. Tutte le funzioni definite in questo file verranno incluse automaticamente nella sua app.

All'interno della console di amministrazione di PowerShell Universal, definisca funzioni, variabili e alias nella scheda Module. Tutte le funzioni definite verranno scritte in un file `PSM1` nella stessa directory del codice dell'applicazione.

<figure><img src="/files/4uVZUKQelykuggZsaPDQ" alt=""><figcaption><p>Scheda Module</p></figcaption></figure>

## Variabili integrate

Le variabili integrate sono disponibili nella [pagina delle variabili](/powershell-universal/it/piattaforma/variables.md#apps).

## Debug

{% hint style="info" %}
Può anche utilizzare gli [strumenti di debug](/powershell-universal/it/sviluppo/debugging-scripts.md#integrated-debugger) con le app.
{% endhint %}

Durante la creazione di un'app, è probabile che incontri problemi con le chiamate ai cmdlet o con la sintassi. Le app si ricaricheranno automaticamente man mano che apporta modifiche ai file dell'app. Se un'app non si avvia, può accedere alla pagina di amministrazione, cliccare su Apps e cliccare sul pulsante Info accanto alla sua app.

La scheda Log mostrerà tutta la registrazione proveniente dall'esecuzione di PowerShell all'interno della sua app. Questo dovrebbe consentirle di individuare facilmente errori e avvisi provenienti dalla sua app.

Può utilizzare `Write-Debug` per aggiungere ulteriori messaggi di log alla sua app. Per abilitare la registrazione di debug, dovrà impostare la variabile `$DebugPreference` all'inizio dello script della sua app.

```powershell
$DebugPreference = 'Continue'
```

## Menu

Può personalizzare il menu dell'app utilizzando il parametro `-Menu`.

```powershell
New-UDApp -Title 'App' -Content {

} -Menu {
    New-UDMenuItem -Text 'Profile' -OnClick {
        Show-UDModal -Content {
            New-UDTypography -Text 'Welcome to your profile!'
        }
    }
}
```

## Avviare e arrestare le app

Analogamente ai job, le app possono essere eseguite in processi PowerShell separati. Può avviare e arrestare un processo dell'app cliccando sul pulsante Start o Stop dalla pagina Apps.

## Runspace persistenti

I runspace persistenti le consentono di mantenere lo stato del runspace all'interno dei gestori di eventi della sua app. Questo è importante per gli utenti che eseguono un qualche tipo di inizializzazione all'interno dei loro endpoint che non desiderano eseguire nelle chiamate successive.

Per impostazione predefinita, i runspace verranno reimpostati dopo ogni esecuzione. Ciò comporterà la perdita di variabili, moduli e funzioni definiti durante l'esecuzione di un endpoint.

Per abilitare i runspace persistenti, dovrà configurare un [ambiente](/powershell-universal/it/config/environments.md) per la sua API. Imposti il parametro `-PersistentRunspace` per abilitare questa funzionalità. Questa configurazione viene effettuata nello script `environments.ps1`.

```
New-PSUEnvironment -Name 'Env' -Path 'powershell.exe' -PersistentRunspace
```

Dovrà assicurarsi che l'ambiente sia utilizzato dall'app.

## Concessione automatica dei token dell'app

Può concedere automaticamente i token dell'app agli utenti che visitano le app. Questo è utile se desidera richiamare l'API di gestione di PowerShell Universal dall'interno di un'app. La sua app dovrà avere l'autenticazione abilitata e dovrà utilizzare il parametro switch `-GrantAppToken` su `New-PSUDashboard`.

```
New-PSUApp -Name 'App' -BaseUrl '/' -Authenticated -GrantAppToken
```

Dall'interno della sua app, ora può richiamare l'API di gestione senza doversi preoccupare della gestione dei token dell'app. L'API verrà richiamata nel contesto dell'utente che sta visitando l'app.

```powershell
New-UDApp -Title "Hello, World!" -Content {
    New-UDButton -Text 'Job' -OnClick {
        Invoke-UAScript -Name 'Test.ps1'
    }
}
```

## Disattivare i toast di errore

Per impostazione predefinita, le app visualizzano un messaggio toast quando viene generato un errore all'interno di uno script endpoint. Per evitare questo comportamento, può utilizzare il parametro `-DisableErrorToast` di `New-UDApp`

```powershell
New-PSUApp -Name 'App' -BaseUrl '/' -Authenticated -DisableErrorToast
```

```powershell
New-UDApp -Title "Hello, World!" -Content {
    New-UDButton -Text 'Job' -OnClick {
        throw "Exception
    }
} 
```

## Disattivare la registrazione all'avvio

All'avvio di un'app, le informazioni sulle variabili e sui moduli vengono visualizzate nel log dell'app. Se desidera sopprimere queste informazioni, può utilizzare il parametro `-DisableStartupLogging`.

```powershell
New-PSUApp -Name 'App' -BaseUrl '/' -DisableStartupLogging
```

## App critiche

Le app critiche, impostate in base al parametro `-Critical`, definiscono le app che faranno sì che l'endpoint di stato del load balancer restituisca un codice di risposta 500 se l'app non è in esecuzione. L'endpoint di stato del load balancer è `/api/v1/status` .

```powershell
New-PSUApp -Name 'App' -BaseUrl '/' -DisableStartupLogging
```

#### Vedere anche

* [Devolutions Academy – Server side data tables](https://academy.devolutions.net/student/page/3466033-server-side-data-tables?curriculum_activity_id=5612259\&path_id=3465905\&sid=aa0a98ab-11ef-4ae6-83f0-e28f268d8343\&sid_i=0)


---

# 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/app/building-dashboards.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.