Dela via

Installera en PowerShell-modul

  • Artikel

När du har skapat PowerShell-modulen vill du förmodligen installera modulen på ett system, så att du eller andra kan använda den. Generellt sett består detta av att kopiera modulfilerna (dvs. .psm1, eller den binära sammansättningen, modulmanifestet och andra associerade filer) till en katalog på datorn. För ett mycket litet projekt kan det vara så enkelt som att kopiera och klistra in filerna med Utforskaren i Windows på en enda fjärrdator. Men för större lösningar kanske du vill använda en mer avancerad installationsprocess. Oavsett hur du får in modulen i systemet kan PowerShell använda ett antal tekniker som gör att användarna kan hitta och använda dina moduler. Därför är det viktigaste problemet för installationen att se till att PowerShell kan hitta din modul. Mer information finns i Importera en PowerShell-modul.

Regler för att installera moduler

Följande information gäller för alla moduler, inklusive moduler som du skapar för eget bruk, moduler som du får från andra parter och moduler som du distribuerar till andra.

Installera moduler i PSModulePath

När det är möjligt installerar du alla moduler i en sökväg som visas i PSModulePath- miljövariabel eller lägger till modulsökvägen till värdet PSModulePath miljövariabel.

Miljövariabeln PSModulePath ($Env:PSModulePath) innehåller platserna för Windows PowerShell-moduler. Cmdletar förlitar sig på värdet för den här miljövariabeln för att hitta moduler.

Som standard innehåller PSModulePath- miljövariabelvärdet följande kataloger för system- och användarmoduler, men du kan lägga till och redigera värdet.

  • $PSHOME\Modules (%windir%\System32\WindowsPowerShell\v1.0\Modules)

    Varning

    Den här platsen är reserverad för moduler som levereras med Windows. Installera inte moduler på den här platsen.

  • $HOME\Documents\WindowsPowerShell\Modules (%HOMEDRIVE%%HOMEPATH%\Documents\WindowsPowerShell\Modules)

  • $Env:ProgramFiles\WindowsPowerShell\Modules (%ProgramFiles%\WindowsPowerShell\Modules)

    Om du vill hämta värdet för miljövariabeln PSModulePath använder du något av följande kommandon.

    $Env:PSModulePath
[Environment]::GetEnvironmentVariable("PSModulePath")

    Om du vill lägga till en modulsökväg till värdet för PSModulePath miljövariabelvärde använder du följande kommandoformat. I det här formatet används metoden SetEnvironmentVariable i klassen System.Environment för att göra en sessionsoberoende ändring av miljövariabeln PSModulePath.

    #Save the current value in the $p variable.
$p = [Environment]::GetEnvironmentVariable("PSModulePath")

#Add the new path to the $p variable. Begin with a semi-colon separator.
$p += ";C:\Program Files (x86)\MyCompany\Modules\"

#Add the paths in $p to the PSModulePath value.
[Environment]::SetEnvironmentVariable("PSModulePath",$p)

    Viktigt!

    När du har lagt till sökvägen till PSModulePathbör du sända ett miljömeddelande om ändringen. Genom att sända ändringen kan andra program, till exempel gränssnittet, hämta ändringen. Om du vill sända ändringen måste produktinstallationskoden skicka ett WM_SETTINGCHANGE meddelande med lParam inställt på strängen "Miljö". Se till att skicka meddelandet när modulinstallationskoden har uppdaterats PSModulePath-.

Använd rätt modulkatalognamn

En välformulerad modul är en modul som lagras i en katalog som har samma namn som basnamnet för minst en fil i modulkatalogen. Om en modul inte är välformulerad känner Windows PowerShell inte igen den som en modul.

"Basnamnet" för en fil är namnet utan filnamnstillägget. I en välformulerad modul måste namnet på katalogen som innehåller modulfilerna matcha basnamnet för minst en fil i modulen.

I fabrikam-exempelmodulen heter till exempel katalogen som innehåller modulfilerna "Fabrikam" och minst en fil har basnamnet Fabrikam. I det här fallet har både Fabrikam.psd1 och Fabrikam.dll basnamnet Fabrikam.

C:\Program Files
  Fabrikam Technologies
    Fabrikam Manager
      Modules
        Fabrikam
          Fabrikam.psd1 (module manifest)
          Fabrikam.dll (module assembly)

Effekten av felaktig installation

