Invoke-Command

Syntax

Invoke-Command
      [-StrictMode <Version>]
      [-ScriptBlock] <ScriptBlock>
      [-NoNewScope]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-Session] <PSSession[]>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-Session] <PSSession[]>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-ComputerName] <String[]>]
      [-Credential <PSCredential>]
      [-Port <Int32>]
      [-UseSSL]
      [-ConfigurationName <String>]
      [-ApplicationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-InDisconnectedSession]
      [-SessionName <String[]>]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-ComputerName] <String[]>]
      [-Credential <PSCredential>]
      [-Port <Int32>]
      [-UseSSL]
      [-ConfigurationName <String>]
      [-ApplicationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-InDisconnectedSession]
      [-SessionName <String[]>]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-CertificateThumbprint <String>]
      [<CommonParameters>]

Invoke-Command
      [-Credential <PSCredential>]
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [[-ConnectionUri] <Uri[]>]
      [-AsJob]
      [-InDisconnectedSession]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-AllowRedirection]
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-CertificateThumbprint <String>]
      [<CommonParameters>]

Invoke-Command
      [-Credential <PSCredential>]
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [[-ConnectionUri] <Uri[]>]
      [-AsJob]
      [-InDisconnectedSession]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-AllowRedirection]
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-ScriptBlock] <ScriptBlock>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-VMId] <Guid[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-ScriptBlock] <ScriptBlock>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -VMName <String[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-VMId] <Guid[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -VMName <String[]>
      [<CommonParameters>]

Invoke-Command
      [-Port <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      -HostName <String[]>
      [-UserName <String>]
      [-KeyFilePath <String>]
      [-Subsystem <String>]
      [-ConnectingTimeout <Int32>]
      [-SSHTransport]
      [-Options <Hashtable>]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-RunAsAdministrator]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -ContainerId <String[]>
      [<CommonParameters>]

Invoke-Command
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-RunAsAdministrator]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -ContainerId <String[]>
      [<CommonParameters>]

Invoke-Command
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      -SSHConnection <Hashtable[]>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      -HostName <String[]>
      [-UserName <String>]
      [-KeyFilePath <String>]
      [-Subsystem <String>]
      [-ConnectingTimeout <Int32>]
      [-SSHTransport]
      [-Options <Hashtable>]
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      -SSHConnection <Hashtable[]>
      [-RemoteDebug]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Description

Cmdleten Invoke-Command kör kommandon på en lokal dator eller fjärrdator och returnerar alla utdata från kommandona, inklusive fel. Med ett enda Invoke-Command kommando kan du köra kommandon på flera datorer.

Om du vill köra ett enda kommando på en fjärrdator använder du parametern ComputerName . Om du vill köra en serie relaterade kommandon som delar data använder du cmdleten New-PSSession för att skapa en PSSession (en beständig anslutning) på fjärrdatorn och använder sedan sessionsparametern Invoke-Command för för att köra kommandot i PSSession. Om du vill köra ett kommando i en frånkopplad session använder du parametern InDisconnectedSession . Om du vill köra ett kommando i ett bakgrundsjobb använder du parametern AsJob .

Du kan också använda Invoke-Command ett körningsskriptblock som ett kommando på en lokal dator. PowerShell kör skriptblocket omedelbart i ett underordnat omfång för det aktuella omfånget.

Läs about_Remote innan du använder Invoke-Command för att köra kommandon på en fjärrdator.

Från och med PowerShell 6.0 kan du använda Secure Shell (SSH) för att upprätta en anslutning till och anropa kommandon på fjärrdatorer. SSH måste vara installerat på den lokala datorn och fjärrdatorn måste konfigureras med en PowerShell SSH-slutpunkt. Fördelen med en SSH-baserad PowerShell-fjärrsession är att den fungerar på flera plattformar (Windows, Linux, macOS). För SSH-baserad session använder du parametrarna HostName eller SSHConnection för att ange fjärrdatorn och relevant anslutningsinformation. Mer information om hur du konfigurerar PowerShell SSH-fjärrkommunikation finns i PowerShell-fjärrkommunikation via SSH.

Vissa kodexempel använder splatting för att minska radlängden. Mer information finns i about_Splatting.

Exempel

