about_Job_Details

Artikel
2025-03-24

Kurze Beschreibung

Enthält Details zu Hintergrundaufträgen auf lokalen und Remotecomputern.

Detaillierte Beschreibung

In diesem Thema wird das Konzept eines Hintergrundauftrags erläutert und technische Informationen dazu bereitgestellt, wie Hintergrundaufträge in PowerShell funktionieren.

Dieses Thema ist eine Ergänzung zu den Themen about_Jobs, about_Thread_Jobs und about_Remote_Jobs .

Informationen zu Hintergrundaufträgen

Ein Hintergrundauftrag führt asynchron einen Befehl oder Ausdruck aus. Es kann ein Cmdlet, eine Funktion, ein Skript oder eine andere befehlsbasierte Aufgabe ausführen. Es ist so konzipiert, dass Befehle ausgeführt werden, die einen längeren Zeitraum dauern, sie können jedoch zum Ausführen eines beliebigen Befehls im Hintergrund verwendet werden.

Wenn ein synchroner Befehl ausgeführt wird, wird die PowerShell-Eingabeaufforderung unterdrückt, bis der Befehl abgeschlossen ist. Ein Hintergrundauftrag unterdrückt die PowerShell-Eingabeaufforderung jedoch nicht. Ein Befehl zum Starten eines Hintergrundauftrags gibt ein Auftragsobjekt zurück. Die Eingabeaufforderung wird sofort zurückgegeben, damit Sie während der Ausführung des Hintergrundauftrags an anderen Aufgaben arbeiten können.

Wenn Sie jedoch einen Hintergrundauftrag starten, erhalten Sie die Ergebnisse nicht sofort, auch wenn der Auftrag sehr schnell ausgeführt wird. Das zurückgegebene Auftragsobjekt enthält nützliche Informationen zum Auftrag, enthält aber nicht die Auftragsergebnisse. Sie müssen einen separaten Befehl ausführen, um die Auftragsergebnisse abzurufen. Sie können auch Befehle ausführen, um den Auftrag zu beenden, auf den Abschluss des Auftrags zu warten und den Auftrag zu löschen.

Um die Anzeigedauer eines Hintergrundauftrags unabhängig von anderen Befehlen zu machen, wird jeder Hintergrundauftrag in einer eigenen PowerShell-Sitzung ausgeführt. Dies kann jedoch eine temporäre Verbindung sein, die nur zum Ausführen des Auftrags erstellt wird und dann zerstört wird, oder es kann sich um eine dauerhafte PSSession sein, mit der Sie mehrere verwandte Aufträge oder Befehle ausführen können.

Verwenden der Auftrags-Cmdlets

Verwenden Sie einen Start-Job Befehl, um einen Hintergrundauftrag auf einem lokalen Computer zu starten. Start-Job gibt ein Auftragsobjekt zurück. Sie können auch Objekte abrufen, die die Aufträge darstellen, die mit dem Get-Job Cmdlet auf dem lokalen Computer gestartet wurden.

Verwenden Sie einen Receive-Job Befehl, um die Auftragsergebnisse abzurufen. Wenn der Auftrag nicht abgeschlossen ist, gibt Receive-Job Teilergebnisse zurück. Sie können das Wait-Job Cmdlet auch verwenden, um die Eingabeaufforderung zu unterdrücken, bis eine oder alle Aufträge, die in der Sitzung gestartet wurden, abgeschlossen sind.

Verwenden Sie das Stop-Job Cmdlet, um einen Hintergrundauftrag zu beenden. Verwenden Sie das Remove-Job Cmdlet, um einen Auftrag zu löschen.

Weitere Informationen zur Funktionsweise der Cmdlets finden Sie im Hilfethema zu den einzelnen Cmdlets und about_Jobs.

Starten von Hintergrundaufträgen auf Remotecomputern

Sie können Hintergrundaufträge auf einem lokalen oder Remotecomputer erstellen und verwalten. Um einen Hintergrundauftrag remote auszuführen, verwenden Sie den AsJob-Parameter eines Cmdlets, z Invoke-Command. B. oder verwenden Sie das Invoke-Command Cmdlet, um einen Start-Job Befehl remote auszuführen. Sie können einen Hintergrundauftrag auch in einer interaktiven Sitzung starten.

