Share via


Cómo escribir un manifiesto de módulo de PowerShell

Después de escribir el módulo de PowerShell, puede agregar un manifiesto de módulo opcional que incluya información sobre el módulo. Por ejemplo, puede describir el autor, especificar archivos en el módulo (por ejemplo, módulos anidados), ejecutar scripts para personalizar el entorno del usuario, cargar archivos de tipo y formato, definir requisitos del sistema y limitar los miembros que exporta el módulo.

Creación de un manifiesto de módulo

Un manifiesto de módulo es un archivo de datos de PowerShell ( ) que describe el contenido de un módulo y determina cómo se procesa un .psd1 módulo. El archivo de manifiesto es un archivo de texto que contiene una tabla hash de claves y valores. Para vincular un archivo de manifiesto a un módulo, debe asignar al manifiesto el mismo nombre que al módulo y almacenar el manifiesto en el directorio raíz del módulo.

Para los módulos simples que contienen solo un ensamblado .psm1 único o binario, un manifiesto de módulo es opcional. Sin embargo, la recomendación es usar un manifiesto de módulo siempre que sea posible, ya que son útiles para ayudarle a organizar el código y mantener la información de control de versiones. Además, se requiere un manifiesto de módulo para exportar un ensamblado instalado en la caché global de ensamblados. También se requiere un manifiesto de módulo para los módulos que admiten la característica Ayuda actualizable. La Ayuda actualizable usa la clave HelpInfoUri del manifiesto del módulo para buscar el archivo de información de Ayuda (HelpInfo XML) que contiene la ubicación de los archivos de ayuda actualizados para el módulo. Para obtener más información sobre la Ayuda actualizable, vea Supporting Updatable Help.

Para crear y usar un manifiesto de módulo

  1. El procedimiento recomendado para crear un manifiesto de módulo es usar el cmdlet New-ModuleManifest. Puede usar parámetros para especificar una o varias de las claves y valores predeterminados del manifiesto. El único requisito es dar nombre al archivo. New-ModuleManifest crea un manifiesto de módulo con los valores especificados e incluye las claves restantes y sus valores predeterminados. Si necesita crear varios módulos, use para crear una plantilla de New-ModuleManifest manifiesto de módulo que se pueda modificar para los distintos módulos. Para obtener un ejemplo de un manifiesto de módulo predeterminado, consulte el manifiesto del módulo de ejemplo.

    New-ModuleManifest -Path C:\myModuleName.psd1 -ModuleVersion "2.0" -Author "YourNameHere"

    Una alternativa es crear manualmente la tabla hash del manifiesto del módulo con la información mínima necesaria, ModuleVersion. Guarde el archivo con el mismo nombre que el módulo y use la .psd1 extensión de archivo. A continuación, puede editar el archivo y agregar las claves y los valores adecuados.

  2. Agregue los elementos adicionales que desee en el archivo de manifiesto.

    Para editar el archivo de manifiesto, use el editor de texto que prefiera. Pero el archivo de manifiesto es un archivo de script que contiene código, por lo que es posible que desee editarlo en un entorno de scripting o desarrollo, como Visual Studio Code. Todos los elementos de un archivo de manifiesto son opcionales, excepto el número ModuleVersion.

    Para obtener descripciones de las claves y los valores que puede incluir en un manifiesto de módulo, vea la tabla Module manifest elements (Elementos del manifiesto del módulo). Para obtener más información, vea las descripciones de parámetros en el cmdlet New-ModuleManifest.

  3. Para solucionar los escenarios que podrían no estar cubiertos por los elementos de manifiesto del módulo base, tiene la opción de agregar código adicional al manifiesto del módulo.

    Por motivos de seguridad, PowerShell solo ejecuta un pequeño subconjunto de las operaciones disponibles en un archivo de manifiesto de módulo. Por lo general, puede usar la instrucción , los operadores aritméticos if y de comparación, y los tipos de datos básicos de PowerShell.

  4. Después de crear el manifiesto del módulo, puede probarlo para confirmar que las rutas de acceso descritas en el manifiesto son correctas. Para probar el manifiesto del módulo, use Test-ModuleManifest.

    Test-ModuleManifest myModuleName.psd1

  5. Asegúrese de que el manifiesto del módulo se encuentra en el nivel superior del directorio que contiene el módulo.

    Al copiar el módulo en un sistema e importarlo, PowerShell usa el manifiesto del módulo para importar el módulo.

  6. Opcionalmente, puede probar directamente el manifiesto del módulo con una llamada a Import-Module mediante el dot-sourcing del propio manifiesto.

    Import-Module .\myModuleName.psd1

