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

# Applications

## Créer une application

La première étape consiste à créer une application dans PowerShell Universal. Il s'agit du conteneur pour toutes vos pages et composants de votre site web d'application. Nous recommandons d'exécuter les applications dans des environnements externes, comme PowerShell 7, afin de les isoler du reste du serveur. Pour créer une application, cliquez sur Apps \ Apps, puis sur Create New App.

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

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

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

## New-UDApp

La cmdlet de niveau supérieur pour les tableaux de bord est `New-UDApp`. Vous devez l'appeler lors du retour d'une application. Vous pouvez l'utiliser avec ou sans pages.

#### Contenu

Le contenu de l'application est une série de composants à afficher sur la page. Il s'agit d'un bloc de script qui retourne tous les composants dans l'ordre où ils seront rendus sur la page. Vous pouvez utiliser le composant Grid pour mettre en page les éléments et afficher des éléments tels que du texte avec 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'application à 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 thème

Vous pouvez supprimer le bouton de thème avec `-DisableThemeToggle`.

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

### Logo

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

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

### Navigation

Pour modifier la mise en page 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 dans votre application. Il existe des composants pour afficher des données, recueillir des saisies utilisateur, ajouter du texte et des images, et bien plus encore. Les composants peuvent être téléchargés en tant que modules PowerShell et ajoutés à votre application.

Les composants sont utilisés en suivant la syntaxe verbe-nom standard de toute cmdlet PowerShell.

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

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

## Pages

Vous pouvez spécifier plusieurs pages dans une application. Chaque page définit une route. À partir de la version 3, toutes les pages sont dynamiques. PowerShell s'exécutera à chaque chargement de page pour afficher la nouvelle page. Étant donné que UD est une application à page unique, le navigateur web n'a pas besoin d'actualiser la page web entière lors de la navigation entre les différentes pages de l'application.

```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/apps/components/pages.md).

## Module

Les applications auront automatiquement accès à toutes les commandes disponibles dans le PSModulePath ainsi qu'aux modules que vous chargez directement dans l'application elle-même. Cela dit, vous pouvez également définir des fonctions au sein de l'application elle-même. Ces fonctions seront incluses dans un module stocké avec le code de votre application. Toutes les fonctions définies dans ce fichier seront automatiquement incluses avec votre application.

Dans la console d'administration de PowerShell Universal, définissez des fonctions, des variables et des alias dans l'onglet Module. Toutes les fonctions définies seront écrites dans un fichier `PSM1` dans le même répertoire que le code de l'application.

<figure><img src="/files/g1fbINq51BJYw6xX45ho" 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#dashboards).

## Débogage

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

Lors de la création d'une application, vous rencontrerez probablement des problèmes avec les appels de cmdlet ou la syntaxe. Les applications se rechargent automatiquement lorsque vous apportez des modifications aux fichiers d'application. Si une application ne démarre pas, vous pouvez accéder à la page d'administration, cliquer sur Apps et cliquer sur le bouton Info à côté de votre application.

L'onglet Log affichera tous les journaux provenant de l'exécution PowerShell au sein de votre application. Cela devrait vous permettre de voir facilement les erreurs et les avertissements provenant de votre application.

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

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

## Menu

Vous pouvez personnaliser le menu de l'application 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 les applications

Similairement aux tâches, les applications peuvent s'exécuter dans des processus PowerShell distincts. Vous pouvez démarrer et arrêter un processus d'application en cliquant sur le bouton Démarrer ou Arrêter depuis la page Apps.

## Runspaces persistants

Les runspaces persistants vous permettent de maintenir l'état du runspace dans les gestionnaires d'événements de votre application. Ceci est important pour les utilisateurs qui effectuent une sorte d'initialisation dans leurs points de terminaison qu'ils ne souhaitent pas exécuter lors des appels suivants.

Par défaut, les runspaces sont réinitialisés après chaque exécution. Cela entraîne la suppression des variables, modules et fonctions définis lors de l'exécution d'un point de terminaison.

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 est configuré dans le script `environments.ps1`.

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

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

## Octroi automatique de jetons d'application

Vous pouvez octroyer automatiquement des jetons d'application aux utilisateurs qui visitent les applications. Ceci est utile si vous souhaitez invoquer l'API de gestion de PowerShell Universal depuis une application. Votre application devra avoir l'authentification activée et vous devrez utiliser le paramètre switch `-GrantAppToken` sur `New-PSUDashboard`.

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

Depuis votre application, vous pouvez désormais invoquer l'API de gestion sans avoir à vous soucier de la gestion des jetons d'application. L'API sera invoquée dans le contexte de l'utilisateur qui visite l'application.

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

## Désactiver les toasts d'erreur

Par défaut, les applications affichent un message toast lorsqu'une erreur est générée dans un script de point de terminaison. 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 {
    New-UDButton -Text 'Job' -OnClick {
        throw "Exception
    }
} 
```

## Désactiver la journalisation de démarrage

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

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

## Applications critiques

Les applications critiques, définies à l'aide du paramètre `-Critical`, désignent les applications dont l'arrêt entraîne le retour d'un code de réponse 500 par le point de terminaison de statut de l'équilibreur de charge. Le point de terminaison de statut de l'équilibreur de charge est `/api/v1/status`.

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


---

# 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:

```
GET https://docs.devolutions.net/powershell-universal/fr/apps/building-dashboards.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