Weitere Informationen zu Remotehintergrundaufträgen finden Sie unter about_Remote_Jobs.

Untergeordnete Aufträge

Jeder Hintergrundauftrag besteht aus einem übergeordneten Auftrag und einem oder mehreren untergeordneten Aufträgen. In Aufträgen, die mit der Verwendung Start-Job oder dem AsJob-Parameter begonnen Invoke-Commandhaben, ist der übergeordnete Job eine Führungskraft. Es werden keine Befehle ausgeführt oder Ergebnisse zurückgegeben. Die Befehle werden tatsächlich von den untergeordneten Aufträgen ausgeführt. Aufträge, die mit der Verwendung anderer Cmdlets begonnen haben, funktionieren möglicherweise anders.

Die untergeordneten Aufträge werden in der ChildJobs-Eigenschaft des übergeordneten Auftragsobjekts gespeichert. Die ChildJobs-Eigenschaft kann ein oder mehrere untergeordnete Auftragsobjekte enthalten. Die untergeordneten Auftragsobjekte weisen einen Name, IDund InstanceId auf, die sich von dem übergeordneten Auftrag unterscheiden, sodass Sie die übergeordneten und untergeordneten Aufträge einzeln oder als Einheit verwalten können.

Verwenden Sie den , um die Aufträge des übergeordneten und untergeordneten Elements eines Auftrags abzurufen. Der Parameter IncludeChildJob wurde in Windows PowerShell 3.0 eingeführt.

Get-Job -IncludeChildJob

Id Name   PSJobTypeName State      HasMoreData   Location    Command
-- ----   ------------- -----      -----------   --------    -------
1  Job1   RemoteJob     Failed     True          localhost   Get-Process
2  Job2                 Completed  True          Server01    Get-Process
3  Job3                 Failed     False         localhost   Get-Process

Um den übergeordneten Auftrag und nur die untergeordneten Aufträge mit einem bestimmten Statuswert abzurufen, verwenden Sie den Parameter ChildJobState des Get-Job Cmdlets. Der Parameter "ChildJobState " wurde in Windows PowerShell 3.0 eingeführt.

Get-Job -ChildJobState Failed

Id Name   PSJobTypeName State      HasMoreData   Location    Command
-- ----   ------------- -----      -----------   --------    -------
1  Job1   RemoteJob     Failed     True          localhost   Get-Process
3  Job3                 Failed     False         localhost   Get-Process

Um die untergeordneten Aufträge eines Auftrags in allen Versionen von PowerShell abzurufen, verwenden Sie die ChildJob-Eigenschaft des übergeordneten Auftrags.

(Get-Job Job1).ChildJobs

Id Name   PSJobTypeName State      HasMoreData   Location    Command
-- ----   ------------- -----      -----------   --------    -------
2  Job2                 Completed  True          Server01    Get-Process
3  Job3                 Failed     False         localhost   Get-Process

Sie können auch einen Get-Job Befehl für den untergeordneten Auftrag verwenden, wie im folgenden Befehl gezeigt:

Get-Job Job3

Id Name   PSJobTypeName State      HasMoreData   Location    Command
-- ----   ------------- -----      -----------   --------    -------
3  Job3                 Failed     False         localhost   Get-Process

Die Konfiguration des untergeordneten Auftrags hängt vom Befehl ab, den Sie zum Starten des Auftrags verwenden.

Wenn Sie Start-Job einen Auftrag auf einem lokalen Computer starten, besteht der Auftrag aus einem übergeordneten Managerauftrag und einem untergeordneten Auftrag, der den Befehl ausführt.
Wenn Sie den AsJob-ParameterInvoke-Command verwenden, um einen Auftrag auf einem oder mehreren Computern zu starten, besteht der Auftrag aus einem leitenden Elternteilauftrag und einem untergeordneten Auftrag für jeden Auftrag, der auf jedem Computer ausgeführt wird.
Wenn Sie Invoke-Command einen Start-Job Befehl auf einem oder mehreren Remotecomputern ausführen, entspricht das Ergebnis einem lokalen Befehl, der auf jedem Remotecomputer ausgeführt wird. Der Befehl gibt ein Auftragsobjekt für jeden Computer zurück. Das Auftragsobjekt besteht aus einem übergeordneten Managerauftrag und einem untergeordneten Auftrag, der den Befehl ausführt.

