about_Modules

  • Artikel

Kort beskrivning

Förklarar hur du installerar, importerar och använder PowerShell-moduler.

Lång beskrivning

PowerShell är både ett kommandogränssnitt och ett skriptspråk. Kommandon i PowerShell implementeras som skript, funktioner eller cmdletar. Språket innehåller nyckelord som ger strukturen och logiken för bearbetning och andra resurser, till exempel variabler, providers, alias.

En modul är en fristående, återanvändbar enhet som kan innehålla cmdletar, leverantörer, funktioner, variabler och andra resurser som kan importeras till en PowerShell-session eller ett anpassat PowerShell-program.

Innan funktionerna i en modul kan användas måste modulen läsas in i PowerShell-sessionen. Som standard läser PowerShell automatiskt in en installerad modul första gången du använder ett kommando från modulen. Du kan konfigurera funktionen för automatisk inläsning av moduler med hjälp av variabeln $PSModuleAutoloadingPreference. Mer information finns i about_Preference_Variables.

Du kan också ta bort eller läsa in moduler manuellt under en PowerShell-session. Om du vill ta bort en modul använder du cmdleten Remove-Module . Om du vill läsa in eller läsa in en modul igen använder du Import-Module.

PowerShell levereras med en basuppsättning moduler. Vem som helst kan skapa nya PowerShell-kommandon eller andra resurser och publicera dem som moduler som användarna kan installera efter behov.

Du kan skriva moduler i C# som kompilerade .NET-sammansättningar, så kallade inbyggda moduler, eller i vanliga PowerShell, så kallade skriptmoduler. Det här avsnittet beskriver hur du använder PowerShell-moduler. Information om hur du skapar PowerShell-moduler finns i Skriva en PowerShell-modul.

Kommentar

Innan PowerShell 3.0 paketerades cmdletar och leverantörer i PowerShell-snapin-moduler. Från och med PowerShell 3.0 läggs snapin-modulen Microsoft.PowerShell.Core till i varje session som standard. Det här är den enda snapin-modulen som finns kvar i PowerShell. Alla andra snapin-moduler konverterades till moduler. Det går inte längre att skapa nya snapin-moduler.

Installera en publicerad modul

En publicerad modul är en modul som är tillgänglig från en registrerad lagringsplats, till exempel PowerShell-galleriet. Modulerna PowerShellGet och Microsoft.PowerShell.PSResourceGet tillhandahåller cmdletar för att hitta, installera och publicera PowerShell-moduler till en registrerad lagringsplats.

PowerShellGet-modulen ingår i PowerShell 5.0 och senare versioner. Modulen Microsoft.PowerShell.PSResourceGet ingår i PowerShell 7.4 och senare versioner. Microsoft.PowerShell.PSResourceGet är den nya föredragna pakethanteraren för PowerShell och kan installeras i tidigare versioner av PowerShell. Använd cmdleten Install-Module eller Install-PSResource för att installera moduler från PowerShell-galleriet.

 Get-Command Install-Module, Install-PSResource

CommandType  Name                Version    Source
-----------  ----                -------    ------
Function     Install-Module      2.9.0      PowerShellGet
Cmdlet       Install-PSResource  1.0.0      Microsoft.PowerShell.PSResourceGet

Mer information finns i Översikt över PowerShellGet.

Installera en modul manuellt

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.

PowerShell levereras med flera förinstallerade moduler. På Windows-baserade datorer innehåller många Windows-funktioner moduler för att hantera funktionen. Modulerna installeras när funktionen installeras. Andra moduler kan komma i ett installationsprogram eller installationsprogram som installerar modulen.

Som standard Modules finns inte mappen för den aktuella användaren. Om du har installerat en modul i omfånget CurrentUser med eller Install-Module Install-PSResourceskapar Modules dessa cmdletar mappen för den aktuella användaren. Om mappen inte finns kan du skapa den manuellt.

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

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

Kopiera hela modulmappen till den nya skapade mappen. I PowerShell använder du cmdleten Copy-Item . Kör till exempel följande kommando för att kopiera MyModule mappen från C:\PSTest till den mapp som du nyss skapade:

Copy-Item -Path C:\PSTest\MyModule -Destination $folder

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 about_PSModulePath.

Automatisk inläsning av modul

Första gången du kör ett kommando från en installerad modul importerar PowerShell automatiskt (läser in) modulen. Modulen måste lagras på de platser som anges i $env:PSModulePath miljövariabeln. Moduler på andra platser måste importeras med hjälp av cmdleten Import-Module .

Med automatisk inläsning av moduler kan du använda kommandon i en modul utan konfiguration eller profilkonfiguration. Du behöver inte hantera moduler när du har installerat dem på datorn.

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