Om modulen inte är välformulerad och dess plats inte ingår i värdet för PSModulePath miljövariabel, fungerar inte grundläggande identifieringsfunktioner i Windows PowerShell, till exempel följande.

  • Funktionen Automatisk inläsning av modul kan inte importera modulen automatiskt.

  • Parametern ListAvailable för cmdleten Get-Module kan inte hitta modulen.

  • Cmdleten Import-Module kan inte hitta modulen. Om du vill importera modulen måste du ange den fullständiga sökvägen till rotmodulfilen eller modulmanifestfilen.

    Ytterligare funktioner, till exempel följande, fungerar inte om inte modulen importeras till sessionen. I välformulerade moduler i PSModulePath miljövariabel fungerar dessa funktioner även när modulen inte importeras till sessionen.

  • Cmdleten Get-Command kan inte hitta kommandon i modulen.

  • Cmdletarna Update-Help och Save-Help kan inte uppdatera eller spara hjälp för modulen.

  • Cmdleten Show-Command kan inte hitta och visa kommandona i modulen.

    Kommandona i modulen saknas i fönstret Show-Command i Windows PowerShell Integrated Scripting Environment (ISE).

Var du ska installera moduler

I det här avsnittet beskrivs var i filsystemet du vill installera Windows PowerShell-moduler. Platsen beror på hur modulen används.

Installera moduler för en specifik användare

Om du skapar en egen modul eller hämtar en modul från en annan part, till exempel en Webbplats för Windows PowerShell-communityn, och du vill att modulen endast ska vara tillgänglig för ditt användarkonto, installerar du modulen i din användarspecifika modulkatalog.

$HOME\Documents\WindowsPowerShell\Modules\<Module Folder>\<Module Files>

Den användarspecifika katalogen Moduler läggs till i värdet för PSModulePath miljövariabel som standard.

Installera moduler för alla användare i programfiler

Om du vill att en modul ska vara tillgänglig för alla användarkonton på datorn installerar du modulen på platsen Programfiler.

$Env:ProgramFiles\WindowsPowerShell\Modules\<Module Folder>\<Module Files>

Anmärkning

Platsen Programfiler läggs till i värdet för miljövariabeln PSModulePath som standard i Windows PowerShell 4.0 och senare. För tidigare versioner av Windows PowerShell kan du manuellt skapa platsen Programfiler (%ProgramFiles%\WindowsPowerShell\Modules) och lägga till den här sökvägen till din PSModulePath-miljövariabel enligt beskrivningen ovan.

Installera moduler i en produktkatalog

Om du distribuerar modulen till andra parter använder du standardplatsen Programfiler som beskrivs ovan eller skapar en egen företagsspecifik eller produktspecifik underkatalog för %ProgramFiles%-katalogen.

Fabrikam Technologies, ett fiktivt företag, levererar till exempel en Windows PowerShell-modul för sin Fabrikam Manager-produkt. Deras modulinstallation skapar en underkatalog för Moduler i produktunderkatalogen Fabrikam Manager.

C:\Program Files
  Fabrikam Technologies
    Fabrikam Manager
      Modules
        Fabrikam
          Fabrikam.psd1 (module manifest)
          Fabrikam.dll (module assembly)

Om du vill aktivera identifieringsfunktionerna för Windows PowerShell-modulen för att hitta Fabrikam-modulen lägger installationsprogrammet för Fabrikam-modulen till modulplatsen till värdet för PSModulePath miljövariabel.

$p = [Environment]::GetEnvironmentVariable("PSModulePath")
$p += ";C:\Program Files\Fabrikam Technologies\Fabrikam Manager\Modules\"
[Environment]::SetEnvironmentVariable("PSModulePath",$p)

Installera moduler i Common Files-katalogen

Om en modul används av flera komponenter i en produkt eller av flera versioner av en produkt installerar du modulen i en modulspecifik underkatalog i underkatalogen %ProgramFiles%\Common Files\Modules.

I följande exempel installeras Fabrikam-modulen i en Fabrikam-underkatalog för underkatalogen %ProgramFiles%\Common Files\Modules. Observera att varje modul finns i en egen underkatalog i underkatalogen Moduler.

C:\Program Files
  Common Files
    Modules
      Fabrikam
        Fabrikam.psd1 (module manifest)
        Fabrikam.dll (module assembly)

