about_Remote_Jobs

Artikel
10/04/2023

Kurze Beschreibung

Beschreibt, wie Aufträge auf Remotecomputern ausgeführt werden.

Detaillierte Beschreibung

PowerShell führt Befehle und Skripts gleichzeitig über Aufträge aus. Es gibt drei Auftragstypen, die von PowerShell bereitgestellt werden, um Parallelität zu unterstützen.

RemoteJob – Befehle und Skripts werden in einer Remotesitzung ausgeführt.
BackgroundJob – Befehle und Skripts werden in einem separaten Prozess auf dem lokalen Computer ausgeführt. Weitere Informationen finden Sie unter about_Jobs.
PSTaskJob oder ThreadJob - Befehle und Skripts werden in einem separaten Thread innerhalb desselben Prozesses auf dem lokalen Computer ausgeführt. Weitere Informationen finden Sie unter about_Thread_Jobs.

Das Remote ausführen von Skripts auf einem separaten Computer oder in einem separaten Prozess bietet eine hervorragende Isolierung. Alle Fehler, die im Remoteauftrag auftreten, wirken sich nicht auf andere ausgeführte Aufträge oder die übergeordnete Sitzung aus, die den Auftrag gestartet hat. Die Remotingschicht erhöht jedoch den Aufwand, einschließlich objekt serialisieren. Alle Objekte werden serialisiert und deserialisiert, während sie zwischen der übergeordneten Sitzung und der Remotesitzung (Auftrag) übergeben werden. Die Serialisierung großer komplexer Datenobjekte kann große Mengen an Rechen- und Speicherressourcen verbrauchen und große Datenmengen über das Netzwerk übertragen.

Wichtig

Die übergeordnete Sitzung, die den Auftrag erstellt hat, überwacht auch den Auftragsstatus und sammelt Pipelinedaten. Der untergeordnete Auftragsvorgang wird vom übergeordneten Prozess beendet, sobald der Auftrag einen abgeschlossenen Zustand erreicht hat. Wenn die übergeordnete Sitzung beendet wird, werden alle ausgeführten untergeordneten Aufträge zusammen mit ihren untergeordneten Prozessen beendet.

Es gibt zwei Möglichkeiten, diese Situation zu umgehen:

Dient Invoke-Command zum Erstellen von Aufträgen, die in getrennten Sitzungen ausgeführt werden. Weitere Informationen finden Sie im Abschnitt "Getrennte Prozesse " in diesem Artikel.
Wird Start-Process verwendet, um einen neuen Prozess anstelle eines Auftrags zu erstellen. Weitere Informationen finden Sie unter Start-Process.

Remoteaufträge

Sie können Aufträge auf Remotecomputern mit drei verschiedenen Methoden ausführen.

Starten Sie eine interaktive Sitzung auf einem Remotecomputer. Starten Sie dann einen Auftrag in der interaktiven Sitzung. Die Prozeduren sind identisch mit dem Ausführen eines lokalen Auftrags, obwohl alle Aktionen auf dem Remotecomputer ausgeführt werden.
Führen Sie einen Auftrag auf einem Remotecomputer aus, der die Ergebnisse an den lokalen Computer zurückgibt. Verwenden Sie diese Methode, wenn Sie die Ergebnisse von Aufträgen erfassen und an einem zentralen Ort auf dem lokalen Computer verwalten möchten.
Führen Sie einen Auftrag auf einem Remotecomputer aus, der seine Ergebnisse auf dem Remotecomputer verwaltet. Verwenden Sie diese Methode, wenn die Auftragsdaten auf dem ursprünglichen Computer sicherer verwaltet werden.

Starten eines Auftrags in einer interaktiven Sitzung

Sie können eine interaktive Sitzung mit einem Remotecomputer starten und dann während der interaktiven Sitzung einen Auftrag starten. Weitere Informationen zu interaktiven Sitzungen finden Sie unter about_Remote und siehe Enter-PSSession.

Das Verfahren zum Starten eines Auftrags in einer interaktiven Sitzung ist fast identisch mit dem Verfahren zum Starten eines Hintergrundauftrags auf dem lokalen Computer. Alle Vorgänge erfolgen jedoch auf dem Remotecomputer, nicht auf dem lokalen Computer.

