Invoke-Command

Invoke-Command [-ScriptBlock] <scriptblock> [[-ComputerName] <string[]>] [-ApplicationName <string>] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-CertificateThumbprint <string>] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-Port <int>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-UseSSL] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-FilePath] <string> [[-ComputerName] <string[]>] [-ApplicationName <string>] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-Port <int>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-UseSSL] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-FilePath] <string> [[-Session] <PSSession[]>] [-AsJob] [-HideComputerName] [-JobName <string>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-FilePath] <string> [[-ConnectionURI] <Uri[]>] [-AllowRedirection] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-ScriptBlock] <scriptblock> [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-ScriptBlock] <scriptblock> [[-Session] <PSSession[]>] [-AsJob] [-HideComputerName] [-JobName <string>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-ScriptBlock] <scriptblock> [[-ConnectionURI] <Uri[]>] [-AllowRedirection] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-CertificateThumbprint <string>] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

C:\PS>invoke-command -filepath c:\scripts\test.ps1 -computerName Server01

Disks: C:, D:, E:
Status: Warning, Normal, Normal

Beschreibung
-----------
Mit diesem Befehl wird das Skript "Test.ps1" auf dem Computer "Server01" ausgeführt. 

Der Befehl gibt mithilfe des FilePath-Parameters ein Skript an, das sich auf dem lokalen Computer befindet. Das Skript wird auf dem Remotecomputer ausgeführt, und die Ergebnisse werden an den lokalen Computer zurückgegeben.

C:\PS>invoke-command -computername server01 -credential domain01\user01 -scriptblock {get-culture}

Beschreibung
-----------
Mit diesem Befehl wird der Befehl "Get-Culture" auf dem Remotecomputer "Server01" ausgeführt. 

Dabei wird der Name des Computers mit dem ComputerName-Parameter angegeben, und mit dem Credential-Parameter wird der Befehl im Sicherheitskontext von "Domain01\User01" ausgeführt, einem Benutzer mit der Berechtigung zur Ausführung von Befehlen. Der ScriptBlock-Parameter wird zur Angabe des Befehls verwendet, der auf dem Remotecomputer ausgeführt werden soll.

Daraufhin wird ein Dialogfeld von Windows PowerShell angezeigt, das zur Angabe des Kennworts sowie einer Authentifizierungsmethode für das Konto "User01" auffordert. Anschließend wird der Befehl auf dem Computer "Server01" ausgeführt und das Ergebnis zurückgegeben.

C:\PS>$s = new-pssession -computername server02 -credential domain01\user01

C:\PS> invoke-command -session $s -scriptblock {get-culture}

Beschreibung
-----------
In diesem Beispiel wird der gleiche Befehl "Get-Culture" in einer Sitzung (einer dauerhaften Verbindung) auf dem Remotecomputer "Server02" ausgeführt. Sitzungen werden normalerweise nur dann erstellt, wenn eine Reihe von Befehlen auf dem Remotecomputer ausgeführt wird.

Im ersten Befehl wird mit dem Cmdlet "New-PSSession" eine Sitzung auf dem Remotecomputer "Server02"erstellt. Anschließend wird die Sitzung in der Variablen "$s" gespeichert.

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" der Befehl "Get-Culture" auf dem Computer "Server02" ausgeführt. Mit dem Session-Parameter wird die Sitzung angegeben, die in der Variablen "$s" gespeichert wurde. 

Der Befehl wird daraufhin von Windows PowerShell in der Sitzung auf dem Computer "Server02" ausgeführt.

C:\PS>invoke-command -computername Server02 -scriptblock {$p = get-process powershell}

C:\PS> invoke-command -computername Server02 -scriptblock {$p.virtualmemorysize}
C:\PS>

C:\PS> $s = new-pssession -computername Server02
C:\PS> invoke-command -session $s -scriptblock {$p = get-process powershell}
C:\PS> invoke-command -session $s -scriptblock {$p.virtualmemorysize}
17930240

Beschreibung
-----------
In diesem Beispiel werden die Auswirkungen der Verwendung des ComputerName-Parameters und des Session-Parameters von Invoke-Command verglichen. Es wird gezeigt, wie mit einer Sitzung eine Reihe von Befehlen mit gemeinsamen Daten ausgeführt wird.