Der übergeordnete Auftrag stellt alle untergeordneten Aufträge dar. Wenn Sie einen übergeordneten Auftrag verwalten, verwalten Sie auch die zugeordneten untergeordneten Aufträge. Wenn Sie beispielsweise einen Übergeordneten Auftrag beenden, werden alle untergeordneten Aufträge beendet. Wenn Sie die Ergebnisse eines Elternauftrags erhalten, erhalten Sie die Ergebnisse aller untergeordneten Aufträge.

Sie können jedoch auch untergeordnete Aufträge einzeln verwalten. Dies ist am nützlichsten, wenn Sie ein Problem mit einem Auftrag untersuchen oder die Ergebnisse einer Reihe von untergeordneten Aufträgen abrufen möchten, die mit dem AsJob-Parameter von Invoke-Command.

Der folgende Befehl verwendet den AsJob-Parameter zum Starten von Invoke-Command Hintergrundaufträgen auf dem lokalen Computer und zwei Remotecomputern. Der Befehl speichert den Auftrag in der $j Variablen.

$invokeCommandSplat = @{
    ComputerName = 'localhost', 'Server01', 'Server02'
    ScriptBlock = {Get-Date}
    AsJob = $true
}
$j = Invoke-Command @invokeCommandSplat

Wenn Sie die Eigenschaften Name und ChildJob des Auftrags anzeigen, $jwird angezeigt, dass der Befehl ein Auftragsobjekt mit drei untergeordneten Aufträgen zurückgegeben hat, eines für jeden Computer.

$j | Format-List Name, ChildJobs

Name      : Job3
ChildJobs : {Job4, Job5, Job6}

Wenn Sie den übergeordneten Auftrag anzeigen, wird angezeigt, dass der Auftrag fehlgeschlagen ist.

$j

Id Name   PSJobTypeName State      HasMoreData   Location
-- ----   ------------- -----      -----------   --------
3  Job3   RemotingJob   Failed     False         localhost,Server...

Wenn Sie jedoch einen Get-Job Befehl ausführen, der die untergeordneten Aufträge abruft, zeigt die Ausgabe an, dass nur ein untergeordneter Auftrag fehlgeschlagen ist.

Get-Job -IncludeChildJobs

Id  Name   PSJobTypeName State      HasMoreData   Location    Command
--  ----   ------------- -----      -----------   --------    -------
3   Job3   RemotingJob   Failed     False         localhost,Server...
4   Job4                 Completed  True          localhost   Get-Date
5   Job5                 Failed     False         Server01    Get-Date
6   Job6                 Completed  True          Server02    Get-Date

Verwenden Sie das Receive-Job Cmdlet, um die Ergebnisse aller untergeordneten Aufträge abzurufen, um die Ergebnisse des übergeordneten Auftrags abzurufen. Sie können aber auch die Ergebnisse eines bestimmten untergeordneten Auftrags abrufen, wie im folgenden Befehl gezeigt.

Receive-Job -Name Job6 -Keep |
    Format-Table ComputerName, DateTime -AutoSize

ComputerName DateTime
------------ --------
Server02     Thursday, March 13, 2008 4:16:03 PM

Das Feature für untergeordnete Aufträge von PowerShell-Hintergrundaufträgen bietet Ihnen mehr Kontrolle über die von Ihnen ausgeführten Aufträge.

Auftragstypen

PowerShell unterstützt verschiedene Arten von Aufträgen für verschiedene Aufgaben. Ab Windows PowerShell 3.0 können Entwickler "Auftragsquelladapter" schreiben, die neue Auftragstypen zu PowerShell hinzufügen und die Auftragsquelladapter in Module einschließen. Wenn Sie das Modul importieren, können Sie den neuen Auftragstyp in Ihrer Sitzung verwenden. Beispielsweise fügt das PSScheduledJob-Modul geplante Aufträge hinzu, und das PSWorkflow-Modul fügt Workflowaufträge hinzu.