Verwenden Sie das Enter-PSSession Cmdlet, um eine interaktive Sitzung mit einem Remotecomputer zu starten. Sie können den ComputerName-Parameter Enter-PSSession verwenden, um eine temporäre Verbindung für die interaktive Sitzung herzustellen. Sie können auch den Parameter Session verwenden, um die interaktive Sitzung in einer PowerShell-Sitzung (PSSession) auszuführen.

Der folgende Befehl startet eine interaktive Sitzung auf dem Server01-Computer.
```
C:\PS> Enter-PSSession -computername Server01
```
Die Eingabeaufforderung ändert sich, um anzuzeigen, dass Sie jetzt mit dem Server01-Computer verbunden sind.
```
Server01\C:>
```
Verwenden Sie das Start-Job Cmdlet, um einen Remoteauftrag in der Sitzung zu starten. Der folgende Befehl führt einen Remoteauftrag aus, der die Ereignisse im Windows PowerShell-Ereignisprotokoll auf dem Server01-Computer abruft. Das Start-Job Cmdlet gibt ein Objekt zurück, das den Auftrag darstellt.

Mit diesem Befehl wird das Auftragsobjekt in der $job Variablen gespeichert.
```
Server01\C:> $job = Start-Job -scriptblock {
  Get-Eventlog "Windows PowerShell"
}
```
Während der Auftrag ausgeführt wird, können Sie die interaktive Sitzung verwenden, um andere Befehle auszuführen, einschließlich anderer Aufträge. Sie müssen die interaktive Sitzung jedoch so lange geöffnet lassen, bis der Auftrag abgeschlossen ist. Wenn Sie die Sitzung beenden, wird der Auftrag unterbrochen, und die Ergebnisse gehen verloren.
Um herauszufinden, ob der Auftrag abgeschlossen ist, zeigen Sie den Wert der $job Variablen an, oder verwenden Sie das Get-Job Cmdlet, um den Auftrag abzurufen. Der folgende Befehl verwendet das Get-Job Cmdlet, um den Auftrag anzuzeigen.
```
Server01\C:> Get-Job $job

SessionId  Name  State      HasMoreData  Location   Command
---------  ----  -----      -----------  --------   -------
1          Job1  Complete   True         localhost  Get-Eventlog "Windows...
```
Die Get-Job Ausgabe zeigt an, dass der Auftrag auf dem Computer "localhost" ausgeführt wird, da der Auftrag auf demselben Computer gestartet wurde und ausgeführt wird (in diesem Fall Server01).
Verwenden Sie das Receive-Job Cmdlet, um die Ergebnisse des Auftrags abzurufen. Sie können die Ergebnisse in der interaktiven Sitzung anzeigen oder in einer Datei auf dem Remotecomputer speichern. Der folgende Befehl ruft die Ergebnisse des Auftrags in der variablen $job ab. Der Befehl verwendet den Umleitungsoperator (>), um die Ergebnisse des Auftrags in der datei PsLog.txt auf dem Server01-Computer zu speichern.
```
Server01\C:> Receive-Job $job > c:\logs\PsLog.txt
```
Verwenden Sie das Exit-PSSession Cmdlet, um die interaktive Sitzung zu beenden. Die Eingabeaufforderung ändert sich, um anzuzeigen, dass Sie sich wieder in der ursprünglichen Sitzung auf dem lokalen Computer befinden.
```
Server01\C:> Exit-PSSession
C:\PS>
```
Um den Inhalt der PsLog.txt Datei auf dem Server01-Computer jederzeit anzuzeigen, starten Sie eine andere interaktive Sitzung, oder führen Sie einen Remotebefehl aus. Dieser Befehlstyp wird am besten in einer PSSession (einer persistenten Verbindung) ausgeführt, falls Sie mehrere Befehle verwenden möchten, um die Daten in der PsLog.txt Datei zu untersuchen und zu verwalten. Weitere Informationen zu PSSessions finden Sie unter about_PSSessions.

