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

# Apps

## Eine App erstellen

Der erste Schritt besteht darin, eine App in PowerShell Universal zu erstellen. Dies ist der Container für alle Seiten und Komponenten Ihrer App-Website. Wir empfehlen, Apps in externen Umgebungen wie PowerShell 7 auszuführen, um sicherzustellen, dass sie vom restlichen Server isoliert sind. Um eine App zu erstellen, klicken Sie auf Apps \ Apps und dann auf Create New App.

Beim Erstellen müssen Sie einen eindeutigen Namen und eine URL für die App angeben. Alle anderen Eigenschaften sind optional. Nach dem Erstellen der App können Sie den App-Code bearbeiten. Versuchen Sie zum Beispiel, eine Komponente zu Ihrer App hinzuzufügen.

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

Sobald Sie Ihre App gespeichert haben, können Sie auf das Globus-Symbol klicken, um das Ergebnis anzuzeigen. Ein Klick auf die Schaltfläche zeigt eine Toast-Nachricht in Ihrem Browser an.

## New-UDApp

Das Cmdlet der obersten Ebene für Dashboards ist `New-UDApp`. Sie müssen es aufrufen, wenn Sie eine App zurückgeben. Sie können es mit oder ohne Seiten verwenden.

#### Inhalt

Der Inhalt der App ist eine Reihe von Komponenten, die auf der Seite angezeigt werden. Es handelt sich um einen Skriptblock, der alle Komponenten in der Reihenfolge zurückgibt, in der sie auf der Seite gerendert werden. Sie können die Grid-Komponente verwenden, um Elemente anzuordnen und Dinge wie Text mit Typografie darzustellen.

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

## Anpassung der Kopfzeile

Sie können die Kopfzeile der App mit mehreren Parametern anpassen.

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

Verwenden Sie den Parameter `-HeaderPosition`, um das Verhalten der Kopfzeile anzupassen.

* absolute\fixed - Bleibt am oberen Rand der Seite, auch beim Scrollen
* relative - Bleibt am oberen Rand der Seite. Beim Scrollen nicht sichtbar.

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

### Farben

Sie können die Farben der Kopfzeile anpassen, indem Sie die Parameter `-HeaderColor` und `-HeaderBackgroundColor` angeben. Diese Farben überschreiben die Themenfarben.

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

### Inhalt

Sie können mit dem Parameter `-HeaderContent` benutzerdefinierten Inhalt definieren, der in die Kopfzeile aufgenommen wird.

