Import-PSSession

Syntax

Import-PSSession
      [-Prefix <String>]
      [-DisableNameChecking]
      [[-CommandName] <String[]>]
      [-AllowClobber]
      [-ArgumentList <Object[]>]
      [-CommandType <CommandTypes>]
      [-Module <String[]>]
      [-FullyQualifiedModule <ModuleSpecification[]>]
      [[-FormatTypeName] <String[]>]
      [-Certificate <X509Certificate2>]
      [-Session] <PSSession>
      [<CommonParameters>]

Description

Cmdleten Import-PSSession importerar kommandon, till exempel cmdletar, funktioner och alias, från en PSSession på en lokal dator eller fjärrdator till den aktuella sessionen. Du kan importera alla kommandon som cmdleten Get-Command kan hitta i PSSession.

Använd ett Import-PSSession kommando för att importera kommandon från ett anpassat gränssnitt, till exempel ett Microsoft Exchange Server-gränssnitt, eller från en session som innehåller Windows PowerShell-moduler och snapin-moduler eller andra element som inte finns i den aktuella sessionen.

Om du vill importera kommandon använder du först cmdleten New-PSSession för att skapa en PSSession. Använd sedan cmdleten Import-PSSession för att importera kommandona. Som standard Import-PSSession importeras alla kommandon förutom kommandon som har samma namn som kommandon i den aktuella sessionen. Om du vill importera alla kommandon använder du parametern AllowClobber .

Du kan använda importerade kommandon precis som med alla kommandon i sessionen. När du använder ett importerat kommando körs den importerade delen av kommandot implicit i sessionen som den importerades från. Fjärråtgärderna hanteras dock helt av Windows PowerShell. Du behöver inte ens vara medveten om dem, förutom att du måste hålla anslutningen till den andra sessionen (PSSession) öppen. Om du stänger den är de importerade kommandona inte längre tillgängliga.

Eftersom importerade kommandon kan ta längre tid att köra än lokala kommandon lägger Import-PSSession du till en AsJob-parameter i varje importerat kommando. Med den här parametern kan du köra kommandot som ett Windows PowerShell-bakgrundsjobb. Mer information finns i artikeln om jobb.

När du använder Import-PSSessionlägger Windows PowerShell till de importerade kommandona i en tillfällig modul som bara finns i sessionen och returnerar ett objekt som representerar modulen. Om du vill skapa en beständiga modul som du kan använda i framtida sessioner använder du cmdleten Export-PSSession .

Cmdleten Import-PSSession använder den implicita fjärrkommunikationsfunktionen i Windows PowerShell. När du importerar kommandon till den aktuella sessionen körs de implicit i den ursprungliga sessionen eller i en liknande session på den ursprungliga datorn.

Från och med Windows PowerShell 3.0 kan du använda cmdleten Import-Module för att importera moduler från en fjärrsession till den aktuella sessionen. Den här funktionen använder implicit fjärrkommunikation. Det motsvarar att använda Import-PSSession för att importera valda moduler från en fjärrsession till den aktuella sessionen.

Exempel

Exempel 1: Importera alla kommandon från en PSSession

$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S

Det här kommandot importerar alla kommandon från en PSSession på Server01-datorn till den aktuella sessionen, förutom kommandon som har samma namn som kommandon i den aktuella sessionen.

Eftersom det här kommandot inte använder parametern CommandName importeras även alla formateringsdata som krävs för de importerade kommandona.

Exempel 2: Importera kommandon som slutar med en specifik sträng

$S = New-PSSession https://ps.testlabs.com/powershell
Import-PSSession -Session $S -CommandName *-test -FormatTypeName *
New-Test -Name Test1
Get-Test test1 | Run-Test

Dessa kommandon importerar kommandona med namn som slutar med "-test" från en PSSession till den lokala sessionen och visar sedan hur du använder en importerad cmdlet.

Det första kommandot använder cmdleten New-PSSession för att skapa en PSSession. PsSession sparas i variabeln $S .

Det andra kommandot använder cmdleten Import-PSSession för att importera kommandon från PSSession in $S till den aktuella sessionen. Den använder parametern CommandName för att ange kommandon med parametern Test noun och FormatTypeName för att importera formateringsdata för testkommandona.