Exempel 1: Kör ett skript på en server

Det här exemplet kör skriptet Test.ps1 på Server01-datorn.

Invoke-Command -FilePath c:\scripts\test.ps1 -ComputerName Server01

Parametern FilePath anger ett skript som finns på den lokala datorn. Skriptet körs på fjärrdatorn och resultatet returneras till den lokala datorn.

Exempel 2: Kör ett kommando på en fjärrserver

Det här exemplet kör ett Get-Culture kommando på server01-fjärrdatorn.

Invoke-Command -ComputerName Server01 -Credential Domain01\User01 -ScriptBlock {
    Get-Culture
}

Parametern ComputerName anger namnet på fjärrdatorn. Parametern Credential används för att köra kommandot i säkerhetskontexten för Domain01\User01, en användare som har behörighet att köra kommandon. Parametern ScriptBlock anger vilket kommando som ska köras på fjärrdatorn.

Som svar begär PowerShell lösenordet och en autentiseringsmetod för User01-kontot. Sedan körs kommandot på Server01-datorn och returnerar resultatet.

Exempel 3: Kör ett kommando i en beständig anslutning

I det här exemplet körs samma Get-Culture kommando i en session, med hjälp av en beständig anslutning, på fjärrdatorn med namnet Server02.

$s = New-PSSession -ComputerName Server02 -Credential Domain01\User01
Invoke-Command -Session $s -ScriptBlock { Get-Culture }

Cmdleten New-PSSession skapar en session på server02-fjärrdatorn och sparar den i variabeln $s . Vanligtvis skapar du bara en session när du kör en serie kommandon på fjärrdatorn.

Cmdleten Invoke-Command Get-Culture kör kommandot på Server02. Parametern Session anger den session som sparats i variabeln $s .

Som svar kör PowerShell kommandot i sessionen på Server02-datorn.

Exempel 4: Använd en session för att köra en serie kommandon som delar data

I det här exemplet jämförs effekterna av att använda parametrarna ComputerName och Session för Invoke-Command. Den visar hur du använder en session för att köra en serie kommandon som delar samma data.

Invoke-Command -ComputerName Server02 -ScriptBlock { $p = Get-Process PowerShell }
Invoke-Command -ComputerName Server02 -ScriptBlock { $p.VirtualMemorySize }
$s = New-PSSession -ComputerName Server02
Invoke-Command -Session $s -ScriptBlock { $p = Get-Process PowerShell }
Invoke-Command -Session $s -ScriptBlock { $p.VirtualMemorySize }

17930240

De två första kommandona använder parametern Invoke-Command ComputerName för för att köra kommandon på server02-fjärrdatorn. Det första kommandot använder cmdleten Get-Process för att hämta PowerShell-processen på fjärrdatorn och för att spara den i variabeln $p . Det andra kommandot hämtar värdet för egenskapen VirtualMemorySize för PowerShell-processen.

När du använder parametern ComputerName skapar PowerShell en ny session för att köra kommandot. Sessionen stängs när kommandot har slutförts. Variabeln $p skapades i en anslutning, men den finns inte i anslutningen som skapades för det andra kommandot.

Problemet löses genom att skapa en beständig session på fjärrdatorn och sedan köra båda kommandona i samma session.

Cmdleten New-PSSession skapar en beständig session på datorn Server02 och sparar sessionen i variabeln $s . Raderna Invoke-Command som följer använder parametern Session för att köra båda kommandona i samma session. Eftersom båda kommandona körs i samma session förblir $p värdet aktivt.

Exempel 5: Anropa ett kommando med ett skriptblock som lagras i en variabel

Det här exemplet visar hur du kör ett kommando som lagras som ett skriptblock i en variabel. När skriptblocket sparas i en variabel kan du ange variabeln som värdet för parametern ScriptBlock .

$command = {
    Get-WinEvent -LogName PowerShellCore/Operational |
      Where-Object -FilterScript { $_.Message -like '*certificate*' }
}
Invoke-Command -ComputerName S1, S2 -ScriptBlock $command

Variabeln $command lagrar kommandot Get-WinEvent som är formaterat som ett skriptblock. Invoke-Command Kör kommandot som lagras i $command på fjärrdatorerna S1 och S2.

