about_Modules

Artikel
10/14/2021
12 minuter för att läsa

Kort beskrivning

Beskriver hur du installerar, importerar och använder PowerShell-moduler.

Lång beskrivning

En modul är ett paket som innehåller PowerShell-medlemmar, till exempel cmdlets, providers, funktioner, arbetsflöden, variabler och alias.

Personer som skriver kommandon kan använda moduler för att organisera sina kommandon och dela dem med andra. Personer som tar emot moduler kan lägga till kommandona i modulerna i sina PowerShell-sessioner och använda dem precis som de inbyggda kommandona.

Det här avsnittet beskriver hur du använder PowerShell-moduler. Information om hur du skriver PowerShell-moduler finns i Skriva en PowerShell-modul.

Vad är en modul?

En modul är ett paket som innehåller PowerShell-medlemmar, till exempel cmdlets, providers, funktioner, arbetsflöden, variabler och alias. Medlemmarna i det här paketet kan implementeras i ett PowerShell-skript, en kompilerad DLL eller en kombination av båda. Dessa filer grupperas vanligtvis tillsammans i en enda katalog. Mer information finns i Understanding a Windows PowerShell Module i SDK-dokumentationen.

Automatisk inläsning av moduler

Från och med PowerShell 3.0 importerar PowerShell moduler automatiskt första gången du kör ett kommando i en installerad modul. Nu kan du använda kommandona i en modul utan konfiguration eller profilkonfiguration, så du behöver inte hantera moduler när du har installerat dem på datorn.

Kommandona i en modul är också lättare att hitta. Get-CommandCmdleten hämtar nu alla kommandon i alla installerade moduler, även om de ännu inte är i sessionen. Du kan hitta ett kommando och använda det utan att behöva importera modulen först.

Vart och ett av följande exempel gör att modulen CimCmdlets, som innehåller Get-CimInstance , importeras till sessionen.

Kör kommandot
```
Get-CimInstance Win32_OperatingSystem
```
Hämta kommandot
```
Get-Command Get-CimInstance
```
Få hjälp för kommandot
```
Get-Help Get-CimInstance
```

Get-Command kommandon som innehåller ett jokertecken ( ) anses vara * för identifiering, inte för användning och importerar inte några moduler.

Endast moduler som lagras på den plats som anges av miljövariabeln PSModulePath importeras automatiskt. Moduler på andra platser måste importeras genom att köra Import-Module cmdleten .

Dessutom importerar inte kommandon som använder PowerShell-providers automatiskt en modul. Om du till exempel använder ett kommando som kräver WSMan:-enheten, till exempel cmdleten, kan du behöva köra cmdleten för att Get-PSSessionConfiguration Import-Module importera modulen Microsoft.WSMan.Management som innehåller WSMan: enheten.

Du kan fortfarande köra kommandot Import-Module för att importera en modul och använda $PSModuleAutoloadingPreference variabeln för att aktivera, inaktivera och konfigurera automatisk import av moduler. Mer information finns i about_Preference_Variables.

Använda en modul

Utför följande uppgifter för att använda en modul:

Installera modulen. (Detta görs ofta åt dig.)
Hitta kommandona som modulen har lagt till.
Använd de kommandon som modulen har lagt till.

Det här avsnittet beskriver hur du utför dessa uppgifter. Den innehåller även annan användbar information om att hantera moduler.

Så här installerar du en modul

Om du får en modul som en mapp med filer i den måste du installera den på datorn innan du kan använda den i PowerShell.

De flesta moduler är installerade åt dig. PowerShell levereras med flera förinstallerade moduler, som ibland kallas kärnmoduler. På Windows-baserade datorer, om funktioner som ingår i operativsystemet har cmdlets för att hantera dem, är dessa moduler förinstallerade. När du installerar en Windows-funktion, genom att till exempel använda guiden Lägg till roller och funktioner i Serverhanteraren eller dialogrutan Aktivera eller inaktivera Windows-funktioner i Kontrollpanelen, installeras alla PowerShell-moduler som ingår i funktionen. Många andra moduler finns i ett installationsprogram eller installationsprogram som installerar modulen.

Använd följande kommando för att skapa en Modules-katalog för den aktuella användaren:

New-Item -Type Directory -Path $HOME\Documents\PowerShell\Modules

Kopiera hela modulmappen till katalogen Modules. Du kan använda valfri metod för att kopiera mappen, inklusive Windows Explorer och Cmd.exe, samt PowerShell. Använd Copy-Item cmdleten i PowerShell. Om du till exempel vill kopiera mappen MyModule C:\ps-test\MyModule från till katalogen Modules skriver du:

