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

# Applis

Créez et configurez des applis PowerShell Universal avec New-UDApp, en personnalisant les en-têtes, la navigation, les menus, les espaces d'exécution persistants et l'authentification par jeton d'appl

## Créer une appli

La première étape consiste à créer une appli dans PowerShell Universal. C'est le conteneur de toutes vos pages et de tous vos composants pour le site web de votre appli. Nous recommandons d'exécuter les applis dans des environnements externes, comme PowerShell 7, afin de garantir qu'elles sont isolées du reste du serveur. Pour créer une appli, ouvrez **Build > Apps** puis Create New App.

Vous devrez fournir un nom et une URL uniques pour l'appli lors de sa création. Toutes les autres propriétés sont facultatives. Après avoir créé l'appli, vous pouvez modifier le code de l'appli. Par exemple, essayez d'ajouter un composant à votre appli.

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

Une fois votre appli enregistrée, vous pouvez cliquer sur l'icône du globe pour voir le résultat. Cliquer sur le bouton affichera un message toast dans votre navigateur.

## New-UDApp

L'applet de commande de premier niveau pour les tableaux de bord est `New-UDApp`. Vous devez l'appeler lorsque vous retournez une appli. Vous pouvez l'utiliser avec ou sans pages.

#### Contenu

Le contenu de l'appli est une série de composants à afficher sur la page. Il s'agit d'un bloc de script qui retournera tous les composants dans l'ordre où ils seront rendus sur la page. Vous pouvez utiliser le composant Grid pour disposer les éléments et afficher des choses comme du texte avec de la typographie.

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

## Personnalisation de l'en-tête

Vous pouvez personnaliser l'en-tête de l'appli à l'aide de plusieurs paramètres.

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

Utilisez le paramètre `-HeaderPosition` pour ajuster le comportement de l'en-tête.

* absolute\fixed - Reste en haut de la page, même lors du défilement
* relative - Reste en haut de la page. Non visible lors du défilement.

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

### Couleurs

Vous pouvez ajuster les couleurs de l'en-tête en spécifiant les paramètres `-HeaderColor` et `-HeaderBackgroundColor`. Ces couleurs remplaceront les couleurs du thème.

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

### Contenu

Vous pouvez définir un contenu personnalisé à inclure dans l'en-tête en utilisant le paramètre `-HeaderContent`.