De tredje och fjärde kommandona använder de importerade kommandona i den aktuella sessionen. Eftersom importerade kommandon faktiskt läggs till i den aktuella sessionen använder du den lokala syntaxen för att köra dem. Du behöver inte använda cmdleten Invoke-Command för att köra ett importerat kommando.

Exempel 3: Importera cmdletar från en PSSession

$S1 = New-PSSession -ComputerName s1
$S2 = New-PSSession -ComputerName s2
Import-PSSession -Session s1 -Type cmdlet -Name New-Test, Get-Test -FormatTypeName *
Import-PSSession -Session s2 -Type Cmdlet -Name Set-Test -FormatTypeName *
New-Test Test1 | Set-Test -RunType Full

Det här exemplet visar att du kan använda importerade cmdletar precis som du skulle använda lokala cmdletar.

Dessa kommandon importerar New-Test cmdletarna och Get-Test från en PSSession på Server01-datorn och cmdleten Set-Test från en PSSession på Server02-datorn.

Även om cmdletarna importerades från olika PSSessioner kan du skicka ett objekt från en cmdlet till en annan utan fel.

Exempel 4: Kör ett importerat kommando som ett bakgrundsjobb

$S = New-PSSession -ComputerName Server01
Import-PSSession -Session $S -CommandName *-test* -FormatTypeName *
$batch = New-Test -Name Batch -AsJob
Receive-Job $batch

Det här exemplet visar hur du kör ett importerat kommando som ett bakgrundsjobb.

Eftersom importerade kommandon kan ta längre tid att köra än lokala kommandon lägger Import-PSSession du till en AsJob-parameter i varje importerat kommando. Med parametern AsJob kan du köra kommandot som ett bakgrundsjobb.

Det första kommandot skapar en PSSession på Server01-datorn och sparar PSSession-objektet i variabeln $S .

Det andra kommandot använder Import-PSSession för att importera test-cmdletar från PSSession till $S den aktuella sessionen.

Det tredje kommandot använder parametern AsJob för den importerade New-Test cmdleten för att köra ett New-Test kommando som ett bakgrundsjobb. Kommandot sparar jobbobjektet som New-Test returneras i variabeln $batch .

Det fjärde kommandot använder cmdleten Receive-Job för att hämta resultatet av jobbet i variabeln $batch .

Exempel 5: Importera cmdletar och funktioner från en Windows PowerShell-modul

$S = New-PSSession -ComputerName Server01
Invoke-Command -Session $S {Import-Module TestManagement}
Import-PSSession -Session $S -Module TestManagement

Det här exemplet visar hur du importerar cmdletar och funktioner från en Windows PowerShell-modul på en fjärrdator till den aktuella sessionen.

Det första kommandot skapar en PSSession på Server01-datorn och sparar den i variabeln $S .

Det andra kommandot använder cmdleten Invoke-Command för att köra ett Import-Module kommando i PSSession i $S.

Vanligtvis läggs modulen till i alla sessioner med ett Import-Module kommando i en Windows PowerShell-profil, men profiler körs inte i PSSessioner.

Det tredje kommandot använder modulparametern Import-PSSession för för att importera cmdletar och funktioner i modulen till den aktuella sessionen.

Exempel 6: Skapa en modul i en temporär fil

PS C:\> Import-PSSession $S -CommandName Get-Date, SearchHelp -FormatTypeName * -AllowClobber

Name              : tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1zunz.ttf
Path              : C:\Users\User01\AppData\Local\Temp\tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1
zunz.ttf\tmp_79468106-4e1d-4d90-af97-1154f9317239_
tcw1zunz.ttf.psm1
Description       : Implicit remoting for http://server01.corp.fabrikam.com/wsman
Guid              : 79468106-4e1d-4d90-af97-1154f9317239
Version           : 1.0
ModuleBase        : C:\Users\User01\AppData\Local\Temp\tmp_79468106-4e1d-4d90-af97-1154f9317239_tcw1
zunz.ttf
ModuleType        : Script
PrivateData       : {ImplicitRemoting}
AccessMode        : ReadWrite
ExportedAliases   : {}
ExportedCmdlets   : {}
ExportedFunctions : {[Get-Date, Get-Date], [SearchHelp, SearchHelp]}
ExportedVariables : {}
NestedModules     : {}

Det här exemplet visar hur Import-PSSession du skapar en modul i en temporär fil på disken. Det visar också att alla kommandon konverteras till funktioner innan de importeras till den aktuella sessionen.