Exempel 6: Kör ett enda kommando på flera datorer

Det här exemplet visar hur du använder Invoke-Command för att köra ett enda kommando på flera datorer.

$parameters = @{
  ComputerName      = 'Server01', 'Server02', 'TST-0143', 'localhost'
  ConfigurationName = 'MySession.PowerShell'
  ScriptBlock       = { Get-WinEvent -LogName PowerShellCore/Operational }
}
Invoke-Command @parameters

Parametern ComputerName anger en kommaavgränsad lista med datornamn. Listan över datorer innehåller värdet localhost, som representerar den lokala datorn. Parametern ConfigurationName anger en alternativ sessionskonfiguration. Parametern ScriptBlock körs Get-WinEvent för att hämta händelseloggarna PowerShellCore/Operational från varje dator.

Exempel 7: Hämta versionen av värdprogrammet på flera datorer

Det här exemplet hämtar versionen av PowerShell-värdprogrammet som körs på 200 fjärrdatorer.

$version = Invoke-Command -ComputerName (Get-Content Machines.txt) -ScriptBlock {
    (Get-Host).Version
}

Eftersom endast ett kommando körs behöver du inte skapa beständiga anslutningar till var och en av datorerna. I stället använder kommandot parametern ComputerName för att ange datorerna. För att ange datorerna använder den cmdleten Get-Content för att hämta innehållet i filen Machine.txt, en fil med datornamn.

Cmdleten Invoke-Command kör ett Get-Host kommando på fjärrdatorerna. Den använder punkt notation för att hämta egenskapen Version för PowerShell-värden.

Dessa kommandon körs en i taget. När kommandona har slutförts sparas utdata från kommandona från alla datorer i variabeln $version . Utdata innehåller namnet på den dator som data kommer från.

Exempel 8: Kör ett bakgrundsjobb på flera fjärrdatorer

Det här exemplet kör ett kommando på två fjärrdatorer. Kommandot Invoke-Command använder parametern AsJob så att kommandot körs som ett bakgrundsjobb. Kommandona körs på fjärrdatorerna, men jobbet finns på den lokala datorn. Resultaten överförs till den lokala datorn.

$s = New-PSSession -ComputerName Server01, Server02
Invoke-Command -Session $s -ScriptBlock { Get-EventLog system } -AsJob

Id   Name    State      HasMoreData   Location           Command
---  ----    -----      -----         -----------        ---------------
1    Job1    Running    True          Server01,Server02  Get-EventLog system

$j = Get-Job
$j | Format-List -Property *

HasMoreData   : True
StatusMessage :
Location      : Server01,Server02
Command       : Get-EventLog system
JobStateInfo  : Running
Finished      : System.Threading.ManualResetEvent
InstanceId    : e124bb59-8cb2-498b-a0d2-2e07d4e030ca
Id            : 1
Name          : Job1
ChildJobs     : {Job2, Job3}
Output        : {}
Error         : {}
Progress      : {}
Verbose       : {}
Debug         : {}
Warning       : {}
StateChanged  :

$results = $j | Receive-Job

Cmdleten New-PSSession skapar sessioner på fjärrdatorerna Server01 och Server02. Cmdleten Invoke-Command kör ett bakgrundsjobb i var och en av sessionerna. Kommandot använder parametern AsJob för att köra kommandot som ett bakgrundsjobb. Det här kommandot returnerar ett jobbobjekt som innehåller två underordnade jobbobjekt, ett för vart och ett av jobben som körs på de två fjärrdatorerna.

Kommandot Get-Job sparar jobbobjektet i variabeln $j . Variabeln $j skickas sedan till cmdleten Format-List för att visa alla egenskaper för jobbobjektet i en lista. Det sista kommandot hämtar resultatet av jobben. Det skickar jobbobjektet till $j cmdleten Receive-Job och lagrar resultatet i variabeln $results .

Exempel 9: Inkludera lokala variabler i en kommandokörning på en fjärrdator

Det här exemplet visar hur du inkluderar värdena för lokala variabler i en kommandokörning på en fjärrdator. Kommandot använder omfångsmodifieraren Using för att identifiera en lokal variabel i ett fjärrkommando. Som standard antas alla variabler definieras i fjärrsessionen. Omfångsmodifieraren Using introducerades i PowerShell 3.0. Mer information om omfångsmodifieraren Using finns i about_Remote_Variables och about_Scopes.