Elementos de manifiesto de módulo

En la tabla siguiente se describen los elementos que puede incluir en un manifiesto de módulo.

Elemento Valor predeterminado Descripción
RootModule
Tipo: String
<empty string> Script de módulo o archivo de módulo binario asociado a este manifiesto. Las versiones anteriores de PowerShell denominan a este elemento ModuleToProcess.
Los tipos posibles para el módulo raíz pueden estar vacíos, lo que crea un módulo Manifiesto, el nombre de un módulo de script ( ) o el nombre de .psm1 un módulo binario ( o .exe .dll ). Al colocar el nombre de un manifiesto de módulo ( .psd1 ) o un archivo de script ( ) en este elemento se produce un .ps1 error.
Ejemplo: RootModule = 'ScriptModule.psm1'
ModuleVersion
Tipo: Version
'0.0.1' Número de versión de este módulo. Si no se especifica un valor, New-ModuleManifest usa el valor predeterminado. La cadena debe ser capaz de convertir al tipo Version , por #.#.#.# ejemplo. Import-Modulecarga el primer módulo que encuentra en el $PSModulePath que coincide con el nombre y tiene al menos una moduleVersion tan alta como el parámetro MinimumVersion. Para importar una versión específica, use el Import-Module parámetro RequiredVersion del cmdlet.
Ejemplo: ModuleVersion = '1.0'
GUID
Tipo: GUID
'<GUID>' Identificador que se usa para identificar de forma única este módulo. Si no se especifica un valor, New-ModuleManifest genera automáticamente el valor. Actualmente no se puede importar un módulo por GUID.
Ejemplo: GUID = 'cfc45206-1e49-459d-a8ad-5b571ef94857'
Autor
Tipo: String
'<Current user>' Autor de este módulo. Si no se especifica un valor, New-ModuleManifest usa el usuario actual.
Ejemplo: Author = 'AuthorNameHere'
CompanyName
Tipo: String
'Unknown' Empresa o proveedor de este módulo. Si no se especifica un valor, New-ModuleManifest usa el valor predeterminado.
Ejemplo: CompanyName = 'Fabrikam'
Copyright
Tipo: String
'(c) <Author>. All rights reserved.' Instrucción copyright de este módulo. Si no se especifica un valor, usa el valor New-ModuleManifest predeterminado con el usuario actual como <Author> . Para especificar un autor, use el parámetro Author.
Ejemplo: Copyright = '2019 AuthorName. All rights reserved.'
Descripción
Tipo: String
<empty string> Descripción de la funcionalidad proporcionada por este módulo.
Ejemplo: Description = 'This is the module's description.'
PowerShellVersion
Tipo: Version
<empty string> Versión mínima del motor de PowerShell requerida por este módulo. Los valores válidos son 1.0, 2.0, 3.0, 4.0, 5.0, 5.1, 6.0, 6.1, 6.2, 7.0 y 7.1.
Ejemplo: PowerShellVersion = '5.0'
PowerShellHostName
Tipo: String
<empty string> Nombre del host de PowerShell requerido por este módulo. PowerShell proporciona este nombre. Para buscar el nombre de un programa host, en el programa, escriba: $host.name .
Ejemplo: PowerShellHostName = 'ConsoleHost'
PowerShellHostVersion
Tipo: Version
<empty string> Versión mínima del host de PowerShell requerida por este módulo.
Ejemplo: PowerShellHostVersion = '2.0'
DotNetFrameworkVersion
Tipo: Version
<empty string> Versión mínima de Microsoft .NET Framework requiere este módulo. Este requisito previo solo es válido para la edición de PowerShell Desktop, como PowerShell 5.1.
Ejemplo: DotNetFrameworkVersion = '3.5'
CLRVersion
Tipo: Version
<empty string> Versión mínima de Common Language Runtime (CLR) requerida por este módulo. Este requisito previo solo es válido para la edición de PowerShell Desktop, como PowerShell 5.1.
Ejemplo: CLRVersion = '3.5'
ProcessorArchitecture
Tipo: ProcessorArchitecture
<empty string> Arquitectura del procesador (None, X86, Amd64) requerida por este módulo. Los valores válidos son x86, AMD64, Arm, IA64, MSIL y None (desconocido o no especificado).
Ejemplo: ProcessorArchitecture = 'x86'
RequiredModules
Tipo: Object[]
@() Módulos que deben importarse en el entorno global antes de importar este módulo. Esto carga los módulos enumerados a menos que ya se hayan cargado. (por ejemplo, es posible que un módulo diferente ya haya cargado algunos módulos). Es posible especificar una versión específica para cargar mediante RequiredVersion en lugar de ModuleVersion . Cuando ModuleVersion se usa, cargará la versión más reciente disponible con un mínimo de la versión especificada. Puede combinar las cadenas y las tablas hash en el valor del parámetro.
Ejemplo: RequiredModules = @("MyModule", @{ModuleName="MyDependentModule"; ModuleVersion="2.0"; GUID="cfc45206-1e49-459d-a8ad-5b571ef94857"})
Ejemplo: RequiredModules = @("MyModule", @{ModuleName="MyDependentModule"; RequiredVersion="1.5"; GUID="cfc45206-1e49-459d-a8ad-5b571ef94857"})
RequiredAssemblies
Tipo: String[]
@() Ensamblados que se deben cargar antes de importar este módulo. Especifica los nombres de archivo del ensamblado ( .dll ) que requiere el módulo.
PowerShell carga los ensamblados especificados antes de actualizar tipos o formatos, importar módulos anidados o importar el archivo de módulo especificado en el valor de la clave RootModule. Use este parámetro para enumerar todos los ensamblados que requiere el módulo.
Ejemplo: RequiredAssemblies = @("assembly1.dll", "assembly2.dll", "assembly3.dll")
ScriptsToProcess
Tipo: String[]
@() Archivos de script ( ) que se ejecutan en el estado de sesión del autor de la .ps1 llamada cuando se importa el módulo. Podría ser el estado de sesión global o, para los módulos anidados, el estado de sesión de otro módulo. Puede usar estos scripts para preparar un entorno tal como podría usar un script de inicio de sesión.
Estos scripts se ejecutan antes de que se cargue cualquiera de los módulos enumerados en el manifiesto.
Ejemplo: ScriptsToProcess = @("script1.ps1", "script2.ps1", "script3.ps1")
TypesToProcess
Tipo: String[]
@() Escriba los archivos ( .ps1xml ) que se cargarán al importar este módulo.
Ejemplo: TypesToProcess = @("type1.ps1xml", "type2.ps1xml", "type3.ps1xml")
FormatsToProcess
Tipo: String[]
@() Dar formato a los archivos ( .ps1xml ) que se cargarán al importar este módulo.
Ejemplo: FormatsToProcess = @("format1.ps1xml", "format2.ps1xml", "format3.ps1xml")
NestedModules
Tipo: Object[]
@() Módulos que se importarán como módulos anidados del módulo especificado en RootModule (alias:ModuleToProcess).
Agregar un nombre de módulo a este elemento es similar a llamar Import-Module desde el código de script o ensamblado. La principal diferencia al usar un archivo de manifiesto es que es más fácil ver lo que se carga. Y, si no se puede cargar un módulo, aún no habrá cargado el módulo real.
Además de otros módulos, también puede cargar archivos de script ( .ps1 ) aquí. Estos archivos se ejecutarán en el contexto del módulo raíz. Esto equivale a dot sourcing del script en el módulo raíz.
Ejemplo: NestedModules = @("script.ps1", @{ModuleName="MyModule"; ModuleVersion="1.0.0.0"; GUID="50cdb55f-5ab7-489f-9e94-4ec21ff51e59"})
FunctionsToExport
Tipo: String[]
@() Especifica las funciones que se van a exportar desde este módulo, para obtener el mejor rendimiento, no usar caracteres comodín y no eliminar la entrada, usar una matriz vacía si no hay ninguna función para exportar. De forma predeterminada, no se exporta ninguna función. Puede usar esta clave para enumerar las funciones exportadas por el módulo.
El módulo exporta las funciones al estado de sesión del autor de la llamada. El estado de sesión del autor de la llamada puede ser el estado de sesión global o, para los módulos anidados, el estado de sesión de otro módulo. Al encadenar módulos anidados, todas las funciones exportadas por un módulo anidado se exportarán al estado de sesión global a menos que un módulo de la cadena restrinja la función mediante la clave FunctionsToExport.
Si el manifiesto exporta alias para las funciones, esta clave puede quitar funciones cuyos alias se enumeran en la clave AliasesToExport, pero esta clave no puede agregar alias de función a la lista.
Ejemplo: FunctionsToExport = @("function1", "function2", "function3")
CmdletsToExport
Tipo: String[]
@() Especifica los cmdlets que se van a exportar desde este módulo, para obtener el mejor rendimiento, no usar caracteres comodín y no eliminar la entrada, usar una matriz vacía si no hay cmdlets para exportar. De forma predeterminada, no se exporta ningún cmdlet. Puede usar esta clave para enumerar los cmdlets exportados por el módulo.
El estado de sesión del autor de la llamada puede ser el estado de sesión global o, para los módulos anidados, el estado de sesión de otro módulo. Al encadenar módulos anidados, todos los cmdlets exportados por un módulo anidado se exportarán al estado de sesión global a menos que un módulo de la cadena restrinja el cmdlet mediante la clave CmdletsToExport.
Si el manifiesto exporta alias para los cmdlets, esta clave puede quitar cmdlets cuyos alias se enumeran en la clave AliasesToExport, pero esta clave no puede agregar alias de cmdlet a la lista.
Ejemplo: CmdletsToExport = @("Get-MyCmdlet", "Set-MyCmdlet", "Test-MyCmdlet")
VariablesToExport
Tipo: String[]
'*' Especifica las variables que exporta el módulo al estado de sesión del autor de la llamada. Se permite el uso de caracteres comodín. De forma predeterminada, se exportan todas las variables ( '*' ). Puede usar esta clave para restringir las variables exportadas por el módulo.
El estado de sesión del autor de la llamada puede ser el estado de sesión global o, para los módulos anidados, el estado de sesión de otro módulo. Al encadenar módulos anidados, todas las variables exportadas por un módulo anidado se exportarán al estado de sesión global a menos que un módulo de la cadena restrinja la variable mediante la clave VariablesToExport.
Si el manifiesto también exporta alias para las variables, esta clave puede quitar variables cuyos alias se enumeran en la clave AliasesToExport, pero esta clave no puede agregar alias de variable a la lista.
Ejemplo: VariablesToExport = @('$MyVariable1', '$MyVariable2', '$MyVariable3')
AliasesToExport
Tipo: String[]
@() Especifica los alias que se van a exportar desde este módulo, para obtener el mejor rendimiento, no usar caracteres comodín y no eliminar la entrada, usar una matriz vacía si no hay ningún alias para exportar. De forma predeterminada, no se exporta ningún alias. Puede usar esta clave para enumerar los alias exportados por el módulo.
El módulo exporta los alias al estado de sesión del autor de la llamada. El estado de sesión del autor de la llamada puede ser el estado de sesión global o, para los módulos anidados, el estado de sesión de otro módulo. Al encadenar módulos anidados, todos los alias exportados por un módulo anidado se exportarán en última instancia al estado de sesión global a menos que un módulo de la cadena restrinja el alias mediante la clave AliasesToExport.
Ejemplo: AliasesToExport = @("MyAlias1", "MyAlias2", "MyAlias3")
DscResourcesToExport
Tipo: String[]
@() Especifica los recursos de DSC que se exportarán desde este módulo. Se permiten los caracteres comodín.
Ejemplo: DscResourcesToExport = @("DscResource1", "DscResource2", "DscResource3")
ModuleList
Tipo: Object[]
@() Especifica todos los módulos que se empaquetan con este módulo. Estos módulos se pueden especificar por nombre, mediante una cadena separada por comas o como una tabla hash con claves ModuleName y GUID. La tabla hash también puede tener una clave ModuleVersion opcional. La clave ModuleList está diseñada para actuar como un inventario de módulos. Estos módulos no se procesan automáticamente.
Ejemplo: ModuleList = @("SampleModule", "MyModule", @{ModuleName="MyModule"; ModuleVersion="1.0.0.0"; GUID="50cdb55f-5ab7-489f-9e94-4ec21ff51e59"})
Lista de archivos
Tipo: String[]
@() Lista de todos los archivos empaquetados con este módulo. Al igual que con ModuleList, FileList es una lista de inventario y, de lo contrario, no se procesa.
Ejemplo: FileList = @("File1", "File2", "File3")
PrivateData
Tipo: Object
@{...} Especifica los datos privados que deben pasarse al módulo raíz especificado por la clave RootModule (alias: ModuleToProcess). PrivateData es una tabla hash que consta de varios elementos: Tags, LicenseUri, ProjectURI, IconUri, ReleaseNotes, Prerelease, RequireLicenseAcceptance y ExternalModuleDependencies.
Etiquetas
Tipo: String[]
@() Las etiquetas ayudan con la detección de módulos en galerías en línea.
Ejemplo: Tags = "PackageManagement", "PowerShell", "Manifest"
LicenseUri
Tipo: Uri
<empty string> Dirección URL de la licencia de este módulo.
Ejemplo: LicenseUri = 'https://www.contoso.com/license'
ProjectUri
Tipo: Uri
<empty string> Dirección URL del sitio web principal de este proyecto.
Ejemplo: ProjectUri = 'https://www.contoso.com/project'
IconUri
Tipo: Uri
<empty string> Dirección URL a un icono que representa este módulo.
Ejemplo: IconUri = 'https://www.contoso.com/icons/icon.png'
Notas de la versión
Tipo: String
<empty string> Especifica las notas de la versión del módulo.
Ejemplo: ReleaseNotes = 'The release notes provide information about the module.
Prelanzamiento
Tipo: String
<empty string> Este parámetro se agregó en PowerShellGet 1.6.6. Cadena de versión preliminar que identifica el módulo como una versión preliminar en galerías en línea.
Ejemplo: PreRelease = 'This module is a prerelease version.
RequireLicenseAcceptance
Tipo: Boolean
$true Este parámetro se agregó en PowerShellGet 1.5. Marca para indicar si el módulo requiere la aceptación explícita del usuario para la instalación, actualización o guardado.
Ejemplo: RequireLicenseAcceptance = $false
ExternalModuleDependencies
Tipo: String[]
@() Este parámetro se agregó en PowerShellGet v2. Lista de módulos externos de los que depende este módulo.
Ejemplo: ExternalModuleDependencies = @("ExtModule1", "ExtModule2", "ExtModule3")
HelpInfoURI
Tipo: String
<empty string> URI de HelpInfo de este módulo.
Ejemplo: HelpInfoURI = 'https://www.contoso.com/help'
DefaultCommandPrefix
Tipo: String
<empty string> Prefijo predeterminado para los comandos exportados desde este módulo. Invalide el prefijo predeterminado mediante Import-Module -Prefix .
Ejemplo: DefaultCommandPrefix = 'My'