In den ersten beiden Befehle wird der ComputerName-Parameter von Invoke-Command zur Ausführung von Befehlen auf dem Remotecomputer "Server02" verwendet. Im ersten Befehl wird der PowerShell-Prozess auf dem Remotecomputer mit dem Befehl "Get-Process" abgerufen und in der Variablen "$p" gespeichert. Im zweiten Befehl wird der Wert der VirtualMemorySize-Eigenschaft des PowerShell-Prozesses abgerufen. 

Der erste Befehl ist erfolgreich. Beim zweiten Befehl tritt jedoch ein Fehler auf, weil Windows PowerShell bei Verwendung des ComputerName-Parameters eine Verbindung ausschließlich zur Ausführung des Befehls herstellt. Sobald der Befehl abgeschlossen ist, wird die Verbindung anschließend geschlossen. Die Variable "$p" wurde zwar in einer Verbindung erstellt, sie ist jedoch nicht in der Verbindung vorhanden, die für den zweiten Befehl erstellt wurde.

Das Problem wird durch Erstellen einer Sitzung (einer dauerhaften Verbindung) auf dem Remotecomputer und Ausführen der beiden verwandten Befehle in der gleichen Sitzung gelöst.

Im dritten Befehl wird mit dem Cmdlet "New-PSSession" eine Sitzung auf dem Computer "Server02" erstellt. Anschließend wird die Sitzung in der Variablen "$s" gespeichert. Im vierten und fünften Befehl wird die Reihe der Befehle aus dem ersten Satz wiederholt, allerdings werden die beiden Befehle hier vom Befehl "Invoke-Command" mit dem Session-Parameter in der gleichen Sitzung ausgeführt. 

Nun sind die Befehle erfolgreich, da beide Befehle in der gleichen Sitzung ausgeführt werden, und der Wert "$p" bleibt in der Sitzung "$s" zur weiteren Verwendung aktiv.

C:\PS>$command = { get-eventlog -log "windows powershell" | where {$_.message -like "*certificate*"} }

C:\PS> invoke-command -computername S1, S2 -scriptblock $command

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie ein Befehl eingegeben wird, der in einer lokalen Variablen gespeichert wird. 

Wenn der gesamte Befehl in einer lokalen Variablen gespeichert wird, können Sie die Variable als Wert des ScriptBlock-Parameters angeben. Es ist nicht erforderlich, den Wert der lokalen Variablen mit dem Schlüsselwort "param" oder der Variablen "ArgumentList" zu senden.

Im ersten Befehl wird ein Get-Eventlog-Befehl in der Variablen "$command" gespeichert. Der Befehl wird als Skriptblock formatiert.

Im zweiten Befehl wird der Befehl mit dem Cmdlet "Invoke-Command" in "$command" auf dem Remotecomputer "S1" und dem Remotecomputer "S2" ausgeführt.

C:\PS>invoke-command -computername server01, server02, TST-0143, localhost -configurationname MySession.PowerShell -scriptblock {get-eventlog "windows powershell"}

Beschreibung
-----------
In diesem Beispiel wird veranschaulicht, wie mit dem Cmdlet "Invoke-Command" ein Befehl auf mehreren Computern ausgeführt wird. 

Im Befehl werden die Computer mit dem ComputerName-Parameter angegeben. Die Computernamen werden in einer durch Trennzeichen getrennten Liste dargestellt. Die Liste der Computer enthält den Wert "localhost", der den lokalen Computer darstellt.

Im Befehl wird mit dem ConfigurationName-Parameter eine alternative Sitzungskonfiguration für Windows PowerShell angegeben, und mit dem ScriptBlock-Parameter wird der Befehl angegeben.

In diesem Beispiel werden die Ereignisse im Windows PowerShell-Ereignisprotokoll mit dem Befehl im Skriptblock für die einzelnen Remotecomputer abgerufen.

C:\PS>$version = invoke-command -computername (get-content machines.txt) -scriptblock {(get-host).version}

Beschreibung
-----------
Mit diesem Befehl wird die Version des Windows PowerShell-Hosts abgerufen, die auf 200 Remotecomputern ausgeführt wird. 

Da nur ein Befehl ausgeführt wird, ist es nicht notwendig, dauerhafte Verbindungen (Sitzungen) für jeden Computer zu erstellen. Stattdessen gibt der Befehl die Computer mit dem ComputerName-Parameter an.