Benutzerdefinierte Auftragstypen unterscheiden sich möglicherweise erheblich von standard-PowerShell-Hintergrundaufträgen. Beispielsweise werden geplante Aufträge auf dem Datenträger gespeichert; sie sind nicht nur in einer bestimmten Sitzung vorhanden. Workflowaufträge können angehalten und fortgesetzt werden.

Die Cmdlets, die Sie zum Verwalten von benutzerdefinierten Aufträgen verwenden, hängen vom Auftragstyp ab. Für einige verwenden Sie die Standardauftrags-Cmdlets, z Get-Job . B. und Start-Job. Andere verfügen über spezielle Cmdlets, die nur einen bestimmten Auftragstyp verwalten. Ausführliche Informationen zu benutzerdefinierten Auftragstypen finden Sie in den Hilfethemen zum Auftragstyp.

Verwenden Sie das Get-Job Cmdlet, um den Auftragstyp eines Auftrags zu finden. Get-Job gibt unterschiedliche Auftragsobjekte für verschiedene Arten von Aufträgen zurück. Der Wert der PSJobTypeName-Eigenschaft der Auftragsobjekte, die Get-Job den Auftragstyp zurückgeben.

In der folgenden Liste werden die integrierten PowerShell-Auftragstypen beschrieben.

BackgroundJob- – Wurde mit dem Cmdlet Start-Job gestartet.
RemoteJob- – Wurde mit dem Parameter AsJob des Cmdlets Invoke-Command gestartet.
CIMJob- – Wurde mit dem parameter AsJob eines Cmdlets aus einem CDXML-Modul gestartet.
WMIJob- – Begann mit der Verwendung des AsJob-Parameters eines Cmdlets aus einem WMI-Modul.
PSEventJob – Erstellt mitRegister-ObjectEvent und Angeben einer Aktion mit dem parameter Action.

Anmerkung

Bevor Sie das Cmdlet Get-Job zum Abrufen von Aufträgen eines bestimmten Typs verwenden, überprüfen Sie, ob das Modul, das den Auftragstyp hinzufügt, in die aktuelle Sitzung importiert wird. Andernfalls können Get-Job keine Aufträge dieses Typs abrufen.

Windows PowerShell 5.1 enthält die folgenden zusätzlichen Auftragstypen.

PSWorkflowJob- – Gestartet mit der Verwendung des AsJob-Parameters eines Workflows.
PSScheduledJob- – Eine Instanz eines geplanten Auftrags, der von einem Auftragstrigger gestartet wurde.

Diese Auftragstypen sind nur in Windows PowerShell 5.1 verfügbar. Die Module, die diese Auftragstypen hinzufügen, sind nicht mit PowerShell 6.0 und höher kompatibel.

Weitere Informationen finden Sie in den folgenden Artikeln:

Beispiele

Die folgenden Befehle erstellen einen lokalen Hintergrundauftrag, einen Remotehintergrundauftrag, einen Workflowauftrag und einen geplanten Auftrag. Anschließend wird das Get-Job Cmdlet verwendet, um die Aufträge abzurufen. Get-Job wird der geplante Auftrag nicht abgerufen, aber es werden alle gestarteten Instanzen des geplanten Auftrags abgerufen.

Starten Sie einen Hintergrundauftrag auf dem lokalen Computer.

PS> Start-Job -Name LocalData {Get-Process}

Id Name        PSJobTypeName   State   HasMoreData   Location   Command
-- ----        -------------   -----   -----------   --------   -------
2  LocalData   BackgroundJob   Running        True   localhost  Get-Process

Starten Sie einen Hintergrundauftrag, der auf einem Remotecomputer ausgeführt wird.

$invokeCommandSplat = @{
    ComputerName = 'Server01'
    AsJob = $true
    JobName = 'RemoteData'
    ScriptBlock = {Get-Process}
}
Invoke-Command @invokeCommandSplat

Id  Name        PSJobTypeName  State   HasMoreData   Location   Command
--  ----        -------------  -----   -----------   --------   -------
2   RemoteData  RemoteJob      Running        True   Server01   Get-Process

Freigeben über