Du kan använda cmdlet-listan Get-Command med kommandona i alla installerade moduler, även om de ännu inte är i sessionen. När du använder Get-Command med jokertecken (*) importerar Inte PowerShell några moduler. Du kan använda jokertecken för kommandoidentifiering utan att läsa in moduler som du kanske inte behöver i sessionen.

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.

Importera en modul manuellt

Du måste importera en modul manuellt när en modul inte är installerad på de platser som anges av $env:PSModulePath miljövariabeln, eller när modulen tillhandahålls som en fristående .dll modul eller .psm1 fil i stället för en paketerad modul.

Du kanske också vill ändra hur modulen importeras i sessionen. Till exempel lägger prefixparametern Import-Module för till ett distinkt prefix till substantivdelen av cmdletarna som importeras från modulen. Parametern NoClobber förhindrar att modulen lägger till kommandon som skulle dölja eller ersätta befintliga kommandon i sessionen. Mer information finns i Hantera namnkonflikter.

Du kan importera en modul som är installerad i din $env:PSModulePath genom att ange modulnamnet. Följande kommando importerar till exempel BitsTransfer-modulen till den aktuella sessionen.

Import-Module BitsTransfer

Om du vill importera en modul som inte finns i använder $env:PSModulePathdu den fullständigt kvalificerade sökvägen till modulmappen. Om du till exempel vill lägga till TestCmdlets-modulen C:\ps-test i 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 i början av 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.

Hitta installerade moduler

Cmdleten Get-Module hämtar De PowerShell-moduler som har importerats i sessionen.

Get-Module

Modulerna i listan kan innehålla moduler som har importerats från valfri plats, inte bara från $env:PSModulePath.

Använd följande kommando för att lista moduler som är installerade i $env:PSModulePath:

Get-Module -ListAvailable

Det här kommandot hämtar alla moduler som är installerade i $env:PSModulePath, inte bara de moduler som importeras till den aktuella sessionen. Det här kommandot visar inte moduler som är installerade på andra platser.

Mer information finns i Get-Module.

Visa en lista över kommandona i en modul

Använd cmdleten Get-Command för att hitta alla tillgängliga kommandon. Du kan använda parametrarna för cmdleten Get-Command för att filtrera kommandon, till exempel 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-Command Get-Command.

Ta bort en modul

När du tar bort en modul tas de kommandon som modulen lade till bort från sessionen. 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 Ta bort modul.

Kommandon kan läggas till 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 från sessionen använder du följande kommandon för att avgöra vilken modul du vill ta bort.

Använd till exempel följande kommando för att hitta källan Get-Date till cmdletarna och Get-Help :

Get-Command Get-Date, Get-Help -All |
    Select-Object -Property Name, CommandType, Module ,PSSnapIn

Följande utdata visar att cmdleten Get-Help finns i snapin-modulen Microsoft.PowerShell.Core . Det går inte att ta bort den här snapin-modulen från sessionen.

Name     CommandType Module                       PSSnapIn
----     ----------- ------                       --------
Get-Date    Function
Get-Date      Cmdlet Microsoft.PowerShell.Utility
Get-Help      Cmdlet                              Microsoft.PowerShell.Core

Det finns två källor för Get-Date. Den ena är en funktion och den andra är en cmdlet i modulen Microsoft.PowerShell.Utility . Du kan ta bort modulen med .Remove-Module Om du vill ta bort funktionen kan du ta bort den Function: från enheten.

Remove-Item Function:Get-Date

Mer information om enheten finns i Function: about_Function_Provider.

Hantera 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.

Import-Module kan lägga till kommandon som döljer och ersätter kommandon i den aktuella sessionen. Namnkonflikter kan leda till att kommandon döljs eller ersätts. Kommandobyte sker när den importerade modulen innehåller ett kommando med samma namn som ett befintligt kommando i sessionen. Det nyligen importerade kommandot ersätter har företräde framför det befintliga kommandot.

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å cmdletar med samma namn, kör den 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.

Du kan köra ett kommando som har dolts eller ersatts av att kvalificera kommandonamnet. Om du vill kvalificera kommandonamnet lägger du till namnet på modulen än den version av kommandot som du vill använda. Till exempel:

Microsoft.PowerShell.Utility\Get-Date

Om du kör Get-Date med modulnamnprefixet ser du till att du kör versionen från modulen Microsoft.PowerShell.Utility .

Om du vill identifiera namnkonflikter använder du parametern Alla i cmdleten Get-Command . Som standard 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.

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 inga 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 endast välja de kommandon som du vill importera, och du kan exkludera kommandon som orsakar namnkonflikter i sessionen. Import-Module

Modulförfattare kan förhindra namnkonflikter med hjälp av 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 DefaultCommandPrefix.

Se även