Kommandot använder cmdleten Import-PSSession för att importera en Get-Date cmdlet och en SearchHelp-funktion till den aktuella sessionen.

Cmdleten Import-PSSession returnerar ett PSModuleInfo-objekt som representerar den tillfälliga modulen. Värdet för egenskapen Path visar att Import-PSSession en skriptmodulfil (.psm1) har skapats på en tillfällig plats. Egenskapen ExportedFunctions visar att både cmdleten Get-Date och SearchHelp-funktionen importerades som funktioner.

Exempel 7: Kör ett kommando som är dolt av ett importerat kommando

PS C:\> Import-PSSession $S -CommandName Get-Date -FormatTypeName * -AllowClobber

PS C:\> Get-Command Get-Date -All

CommandType   Name       Definition
-----------   ----       ----------
Function      Get-Date   ...
Cmdlet        Get-Date   Get-Date [[-Date] <DateTime>] [-Year <Int32>] [-Month <Int32>]

PS C:\> Get-Date
09074

PS C:\> (Get-Command -Type Cmdlet -Name Get-Date).PSSnapin.Name
Microsoft.PowerShell.Utility

PS C:\> Microsoft.PowerShell.Utility\Get-Date
Sunday, March 15, 2009 2:08:26 PM

Det här exemplet visar hur du kör ett kommando som är dolt av ett importerat kommando.

Det första kommandot importerar en Get-Date cmdlet från PSSession i variabeln $S . Eftersom den aktuella sessionen innehåller en Get-Date cmdlet krävs parametern AllowClobber i kommandot .

Det andra kommandot använder parametern Alla i cmdleten Get-Command för att hämta alla Get-Date kommandon i den aktuella sessionen. Utdata visar att sessionen innehåller den ursprungliga Get-Date cmdleten och en Get-Date funktion. Funktionen Get-Date kör den importerade Get-Date cmdleten i PSSession i $S.

Det tredje kommandot kör ett Get-Date kommando. Eftersom funktioner har företräde framför cmdletar kör Windows PowerShell den importerade Get-Date funktionen, som returnerar ett Julian-datum.

De fjärde och femte kommandona visar hur du använder ett kvalificerat namn för att köra ett kommando som är dolt av ett importerat kommando.

Det fjärde kommandot hämtar namnet på snapin-modulen för Windows PowerShell som lade till den ursprungliga Get-Date cmdleten i den aktuella sessionen.

Det femte kommandot använder det snapin-in-qualified namnet på cmdleten Get-Date för att köra ett Get-Date kommando.

Mer information om kommandopriorence och dolda kommandon finns i about_Command_Precedence.

Exempel 8: Importera kommandon som har en specifik sträng i sina namn

PS C:\> Import-PSSession -Session $S -CommandName **Item** -AllowClobber

Det här kommandot importerar kommandon vars namn inkluderar Objekt från PSSession i $S. Eftersom kommandot innehåller parametern CommandName , men inte parametern FormatTypeData , importeras bara kommandot.

Använd det här kommandot när du använder Import-PSSession för att köra ett kommando på en fjärrdator och du redan har formateringsdata för kommandot i den aktuella sessionen.

Exempel 9: Använd modulparametern för att identifiera vilka kommandon som importerades till sessionen

PS C:\> $M = Import-PSSession -Session $S -CommandName *bits* -FormatTypeName *bits*
PS C:\> Get-Command -Module $M
CommandType     Name
-----------     ----
Function        Add-BitsFile
Function        Complete-BitsTransfer
Function        Get-BitsTransfer
Function        Remove-BitsTransfer
Function        Resume-BitsTransfer
Function        Set-BitsTransfer
Function        Start-BitsTransfer
Function        Suspend-BitsTransfer

Det här kommandot visar hur du använder modulparametern Get-Command för för att ta reda på vilka kommandon som importerades till sessionen med ett Import-PSSession kommando.

Det första kommandot använder cmdleten Import-PSSession för att importera kommandon vars namn innehåller "bitar" från PSSession i variabeln $S . Kommandot Import-PSSession returnerar en tillfällig modul och kommandot sparar modulen i variabeln $m .

Det andra kommandot använder cmdleten Get-Command för att hämta de kommandon som exporteras av modulen i variabeln $M .

