about_Modules

  • Artikel
  • 11 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 cmdletar, 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 till 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 cmdletar, 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 Förstå en Windows PowerShell-modul i SDK-dokumentationen.

Automatisk inläsning av modul

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å enklare att hitta. Cmdleten Get-Command 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 CimCmdlets-modulen, som innehåller Get-CimInstance, importeras till din session.

  • 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 jokertecken (*) anses vara för identifiering, inte använda 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 cmdleten Import-Module .

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

Du kan fortfarande köra Import-Module kommandot för att importera en modul och använda variabeln $PSModuleAutoloadingPreference 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:

  1. Installera modulen. (Detta görs ofta för dig.)
  2. Hitta de kommandon som modulen lade till.
  3. Använd de kommandon som modulen lade 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 . Om funktioner som ingår i operativsystemet har cmdletar för att hantera dem på Windows-baserade datorer, förinstalleras dessa moduler. När du installerar en Windows-funktion med hjälp av till exempel 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 modulkatalog för den aktuella användaren:

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

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

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

Du kan installera en modul på valfri plats, men om du installerar modulerna på en standardmodulplats blir det enklare att hantera dem. Mer information om standardmodulplatserna 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 modulerna som redan har importerats till sessionen skriver du följande i PowerShell-prompten:

Get-Module

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

Så här hittar du kommandona i en modul

Använd cmdleten Get-Command för att hitta alla tillgängliga kommandon. Du kan använda cmdletens Get-Command parametrar 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 cmdleten finns i Get-CommandGet-Command.

Så här får du hjälp med kommandona i en modul

Om modulen innehåller hjälpfiler för de kommandon som exporteras visar Get-Help cmdleten hjälpavsnitten. Använd samma Get-Help kommandoformat som du skulle använda 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 ladda ned uppdateringar till 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 när en modul inte har installerats på de platser som anges av MILJÖvariabeln PSModulePath , $env: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 en mapp.

Du kan också välja att importera en modul så att du kan använda parametrarna Import-Module för kommandot, till exempel prefixparametern, som lägger till ett distinkt prefix till substantivnamnen för alla importerade kommandon, eller 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 cmdleten Import-Module .

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 sessionen 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 lägga till modulen TestCmdlets.dll i C:\ps-test katalogen i sessionen 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 till kommandot i Import-Module 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 lade 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 återställs åtgärden att importera en modul. Om du tar bort en modul avinstalleras inte modulen. Mer information finns i Remove-Module.

Modul- och DSC-resursplatser och PSModulePath

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

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

  • 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 omfångsparameter 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(Installera-modul).

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

    Som standard är $HOME\Documents\PowerShell\Modulesden platsen på Windows 10 och högre . På Linux eller Mac är $HOME/.local/share/powershell/ModulesCurrentUser-platsen .

    Anteckning

    Du kan kontrollera platsen för mappen Dokument med följande kommando: [Environment]::GetFolderPath('MyDocuments').

  • AllUsers-platsen finns $env:PROGRAMFILES\PowerShell\Modules i Windows. På Linux eller Mac lagras modulerna på /usr/local/share/powershell/Modules.

Anteckning

Om du vill lägga till eller ändra filer i $env:Windir\System32 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å variabeln Sökvägsmiljö och har samma format.

Om du vill visa standardmodulplatserna 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 till C:\ps-test\Modules katalogen skriver du:

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

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

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

Om du vill göra ändringen beständig kan du också använda metoden SetEnvironmentVariable i 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 fler än ett kommando i sessionen har samma namn. Om du importerar en modul uppstår 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 kommandot som körs när du skriver kommandonamnet, men du kan köra det med hjälp av en annan metod, till exempel genom att kvalificera kommandonamnet med namnet på modulen eller snapin-modulen som den har sitt ursprung i.

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. Kommandon i sessionen kan också dölja kommandon som modulen har lagt till.

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

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

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

Modulförfattare kan förhindra namnkonflikter med egenskapen DefaultCommandPrefix för modulmanifestet för att lägga till ett standardprefix i 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 härstammar från.

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

Om 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å cmdletar 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 cmdletar, providers och funktioner och objekt, till exempel variabler, alias och PowerShell-enheter. Snapin-moduler kan bara lägga till cmdletar 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 till en cmdlet i sessionen:

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

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

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

Mer information om PowerShell-snapin-moduler finns i about_PSSnapins.

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

VARNING! Vissa importerade kommandonamn innehåller icke godkända verb som kan göra dem mindre identifierbara. Använd parametern Verbose för mer information eller skriv 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 icke-kompatibla kommandon. Även om meddelandet visas för modulanvändare bör namngivningsproblemet åtgärdas av modulförfattaren.

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

Inbyggda moduler och snapin-moduler

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

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

Anteckning

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

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.ODataUtils
  • Microsoft.PowerShell.Security
  • Microsoft.PowerShell.Utility
  • Microsoft.WSMan.Management
  • PackageManagement
  • PowerShellGet
  • PSDesiredStateConfiguration
  • PSDiagnostics
  • PSScheduledJob
  • PSWorkflow
  • PSWorkflowUtility
  • ISE

Loggningsmodulhändelser

Från och med PowerShell 3.0 kan du registrera körningshändelser för cmdletar 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 inställning, Aktivera modulloggning, för att aktivera modulloggning i alla PowerShell-sessioner. Mer information finns i about_EventLogs och about_Group_Policy_Settings.

Se även