Installationsprogrammet försäkrar sedan värdet för miljövariabeln PSModulePath innehåller sökvägen till Common Files\Modules-underkatalogen.

$m = $Env:ProgramFiles + '\Common Files\Modules'
$p = [Environment]::GetEnvironmentVariable("PSModulePath")
$q = $p -split ';'
if ($q -notcontains $m) {
    $q += ";$m"
}
$p = $q -join ';'
[Environment]::SetEnvironmentVariable("PSModulePath", $p)

Installera flera versioner av en modul

Om du vill installera flera versioner av samma modul använder du följande procedur.

  1. Skapa en katalog för varje version av modulen. Inkludera versionsnumret i katalognamnet.
  2. Skapa ett modulmanifest för varje version av modulen. I värdet för ModuleVersion-nyckeln i manifestet anger du modulversionsnumret. Spara manifestfilen (.psd1) i den versionsspecifika katalogen för modulen.
  3. Lägg till modulens rotmappssökväg till värdet för miljövariabeln PSModulePath, enligt följande exempel.

Om du vill importera en viss version av modulen kan slutanvändaren använda parametrarna MinimumVersion eller RequiredVersion för cmdleten Import-Module.

Om fabrikam-modulen till exempel är tillgänglig i versionerna 8.0 och 9.0 kan fabrikammodulens katalogstruktur likna följande.

C:\Program Files
Fabrikam Manager
 Fabrikam8
   Fabrikam
     Fabrikam.psd1 (module manifest: ModuleVersion = "8.0")
     Fabrikam.dll (module assembly)
 Fabrikam9
   Fabrikam
     Fabrikam.psd1 (module manifest: ModuleVersion = "9.0")
     Fabrikam.dll (module assembly)

Installationsprogrammet lägger till båda modulsökvägarna till värdet PSModulePath miljövariabel.

$p = [Environment]::GetEnvironmentVariable("PSModulePath")
$p += ";C:\Program Files\Fabrikam\Fabrikam8;C:\Program Files\Fabrikam\Fabrikam9"
[Environment]::SetEnvironmentVariable("PSModulePath",$p)

När de här stegen är klara hämtar parametern ListAvailable för cmdleten Get-Module båda Fabrikam-modulerna. Om du vill importera en viss modul använder du parametrarna MinimumVersion eller RequiredVersion för cmdleten Import-Module.

Om båda modulerna importeras till samma session och modulerna innehåller cmdletar med samma namn gäller de cmdletar som importerades senast i sessionen.

Hantera kommandonamnskonflikter

Kommandonamnskonflikter kan uppstå när kommandon som en modul exporterar har samma namn som kommandon i användarens session.

När en session innehåller två kommandon som har samma namn kör Windows PowerShell den kommandotyp som har företräde. När en session innehåller två kommandon som har samma namn och samma typ kör Windows PowerShell kommandot som lades till i sessionen senast. Om du vill köra ett kommando som inte körs som standard kan användarna kvalificera kommandonamnet med modulnamnet.

Om sessionen till exempel innehåller en Get-Date funktion och cmdleten Get-Date kör Windows PowerShell funktionen som standard. Kör cmdleten genom att förorda kommandot med modulnamnet, till exempel:

Microsoft.PowerShell.Utility\Get-Date

För att förhindra namnkonflikter kan modulförfattare använda DefaultCommandPrefix nyckel i modulmanifestet för att ange ett substantivprefix för alla kommandon som exporteras från modulen.

Användare kan använda parametern Prefix för cmdleten Import-Module för att använda ett alternativt prefix. Värdet för parametern Prefix har företräde framför värdet för nyckeln DefaultCommandPrefix.

Stöd för sökvägar i icke-Windows-system

Icke-Windows-plattformar använder kolontecknet (:) som sökvägsavgränsare och ett snedstreck (/) som katalogavgränsare. Klassen [System.IO.Path] har statiska medlemmar som kan användas för att få koden att fungera på valfri plattform:

  • [System.IO.Path]::PathSeparator – returnerar det tecken som används för att avgränsa sökvägar i en PATH-miljövariabel för värdplattformen
  • [System.IO.Path]::DirectorySeparatorChar – returnerar tecknet som används för att separera katalognamn med en sökväg för värdplattformen

Använd dessa statiska egenskaper i stället för ; och \ tecken när du skapar sökvägssträngar.

Se även

om_Kommando_Precedens

Skriva en Windows PowerShell-modul