Skriva ett PowerShell-modulmanifest

Artikel
03/25/2025

När du har skrivit PowerShell-modulen kan du lägga till ett valfritt modulmanifest som innehåller information om modulen. Du kan till exempel beskriva författaren, ange filer i modulen (till exempel kapslade moduler), köra skript för att anpassa användarens miljö, läsa in typ- och formateringsfiler, definiera systemkrav och begränsa de medlemmar som modulen exporterar.

Skapa ett modulmanifest

Ett modulmanifest är en PowerShell-datafil (.psd1) som beskriver innehållet i en modul och avgör hur en modul bearbetas. Manifestfilen är en textfil som innehåller en hashtabell med nycklar och värden. Du länkar en manifestfil till en modul genom att namnge manifestet på samma sätt som modulen och lagra manifestet i modulens rotkatalog.

För enkla moduler som bara innehåller en enda .psm1 eller binär sammansättning är ett modulmanifest valfritt. Men rekommendationen är att använda ett modulmanifest när det är möjligt, eftersom de är användbara för att hjälpa dig att organisera koden och underhålla versionsinformation. Och ett modulmanifest krävs för att exportera en sammansättning som är installerad i Global Assembly Cache. Ett modulmanifest krävs också för moduler som stöder funktionen Updatable Help. Updatable Help använder nyckeln HelpInfoUri i modulmanifestet för att hitta hjälpinformationsfilen (HelpInfo XML) som innehåller platsen för de uppdaterade hjälpfilerna för modulen. Mer information om uppdaterad hjälp finns i Support updatable Help.

Skapa och använda ett modulmanifest

Det bästa sättet att skapa ett modulmanifest är att använda cmdleten New-ModuleManifest. Du kan använda parametrar för att ange en eller flera av manifestets standardnycklar och värden. Det enda kravet är att namnge filen. New-ModuleManifest skapar ett modulmanifest med dina angivna värden och innehåller de återstående nycklarna och deras standardvärden. Om du behöver skapa flera moduler använder du New-ModuleManifest för att skapa en modulmanifestmall som kan ändras för dina olika moduler. Ett exempel på ett standardmodulmanifest finns i exempelmodulmanifestet.

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

Ett alternativ är att manuellt skapa modulmanifestets hash-tabell med den minimala information som krävs, ModuleVersion. Du sparar filen med samma namn som modulen och använder filnamnstillägget .psd1. Du kan sedan redigera filen och lägga till lämpliga nycklar och värden.
Lägg till eventuella ytterligare element som du vill använda i manifestfilen.

Om du vill redigera manifestfilen använder du valfri textredigerare. Manifestfilen är dock en skriptfil som innehåller kod, så du kanske vill redigera den i en skript- eller utvecklingsmiljö, till exempel Visual Studio Code. Alla element i en manifestfil är valfria, förutom numret ModuleVersion.

Beskrivningar av de nycklar och värden som du kan inkludera i ett modulmanifest finns i manifestelementen Module tabell. Mer information finns i parameterbeskrivningarna i cmdleten New-ModuleManifest.
För att hantera scenarier som kanske inte omfattas av basmodulmanifestelementen kan du lägga till ytterligare kod i modulmanifestet.

Av säkerhetsskäl kör PowerShell bara en liten delmängd av de tillgängliga åtgärderna i en modulmanifestfil. I allmänhet kan du använda if-instruktionen, aritmetiska operatorer och jämförelseoperatorer och de grundläggande PowerShell-datatyperna.
När du har skapat modulmanifestet kan du testa det för att bekräfta att alla sökvägar som beskrivs i manifestet är korrekta. Om du vill testa modulmanifestet använder du Test-ModuleManifest.

Test-ModuleManifest myModuleName.psd1
Se till att modulmanifestet finns på den översta nivån i katalogen som innehåller modulen.

När du kopierar modulen till ett system och importerar den använder PowerShell modulmanifestet för att importera modulen.
Du kan också testa modulmanifestet direkt med ett anrop till Import-Module genom att punktkällor själva manifestet.

Import-Module .\myModuleName.psd1