```powershell
New-UDApp -Content {

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

### Themen-Umschalter deaktivieren

Sie können den Themen-Umschalter mit `-DisableThemeToggle` entfernen.

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

### Logo

Sie können das Logo-Bild ändern, indem Sie dem Parameter `-Logo` eine URL übergeben.

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

### Navigation

Um das Navigationslayout zu ändern, verwenden Sie die Parameter `-Navigation` und `-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
```

## Komponenten

Komponenten sind die einzelnen Widgets, die Sie in Ihrer App platzieren können. Es gibt Komponenten zum Anzeigen von Daten, zum Erfassen von Benutzereingaben, zum Hinzufügen von Text und Bildern und mehr. Komponenten können als PowerShell-Module heruntergeladen und Ihrer App hinzugefügt werden.

Komponenten werden mit der Standard-Verb-Name-Syntax wie bei jedem PowerShell-Cmdlet aufgerufen.

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

Erfahren Sie mehr über [Komponenten hier](/powershell-universal/de/apps/components.md).

## Seiten

Sie können mehrere Seiten innerhalb einer App angeben. Jede Seite definiert eine Route. Ab v3 sind alle Seiten dynamisch. PowerShell wird bei jedem Seitenaufruf ausgeführt, um die neue Seite zu rendern. Da UD eine Single-Page-Anwendung ist, muss der Webbrowser beim Navigieren zwischen den verschiedenen App-Seiten nicht die gesamte Webseite aktualisieren.

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

Erfahren Sie mehr über [Seiten hier](/powershell-universal/de/apps/components/pages.md).

## Modul

Apps haben automatisch Zugriff auf alle Befehle, die innerhalb des PSModulePath verfügbar sind, sowie auf Module, die Sie direkt in die App selbst laden. Sie können jedoch auch Funktionen innerhalb der App selbst definieren. Diese Funktionen werden in ein Modul aufgenommen, das neben Ihrem App-Code gespeichert wird. Alle in dieser Datei definierten Funktionen werden automatisch in Ihre App aufgenommen.

Definieren Sie in der PowerShell Universal-Administrationskonsole Funktionen, Variablen und Aliase auf der Registerkarte Module. Alle definierten Funktionen werden in eine `PSM1`-Datei im selben Verzeichnis wie der Anwendungscode geschrieben.

<figure><img src="/files/TYsFyHp0OEvxPUdDJP7H" alt=""><figcaption><p>Registerkarte Module</p></figcaption></figure>

## Integrierte Variablen

Integrierte Variablen finden Sie auf der [Variablen-Seite](/powershell-universal/de/plattform/variables.md#apps).

## Debugging

{% hint style="info" %}
Sie können auch die [Debugging-Werkzeuge](/powershell-universal/de/entwicklung/debugging-scripts.md#integrated-debugger) mit Apps verwenden.
{% endhint %}

Beim Erstellen einer App werden Sie wahrscheinlich auf Probleme mit Cmdlet-Aufrufen oder der Syntax stoßen. Apps werden automatisch neu geladen, wenn Sie Änderungen an den App-Dateien vornehmen. Wenn eine App nicht startet, können Sie zur Administrationsseite navigieren, auf Apps klicken und die Schaltfläche Info neben Ihrer App anklicken.

Die Registerkarte Log zeigt alle Protokollierungen der PowerShell-Ausführung innerhalb Ihrer App. Dadurch sollten Sie Fehler und Warnungen aus Ihrer App leicht erkennen können.

Sie können `Write-Debug` verwenden, um Ihrer App zusätzliche Protokollmeldungen hinzuzufügen. Um die Debug-Protokollierung zu aktivieren, müssen Sie die Variable `$DebugPreference` am Anfang Ihres App-Skripts setzen.

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

## Menü

Sie können das App-Menü mit dem Parameter `-Menu` anpassen.

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

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

## Apps starten und stoppen

Ähnlich wie Jobs können Apps in separaten PowerShell-Prozessen ausgeführt werden. Sie können einen App-Prozess starten und stoppen, indem Sie auf der Seite Apps auf die Schaltfläche Start oder Stop klicken.

## Persistente Runspaces

Persistente Runspaces ermöglichen es Ihnen, den Runspace-Status innerhalb Ihrer App-Event-Handler beizubehalten. Dies ist wichtig für Benutzer, die eine Art Initialisierung innerhalb ihrer Endpunkte durchführen, die bei nachfolgenden Aufrufen nicht erneut ausgeführt werden soll.

Standardmäßig werden Runspaces nach jeder Ausführung zurückgesetzt. Dies führt dazu, dass Variablen, Module und Funktionen, die während der Ausführung eines Endpunkts definiert wurden.

Um persistente Runspaces zu aktivieren, müssen Sie eine [Umgebung ](/powershell-universal/de/config/environments.md)für Ihre API konfigurieren. Setzen Sie den Parameter `-PersistentRunspace`, um diese Funktion zu aktivieren. Dies wird im Skript `environments.ps1` konfiguriert.

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

Sie müssen sicherstellen, dass die Umgebung von der App verwendet wird.

## App-Token automatisch gewähren

Sie können App-Token automatisch an Benutzer gewähren, die Apps besuchen. Dies ist nützlich, wenn Sie die Management-API von PowerShell Universal aus einer App aufrufen möchten. Für Ihre App muss die Authentifizierung aktiviert sein, und Sie müssen den Switch-Parameter `-GrantAppToken` bei `New-PSUDashboard` verwenden.

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

Aus Ihrer App heraus können Sie nun die Management-API aufrufen, ohne sich um die Verwaltung von App-Token kümmern zu müssen. Die API wird im Kontext des Benutzers aufgerufen, der die App besucht.

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

## Fehler-Toasts deaktivieren

Standardmäßig zeigen Apps eine Toast-Nachricht an, wenn innerhalb eines Endpunkt-Skripts ein Fehler generiert wird. Um dieses Verhalten zu vermeiden, können Sie den Parameter `-DisableErrorToast` von `New-UDApp` verwenden

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

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

## Startprotokollierung deaktivieren

Beim Starten einer App werden Informationen über die Variablen und Module im App-Protokoll angezeigt. Wenn Sie diese Informationen unterdrücken möchten, können Sie den Parameter `-DisableStartupLogging` verwenden.

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

## Kritische Apps

Kritische Apps, die über den Parameter `-Critical` festgelegt werden, definieren Apps, die dazu führen, dass der Load-Balancer-Statusendpunkt einen 500-Antwortcode zurückgibt, wenn die App nicht ausgeführt wird. Der Load-Balancer-Statusendpunkt ist `/api/v1/status` .

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

#### Siehe auch

* [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/de/apps/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.