Im Befehl wird mit dem Cmdlet "Invoke-Command" ein Get-Host-Befehl ausgeführt. Mit der punktierten Notation wird die Version-Eigenschaft des Windows PowerShell-Hosts abgerufen.

Um die Computer anzugeben, wird mit dem Cmdlet "Get-Content" der Inhalt der Datei "Machine.txt" mit Computernamen abgerufen.

Diese Befehle werden synchron (einzeln) ausgeführt. Wenn die Ausführung der Befehle abgeschlossen wurde, wird die Ausgabe der Befehle von allen Computern in der Variablen "$version" gespeichert. Die Ausgabe enthält den Namen des Computers, von dem die Daten stammen.

C:\PS>$s = new-pssession -computername Server01, Server02

C:\PS> invoke-command -session $s -scriptblock {get-eventlog system} -AsJob

Id   Name    State      HasMoreData   Location           Command
---  ----    -----      -----         -----------        --------             -------
1    Job1    Running    True          Server01,Server02  get-eventlog system


C:\PS> $j = Get-Job

C:\PS> $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  :

C:\PS> $results = $j | Receive-Job

Beschreibung
-----------
Mit diesen Befehlen wird ein Hintergrundauftrag auf zwei Remotecomputern ausgeführt. Da der Invoke-Command-Befehl den AsJob-Parameter verwendet, werden die Befehle auf den Remotecomputern ausgeführt, der Auftrag befindet sich jedoch auf dem lokalen Computer, und die Ergebnisse werden an den lokalen Computer übermittelt.

Im ersten Befehl werden mit dem Cmdlet "New-PSSession" Sitzungen auf dem Remotecomputer "Server01" sowie auf dem Remotecomputer "Server02" erstellt.

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" ein Hintergrundauftrag in der jeweiligen Sitzung ausgeführt. Bei dem Befehl wird der Befehl mithilfe des AsJob-Parameters als Hintergrundauftrag ausgeführt. Dieser Befehl gibt ein Auftragsobjekt mit zwei untergeordneten Auftragsobjekten zurück, eines für jeden Auftrag, der auf den beiden Remotecomputern ausgeführt wurde.

Im dritten Befehl wird das Auftragsobjekt mit einem Get-Job-Befehl in der Variablen "$j" gespeichert. 

Der vierte Befehl sendet den Wert der Variablen "$j" mithilfe eines Pipelineoperators (|) an das Cmdlet "Format-List", das alle Eigenschaften des Auftragsobjekts in einer Liste anzeigt.

Im fünften Befehl werden die Ergebnisse der Aufträge abgerufen. Das Auftragsobjekt wird in "$j" über die Pipeline an das Cmdlet "Receive-Job" übergeben, und die Ergebnisse werden in der Variablen "$results" gespeichert.

C:\PS>$MWFO-LOg = Microsoft-Windows-Forwarding/Operational

C:\PS> invoke-command -computername server01 -scriptblock {param($log, $num) get-eventlog -logname $log -newest $num} -ArgumentList $MWFO-log, 10

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie die Werte von lokalen Variablen in einem Befehl auf einem Remotecomputer eingeschlossen werden.

Im ersten Befehl wird der Name des Microsoft Windows-Forwarding/Operational-Ereignisprotokolls in der Protokollvariablen "$MWFO" gespeichert.

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" der Befehl "Get-EventLog" auf dem Remotecomputer "Server01" ausgeführt, um die 10 aktuellsten Ereignisse aus dem Microsoft Windows-Forwarding/Operational-Ereignisprotokoll abzurufen.

Dieser Befehl erstellt die Variablen "$log" und "$num" mit dem Schlüsselwort "param", die im Befehl "Get-EventLog" als Platzhalter verwendet werden. Diese Platzhalter haben beliebige Namen, die nicht zu den Namen der lokalen Variablen passen müssen, mit denen die Werte angeben werden.

Die Werte des ArgumentList-Parameters veranschaulichen die beiden unterschiedlichen Möglichkeiten zur Angabe von Werten in der Argumentliste. Die Variable "$MFWO" wird im ersten Befehl definiert und stellt den Wert des Platzhalters "$log" dar. Der Wert der Variablen "$num" beträgt 10.

Bevor der Befehl an den Remotecomputer gesendet wird, werden die Variablen durch die angegebenen Werte ersetzt.