$Log = 'PowerShellCore/Operational'
Invoke-Command -ComputerName Server01 -ScriptBlock {
    Get-WinEvent -LogName $Using:Log -MaxEvents 10
}

Variabeln $Log lagrar namnet på händelseloggen, PowerShellCore/Operational. Cmdleten Invoke-Command körs Get-WinEvent på Server01 för att hämta de tio senaste händelserna från händelseloggen. Värdet för LogName-parametern är variabeln $Log som prefixeras av Using omfångsmodifieraren för att indikera att den skapades i den lokala sessionen, inte i fjärrsessionen.

Exempel 10: Dölj datornamnet

Det här exemplet visar effekten av att använda parametern HideComputerName för Invoke-Command. HideComputerName ändrar inte det objekt som den här cmdleten returnerar. Den ändrar bara visningen. Du kan fortfarande använda cmdletarna Format för att visa egenskapen PsComputerName för något av de berörda objekten.

Invoke-Command -ComputerName S1, S2 -ScriptBlock { Get-Process PowerShell }

PSComputerName    Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id   ProcessName
--------------    -------  ------    -----      ----- -----   ------     --   -----------
S1                575      15        45100      40988   200     4.68     1392 PowerShell
S2                777      14        35100      30988   150     3.68     67   PowerShell

Invoke-Command -ComputerName S1, S2 -HideComputerName -ScriptBlock {
    Get-Process PowerShell
}

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id   ProcessName
-------  ------    -----      ----- -----   ------     --   -----------
575      15        45100      40988   200     4.68     1392 PowerShell
777      14        35100      30988   150     3.68     67   PowerShell

De första två kommandona använder Invoke-Command för att köra ett Get-Process kommando för PowerShell-processen. Utdata från det första kommandot innehåller egenskapen PsComputerName , som innehåller namnet på den dator där kommandot kördes. Utdata från det andra kommandot, som använder HideComputerName, innehåller inte kolumnen PsComputerName .

Exempel 11: Använd nyckelordet Param i ett skriptblock

Nyckelordet Param och parametern ArgumentList används för att skicka variabelvärden till namngivna parametrar i ett skriptblock. I det här exemplet visas filnamn som börjar med bokstaven a och har .pdf tillägget.

Mer information om nyckelordet finns i Param about_Language_Keywords.

$parameters = @{
    ComputerName = 'Server01'
    ScriptBlock  = {
        Param ($param1, $param2)
        Get-ChildItem -Name $param1 -Include $param2
    }
    ArgumentList = 'a*', '*.pdf'
}
Invoke-Command @parameters

aa.pdf
ab.pdf
ac.pdf
az.pdf

Invoke-Command använder parametern ScriptBlock som definierar två variabler och $param1 $param2. Get-ChildItem använder de namngivna parametrarna, Namn och Inkludera med variabelnamnen. ArgumentList skickar värdena till variablerna.

Exempel 12: Använd den $args automatiska variabeln i ett skriptblock

Den $args automatiska variabeln och parametern ArgumentList används för att skicka matrisvärden till parameterpositioner i ett skriptblock. I det här exemplet visas en servers kataloginnehåll i .txt filer. Parametern Get-ChildItem Path är position 0 och filterparametern är position 1.

Mer information om variabeln finns i $args about_Automatic_Variables

$parameters = @{
    ComputerName = 'Server01'
    ScriptBlock  = { Get-ChildItem $args[0] $args[1] }
    ArgumentList = 'C:\Test', '*.txt*'
}
Invoke-Command @parameters

Directory: C:\Test

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---           6/12/2019    15:15            128 alog.txt
-a---           7/27/2019    15:16            256 blog.txt
-a---           9/28/2019    17:10             64 zlog.txt

Invoke-Command använder en ScriptBlock-parameter och Get-ChildItem anger matrisvärdena $args[0] och $args[1] . ArgumentList skickar $args matrisvärdena till parameterpositionerna Get-ChildItem för Sökväg och Filter.

Exempel 13: Kör ett skript på alla datorer som anges i en textfil