Modulmanifestelement

I följande tabell beskrivs de element som du kan inkludera i ett modulmanifest.

Komponent	Standardinställning	Beskrivning
RootModule Typ: `String`	`<empty string>`	Skriptmodul eller binär modulfil som är associerad med det här manifestet. Tidigare versioner av PowerShell kallade det här elementet ModuleToProcess. Möjliga typer för rotmodulen kan vara tomma, vilket skapar en Manifest-modul, namnet på en skriptmodul (`.psm1`) eller namnet på en binär modul (`.exe` eller `.dll`). Att placera namnet på ett modulmanifest (`.psd1`) eller en skriptfil (`.ps1`) i det här elementet orsakar ett fel. Exempel: `RootModule = 'ScriptModule.psm1'`
ModuleVersion Typ: `Version`	`'0.0.1'`	Versionsnummer för den här modulen. Om ett värde inte anges använder `New-ModuleManifest` standardvärdet. Strängen måste kunna konverteras till typen `Version` till exempel `#.#.#.#`. `Import-Module` läser in den första modulen som hittas på den $PSModulePath som matchar namnet och har minst lika hög ModuleVersionsom parametern MinimumVersion. Om du vill importera en viss version använder du parametern `Import-Module` cmdleten RequiredVersion. Exempel: `ModuleVersion = '1.0'`
GUID Typ: `GUID`	`'<GUID>'`	ID som används för att unikt identifiera den här modulen. Om ett värde inte har angetts genereras värdet automatiskt `New-ModuleManifest`. Du kan för närvarande inte importera en modul med GUID-. Exempel: `GUID = 'cfc45206-1e49-459d-a8ad-5b571ef94857'`
Författare Typ: `String`	`'<Current user>'`	Författare till den här modulen. Om ett värde inte har angetts använder `New-ModuleManifest` den aktuella användaren. Exempel: `Author = 'AuthorNameHere'`
CompanyName Typ: `String`	`'Unknown'`	Företag eller leverantör av den här modulen. Om ett värde inte anges använder `New-ModuleManifest` standardvärdet. Exempel: `CompanyName = 'Fabrikam'`
Copyright Typ: `String`	`'(c) <Author>. All rights reserved.'`	Copyright-instruktion för den här modulen. Om ett värde inte har angetts använder `New-ModuleManifest` standardvärdet med den aktuella användaren som `<Author>`. Om du vill ange en författare använder du parametern Author. Exempel: `Copyright = '2019 AuthorName. All rights reserved.'`
Beskrivning Typ: `String`	`<empty string>`	Beskrivning av de funktioner som tillhandahålls av den här modulen. Exempel: `Description = 'This is the module's description.'`
PowerShellVersion Typ: `Version`	`<empty string>`	Lägsta version av PowerShell-motorn som krävs av den här modulen. Giltiga värden är 1.0, 2.0, 3.0, 4.0, 5.0, 5.1, 6.0, 6.1, 6.2, 7.0 och 7.1. Exempel: `PowerShellVersion = '5.0'`
PowerShellHostName Typ: `String`	`<empty string>`	Namnet på Den PowerShell-värd som krävs av den här modulen. Det här namnet tillhandahålls av PowerShell. Om du vill hitta namnet på ett värdprogram skriver du i programmet: `$Host.Name`. Exempel: `PowerShellHostName = 'ConsoleHost'`
PowerShellHostVersion Typ: `Version`	`<empty string>`	Lägsta version av PowerShell-värden som krävs av den här modulen. Exempel: `PowerShellHostVersion = '2.0'`
DotNetFrameworkVersion Typ: `Version`	`<empty string>`	Lägsta version av Microsoft .NET Framework som krävs i den här modulen. Den här förutsättningen är endast giltig för PowerShell Desktop-versionen, till exempel Windows PowerShell 5.1, och gäller endast för .NET Framework-versioner som är lägre än 4,5. Exempel: `DotNetFrameworkVersion = '3.5'`
CLRVersion Typ: `Version`	`<empty string>`	Lägsta version av CLR (Common Language Runtime) som krävs av den här modulen. Den här förutsättningen är endast giltig för PowerShell Desktop-versionen, till exempel Windows PowerShell 5.1, och gäller endast för .NET Framework-versioner som är lägre än 4,5. Exempel: `CLRVersion = '3.5'`
ProcessorArchitecture Typ: `ProcessorArchitecture`	`<empty string>`	Processorarkitektur (Ingen, X86, Amd64) som krävs av den här modulen. Giltiga värden är x86, AMD64, Arm, IA64, MSIL och None (okänd eller ospecificerad). Exempel: `ProcessorArchitecture = 'x86'`
RequiredModules Typ: `Object[]`	`@()`	Moduler som måste importeras till den globala miljön innan du importerar den här modulen. Detta läser in alla moduler som anges om de inte redan har lästs in. Vissa moduler kan till exempel redan ha lästs in av en annan modul. Det går att ange en specifik version som ska läsas in med hjälp av `RequiredVersion` i stället för `ModuleVersion`. När `ModuleVersion` används läses den senaste tillgängliga versionen in med minst den angivna versionen. Du kan kombinera strängar och hash-tabeller i parametervärdet. Exempel: `RequiredModules = @("MyModule", @{ModuleName="MyDependentModule"; ModuleVersion="2.0"; GUID="cfc45206-1e49-459d-a8ad-5b571ef94857"})` Exempel: `RequiredModules = @("MyModule", @{ModuleName="MyDependentModule"; RequiredVersion="1.5"; GUID="cfc45206-1e49-459d-a8ad-5b571ef94857"})`
RequiredAssemblies Typ: `String[]`	`@()`	Sammansättningar som måste läsas in innan du importerar den här modulen. Anger de sammansättnings- (`.dll`) filnamn som modulen kräver. PowerShell läser in de angivna sammansättningarna innan du uppdaterar typer eller format, importerar kapslade moduler eller importerar modulfilen som anges i värdet för RootModule-nyckeln. Använd den här parametern om du vill visa en lista över alla sammansättningar som krävs för modulen. Exempel: `RequiredAssemblies = @("assembly1.dll", "assembly2.dll", "assembly3.dll")`
ScriptsToProcess Typ: `String[]`	`@()`	Skriptfiler (`.ps1`) som körs i anroparens sessionstillstånd när modulen importeras. Detta kan vara det globala sessionstillståndet eller, för kapslade moduler, sessionstillståndet för en annan modul. Du kan använda dessa skript för att förbereda en miljö precis som du kan använda en logg i skript. Dessa skript körs innan någon av modulerna som anges i manifestet läses in. Exempel: `ScriptsToProcess = @("script1.ps1", "script2.ps1", "script3.ps1")`
TypesToProcess Typ: `String[]`	`@()`	Skriv filer (`.ps1xml`) som ska läsas in när du importerar den här modulen. Exempel: `TypesToProcess = @("type1.ps1xml", "type2.ps1xml", "type3.ps1xml")`
FormatsToProcess Typ: `String[]`	`@()`	Formatera filer (`.ps1xml`) som ska läsas in när du importerar den här modulen. Exempel: `FormatsToProcess = @("format1.ps1xml", "format2.ps1xml", "format3.ps1xml")`
NestedModules Typ: `Object[]`	`@()`	Moduler som ska importeras som kapslade moduler i modulen som anges i RootModule (alias:ModuleToProcess). Att lägga till ett modulnamn i det här elementet liknar att anropa `Import-Module` inifrån skriptet eller sammansättningskoden. Den största skillnaden med hjälp av en manifestfil är att det är lättare att se vad du läser in. Och om en modul inte kan läsas in har du ännu inte läst in den faktiska modulen. Förutom andra moduler kan du även läsa in skriptfiler (`.ps1`) här. Dessa filer körs i kontexten för rotmodulen. Detta motsvarar punktkällor för skriptet i rotmodulen. Exempel: `NestedModules = @("script.ps1", @{ModuleName="MyModule"; ModuleVersion="1.0.0.0"; GUID="50cdb55f-5ab7-489f-9e94-4ec21ff51e59"})`
FunctionsToExport Typ: `String[]`	`@()`	Anger vilka funktioner som ska exporteras från den här modulen för bästa prestanda, använd inte jokertecken och ta inte bort posten, använd en tom matris om det inte finns några funktioner att exportera. Som standard exporteras inga funktioner. Du kan använda den här nyckeln för att visa de funktioner som exporteras av modulen. Modulen exporterar funktionerna till anroparens sessionstillstånd. Anroparens sessionstillstånd kan vara det globala sessionstillståndet eller, för kapslade moduler, sessionstillståndet för en annan modul. När kapslade moduler länkas exporteras alla funktioner som exporteras av en kapslad modul till det globala sessionstillståndet om inte en modul i kedjan begränsar funktionen med hjälp av FunctionsToExport-nyckeln. Om manifestet exporterar alias för funktionerna kan den här nyckeln ta bort funktioner vars alias visas i AliasToExportera nyckel, men den här nyckeln kan inte lägga till funktionsalias i listan. Exempel: `FunctionsToExport = @("function1", "function2", "function3")`
CmdletsToExport Typ: `String[]`	`@()`	Anger de cmdletar som ska exporteras från den här modulen för bästa prestanda, använd inte jokertecken och ta inte bort posten, använd en tom matris om det inte finns några cmdletar att exportera. Som standard exporteras inga cmdletar. Du kan använda den här nyckeln för att lista de cmdletar som exporteras av modulen. Anroparens sessionstillstånd kan vara det globala sessionstillståndet eller, för kapslade moduler, sessionstillståndet för en annan modul. När du kedjar kapslade moduler exporteras alla cmdletar som exporteras av en kapslad modul till det globala sessionstillståndet om inte en modul i kedjan begränsar cmdleten med hjälp av CmdletsToExport nyckel. Om manifestet exporterar alias för cmdletarna kan den här nyckeln ta bort cmdletar vars alias visas i AliasToExport nyckel, men den här nyckeln kan inte lägga till cmdlet-alias i listan. Exempel: `CmdletsToExport = @("Get-MyCmdlet", "Set-MyCmdlet", "Test-MyCmdlet")`
VariablesToExport Typ: `String[]`	`'*'`	Anger de variabler som modulen exporterar till anroparens sessionstillstånd. Jokertecken tillåts. Som standard exporteras alla variabler (`''`). Du kan använda den här nyckeln för att begränsa de variabler som exporteras av modulen. Anroparens sessionstillstånd kan vara det globala sessionstillståndet eller, för kapslade moduler, sessionstillståndet för en annan modul. När du kedjar kapslade moduler exporteras alla variabler som exporteras av en kapslad modul till det globala sessionstillståndet om inte en modul i kedjan begränsar variabeln med hjälp av VariablesToExport* nyckel. Om manifestet även exporterar alias för variablerna kan den här nyckeln ta bort variabler vars alias visas i AliasToExportera nyckel, men den här nyckeln kan inte lägga till variabelalias i listan. Exempel: `VariablesToExport = @('$MyVariable1', '$MyVariable2', '$MyVariable3')`
AliasToExportera Typ: `String[]`	`@()`	Anger vilka alias som ska exporteras från den här modulen för bästa prestanda, använd inte jokertecken och ta inte bort posten, använd en tom matris om det inte finns några alias att exportera. Som standard exporteras inga alias. Du kan använda den här nyckeln för att lista de alias som exporteras av modulen. Modulen exporterar aliasen till anroparens sessionstillstånd. Anroparens sessionstillstånd kan vara det globala sessionstillståndet eller, för kapslade moduler, sessionstillståndet för en annan modul. När du kedjar kapslade moduler exporteras alla alias som exporteras av en kapslad modul till slut till det globala sessionstillståndet om inte en modul i kedjan begränsar aliaset med hjälp av AliasToExport nyckel. Exempel: `AliasesToExport = @("MyAlias1", "MyAlias2", "MyAlias3")`
DscResourcesToExport Typ: `String[]`	`@()`	Anger DSC-resurser som ska exporteras från den här modulen. Jokertecken tillåts. Exempel: `DscResourcesToExport = @("DscResource1", "DscResource2", "DscResource3")`
ModuleList Typ: `Object[]`	`@()`	Anger alla moduler som är paketerade med den här modulen. Dessa moduler kan anges med namn, med hjälp av en kommaavgränsad sträng eller som en hash-tabell med ModuleName- och GUID- nycklar. Hash-tabellen kan också ha en valfri ModuleVersion nyckel. Nyckeln ModuleList är utformad för att fungera som en modulinventering. Dessa moduler bearbetas inte automatiskt. Exempel: `ModuleList = @("SampleModule", "MyModule", @{ModuleName="MyModule"; ModuleVersion="1.0.0.0"; GUID="50cdb55f-5ab7-489f-9e94-4ec21ff51e59"})`
FileList Typ: `String[]`	`@()`	Lista över alla filer som paketeras med den här modulen. Precis som med ModuleListär FileList en inventeringslista och bearbetas inte på annat sätt. Exempel: `FileList = @("File1", "File2", "File3")`
PrivateData Typ: `Object`	`@{...}`	Anger alla privata data som måste skickas till rotmodulen som anges av nyckeln RootModule (alias: ModuleToProcess). PrivateData är en hash-tabell som består av flera element: Taggar, LicenseUri, ProjectURI, IconUri, ReleaseNotes, Prerelease, RequireLicenseAcceptanceoch ExternalModuleDependencies.
Taggar Typ: `String[]`	`@()`	Taggar hjälper till med modulidentifiering i onlinegallerier. Exempel: `Tags = "PackageManagement", "PowerShell", "Manifest"`
LicenseUri Typ: `Uri`	`<empty string>`	En URL till licensen för den här modulen. Exempel: `LicenseUri = 'https://www.contoso.com/license'`
ProjectUri Typ: `Uri`	`<empty string>`	En URL till huvudwebbplatsen för det här projektet. Exempel: `ProjectUri = 'https://www.contoso.com/project'`
IconUri Typ: `Uri`	`<empty string>`	En URL till en ikon som representerar den här modulen. Exempel: `IconUri = 'https://www.contoso.com/icons/icon.png'`
ReleaseNotes Typ: `String`	`<empty string>`	Anger modulens viktig information. Exempel: `ReleaseNotes = 'The release notes provide information about the module.`
PreRelease Typ: `String`	`<empty string>`	Den här parametern lades till i PowerShellGet 1.6.6. En PreRelease sträng som identifierar modulen som en förhandsversion i onlinegallerier. Exempel: `PreRelease = 'alpha'`
RequireLicenseAcceptance Typ: `Boolean`	`$false`	Den här parametern lades till i PowerShellGet 1.5. Flagga för att ange om modulen kräver explicit användargodkännande för installation, uppdatering eller sparande. Exempel: `RequireLicenseAcceptance = $false`
ExternalModuleDependencies Typ: `String[]`	`@()`	Den här parametern lades till i PowerShellGet v2. En lista över externa moduler som modulen är beroende av. Exempel: `ExternalModuleDependencies = @("ExtModule1", "ExtModule2", "ExtModule3")`
HelpInfoURI- Typ: `String`	`<empty string>`	HelpInfo-URI för den här modulen. Exempel: `HelpInfoURI = 'https://www.contoso.com/help'`
DefaultCommandPrefix Typ: `String`	`<empty string>`	Standardprefix för kommandon som exporteras från den här modulen. Åsidosätt standardprefixet med hjälp av `Import-Module -Prefix`. Exempel: `DefaultCommandPrefix = 'My'`

Exempel på modulmanifest

Följande exempelmodulmanifest skapades med New-ModuleManifest i PowerShell 7 och innehåller standardnycklarna och värdena.

#
# 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 = $false

        # 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 = ''

}

Dela via

Skriva ett PowerShell-modulmanifest

Skapa ett modulmanifest

Skapa och använda ett modulmanifest

Modulmanifestelement

Exempel på modulmanifest

Se även

Ytterligare resurser