Manifiesto de módulo de ejemplo

El siguiente manifiesto de módulo de ejemplo se New-ModuleManifest creó con en PowerShell 7 y contiene las claves y los valores predeterminados.

#
# Module manifest for module 'SampleModuleManifest'
#
# Generated by: User01
#
# Generated on: 10/15/2019
#

@{

# Script module or binary module file associated with this manifest.
# RootModule = ''

# Version number of this module.
ModuleVersion = '0.0.1'

# Supported PSEditions
# CompatiblePSEditions = @()

# ID used to uniquely identify this module
GUID = 'b632e90c-df3d-4340-9f6c-3b832646bf87'

# Author of this module
Author = 'User01'

# Company or vendor of this module
CompanyName = 'Unknown'

# Copyright statement for this module
Copyright = '(c) User01. All rights reserved.'

# Description of the functionality provided by this module
# Description = ''

# Minimum version of the PowerShell engine required by this module
# PowerShellVersion = ''

# Name of the PowerShell host required by this module
# PowerShellHostName = ''

# Minimum version of the PowerShell host required by this module
# PowerShellHostVersion = ''

# Minimum version of Microsoft .NET Framework required by this module. This prerequisite is valid for the PowerShell Desktop edition only.
# DotNetFrameworkVersion = ''

# Minimum version of the common language runtime (CLR) required by this module. This prerequisite is valid for the PowerShell Desktop edition only.
# CLRVersion = ''

# Processor architecture (None, X86, Amd64) required by this module
# ProcessorArchitecture = ''

# Modules that must be imported into the global environment prior to importing this module
# RequiredModules = @()

# Assemblies that must be loaded prior to importing this module
# RequiredAssemblies = @()

# Script files (.ps1) that are run in the caller's environment prior to importing this module.
# ScriptsToProcess = @()

# Type files (.ps1xml) to be loaded when importing this module
# TypesToProcess = @()

# Format files (.ps1xml) to be loaded when importing this module
# FormatsToProcess = @()

# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess
# NestedModules = @()

# Functions to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no functions to export.
FunctionsToExport = @()

# Cmdlets to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no cmdlets to export.
CmdletsToExport = @()

# Variables to export from this module
VariablesToExport = '*'

# Aliases to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no aliases to export.
AliasesToExport = @()

# DSC resources to export from this module
# DscResourcesToExport = @()

# List of all modules packaged with this module
# ModuleList = @()

# List of all files packaged with this module
# FileList = @()

# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell.
PrivateData = @{

    PSData = @{

        # Tags applied to this module. These help with module discovery in online galleries.
        # Tags = @()

        # A URL to the license for this module.
        # LicenseUri = ''

        # A URL to the main website for this project.
        # ProjectUri = ''

        # A URL to an icon representing this module.
        # IconUri = ''

        # ReleaseNotes of this module
        # ReleaseNotes = ''

        # Prerelease string of this module
        # Prerelease = ''

        # Flag to indicate whether the module requires explicit user acceptance for install/update/save
        RequireLicenseAcceptance = $true

        # External dependent modules of this module
        # ExternalModuleDependencies = @()

    } # End of PSData hashtable

} # End of PrivateData hashtable

# HelpInfo URI of this module
# HelpInfoURI = ''

# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix.
# DefaultCommandPrefix = ''

}

Consulte también

about_Comparison_Operators

about_If

Caché global de ensamblados

Import-Module

New-ModuleManifest

Test-ModuleManifest

Update-ModuleManifest

Escritura de un módulo de Windows PowerShell