I det här exemplet används cmdleten Invoke-Command för att köra skriptet Sample.ps1 på alla datorer som anges i Servers.txt filen. Kommandot använder parametern FilePath för att ange skriptfilen. Med det här kommandot kan du köra skriptet på fjärrdatorerna, även om skriptfilen inte är tillgänglig för fjärrdatorerna.

$parameters = @{
    ComputerName = (Get-Content Servers.txt)
    FilePath     = 'C:\Scripts\Sample.ps1'
    ArgumentList = 'Process', 'Service'
}
Invoke-Command @parameters

När du skickar kommandot kopieras innehållet i Sample.ps1 filen till ett skriptblock och skriptblocket körs på var och en av fjärrdatorerna. Den här proceduren motsvarar att använda parametern ScriptBlock för att skicka innehållet i skriptet.

Exempel 14: Kör ett kommando på en fjärrdator med hjälp av en URI

Det här exemplet visar hur du kör ett kommando på en fjärrdator som identifieras av en URI (Uniform Resource Identifier). Det här exemplet kör ett Set-Mailbox kommando på en fjärransluten Exchange-server.

$LiveCred = Get-Credential
$parameters = @{
  ConfigurationName = 'Microsoft.Exchange'
  ConnectionUri     = 'https://ps.exchangelabs.com/PowerShell'
  Credential        = $LiveCred
  Authentication    = 'Basic'
  ScriptBlock       = { Set-Mailbox Dan -DisplayName 'Dan Park' }
}
Invoke-Command @parameters

Den första raden använder cmdleten Get-Credential för att lagra Windows Live ID-autentiseringsuppgifter i variabeln $LiveCred . PowerShell uppmanar användaren att ange autentiseringsuppgifter för Windows Live ID.

Variabeln $parameters är en hash-tabell som innehåller de parametrar som ska skickas till cmdleten Invoke-Command . Cmdleten Invoke-Command kör ett Set-Mailbox kommando med microsoft.Exchange-sessionskonfigurationen. Parametern ConnectionURI anger URL:en för Exchange-serverslutpunkten. Parametern Credential anger de autentiseringsuppgifter som lagras i variabeln $LiveCred . Parametern AuthenticationMechanism anger användningen av grundläggande autentisering. Parametern ScriptBlock anger ett skriptblock som innehåller kommandot.

Exempel 15: Använd ett sessionsalternativ

Det här exemplet visar hur du skapar och använder en SessionOption-parameter .

$so = New-PSSessionOption -SkipCACheck -SkipCNCheck -SkipRevocationCheck
$parameters = @{
    ComputerName  = 'server01'
    UseSSL        = $true
    ScriptBlock   = { Get-HotFix }
    SessionOption = $so
    Credential    = 'server01\user01'
}
Invoke-Command @parameters

Cmdleten New-PSSessionOption skapar ett sessionsalternativobjekt som gör att fjärrslutet inte verifierar certifikatutfärdare, kanoniskt namn och återkallningslistor när den inkommande HTTPS-anslutningen utvärderas. SessionOption-objektet sparas i variabeln$so.

Cmdleten Invoke-Command kör ett Get-HotFix kommando via fjärranslutning. Parametern SessionOption får variabeln $so .

Exempel 16: Hantera URI-omdirigering i ett fjärrkommando

Det här exemplet visar hur du använder parametrarna AllowRedirection och SessionOption för att hantera URI-omdirigering i ett fjärrkommando.

$max = New-PSSessionOption -MaximumRedirection 1
$parameters = @{
  ConnectionUri    = 'https://ps.exchangelabs.com/PowerShell'
  ScriptBlock      = { Get-Mailbox dan }
  AllowRedirection = $true
  SessionOption    = $max
}
Invoke-Command @parameters

Cmdleten New-PSSessionOption skapar ett PSSessionOption-objekt som sparas i variabeln $max . Kommandot använder parametern MaximumRedirection för att ange egenskapen MaximumConnectionRedirectionCount för PSSessionOption-objektet till 1.

Cmdleten Invoke-Command kör ett Get-Mailbox kommando på en fjärransluten Microsoft Exchange Server. Parametern AllowRedirection ger explicit behörighet att omdirigera anslutningen till en alternativ slutpunkt. Parametern SessionOption använder sessionsobjektet som lagras i variabeln $max .