C:\PS>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


C:\PS> invoke-command -computername S1, S2 -scriptblock {get-process powershell} -HideComputerName

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

Beschreibung
-----------
In diesem Beispiel wird die Verwendung des HideComputerName-Parameters von Invoke-Command veranschaulicht. 

In den ersten beiden Befehlen wird mit dem Cmdlet "Invoke-Command" ein Get-Process-Befehl für den PowerShell-Prozess ausgeführt. Die Ausgabe des ersten Befehls enthält die PsComputerName-Eigenschaft mit dem Namen des Computers, auf dem der Befehl ausgeführt wurde. Die Ausgabe des zweiten Befehls, in dem der HideComputerName-Parameter verwendet wird, enthält nicht die Spalte "PsComputerName".

Das Objekt wird durch den HideComputerName-Parameter nicht verändert. Sie können die PsComputerName-Eigenschaft eines beliebigen betroffenen Objekts auch weiterhin mit den Format-Cmdlets anzeigen.

C:\PS>invoke-command -comp (get-content servers.txt) -filepath c:\scripts\sample.ps1 -argumentlist Process, Service

Beschreibung
-----------
In diesem Beispiel wird das Skript "Sample.ps1" mit dem Cmdlet "Invoke-Command" auf allen Computern ausgeführt, die in der Datei "Servers.txt" aufgeführt sind. Im Befehl wird die Skriptdatei mit dem FilePath-Parameter angegeben. Mit diesem Befehl können Sie das Skript auf den Remotecomputern ausführen, auch wenn die Skriptdatei nicht über die Remotecomputer zugreifbar ist.

Wenn Sie den Befehl senden, wird der Inhalt der Datei "Sample.ps1" in einen Skriptblock kopiert, und der Skriptblock wird auf jedem Remotecomputer ausgeführt. Dieses Verfahren entspricht dem Senden des Skriptinhalts mit dem ScriptBlock-Parameter.

C:\PS>$LiveCred = Get-Credential

C:\PS> Invoke-Command -ConfigurationName Microsoft.Exchange `
         -ConnectionUri https://ps.exchangelabs.com/powershell `
         -Credential $LiveCred  -Authentication Basic `
         -scriptblock {Invoke-Command {Set-Mailbox dan -DisplayName "Dan Park"}

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie ein Befehl auf einem Remotecomputer ausgeführt wird, der von einem URI (Internetadresse) identifiziert wird. In diesem konkreten Beispiel wird der Befehl "Set-Mailbox" auf einem Exchange-Remoteserver ausgeführt. Das Graviszeichen (`) im Befehl ist das Zeilenfortsetzungszeichen von Windows PowerShell.

Der erste Befehl verwendet das Cmdlet "Get-Credential", um die Windows Live ID-Anmeldeinformationen in der Variablen "$LiveCred" zu speichern. Geben Sie die Anmeldeinformationen für die Windows Live ID ein, wenn das entsprechende Dialogfeld angezeigt wird.

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" der Befehl "Set-Mailbox" ausgeführt. Im Befehl wird mit dem ConfigurationName-Parameter angegeben, dass der Befehl in einer Sitzung ausgeführt werden soll, die die Microsoft.Exchange-Sitzungskonfiguration verwendet. Der ConnectionURI-Parameter gibt die URL des Exchange-Server-Endpunkts an. 

Der Credential-Parameter gibt die in der Variablen "$LiveCred" gespeicherten Anmeldeinformationen für die Windows Live ID an. Der AuthenticationMechanism-Parameter gibt die Verwendung der Standardauthentifizierung an. Mit dem ScriptBlock-Parameter wird ein Skriptblock angegeben, der den Befehl enthält.

C:\PS>$max = New-PSSessionOption -MaximumRedirection 1