```powershell
New-UDApp -Content {

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

### Désactiver le bouton de bascule du thème

Vous pouvez retirer le bouton de bascule du thème avec `-DisableThemeToggle`.

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

### Logo

Vous pouvez changer l'image du logo en fournissant une URL au paramètre `-Logo`.

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

### Navigation

Pour changer la disposition de la navigation, utilisez les paramètres `-Navigation` et `-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
```

## Composants

Les composants sont les widgets individuels que vous pouvez placer sur votre appli. Il existe des composants pour afficher des données, recueillir la saisie de l'utilisateur, ajouter du texte et des images, et plus encore. Les composants peuvent être téléchargés en tant que modules PowerShell et ajoutés à votre appli.

Les composants sont appelés à l'aide de la syntaxe standard verbe-nom de n'importe quelle applet de commande PowerShell.

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

En savoir plus sur les [composants ici](/powershell-universal/fr/applis/components.md).

## Pages

Vous pouvez spécifier plusieurs pages dans une appli. Chaque page définit une route. Depuis la v3, toutes les pages sont dynamiques. PowerShell s'exécutera à chaque chargement de page pour rendre la nouvelle page. Comme UD est une application à page unique, le navigateur Web n'a pas besoin d'actualiser la page Web au complet lors de la navigation entre les différentes pages de l'appli.

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

En savoir plus sur les [Pages ici](/powershell-universal/fr/applis/components/pages.md).

## Module

Les applis auront automatiquement accès à toutes les commandes disponibles dans le PSModulePath ainsi qu'aux modules que vous chargez directement dans l'appli elle-même. Cela dit, vous pouvez également définir des fonctions dans l'appli elle-même. Ces fonctions seront incluses dans un module qui est stocké aux côtés du code de votre appli. Toute fonction définie dans ce fichier sera automatiquement incluse dans votre appli.

Dans la console d'administration de PowerShell Universal, définissez les fonctions, les variables et les alias dans l'onglet Module. Toute fonction définie sera écrite dans un fichier `PSM1` dans le même répertoire que le code de l'application.

<figure><img src="https://218893503-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FAje1UFQFSPx2kH2ueeCf%2Fuploads%2Fgit-blob-4b8c66dd3dbf4cb048b41327f1a6ecbf2958cc88%2Fimage%20(134).png?alt=media" alt=""><figcaption><p>Onglet Module</p></figcaption></figure>

## Variables intégrées

Les variables intégrées se trouvent sur la [page des variables](/powershell-universal/fr/plateforme/variables.md#apps).

## Débogage

{% hint style="info" %}
Vous pouvez aussi utiliser les [outils de débogage](/powershell-universal/fr/developpement/debugging-scripts.md#integrated-debugger) avec les applis.
{% endhint %}

Lors de la création d'une appli, vous rencontrerez probablement des problèmes avec les appels d'applets de commande ou la syntaxe. Les applis se rechargent automatiquement à mesure que vous modifiez les fichiers de l'appli. Si une appli ne démarre pas, naviguez vers **Build > Apps** et cliquez sur le bouton Info à côté de votre appli.

L'onglet Log affichera toute la journalisation provenant de l'exécution PowerShell effectuée dans votre appli. Cela devrait vous permettre de voir facilement les erreurs et les avertissements provenant de votre appli.

Vous pouvez utiliser `Write-Debug` pour ajouter des messages de journal supplémentaires à votre appli. Pour activer la journalisation de débogage, vous devrez définir la variable `$DebugPreference` en haut du script de votre appli.

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

## Menu

Vous pouvez personnaliser le menu de l'appli en utilisant le paramètre `-Menu`.

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

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

## Démarrer et arrêter des applis

Comme pour les tâches, les applis peuvent s'exécuter dans des processus PowerShell distincts. Vous pouvez démarrer et arrêter un processus d'appli en cliquant sur le bouton Start ou Stop de la page Apps.

## Runspaces persistants

Les runspaces persistants vous permettent de maintenir l'état du runspace dans les gestionnaires d'événements de votre appli. C'est important pour les utilisateurs qui effectuent une forme d'initialisation dans leurs terminaux et qui ne veulent pas qu'elle s'exécute lors des appels subséquents.

Par défaut, les runspaces seront réinitialisés après chaque exécution. Cela entraînera les variables, les modules et les fonctions définis durant l'exécution d'un terminal.

Pour activer les runspaces persistants, vous devrez configurer un [environnement ](/powershell-universal/fr/config/environments.md)pour votre API. Définissez le paramètre `-PersistentRunspace` pour activer cette fonctionnalité. Cela se configure dans le script `environments.ps1`.

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

Vous devrez vous assurer que l'environnement est utilisé par l'appli.

## Accorder automatiquement des jetons d'appli

Vous pouvez accorder automatiquement des jetons d'appli aux utilisateurs qui visitent des applis. C'est utile si vous voulez appeler l'API de gestion de PowerShell Universal depuis une appli. Votre appli devra avoir l'authentification activée et vous devrez utiliser le paramètre de commutateur `-GrantAppToken` sur `New-PSUDashboard`.

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

Depuis votre appli, vous pouvez maintenant appeler l'API de gestion sans avoir à vous soucier de la gestion des jetons d'appli. L'API sera appelée dans le contexte de l'utilisateur qui visite l'appli.

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

## Désactiver les messages toast d'erreur

Par défaut, les applis affichent un message toast lorsqu'une erreur est générée dans un script de terminal. Pour éviter ce comportement, vous pouvez utiliser le paramètre `-DisableErrorToast` de `New-UDApp`

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

```powershell
New-UDApp -Title "Hello, World!" -Content {
    throw "Exception
} 
```

## Désactiver la journalisation de démarrage

Au démarrage d'une appli, des informations sur les variables et les modules sont affichées dans le journal de l'appli. Si vous souhaitez supprimer ces informations, vous pouvez utiliser le paramètre `-DisableStartupLogging`.

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

## Applis critiques

Les applis critiques, définies à l'aide du paramètre `-Critical`, désignent les applis qui feront en sorte que le terminal d'état de l'équilibreur de charge retourne un code de réponse 500 si l'appli n'est pas en cours d'exécution. Le terminal d'état de l'équilibreur de charge est `/api/v1/status` .

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

#### Voir aussi

* [Devolutions Academy – Tables de données côté serveur](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/fr/applis/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.