Om fjärrdatorn som anges av ConnectionURI returnerar ett omdirigeringsmeddelande omdirigerar PowerShell anslutningen, men om det nya målet returnerar ett annat omdirigeringsmeddelande överskrids omdirigeringsvärdet 1 och Invoke-Command returnerar ett icke-avslutande fel.

Exempel 17: Få åtkomst till en nätverksresurs i en fjärrsession

Det här exemplet visar hur du kommer åt en nätverksresurs från en fjärrsession. Tre datorer används för att demonstrera exemplet. Server01 är den lokala datorn, Server02 är fjärrdatorn och Net03 innehåller nätverksresursen. Server01 ansluter till Server02 och sedan gör Server02 ett andra hopp till Net03 för att få åtkomst till nätverksresursen. Mer information om hur PowerShell-fjärrkommunikation stöder hopp mellan datorer finns i Göra det andra hoppet i PowerShell-fjärrkommunikation.

Den nödvändiga CredSSP-delegeringen (CredSSP) är aktiverad i klientinställningarna på den lokala datorn och i tjänstinställningarna på fjärrdatorn. Om du vill köra kommandona i det här exemplet måste du vara medlem i gruppen Administratörer på den lokala datorn och fjärrdatorn.

Enable-WSManCredSSP -Role Client -DelegateComputer Server02
$s = New-PSSession Server02
Invoke-Command -Session $s -ScriptBlock { Enable-WSManCredSSP -Role Server -Force }
$parameters = @{
  ComputerName   = 'Server02'
  ScriptBlock    = { Get-Item \\Net03\Scripts\LogFiles.ps1 }
  Authentication = 'CredSSP'
  Credential     = 'Domain01\Admin01'
}
Invoke-Command @parameters

Cmdleten Enable-WSManCredSSP aktiverar CredSSP-delegering från den lokala Server01-datorn till server02-fjärrdatorn. Parametern Roll anger Klienten för att konfigurera credSSP-klientinställningen på den lokala datorn.

New-PSSession skapar ett PSSession-objekt för Server02 och lagrar objektet i variabeln $s .

Cmdleten Invoke-Command använder variabeln $s för att ansluta till fjärrdatorn Server02. Parametern ScriptBlock körs Enable-WSManCredSSP på fjärrdatorn. Parametern Roll anger Server för att konfigurera credSSP-serverinställningen på fjärrdatorn.

Variabeln $parameters innehåller parametervärdena för att ansluta till nätverksresursen. Cmdleten Invoke-Command kör ett Get-Item kommando i sessionen i $s. Det här kommandot hämtar ett skript från nätverksresursen \\Net03\Scripts . Kommandot använder parametern Autentisering med värdet CredSSP och parametern Credential med värdet Domain01\Admin01.

Exempel 18: Starta skript på många fjärrdatorer

Det här exemplet kör ett skript på mer än hundra datorer. För att minimera påverkan på den lokala datorn ansluter den till varje dator, startar skriptet och kopplar sedan från varje dator. Skriptet fortsätter att köras i de frånkopplade sessionerna.

$parameters = @{
  ComputerName          = (Get-Content -Path C:\Test\Servers.txt)
  InDisconnectedSession = $true
  FilePath              = '\\Scripts\Public\ConfigInventory.ps1'
  SessionOption         = @{
      OutputBufferingMode = 'Drop'
      IdleTimeout         = [timespan]::FromHours(12)
  }
}
Invoke-Command @parameters

Kommandot använder Invoke-Command för att köra skriptet. Värdet för parametern ComputerName är ett Get-Content kommando som hämtar namnen på fjärrdatorerna från en textfil. Parametern InDisconnectedSession kopplar från sessionerna så snart kommandot startas. Värdet för Parametern FilePath är skriptet som Invoke-Command körs på varje dator.

Värdet för SessionOption är en hash-tabell. Värdet OutputBufferingMode är inställt på Drop och värdet IdleTimeout är inställt på 12 timmar.

Använd cmdleten Receive-PSSession för att hämta resultatet av kommandon och skript som körs i frånkopplade sessioner.

