> 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/es/plataforma/modules.md). # Módulos Gestione módulos de PowerShell en PowerShell Universal, cubriendo instalaciones desde la Gallery, orígenes de paquetes, creación de módulos personalizados y configuración del módulo raíz. La página Módulos proporciona información sobre los módulos instalados en el sistema. ## Visualización de módulos Puede ver y buscar los módulos accesibles por PowerShell Universal en **Gestionar > Módulos > Instalados**. La búsqueda proporciona un resultado con comodines de los módulos encontrados en cada uno de los entornos definidos en PowerShell Universal. ## Instalar módulos desde la Gallery Los módulos se pueden instalar desde la PowerShell Gallery en **Gestionar > Módulos > Descubrir**. Seleccione un origen junto al cuadro de búsqueda para buscar en ese origen en lugar de localmente. Una vez encontrado un módulo, podrá hacer clic en el botón Instalar para guardarlo localmente. Los módulos instalados con este método se instalarán en el directorio Repository, dentro de Modules. ## Orígenes de paquetes PowerShell Universal se integra con el módulo `PackageManagement v3` y detectará automáticamente los orígenes de paquetes registrados. Por ejemplo, puede registrar un origen de paquetes con el comando siguiente. ```powershell Register-PSResourceRepository -Name MyNuGet -Uri https://www.nuget.org/api/v2 ``` Los orígenes de paquetes registrados se enumeran en **Gestionar > Módulos > Orígenes** y están disponibles al descubrir módulos. ## Creación de módulos También puede crear módulos directamente en PowerShell Universal. Estos módulos se crearán en el directorio Repository, dentro de Modules. Estos módulos estarán disponibles en todos los entornos. Para crear un nuevo módulo, vaya a **Gestionar > Módulos > Módulos personalizados** y haga clic en Crear nuevo módulo. Defina el nombre y la versión del módulo. Una vez creado, el módulo se enumerará en Universal Modules con la opción de editar sus propiedades y contenido, así como de eliminar el módulo. Al editar el módulo, se abrirá un editor de código donde podrá definir funciones, variables y alias para exportar. ## Módulos con recursos de Universal {% hint style="info" %} Puede [encontrar aquí](https://github.com/ironmansoftware/universal-modules) un módulo de ejemplo. {% endhint %} ### Instalar Los módulos pueden contener recursos de PowerShell Universal, como scripts, API y aplicaciones. Al añadir estos módulos a su entorno, estos recursos se añadirán automáticamente a su instancia de PowerShell Universal. Estos recursos serán de solo lectura dentro del entorno. Para eliminarlos, tendrá que eliminar el módulo. En la consola de administración, abra **Gestionar > Módulos > Instalados**. Haga clic en el botón de descarga situado a la izquierda del módulo para instalarlo. Una vez instalado, se añadirán los recursos de solo lectura a su entorno. También puede guardar los módulos directamente en la carpeta del repositorio de PowerShell Universal. ```powershell Save-Module Universal.Apps.WindowsSystemInformation -Path $Env:ProgramData\UniversalAutomation\Repository\Modules ``` ### Crear A continuación se muestra un ejemplo de la estructura de un módulo de Universal. Si el módulo contiene la carpeta `.universal`, los recursos se cargarán desde ella automáticamente. ``` .universal scripts.ps1 PSUModule.psd1 PSUModule.psm1 ``` Los recursos no pueden usar rutas y deben usar el nombre del módulo y del comando para asociar los recursos con sus respectivos scripts. Por ejemplo, el fichero `scripts.ps1` anterior tendría que escribirse de la siguiente manera. ```powershell New-PSUScript -Module 'PSUModule' -Command 'Start-MyScript' ``` En `PSUModule.psm1`, tendría que definir la función `Start-MyScript`. Esta es la función que se llamará al ejecutar el script. ```powershell function Start-MyScript { } ``` ### Publicar Al crear módulos que amplían PowerShell Universal, puede incluir la etiqueta `PowerShellUniversal` en el manifiesto del módulo para que aparezcan en la [página de módulos de PowerShell Universal](/powershell-universal/es/readme.md) y en la consola de administración de PSU. [Publique los módulos en la PowerShell Gallery](https://jeffbrown.tech/how-to-publish-your-first-powershell-gallery-package/) para compartirlos con otros. ## Módulo raíz Puede definir un módulo raíz como la configuración de PowerShell Universal. Esto permite configuraciones reproducibles basadas en módulos publicados. Un módulo raíz se define en la configuración de la aplicación del servidor de PowerShell Universal. Cuando PowerShell Universal se inicia, cargará este módulo y sus dependencias automáticamente. El módulo raíz debe encontrarse en el PSModulePath o en la carpeta Modules del repositorio. ### Ejemplo A continuación se muestra un ejemplo de uso de un módulo raíz y dependencias para definir una configuración de PowerShell Universal. Los recursos proporcionados por los módulos son de solo lectura dentro de la plataforma. Al usar módulos, puede asegurarse de que se empaqueten y despliegue versiones específicas de los recursos en sus instancias de PowerShell Universal. {% hint style="success" %} El módulo raíz puede aparecer en cualquier parte del PSModulePath registrado para su servidor o cuenta de servicio. También puede residir en la carpeta de módulos de su repositorio. El ejemplo siguiente usa rutas relativas. {% endhint %} #### ARD.Core El módulo ARD.Core define unas cuantas funciones y un entorno que utilizan otros módulos. Aquí hay un ejemplo de un entorno básico definido. {% code title="Modules\ARD.Core\1.0.0.universal\environments.ps1" %} ```powershell New-PSUEnvironment -Name 'ARD.Core' -Path pwsh.exe -Type PowerShell7 ``` {% endcode %} Las funciones se definen en el fichero PSM1 del módulo. {% 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 %} El manifiesto del módulo exporta la función y proporciona algunos metadatos básicos. {% 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 El módulo ARD.Endpoints tiene una estructura similar al módulo ARD.Core, pero expone un endpoint en lugar de un entorno. Este endpoint de ejemplo llama a la función `Get-ARDResponse` cuando se llama a la URL `ard.endpoint`. Observe que el endpoint usa el endpoint de ARD.Core proporcionado por el módulo anterior. {% 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 %} El fichero ARD.Endpoints.psm1 define la función a exportar que también podemos usar para el endpoint. El endpoint usa la función de ARD.Core para devolver una respuesta. Esto funciona porque todos son simplemente módulos normales de PowerShell. {% code title="Modules\ARD.Endpoints\1.0.0\ARD.Endpoints.psm1" %} ```powershell function Get-ARDResponse { Get-ARDCore } ``` {% endcode %} El fichero ARD.Endpoints.psd1 exportará la función y también tomará una dependencia de ARD.Core para asegurar que ese módulo se cargue primero, porque el endpoint depende de que existan tanto la función como el entorno. {% 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 PowerShell Universal cargará primero el módulo raíz. Toma una dependencia tanto del módulo core como del de endpoints, pero no define ninguna funcionalidad por sí mismo. PowerShell Universal determinará el orden de carga adecuado y luego cargará los recursos durante el inicio. ```powershell @{ Description = "A PowerShell Universal configuration" Version = "1.0.0" RequiredModules = @("ARD.Core", "ARD.Endpoints") } ``` En la configuración de la aplicación, puede seleccionar el módulo raíz y la versión. {% code title="appsettings.json" %} ```json { "Data": { "Module": "ARD.Root", "ModuleVersion": "1.0.0" } } ``` {% endcode %} También puede configurarlo mediante variables de entorno. Cambiar el fichero o las variables de entorno requerirá reiniciar PowerShell Universal. ```powershell $ENV:Data__Module = "ARD.Root" $ENV:Data__ModuleVersion = "1.0.0" ``` ## Instalar módulos manualmente PowerShell Universal añadirá el directorio `Modules` del repositorio al `$ENV:PSModulePath` de todos los entornos. Añadir módulos a este directorio garantizará que el módulo esté disponible para cualquier proceso de PowerShell que se ejecute con PowerShell Universal. ## Información del módulo Esta sección incluye información sobre determinados módulos y su uso en PowerShell Universal. ### ActiveDirectory El módulo `ActiveDirectory` admite compatibilidad nativa con PowerShell 7 al usar la versión 1.0.1.0. Al usar la versión 1.0.0.0, se utiliza la capa de compatibilidad de Windows al ejecutar los comandos en PowerShell 7 y en el entorno Integrated. Esto puede causar problemas en PowerShell Universal. Nuestras recomendaciones para este módulo son las siguientes. #### Windows Server 2019 y superior Actualice el módulo `ActiveDirectory` a la versión 1.0.1.0, que tiene compatibilidad con PowerShell Core #### Windows Server 2016 e inferior Elija una de las 2 soluciones alternativas disponibles: * Incluya el parámetro `-SkipEditionCheck` con **Import-Module** al importar el módulo ActiveDirectory * Use el entorno de Windows PowerShell 5.1 en lugar de Integrated/PowerShell Core #### Lecturas adicionales {% embed url="" %} ### Exchange Microsoft Exchange local se puede gestionar mediante sesiones remotas en PowerShell. Si usa sesiones en aplicaciones, deberá considerar gestionar la sesión de forma que evite tener que abrir una nueva sesión para cada solicitud. Esto mejora considerablemente el rendimiento. El ejemplo siguiente usa el ámbito `$Cache:` para conservar la sesión entre solicitudes. Aunque este ejemplo usa PSSessions y Exchange, podría usar el mismo patrón para otros tipos de conexiones persistentes. ```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 } } ``` ## Versiones de módulos validadas Las siguientes versiones de módulos se han validado con PowerShell Universal. La validación de módulos garantiza que estos módulos se carguen e interactúen con sus respectivos servicios. | Módulo | Versión del módulo | Versión de PSU | Entornos de 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/es/plataforma/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.