Die folgenden Befehle verwenden das New-PSSession Cmdlet, um eine PSSession zu erstellen, die mit dem Server01-Computer verbunden ist, und sie verwenden das Invoke-Command Cmdlet, um einen Get-Content Befehl in der PSSession auszuführen, um den Inhalt der Datei anzuzeigen.
```
$s = New-PSSession -computername Server01
Invoke-Command -session $s -scriptblock {
  Get-Content c:\logs\pslog.txt}
```

Starten eines Remoteauftrags, der die Ergebnisse an den lokalen Computer (AsJob) zurückgibt

Um einen Auftrag auf einem Remotecomputer zu starten, der die Befehlsergebnisse an den lokalen Computer zurückgibt, verwenden Sie den AsJob-Parameter eines Cmdlets, z. B. das Invoke-Command Cmdlet.

Wenn Sie den AsJob-Parameter verwenden, wird das Auftragsobjekt tatsächlich auf dem lokalen Computer erstellt, obwohl der Auftrag auf dem Remotecomputer ausgeführt wird. Nach Abschluss des Auftrags werden die Ergebnisse an den lokalen Computer zurückgegeben.

Sie können die Cmdlets verwenden, die das Substantiv "Auftrag" (die Cmdlets "Auftrag") enthalten, um jeden auftrag zu verwalten, der von jedem Cmdlet erstellt wurde. Viele der Cmdlets mit AsJob-Parametern verwenden keine PowerShell-Remoting, sodass Sie sie auch auf Computern verwenden können, die nicht für Remoting konfiguriert sind und die die Anforderungen für Remoting nicht erfüllen.

Der folgende Befehl verwendet den AsJob-Parameter , Invoke-Command um einen Auftrag auf dem Server01-Computer zu starten. Der Auftrag führt einen Get-Eventlog Befehl aus, der die Ereignisse im Systemprotokoll abruft. Sie können den JobName-Parameter verwenden, um dem Auftrag einen Anzeigenamen zuzuweisen.
```
Invoke-Command -computername Server01 -scriptblock {
  Get-Eventlog system} -AsJob
```
Die Ergebnisse des Befehls ähneln der folgenden Beispielausgabe.
```
SessionId   Name   State    HasMoreData   Location   Command
---------   ----   -----    -----------   --------   -------
1           Job1   Running  True          Server01   Get-Eventlog system
```
Wenn der AsJob-Parameter verwendet wird, Invoke-Command wird derselbe Auftragsobjekttyp zurückgegeben, Start-Job der zurückgegeben wird. Sie können das Auftragsobjekt in einer Variablen speichern oder einen Get-Job Befehl verwenden, um den Auftrag abzurufen.

Beachten Sie, dass der Wert der Location-Eigenschaft anzeigt, dass der Auftrag auf dem Server01-Computer ausgeführt wurde.
Um einen Auftrag zu verwalten, der mit dem Parameter "AsJob " des Invoke-Command Cmdlets gestartet wurde, verwenden Sie die Cmdlets "Auftrag". Da sich das Auftragsobjekt, das den Remoteauftrag darstellt, auf dem lokalen Computer befindet, müssen Sie keine Remotebefehle ausführen, um den Auftrag zu verwalten.

Um festzustellen, ob der Auftrag abgeschlossen ist, verwenden Sie einen Get-Job Befehl. Der folgende Befehl ruft alle Aufträge ab, die in der aktuellen Sitzung gestartet wurden.
```
Get-Job
```
Da der Remoteauftrag in der aktuellen Sitzung gestartet wurde, ruft ein lokaler Get-Job Befehl den Auftrag ab. Die State-Eigenschaft des Auftragsobjekts zeigt, dass der Befehl erfolgreich abgeschlossen wurde.
```
SessionId   Name   State      HasMoreData   Location   Command
---------   ----   -----      -----------   --------   -------
1           Job1   Completed  True          Server01   Get-Eventlog system
```
Verwenden Sie das Receive-Job Cmdlet, um die Ergebnisse des Auftrags abzurufen. Da die Auftragsergebnisse automatisch an den Computer zurückgegeben werden, auf dem sich das Auftragsobjekt befindet, können Sie die Ergebnisse mit einem lokalen Receive-Job Befehl abrufen.