C:\PS> Invoke-Command -ConnectionUri https://ps.exchangelabs.com/powershell `
         -scriptblock {Invoke-Command {Get-Mailbox dan} `
         -AllowRedirection -SessionOption $max

Beschreibung
-----------
Dieser Befehl verdeutlicht, wie der AllowRedirection-Parameter und der SessionOption-Parameter verwendet werden, um die URI-Umleitung in einem Remotebefehl zu verwalten.

Der erste Befehl verwendet das Cmdlet "New-PSSessionOption", um ein PSSessionOpption-Objekt zu erstellen, das in der Variablen "$max" gespeichert wird. Der Befehl legt die MaximumConnectionRedirectionCount-Eigenschaft des PSSessionOption-Objekts mithilfe des MaximumRedirection-Parameters auf 1 fest. 

Im zweiten Befehl wird der Befehl "Get-Mailbox" mit dem Cmdlet "Invoke-Command" auf einem Remoteserver unter Microsoft Exchange Server ausgeführt. Der Befehl stellt die explizite Berechtigung zum Umleiten der Verbindung an einen alternativen Endpunkt mit dem AllowRedirection-Parameter bereit. Er verwendet außerdem den SessionOption-Parameter, um das Sitzungsobjekt in der Variablen "$max" anzugeben.

Wenn der vom ConnectionURI-Parameter angegebene Remotecomputer eine Umleitungsmeldung zurückgibt, wird die Verbindung von Windows PowerShell daraufhin umgeleitet. Wenn das neue Ziel jedoch erneut eine Umleitungsmeldung zurückgibt, wird der Anzahlwert für die Umleitung von 1 überschritten, und von Invoke-Command wird ein Fehler ohne Abbruch zurückgegeben.

C:\PS>$so = New-PSSessionOption -SkipCACheck

PS C:\> invoke-command $s { get-hotfix } -SessionOption $so -credential server01\user01

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie ein SessionOption-Parameter erstellt und verwendet wird. 

Im ersten Befehl wird mit dem Cmdlet "New-PSSessionOption" eine Sitzungsoption erstellt. Das resultierende SessionOption-Objekt wird im $so-Parameter gespeichert.

Im zweiten Befehl wird der Befehl "Get-Hotfix" mit dem Cmdlet "Invoke-Command" remote ausgeführt. Der Wert des SessionOption-Parameters entspricht dem SessionOption-Objekt in der Variablen "$so".

C:\PS>enable-wsmanCredSSP -delegate server02

C:\PS> connect-wsman Server02

C:\PS> set-item wsman:\server02*\service\auth\credSSP -value $true

C:\PS> $s = new-pssession server02

C:\PS> invoke-command -session $s -script {get-item \\Net03\Scripts\LogFiles.ps1} -authentication credssp -credential domain01\admin01

Beschreibung
-----------
In diesem Beispiel wird veranschaulicht, wie von einer Remotesitzung aus auf eine Netzwerkfreigabe zugegriffen wird. 

Der Befehl erfordert, dass CredSSP-Delegierung in den Clienteinstellungen auf dem lokalen Computer und in den Diensteinstellungen auf dem Remotecomputer aktiviert wird. Um die Befehle in diesem Beispiel auszuführen, müssen Sie Mitglied der Gruppe "Administratoren" auf dem lokalen Computer und dem Remotecomputer sein.

Der erste Befehl verwendet das Cmdlet "Enable-WSManCredSSP", um die CredSSP-Delegierung vom lokalen Computer "Server01" an den Remotecomputer "Server02" zu aktivieren. Dadurch wird die CredSSP-Clienteinstellung auf dem lokalen Computer konfiguriert.

Der zweite Befehl verwendet das Cmdlet "Connect-WSman", um eine Verbindung mit dem Computer "Server02" herzustellen. Durch diese Aktion wird dem Laufwerk "WSMan:" auf dem lokalen Computer ein Knoten für Computer "Server02" hinzugefügt. So können die Einstellungen für die WS-Verwaltung auf dem Computer "Server02" angezeigt und geändert werden.

Der dritte Befehl verwendet das Cmdlet "Set-Item", um den Wert des CredSSP-Elements im Service-Knoten von Computer "Server02" in "True" zu ändern. Durch diese Aktion wird CredSSP in den Diensteinstellungen auf dem Remotecomputer aktiviert.

Der vierte Befehl verwendet das Cmdlet "New-PSSession" zum Erstellen einer PSSession auf dem Computer "Server02". Die PSSession wird in der Variablen "$s" gespeichert.

Der fünfte Befehl verwendet das Cmdlet "Invoke-Command", um einen Get-Item-Befehl in der Sitzung in "$s" auszuführen, der ein Skript aus der Netzwerkfreigabe "Net03\Scripts" abruft. Der Befehl verwendet den Credential-Parameter sowie den Authentication-Parameter mit dem Wert "CredSSP".