Modulparametern tar ett strängvärde som är utformat för modulnamnet. Men när du skickar ett modulobjekt använder Windows PowerShell metoden ToString på modulobjektet, som returnerar modulnamnet.

Kommandot Get-Command motsvarar Get-Command $M.Name".

Parametrar

-AllowClobber

-ArgumentList

-Certificate

-CommandName

-CommandType

-DisableNameChecking

-FormatTypeName

-FullyQualifiedModule

-Module

-Prefix

-Session

Indata

None

Du kan inte skicka objekt till den här cmdleten.

Utdata

PSModuleInfo

Den här cmdleten returnerar samma modulobjekt som New-Module och Get-Module cmdletar returnerar. Den importerade modulen är dock tillfällig och finns bara i den aktuella sessionen. Om du vill skapa en permanent modul på disken använder du cmdleten Export-PSSession .

Kommentarer

• Import-PSSession förlitar sig på PowerShell-fjärrkommunikationsinfrastrukturen. Om du vill använda den här cmdleten måste datorn konfigureras för WS-Management-fjärrkommunikation. Mer information finns i about_Remote och about_Remote_Requirements.
• Import-PSSession importerar inte variabler eller PowerShell-leverantörer.
• När du importerar kommandon som har samma namn som kommandon i den aktuella sessionen kan de importerade kommandona dölja alias, funktioner och cmdletar i sessionen och de kan ersätta funktioner och variabler i sessionen. Om du vill förhindra namnkonflikter använder du parametern Prefix . Mer information finns i about_Command_Precedence.
• Import-PSSession konverterar alla kommandon till funktioner innan de importeras. Därför fungerar importerade kommandon lite annorlunda än de skulle göra om de behöll sin ursprungliga kommandotyp. Om du till exempel importerar en cmdlet från en PSSession och sedan importerar en cmdlet med samma namn från en modul eller snapin-modul, körs cmdleten som importeras från PSSession alltid som standard eftersom funktioner har företräde framför cmdletar. Om du importerar ett alias till en session som har ett alias med samma namn används alltid det ursprungliga aliaset eftersom alias har företräde framför funktioner. Mer information finns i about_Command_Precedence.
• Import-PSSession använder cmdleten Write-Progress för att visa förloppet för kommandot. Du kan se förloppsindikatorn medan kommandot körs.
• Om du vill hitta de kommandon som ska importeras Import-PSSession använder du cmdleten Invoke-Command för att köra ett Get-Command kommando i PSSession. För att hämta formateringsdata för kommandona använder den cmdleten Get-FormatData . Du kan se felmeddelanden från dessa cmdletar när du kör ett Import-PSSession kommando. Import-PSSession Det går inte heller att importera kommandon från en PSSession som inte innehåller Get-Commandcmdletarna , Get-FormatData, Select-Objectoch Get-Help .
• Importerade kommandon har samma begränsningar som andra fjärrkommandon, inklusive oförmåga att starta ett program med ett användargränssnitt, till exempel Anteckningar.
• Eftersom Windows PowerShell-profiler inte körs i PSSessioner är kommandona som en profil lägger till i en session inte tillgängliga för Import-PSSession. Om du vill importera kommandon från en profil använder du ett Invoke-Command kommando för att köra profilen i PSSession manuellt innan du importerar kommandon.
• Den temporära modulen som Import-PSSession skapar kan innehålla en formateringsfil, även om kommandot inte importerar formateringsdata. Om kommandot inte importerar formateringsdata innehåller formateringsfiler som skapas inte formateringsdata.
• Om du vill använda Import-PSSessionkan körningsprincipen i den aktuella sessionen inte vara Begränsad eller AllSigned, eftersom den tillfälliga modulen som Import-PSSession skapar innehåller osignerade skriptfiler som är förbjudna av dessa principer. Om du vill använda Import-PSSession utan att ändra körningsprincipen för den lokala datorn använder du parametern Set-ExecutionPolicy Omfång för för att ange en mindre restriktiv körningsprincip för en enda process.
• I Windows PowerShell 2.0 innehåller hjälpavsnitt för kommandon som importeras från en annan session inte prefixet som du tilldelar med hjälp av prefixparametern . Om du vill få hjälp med ett importerat kommando i Windows PowerShell 2.0 använder du det ursprungliga (icke-prefixerade) kommandonamnet.

Relaterade länkar

• Export-PSSession