Exempel 19: Kör ett kommando på en fjärrdator med hjälp av SSH

Det här exemplet visar hur du kör ett kommando på en fjärrdator med secure shell (SSH). Om SSH har konfigurerats på fjärrdatorn för att fråga efter lösenord får du en lösenordsprompt. Annars måste du använda SSH-nyckelbaserad användarautentisering.

Invoke-Command -HostName UserA@LinuxServer01 -ScriptBlock { Get-MailBox * }

Exempel 20: Kör ett kommando på en fjärrdator med hjälp av SSH och ange en användarautentiseringsnyckel

Det här exemplet visar hur du kör ett kommando på en fjärrdator med hjälp av SSH och anger en nyckelfil för användarautentisering. Du uppmanas inte att ange ett lösenord om inte nyckelautentiseringen misslyckas och fjärrdatorn har konfigurerats för att tillåta grundläggande lösenordsautentisering.

$parameters = @{
    HostName    = 'UserA@LinuxServer01'
    ScriptBlock = { Get-MailBox * }
    KeyFilePath = '/UserA/UserAKey_rsa'
}
Invoke-Command

Exempel 21: Kör en skriptfil på flera fjärrdatorer med SSH som jobb

Det här exemplet visar hur du kör en skriptfil på flera fjärrdatorer med hjälp av SSH och parameteruppsättningen SSHConnection . Parametern SSHConnection tar en matris med hash-tabeller som innehåller anslutningsinformation för varje dator. Det här exemplet kräver att mål-fjärrdatorerna har SSH konfigurerat för att stödja nyckelbaserad användarautentisering.

$sshConnections = @(
    @{
        HostName    = "WinServer1"
        UserName    = "Domain\UserA"
        KeyFilePath = "C:\Users\UserA\id_rsa"
    }
    @{
        HostName    = "UserB@LinuxServer5"
        KeyFilePath = "/Users/UserB/id_rsa"
    }
)
$results = Invoke-Command -FilePath c:\Scripts\GetInfo.ps1 -SSHConnection $sshConnections

Exempel 22: Ansluta till en fjärr-SSH-session med SSH-alternativ

Det här exemplet visar hur du kör en skriptfil på en Linux-baserad fjärrdator med hjälp av SSH-alternativ. Parametern Alternativ tar en hashtabell med värden som skickas som alternativ till det underliggande ssh kommandot den etablerade anslutningen till fjärrsystemet.

$options = @{
    Port=22
    User = 'UserB'
    Host = 'LinuxServer5'
}
$results = Invoke-Command -FilePath c:\Scripts\CollectEvents.ps1 -KeyFilePath '/Users/UserB/id_rsa' -Options $options

Parametrar

-AllowRedirection

-ApplicationName

-ArgumentList

-AsJob

-Authentication

-CertificateThumbprint

-ComputerName

-ConfigurationName

-ConnectingTimeout

-ConnectionUri

-ContainerId

-Credential

-EnableNetworkAccess

-FilePath

-HideComputerName

-HostName

-InDisconnectedSession

-InputObject

-JobName

-KeyFilePath

-NoNewScope

-Options

-Port

-RemoteDebug

-RunAsAdministrator

-ScriptBlock

-Session

-SessionName

-SessionOption

-SSHConnection

-SSHTransport

-Subsystem

-ThrottleLimit

-UserName

-UseSSL

-VMId

-VMName

Indata

ScriptBlock

Du kan skicka ett kommando i ett skriptblock till Invoke-Command. Använd den $Input automatiska variabeln för att representera indataobjekten i kommandot.

Utdata

System.Management.Automation.PSRemotingJob

Om du använder parametern AsJob returnerar den här cmdleten ett jobbobjekt.

PSSession

Om du använder parametern InDisconnectedSession returnerar den här cmdleten ett PSSession-objekt .

Object

Som standard returnerar den här cmdleten utdata från det anropade kommandot, vilket är värdet för parametern ScriptBlock .

Kommentarer

PowerShell innehåller följande alias för Invoke-Command:

• Alla plattformar:
  • icm

Om du vill använda parametern Invoke-Command ComputerName för att köra ett kommando på den lokala datorn måste du köra PowerShell med alternativet Kör som administratör i Windows Vista och senare versioner av Windows-operativsystemet.