Der folgende Befehl verwendet das Receive-Job Cmdlet, um die Ergebnisse des Auftrags abzurufen. Er verwendet die Sitzungs-ID, um den Auftrag zu identifizieren. Mit diesem Befehl werden die Auftragsergebnisse in der variablen $results gespeichert. Sie können die Ergebnisse auch an eine Datei umleiten.
```
$results = Receive-Job -id 1
```

Starten eines Remoteauftrags, der die Ergebnisse auf dem Remotecomputer hält

Um einen Auftrag auf einem Remotecomputer zu starten, der die Befehlsergebnisse auf dem Remotecomputer behält, verwenden Sie das Invoke-Command Cmdlet, um einen Start-Job Befehl auf einem Remotecomputer auszuführen. Mit dieser Methode können Sie Aufträge auf mehreren Computern ausführen.

Wenn Sie einen Start-Job Befehl remote ausführen, wird das Auftragsobjekt auf dem Remotecomputer erstellt, und die Auftragsergebnisse werden auf dem Remotecomputer verwaltet. Aus Sicht des Auftrags sind alle Vorgänge lokal. Sie führen nur Befehle remote aus, um einen lokalen Auftrag auf dem Remotecomputer zu verwalten.

Verwenden Sie das Invoke-Command Cmdlet, um einen Start-Job Befehl auf einem Remotecomputer auszuführen.

Für diesen Befehl ist eine PSSession (eine dauerhafte Verbindung) erforderlich. Wenn Sie den ComputerName-Parameter Invoke-Command zum Herstellen einer temporären Verbindung verwenden, wird der Invoke-Command Befehl als abgeschlossen betrachtet, wenn das Auftragsobjekt zurückgegeben wird. Daher wird die temporäre Verbindung geschlossen, und der Auftrag wird abgebrochen.

Der folgende Befehl verwendet das New-PSSession Cmdlet, um eine PSSession zu erstellen, die mit dem Server01-Computer verbunden ist. Der Befehl speichert die PSSession in der $s Variablen.
```
$s = New-PSSession -computername Server01
```
Der nächste Befehl verwendet das Invoke-Command Cmdlet, um einen Start-Job Befehl in der PSSession auszuführen. Der Start-Job Befehl und der Get-Eventlog Befehl sind in geschweifte Klammern eingeschlossen.
```
Invoke-Command -session $s -scriptblock {
  Start-Job -scriptblock {Get-Eventlog system}}
```
Die Ergebnisse ähneln der folgenden Beispielausgabe.
```
Id       Name    State      HasMoreData     Location   Command
--       ----    -----      -----------     --------   -------
2        Job2    Running    True            Localhost  Get-Eventlog system
```
Wenn Sie einen Start-Job Befehl remote ausführen, Invoke-Command wird derselbe Auftragsobjekttyp zurückgegeben, Start-Job der zurückgegeben wird. Sie können das Auftragsobjekt in einer Variablen speichern oder einen Get-Job Befehl verwenden, um den Auftrag abzurufen.

Beachten Sie, dass der Wert der Location-Eigenschaft anzeigt, dass der Auftrag auf dem lokalen Computer ausgeführt wurde, auch wenn der Auftrag auf dem Server01-Computer ausgeführt wurde. Da das Auftragsobjekt auf dem Server01-Computer erstellt wird und der Auftrag auf demselben Computer ausgeführt wird, gilt es als lokaler Hintergrundauftrag.
Verwenden Sie zum Verwalten eines Remoteauftrags die Cmdlets "Auftrag ". Da sich das Auftragsobjekt auf dem Remotecomputer befindet, müssen Sie Remotebefehle ausführen, um die Auftragsergebnisse abzurufen, zu beenden, zu warten oder abzurufen.

Um festzustellen, ob der Auftrag abgeschlossen ist, verwenden Sie einen Invoke-Command Befehl, um einen Get-Job Befehl in der PSSession auszuführen, die mit dem Server01-Computer verbunden ist.
```
Invoke-Command -session $s -scriptblock {Get-Job}
```
Der Befehl gibt ein Auftragsobjekt zurück. Die State-Eigenschaft des Auftragsobjekts zeigt, dass der Befehl erfolgreich abgeschlossen wurde.
```
SessionId   Name  State      HasMoreData   Location   Command
---------   ----  -----      -----------   --------   -------
2           Job2  Completed  True          LocalHost   Get-Eventlog system
```
Um die Ergebnisse des Auftrags abzurufen, verwenden Sie das Invoke-Command Cmdlet, um einen Receive-Job Befehl in der PSSession auszuführen, die mit dem Server01-Computer verbunden ist.