Copy-Item -Path C:\ps-test\MyModule -Destination `
    $HOME\Documents\PowerShell\Modules

Du kan installera en modul på valfri plats, men om du installerar modulerna på en standardmodulplats blir de enklare att hantera. Mer information om standardplatserna för moduler finns i avsnittet Modul- och DSC-resursplatser och PSModulePath.

Hitta installerade moduler

Om du vill hitta moduler som är installerade på en standardmodulplats, men som ännu inte har importerats till sessionen, skriver du:

Get-Module -ListAvailable

Om du vill hitta de moduler som redan har importerats till din session skriver du följande i PowerShell-prompten:

Get-Module

Mer information om Get-Module cmdleten finns i Get-Module.

Hitta kommandona i en modul

Använd Get-Command cmdleten för att hitta alla tillgängliga kommandon. Du kan använda parametrarna för Get-Command cmdleten för att filtrera kommandon som efter modul, namn och substantiv.

Om du vill hitta alla kommandon i en modul skriver du:

Get-Command -Module <module-name>

Om du till exempel vill hitta kommandona i BitsTransfer-modulen skriver du:

Get-Command -Module BitsTransfer

Mer information om Get-Command cmdleten finns i Get-Command.

Så här Få hjälp för kommandona i en modul

Om modulen innehåller hjälpfiler för de kommandon som exporteras visas Get-Help hjälpavsnitten i cmdleten. Använd samma Get-Help kommandoformat som du använder för att få hjälp med alla kommandon i PowerShell.

Från och med PowerShell 3.0 kan du ladda ned hjälpfiler för en modul och hämta uppdateringar av hjälpfilerna så att de aldrig blir föråldrade.

Om du vill få hjälp med kommandon i en modul skriver du:

Get-Help <command-name>

Om du vill få hjälp online för kommandot i en modul skriver du:

Get-Help <command-name> -Online

Om du vill ladda ned och installera hjälpfilerna för kommandona i en modul skriver du:

Update-Help -Module <module-name>

Mer information finns i Get-Help och Update-Help.

Importera en modul

Du kan behöva importera en modul eller importera en modulfil. Import krävs om en modul inte är installerad på de platser som anges av miljövariabeln PSModulePath, eller om modulen består av en fil, till exempel en .dll- eller .psm1-fil, i stället för en typisk modul som levereras som $env:PSModulePath en mapp.

Du kan också välja att importera en modul så att du kan använda parametrarna för kommandot, till exempel parametern Prefix, som lägger till ett prefix som lägger till ett prefix till substantivnamnen för alla importerade kommandon, eller Import-Module parametern NoClobber, vilket förhindrar att modulen lägger till kommandon som döljer eller ersätter befintliga kommandon i sessionen.

Om du vill importera moduler använder du Import-Module cmdleten .

Om du vill importera moduler på en PSModulePath-plats till den aktuella sessionen använder du följande kommandoformat.

Import-Module <module-name>

Följande kommando importerar till exempel BitsTransfer-modulen till den aktuella sessionen.

Import-Module BitsTransfer

Om du vill importera en modul som inte finns på en standardmodulplats använder du den fullständigt kvalificerade sökvägen till modulmappen i kommandot .

Om du till exempel vill lägga till modulen TestCmdlets i C:\ps-test katalogen i din session skriver du:

Import-Module C:\ps-test\TestCmdlets

Om du vill importera en modulfil som inte finns i en modulmapp använder du den fullständigt kvalificerade sökvägen till modulfilen i kommandot .

Om du till exempel vill TestCmdlets.dll modulen i C:\ps-test katalogen i din session skriver du:

Import-Module C:\ps-test\TestCmdlets.dll

Mer information om hur du lägger till moduler i sessionen finns i Import-Module.

Importera en modul till varje session

Kommandot Import-Module importerar moduler till din aktuella PowerShell-session. Om du vill importera en modul till varje PowerShell-session som du startar lägger du Import-Module till kommandot i din PowerShell-profil.

Mer information om profiler finns i about_Profiles.

Ta bort en modul

När du tar bort en modul tas de kommandon som modulen har lagt till bort från sessionen.

Om du vill ta bort en modul från sessionen använder du följande kommandoformat.

Remove-Module <module-name>

Följande kommando tar till exempel bort BitsTransfer-modulen från den aktuella sessionen.

Remove-Module BitsTransfer

Om du tar bort en modul så ångras importen av en modul. Modulen avinstalleras inte om du tar bort en modul. Mer information finns i Remove-Module.

Modul- och DSC-resursplatser och PSModulePath

$env:PSModulePathMiljövariabeln innehåller en lista över mappplatser som genomsöks för att hitta moduler och resurser.

Som standard är de effektiva platser som $env:PSModulePath tilldelats:

Systemomfattande platser: $PSHOME\Modules

Dessa mappar innehåller moduler som levereras med Windows och PowerShell.

DSC-resurser som ingår i PowerShell lagras i $PSHOME\Modules\PSDesiredStateConfiguration\DSCResources mappen .
Användarspecifika moduler: Det här är moduler som installeras av användaren i användarens omfång. Install-Module har en Scope-parameter som gör att du kan ange om modulen är installerad för den aktuella användaren eller för alla användare. Mer information finns i Install-Module.

Den användarspecifika CurrentUser-platsen Windows mappen PowerShell\Modules som finns på dokumentplatsen i din användarprofil. Den specifika sökvägen till den platsen varierar beroende på vilken version Windows och om du använder mappomdirigering eller inte. Microsoft OneDrive också ändra platsen för mappen Dokument.

Som standard på Windows 10 högre är den platsen $HOME\Documents\PowerShell\Modules . På Linux eller Mac är platsen CurrentUser $HOME/.local/share/powershell/Modules .

Anteckning

Du kan kontrollera platsen för mappen Dokument med följande kommando: [Environment]::GetFolderPath('MyDocuments') .
Platsen AllUsers finns $env:PROGRAMFILES\PowerShell\Modules på Windows. På Linux eller Mac lagras modulerna på /usr/local/share/powershell/Modules .

Anteckning

Om du vill lägga till eller ändra $env:Windir\System32 filer i katalogen startar du PowerShell med alternativet Kör som administratör.

Du kan ändra standardmodulplatserna i systemet genom att ändra värdet för miljövariabeln PSModulePath, $Env:PSModulePath . Miljövariabeln PSModulePath modelleras på miljövariabeln Path och har samma format.

Om du vill visa standardplatserna för modulen skriver du:

$Env:PSModulePath

Om du vill lägga till en standardmodulplats använder du följande kommandoformat.

$Env:PSModulePath = $Env:PSModulePath + ";<path>"

Semikolonet ( ; ) i kommandot separerar den nya sökvägen från sökvägen som föregår den i listan.

Om du till exempel vill lägga C:\ps-test\Modules till katalogen skriver du:

$Env:PSModulePath + ";C:\ps-test\Modules"

Om du vill lägga till en standardmodulplats i Linux eller MacOS använder du följande kommandoformat:

$Env:PSModulePath += ":<path>"

Om du till exempel vill lägga /usr/local/Fabrikam/Modules till katalogen i värdet för miljövariabeln PSModulePath skriver du:

$Env:PSModulePath += ":/usr/local/Fabrikam/Modules"

I Linux eller MacOS separerar kolon ( ) i kommandot den nya sökvägen från sökvägen : som föregår den i listan.

När du lägger till en sökväg till PSModulePath inkluderar Get-Module Import-Module kommandona moduler i sökvägen.

Värdet som du anger påverkar bara den aktuella sessionen. Om du vill göra ändringen beständig lägger du till kommandot i Din PowerShell-profil eller använder System i Kontrollpanelen för att ändra värdet för miljövariabeln PSModulePath i registret.

För att göra ändringen beständig kan du också använda metoden SetEnvironmentVariable för klassen System.Environment för att lägga till en sökväg till miljövariabeln PSModulePath.

Mer information om PSModulePath-variabeln finns i about_Environment_Variables.

Moduler och namnkonflikter

Namnkonflikter uppstår när mer än ett kommando i sessionen har samma namn. Att importera en modul orsakar en namnkonflikt när kommandon i modulen har samma namn som kommandon eller objekt i sessionen.

Namnkonflikter kan resultera i att kommandon döljs eller ersätts.

Dold

Ett kommando är dolt när det inte är det kommando som körs när du skriver in kommandonamnet, men du kan köra det med en annan metod, till exempel genom att kvalificera kommandonamnet med namnet på den modul eller snapin-modul som det kommer från.

Ersatt

Ett kommando ersätts när du inte kan köra det eftersom det har skrivits över av ett kommando med samma namn. Även om du tar bort modulen som orsakade konflikten kan du inte köra ett ersatt kommando om du inte startar om sessionen.

Import-Module kan lägga till kommandon som döljer och ersätter kommandon i den aktuella sessionen. Dessutom kan kommandon i sessionen dölja kommandon som modulen har lagt till.

Om du vill identifiera namnkonflikter använder du parametern Alla för Get-Command cmdleten . Från och med PowerShell 3.0 Get-Command hämtar endast de kommandon som körs när du skriver kommandonamnet. Parametern Alla hämtar alla kommandon med det specifika namnet i sessionen.

Använd parametrarna NoClobber eller Prefix för cmdleten för att förhindra Import-Module namnkonflikter. Prefixparametern lägger till ett prefix till namnen på importerade kommandon så att de är unika i sessionen. NoClobber-parametern importerar inte några kommandon som skulle dölja eller ersätta befintliga kommandon i sessionen.

Du kan också använda parametrarna Alias, Cmdlet, Funktion och Variabel för för att välja de kommandon som du vill importera och du kan undanta kommandon som orsakar namnkonflikter i Import-Module sessionen.

Modulförfattare kan förhindra namnkonflikter genom att använda egenskapen DefaultCommandPrefix för modulmanifestet för att lägga till ett standardprefix till alla kommandonamn. Värdet för prefixparametern har företräde framför värdet för DefaultCommandPrefix.

Även om ett kommando är dolt kan du köra det genom att kvalificera kommandonamnet med namnet på modulen eller snapin-modulen som det kom från.

Prioritetsreglerna för PowerShell-kommandon avgör vilket kommando som körs när sessionen innehåller kommandon med samma namn.

När en session till exempel innehåller en funktion och en cmdlet med samma namn kör PowerShell funktionen som standard. När sessionen innehåller kommandon av samma typ med samma namn, till exempel två cmdlets med samma namn, körs som standard det senast tillagda kommandot.

Mer information, inklusive en förklaring av prioritetsregler och instruktioner för att köra dolda kommandon, finns i about_Command_Precedence.

Moduler och snapin-moduler

Du kan lägga till kommandon i sessionen från moduler och snapin-moduler. Moduler kan lägga till alla typer av kommandon, inklusive cmdlets, providers, funktioner och objekt, till exempel variabler, alias och PowerShell-enheter. Snapin-modulen kan bara lägga till cmdlets och providers.

Innan du tar bort en modul eller snapin-modul från sessionen använder du följande kommandon för att avgöra vilka kommandon som ska tas bort.

Använd följande kommandoformat för att hitta källan för en cmdlet i sessionen:

Get-Command <cmdlet-name> | Format-List -Property verb,noun,pssnapin,module

Om du till exempel vill hitta källan för Get-Date cmdleten skriver du:

Get-Command Get-Date | Format-List -Property verb,noun,module

Kommandona som en modul exporterar bör följa namngivningsreglerna för PowerShell-kommandon. Om modulen som du importerar exporterar cmdlets eller funktioner som har ej godkända verb i sina namn, visar Import-Module cmdleten följande varningsmeddelande.

VARNING! Vissa importerade kommandonamn innehåller ej godkända verb, vilket kan göra dem mindre identifieringsbara. Använd den utförliga parametern för mer information eller Get-Verb för att se listan över godkända verb.

Det här meddelandet är bara en varning. Den fullständiga modulen importeras fortfarande, inklusive kommandon som inte uppfyller kraven. Även om meddelandet visas för modulanvändare bör namnproblemet åtgärdas av modulförfattaren.

Om du vill ignorera varningsmeddelandet använder du parametern DisableNameChecking för Import-Module cmdleten .

Inbyggda moduler och snapin-moduler

I PowerShell 2.0 och i äldre värdprogram i PowerShell 3.0 och senare paketeras kärnkommandona som installeras med PowerShell i snapin-modulen som läggs till automatiskt i varje PowerShell-session.

Från och med PowerShell 3.0 läggs InitialSessionState.CreateDefault2 snapin-modulen Microsoft.PowerShell.Core till i varje session som standard för värdprogram som implementerar det inledande sessionstillståndet API. Moduler läses in automatiskt vid första användning.

Anteckning

Fjärrsessioner, inklusive sessioner som startas med hjälp av cmdleten, är äldre sessioner där de inbyggda kommandona paketeras i New-PSSession snapin-modulen.

Följande moduler (eller snapin-moduler) installeras med PowerShell.

CimCmdlets
Microsoft.PowerShell.Archive
Microsoft.PowerShell.Core
Microsoft.PowerShell.Diagnostics
Microsoft.PowerShell.Host
Microsoft.PowerShell.Management
Microsoft.PowerShell.Security
Microsoft.PowerShell.Utility
Microsoft.WSMan.Management
PackageManagement
PowerShellGet
PSDesiredStateConfiguration
PSDiagnostics
PSReadline

Logga modulhändelser

Från och med PowerShell 3.0 kan du registrera körningshändelser för cmdlets och funktioner i PowerShell-moduler och snapin-moduler genom att ange egenskapen LogPipelineExecutionDetails för moduler och snapin-moduler till $True . Du kan också använda en grupprincip aktivera modulloggning för att aktivera modulloggning i alla PowerShell-sessioner. Mer information finns i artiklarna om loggning och grupprinciper.