När du kör kommandon på flera datorer ansluter PowerShell till datorerna i den ordning de visas i listan. Kommandoutdata visas dock i den ordning som de tas emot från fjärrdatorerna, vilket kan vara annorlunda.

Fel som uppstår från kommandot som Invoke-Command körs ingår i kommandoresultatet. Fel som skulle avsluta fel i ett lokalt kommando behandlas som icke-avslutande fel i ett fjärrkommando. Den här strategin ser till att avslutande fel på en dator inte stänger kommandot på alla datorer där den körs. Den här metoden används även när ett fjärrkommando körs på en enda dator.

Om fjärrdatorn inte finns i en domän som den lokala datorn litar på kanske datorn inte kan autentisera användarens autentiseringsuppgifter. Om du vill lägga till fjärrdatorn i listan över betrodda värdar i WS-Management använder du följande kommando i providern WSMAN , där <Remote-Computer-Name> är namnet på fjärrdatorn:

Set-Item -Path WSMan:\Localhost\Client\TrustedHosts -Value \<Remote-Computer-Name\>

När du kopplar från en PSSession med parametern InDisconnectedSession kopplas sessionstillståndet från och tillgängligheten är Ingen. Värdet för egenskapen State är relativt till den aktuella sessionen. Värdet Frånkopplad innebär att PSSession inte är ansluten till den aktuella sessionen. Det betyder dock inte att PSSession är frånkopplad från alla sessioner. Den kan vara ansluten till en annan session. Om du vill avgöra om du kan ansluta eller återansluta till sessionen använder du egenskapen Tillgänglighet .

Ett tillgänglighetsvärde på Ingen anger att du kan ansluta till sessionen. Värdet Upptagen anger att du inte kan ansluta till PSSession eftersom den är ansluten till en annan session. Mer information om värdena för egenskapen State för sessioner finns i RunspaceState. Mer information om värdena för egenskapen Tillgänglighet för sessioner finns i RunspaceAvailability.

Parametrarna HostName och SSHConnection inkluderades från och med PowerShell 6.0. De lades till för att tillhandahålla PowerShell-fjärrkommunikation baserat på Secure Shell (SSH). PowerShell och SSH stöds på flera plattformar (Windows, Linux, macOS) och PowerShell-fjärrkommunikation fungerar på dessa plattformar där PowerShell och SSH installeras och konfigureras. Detta är separat från den tidigare Windows-fjärrkommunikationen som baseras på WinRM och många av WinRM-specifika funktioner och begränsningar gäller inte. Till exempel stöds inte WinRM-baserade kvoter, sessionsalternativ, anpassad slutpunktskonfiguration och funktioner för frånkoppling/återanslutning. Mer information om hur du konfigurerar PowerShell SSH-fjärrkommunikation finns i PowerShell-fjärrkommunikation via SSH.

Den ssh körbara filen hämtar konfigurationsdata från följande källor i följande ordning:

1. kommandoradsalternativ
2. användarens konfigurationsfil (~/.ssh/config)
3. systemomfattande konfigurationsfil (/etc/ssh/ssh_config)

Följande cmdlet-parametrar mappas till ssh parametrar och alternativ:

Cmdlet-parameter	ssh-parameter	motsvarande ssh -o-alternativ
-KeyFilePath	-i <KeyFilePath>	-o IdentityFile=<KeyFilePath>
-UserName	-l <UserName>	-o User=<UserName>
-Port	-p <Port>	-o Port=<Port>
-ComputerName -Subsystem	-s <ComputerName> <Subsystem>	-o Host=<ComputerName>

Alla värden som uttryckligen skickas av parametrar har företräde framför värden som skickas i hashtabellen Alternativ . Mer information om ssh_config filer finns i ssh_config(5).

Relaterade länkar

• about_PSSessions
• about_Remote
• about_Remote_Disconnected_Sessions
• about_Remote_Troubleshooting
• about_Remote_Variables
• about_Scopes
• Enter-PSSession
• Exit-PSSession
• Get-PSSession
• Invoke-Item
• New-PSSession
• Remove-PSSession
• WSMan-provider