> 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/plateforme/modules.md).
# Modules
La page Modules fournit des informations sur les modules installés dans le système.
## Affichage des modules
Vous pouvez afficher et rechercher les modules accessibles par PowerShell Universal en visitant la page Plateforme \ Modules. La recherche fournit un résultat avec caractères génériques des modules trouvés dans chacun des environnements définis dans PowerShell Universal.
## Installer des modules depuis la galerie
Les modules peuvent être installés depuis la galerie PowerShell. Pour rechercher un module, vous pouvez modifier la liste déroulante à côté de la zone de recherche de Local à PowerShell Gallery. Les recherches effectuées seront exécutées sur la galerie plutôt que localement.
Une fois qu'un module est trouvé, vous pourrez cliquer sur le bouton Installer pour l'enregistrer localement. Les modules installés de cette façon seront installés dans le répertoire du référentiel, sous Modules.
## Sources de paquets
PowerShell Universal s'intègre avec le module `PackageManagement v3` et détectera automatiquement les sources de paquets enregistrées. Par exemple, vous pouvez enregistrer une source de paquets avec la commande ci-dessous.
```powershell
Register-PSResourceRepository -Name MyNuGet -Uri https://www.nuget.org/api/v2
```
Une fois la source enregistrée, elle sera affichée dans la liste déroulante de la page des modules.
## Création de modules
Vous pouvez également créer des modules directement dans PowerShell Universal. Ces modules seront créés dans le répertoire du référentiel, sous Modules.
Ces modules seront disponibles dans tous les environnements.
Pour créer un nouveau module, accédez à Plateforme \ Modules et cliquez sur Créer un nouveau module. Définissez le nom et la version du module.
Une fois créé, le module sera répertorié sous Modules universels avec la possibilité de modifier ses propriétés et son contenu, ainsi que de supprimer le module.
Lors de la modification du module, un éditeur de code s'ouvrira dans lequel vous pourrez définir des fonctions, des variables et des alias à exporter.
## Modules avec des ressources universelles
{% hint style="info" %}
Un exemple de module peut être [trouvé ici](https://github.com/ironmansoftware/universal-modules).
{% endhint %}
### Installer
Les modules peuvent contenir des ressources PowerShell Universal telles que des scripts, des API et des applications. L'ajout de ces modules à votre environnement ajoutera automatiquement ces ressources à votre instance PowerShell Universal. Ces ressources seront en lecture seule dans l'environnement. Pour les supprimer, vous devrez retirer le module.
Dans la console d'administration, cliquez sur Plateforme \ Modules, puis sélectionnez Modules PowerShell Universal.
Modules PowerShell Universal
Cliquez sur le bouton de téléchargement à gauche du module pour l'installer. Une fois installées, les ressources en lecture seule seront ajoutées à votre environnement.
Application d'informations système Windows
Vous pouvez également enregistrer des modules directement dans le dossier du référentiel PowerShell Universal.
```powershell
Save-Module Universal.Apps.WindowsSystemInformation -Path $Env:ProgramData\UniversalAutomation\Repository\Modules
```
### Créer
Voici un exemple de la structure d'un module universel. Si le module contient le dossier `.universal`, les ressources seront chargées automatiquement à partir de celui-ci.
```
.universal
scripts.ps1
PSUModule.psd1
PSUModule.psm1
```
Les ressources ne peuvent pas utiliser de chemins et doivent utiliser le nom du module et de la commande pour associer les ressources à leurs scripts respectifs.
Par exemple, le fichier `scripts.ps1` ci-dessus devrait être écrit comme suit.
```powershell
New-PSUScript -Module 'PSUModule' -Command 'Start-MyScript'
```
Dans `PSUModule.psm1`, vous devrez définir la fonction `Start-MyScript`. C'est cette fonction qui sera appelée lors de l'exécution du script.
```powershell
function Start-MyScript {
}
```
### Publier
Lors de la création de modules qui étendent PowerShell Universal, vous pouvez inclure l'étiquette `PowerShellUniversal` dans le manifeste de votre module pour qu'ils soient répertoriés dans la [page des modules PowerShell Universal](https://ironmansoftware.com/powershell-universal/modules) et dans la console d'administration PSU.
[Publiez des modules dans la galerie PowerShell](https://jeffbrown.tech/how-to-publish-your-first-powershell-gallery-package/) afin de les partager avec d'autres utilisateurs.
## Module racine
Vous pouvez définir un module racine comme configuration de PowerShell Universal. Cela permet des configurations reproductibles basées sur des modules publiés. Un module racine est défini dans les paramètres de l'application pour le serveur PowerShell Universal. Au démarrage de PowerShell Universal, ce module et ses dépendances seront chargés automatiquement. Le module racine doit être trouvé dans le PSModulePath ou dans le dossier Modules du référentiel.
### Exemple
Voici un exemple d'utilisation d'un module racine et de dépendances pour définir une configuration PowerShell Universal. Les ressources fournies par les modules sont en lecture seule dans la plateforme. En utilisant des modules, vous pouvez vous assurer que des versions spécifiques des ressources sont empaquetées et déployées dans vos instances PowerShell Universal.
{% hint style="success" %}
Le module racine peut apparaître n'importe où dans le PSModulePath enregistré pour votre serveur ou compte de service. Il peut également résider dans le dossier des modules de votre référentiel. L'exemple ci-dessous utilise des chemins relatifs.
{% endhint %}
#### ARD.Core
Le module ARD.Core définit quelques fonctions et un environnement utilisé par d'autres modules. Voici un exemple de définition d'un environnement de base.
{% code title="Modules\ARD.Core\1.0.0.universal\environments.ps1" %}
```powershell
New-PSUEnvironment -Name 'ARD.Core' -Path pwsh.exe -Type PowerShell7
```
{% endcode %}
Les fonctions sont définies dans le fichier PSM1 du module.
{% code title="Modules\ARD.Core\1.0.0\ARD.Core.psm1" %}
```powershell
function Get-ARDCore {
@{
Name = "ARD.Core"
Description = "This is a test function result"
}
}
```
{% endcode %}
Le manifeste du module exporte la fonction et fournit quelques métadonnées de base.
{% code title="Modules\ARD.Core\1.0.0\ARD.Core.psd1" %}
```powershell
@{
RootModule = "ARD.Core.psm1"
Description = "ARD.Core is the base module for other modules"
Version = "1.0.0"
FunctionsToExport = @("Get-ARDCore")
}
```
{% endcode %}
#### ARD.Endpoints
Le module ARD.Endpoints est structuré de manière similaire au module ARD.Core, mais expose un point de terminaison plutôt qu'un environnement. Cet exemple de point de terminaison appelle la fonction `Get-ARDResponse` lorsque l'URL `ard.endpoint` est appelée. Notez que le point de terminaison utilise l'environnement ARD.Core fourni par le module ci-dessus.
{% code title="Modules\ARD.Endpoints\1.0.0.universal\endpoints.ps1" %}
```powershell
New-PSUEndpoint -Url /ard.endpoint -Module 'ARD.Endpoints' -Command "Get-ARDResponse" -Environment 'ARD.Core'
```
{% endcode %}
Le fichier ARD.Endpoints.psm1 définit la fonction à exporter que nous pouvons également utiliser pour le point de terminaison. Le point de terminaison utilise la fonction d'ARD.Core pour retourner une réponse. Cela fonctionne parce qu'ils ne sont que des modules PowerShell ordinaires.
{% code title="Modules\ARD.Endpoints\1.0.0\ARD.Endpoints.psm1" %}
```powershell
function Get-ARDResponse {
Get-ARDCore
}
```
{% endcode %}
Le fichier ARD.Endpoints.psd1 exportera la fonction et prendra également une dépendance sur ARD.Core pour s'assurer que ce module est chargé en premier, car le point de terminaison repose à la fois sur la fonction et sur l'existence de l'environnement.
{% code title="Modules\ARD.Endpoints\1.0.0\ARD.Endpoints.psd1" %}
```powershell
@{
RootModule = "ARD.Endpoints.psm1"
Description = "Sample endpoints"
Version = "1.0.0"
RequiredModules = @("ARD.Core")
FunctionsToExport = @("Get-ARDResponse")
}
```
{% endcode %}
#### ARD.Root
Le module racine sera chargé en premier par PowerShell Universal. Il prend une dépendance sur les modules core et endpoints, mais ne définit aucune fonctionnalité par lui-même. PowerShell Universal déterminera l'ordre de chargement approprié, puis chargera les ressources au démarrage.
```powershell
@{
Description = "A PowerShell Universal configuration"
Version = "1.0.0"
RequiredModules = @("ARD.Core", "ARD.Endpoints")
}
```
Dans les paramètres de l'application, vous pouvez sélectionner le module racine et sa version.
{% code title="appsettings.json" %}
```json
{
"Data": {
"Module": "ARD.Root",
"ModuleVersion": "1.0.0"
}
}
```
{% endcode %}
Vous pouvez également configurer via des variables d'environnement. La modification du fichier ou des variables d'environnement nécessitera un redémarrage de PowerShell Universal.
```powershell
$ENV:Data__Module = "ARD.Root"
$ENV:Data__ModuleVersion = "1.0.0"
```
## Installer des modules manuellement
PowerShell Universal ajoutera le répertoire `Modules` du référentiel au `$ENV:PSModulePath` pour tous les environnements. L'ajout de modules à ce répertoire garantira que le module est disponible pour tout processus PowerShell s'exécutant avec PowerShell Universal.
## Informations sur les modules
Cette section contient des informations sur certains modules et leur utilisation dans PowerShell Universal.
### ActiveDirectory
Le module `ActiveDirectory` prend en charge le support natif de PowerShell 7 lors de l'utilisation de la version 1.0.1.0. Lors de l'utilisation de la version 1.0.0.0, la couche de compatibilité Windows est utilisée lors de l'exécution des commandes dans PowerShell 7 et l'environnement intégré. Cela peut causer des problèmes dans PowerShell Universal. Nos recommandations pour ce module sont les suivantes.
#### Windows Server 2019 et versions ultérieures
Mettez à jour le module `ActiveDirectory` vers la version 1.0.1.0 qui prend en charge PowerShell Core.
#### Windows Server 2016 et versions antérieures
Choisissez l'une des 2 solutions de contournement disponibles :
* Incluez le paramètre `-SkipEditionCheck` avec **Import-Module** lors de l'importation du module ActiveDirectory
* Utilisez l'environnement Windows PowerShell 5.1 au lieu de l'environnement intégré/PowerShell Core
#### Pour aller plus loin
{% embed url="" %}
### Exchange
Microsoft Exchange sur site peut être géré à l'aide de sessions distantes dans PowerShell. Si vous utilisez des sessions dans des applications, vous devriez envisager de gérer la session de manière à éviter d'ouvrir une nouvelle session pour chaque requête. Cela améliore considérablement les performances. L'exemple ci-dessous utilise la portée `$Cache:` pour maintenir la session entre les requêtes.
Bien que cet exemple utilise PSSessions et Exchange, vous pourriez utiliser le même modèle pour d'autres types de connexions persistantes.
```powershell
$Cache:ExchangeServer = ''
$Cache:ExchangeCredential = ''
$Cache:ExchangeSessionInfo = @{
Authentication = 'Kerberos'
ConfigurationName = 'Microsoft.Exchange'
ConnectionUri = 'https://{0}/PowerShell/' -f $Cache:ExchangeServer
Credential = $Cache:ExchangeCredential
WarningAction = 'SilentlyContinue'
}
#region PRIVATE FUNCTIONS
Function Script:Connect-ExchServer {
$exchSession = New-PSSession @Cache:ExchangeSessionInfo
Import-PSSession $exchSession -WarningAction 'SilentlyContinue'
}
Function Script:Test-ExchConnected {
$Current = Get-PSSession | Where-Object { $_.ConfigurationName -eq 'Microsoft.Exchange' }
if ($Current.State -eq 'Opened' -and $Current.Availability -eq 'Available') {
$true
}
else {
$false
}
}
#endregion
#region PUBLIC FUNCTIONS
Function Clear-ExchConnection {
# called publicly in "End{}" blocks.
Get-PSSession | Where-Object { $_.ConfigurationName -eq 'Microsoft.Exchange' } | Remove-PSSession -ErrorAction $Cache:ErrorAction
Get-Module | Where-Object { $_.Description -match $Cache:ExchangeServer } | Remove-Module -Force -ErrorAction $Cache:ErrorAction
}
Function Confirm-ExchConnected {
# called publicly in "Begin{}" blocks, or just before Exhange actions in functions or scripts.
if (!( Test-ExchConnected )) {
Clear-ExchConnection
Connect-ExchServer
}
}
#endregion
function Invoke-ExampleExchFunction {
Param (
$something
)
Begin {
$null = Confirm-ExchConnected
}
Process {
return $something
}
End {
Clear-ExchConnection
}
}
```
## Versions de modules validées
Les versions de modules ci-dessous ont été validées avec PowerShell Universal. La validation des modules garantit que ces modules se chargent et interagissent avec leurs services respectifs.
| Module | Version du module | Version PSU | Environnements PSU |
| ------------------------------ | ----------------- | ----------- | ------------------------ |
| Microsoft.Graph.Authentication | 2.26.1 | 5.5.2 | PowerShell 7 |
| ExchangeOnlineManagement | 3.7.2 | 5.5.2 | PowerShell 7 |
| MicrosoftTeams | 6.9.0 | 5.5.2 | PowerShell 7 |
| Az.Accounts | 4.1.0 | 5.5.2 | PowerShell 7, Integrated |
---
# 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/plateforme/modules.md?ask=
```
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.