Der folgende Befehl verwendet das Receive-Job Cmdlet, um die Ergebnisse des Auftrags abzurufen. Er verwendet die Sitzungs-ID, um den Auftrag zu identifizieren. Mit diesem Befehl werden die Auftragsergebnisse in der $results Variablen gespeichert. Er verwendet den Parameter "Keep" Receive-Job , um das Ergebnis im Auftragscache auf dem Remotecomputer beizubehalten.
```
$results = Invoke-Command -session $s -scriptblock {
  Receive-Job -SessionId 2 -Keep
}
```
Sie können die Ergebnisse auch an eine Datei auf dem lokalen oder Remotecomputer umleiten. Der folgende Befehl verwendet einen Umleitungsoperator, um die Ergebnisse in einer Datei auf dem Server01-Computer zu speichern.
```
Invoke-Command -session $s -command {
  Receive-Job -SessionId 2 > c:\logs\pslog.txt
}
```

So wird's ausgeführt als getrennter Prozess

Wie bereits erwähnt, werden alle ausgeführten untergeordneten Aufträge zusammen mit ihren untergeordneten Prozessen beendet, wenn die übergeordnete Sitzung beendet wird. Sie können Remoting auf dem lokalen Computer verwenden, um Aufträge auszuführen, die nicht an die aktuelle PowerShell-Sitzung angefügt sind.

Erstellen Sie eine neue PowerShell-Sitzung auf dem lokalen Computer. Die Verwendung Invoke-Command zum Starten eines Auftrags in dieser Sitzung. Invoke-Command ermöglicht es Ihnen, eine Remotesitzung zu trennen und die übergeordnete Sitzung zu beenden. Später können Sie eine neue PowerShell-Sitzung starten und eine Verbindung mit der zuvor getrennten Sitzung herstellen, um die Überwachung des Auftrags fortzusetzen. Alle Daten, die an die ursprüngliche PowerShell-Sitzung zurückgegeben wurden, gehen jedoch verloren, wenn diese Sitzung beendet wird. Es werden nur neue Datenobjekte generiert, die nach dem Trennen zurückgegeben werden, wenn die Verbindung erneut hergestellt wird.

# Create remote session on local machine
PS> $session = New-PSSession -cn localhost

# Start remote job
PS> $job = Invoke-Command -Session $session -ScriptBlock { 1..60 | % { sleep 1; "Output $_" } } -AsJob
PS> $job

Id     Name     PSJobTypeName   State         HasMoreData     Location      Command
--     ----     -------------   -----         -----------     --------      -------
1      Job1     RemoteJob       Running       True            localhost     1..60 | % { sleep 1; ...

# Disconnect the job session
PS> Disconnect-PSSession $session

Id Name         Transport ComputerName    ComputerType    State         ConfigurationName     Availability
-- ----         --------- ------------    ------------    -----         -----------------     ------------
1 Runspace1     WSMan     localhost       RemoteMachine   Disconnected  Microsoft.PowerShell          None

PS> $job

Id     Name     PSJobTypeName   State         HasMoreData     Location      Command
--     ----     -------------   -----         -----------     --------      -------
1      Job1     RemoteJob       Disconnected  True            localhost     1..60 | % { sleep 1;

# Reconnect the session to a new job object
PS> $jobNew = Receive-PSSession -Session $session -OutTarget Job
PS> $job | Wait-Job | Receive-Job
Output 9
Output 10
Output 11
...

In diesem Beispiel werden die Aufträge weiterhin an eine übergeordnete PowerShell-Sitzung angefügt. Die übergeordnete Sitzung ist jedoch nicht die ursprüngliche PowerShell-Sitzung, in Invoke-Command der sie ausgeführt wurde.

Freigeben über