> 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 Gérer les modules PowerShell dans PowerShell Universal, ce qui comprend les installations à partir de la Gallery, les sources de paquets, la création de modules personnalisés et la configuration du mo La page Modules fournit de l'information sur les modules installés dans le système. ## Affichage des modules Vous pouvez afficher et rechercher les modules accessibles par PowerShell Universal sous **Gérer > Modules > Installés**. 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 à partir de la Gallery Les modules peuvent être installés à partir de la PowerShell Gallery sous **Gérer > Modules > Découvrir**. Sélectionnez une source à côté de la zone de recherche pour effectuer la recherche dans cette source plutôt que localement. Une fois un module trouvé, vous pourrez cliquer sur le bouton Installer pour l'enregistrer localement. Les modules installés de cette manière seront installés dans le répertoire du dépôt, sous Modules. ## Sources de paquets PowerShell Universal s'intègre au module `PackageManagement v3` et détecte 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 ``` Les sources de paquets enregistrées sont listées sous **Gérer > Modules > Sources** et sont disponibles lors de la découverte de modules. ## Créer des modules Vous pouvez aussi créer des modules directement dans PowerShell Universal. Ces modules seront créés dans le répertoire du dépôt, sous Modules. Ces modules seront disponibles dans tous les environnements. Pour créer un nouveau module, allez à **Gérer > Modules > Modules personnalisés** et cliquez sur Créer un nouveau module. Définissez le nom et la version du module. Une fois créé, le module sera listé sous Universal Modules avec l'option 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 les fonctions, les variables et les alias à exporter. ## Modules avec des ressources Universal {% hint style="info" %} Un exemple de module se trouve [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 applis. 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 retirer, vous devrez retirer le module. Dans la console d'administration, ouvrez **Gérer > Modules > Installés**. Cliquez sur le bouton de téléchargement du côté gauche du module pour l'installer. Une fois installé, des ressources en lecture seule seront ajoutées à votre environnement. Vous pouvez aussi enregistrer des modules directement dans le dossier du dépôt PowerShell Universal. ```powershell Save-Module Universal.Apps.WindowsSystemInformation -Path $Env:ProgramData\UniversalAutomation\Repository\Modules ``` ### Créer Voici un exemple de la disposition d'un module Universal. Si le module contient le dossier `.universal`, les ressources en seront chargées automatiquement. ``` .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 ceci. ```powershell New-PSUScript -Module 'PSUModule' -Command 'Start-MyScript' ``` Dans `PSUModule.psm1`, vous devriez définir la fonction `Start-MyScript`. C'est la fonction qui sera appelée lors de l'exécution du script. ```powershell function Start-MyScript { } ``` ### Publier Lorsque vous créez des modules qui étendent PowerShell Universal, vous pouvez inclure la balise `PowerShellUniversal` dans le manifeste de votre module pour qu'ils soient listés dans la [page PowerShell Universal Modules](/powershell-universal/fr/readme.md) et dans la console d'administration de PSU. [Publiez des modules dans la PowerShell Gallery](https://jeffbrown.tech/how-to-publish-your-first-powershell-gallery-package/) afin de les partager avec d'autres personnes. ## Module racine Vous pouvez définir un module racine comme configuration de PowerShell Universal. Cela permet d'obtenir 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, celui-ci chargera automatiquement ce module et ses dépendances. Le module racine doit se trouver dans le PSModulePath ou dans le dossier Modules du dépôt. ### 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 précises des ressources sont empaquetées et déployées dans vos instances PowerShell Universal. {% hint style="success" %} Le module racine peut se trouver n'importe où dans le PSModulePath enregistré pour votre serveur ou votre compte de service. Il peut aussi résider dans le dossier de modules de votre dépôt. L'exemple ci-dessous utilise des chemins relatifs. {% endhint %} #### ARD.Core Le module ARD.Core définit quelques fonctions et un environnement qui est utilisé par d'autres modules. Voici un exemple d'environnement de base défini. {% 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 a une structure semblable à celle du module ARD.Core, mais il expose un terminal plutôt qu'un environnement. Cet exemple de terminal appelle la fonction `Get-ARDResponse` lorsque l'URL `ard.endpoint` est appelée. Notez que le terminal utilise le terminal 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 aussi utiliser pour le terminal. Le terminal utilise la fonction d'ARD.Core pour retourner une réponse. Cela fonctionne parce qu'il s'agit tout simplement de 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 aussi une dépendance sur ARD.Core afin de s'assurer que ce module est chargé en premier, parce que le terminal dépend de l'existence de la fonction et 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 le module core et sur le module endpoints, mais ne définit lui-même aucune fonctionnalité. 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 la version. {% code title="appsettings.json" %} ```json { "Data": { "Module": "ARD.Root", "ModuleVersion": "1.0.0" } } ``` {% endcode %} Vous pouvez aussi le configurer au moyen de variables d'environnement. La modification du fichier ou des variables d'environnement exigera 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 dépôt au `$ENV:PSModulePath` pour tous les environnements. L'ajout de modules à ce répertoire garantira que le module est disponible pour tout processus PowerShell exécuté avec PowerShell Universal. ## Information sur les modules Cette section comprend de l'information sur certains modules et leur utilisation dans PowerShell Universal. ### ActiveDirectory Le module `ActiveDirectory` prend en charge nativement PowerShell 7 lorsque la version 1.0.1.0 est utilisée. Lorsque la version 1.0.0.0 est utilisée, la couche de compatibilité Windows est utilisée lors de l'exécution des commandes dans PowerShell 7 et l'environnement Integrated. 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 : * Inclure le paramètre `-SkipEditionCheck` avec **Import-Module** lors de l'importation du module ActiveDirectory * Utiliser l'environnement Windows PowerShell 5.1 au lieu de Integrated/PowerShell Core #### Pour en savoir plus {% embed url="" %} ### Exchange Microsoft Exchange local peut être géré au moyen de sessions distantes dans PowerShell. Si vous utilisez des sessions dans des applis, vous voudrez envisager de gérer la session de manière à éviter d'avoir à ouvrir une nouvelle session pour chaque requête. Cela améliore grandement la performance. L'exemple ci-dessous utilise la portée `$Cache:` pour faire persister la session d'une requête à l'autre. Bien que cet exemple utilise des 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 de 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, and the optional `goal` query parameter: ``` GET https://docs.devolutions.net/powershell-universal/fr/plateforme/modules.md?ask=&goal= ``` `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.