THEMA
    about_Remote_Jobs

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

AUSFÜHRLICHE BESCHREIBUNG
    Ein Hintergrundauftrag ist ein Befehl, der asynchron und ohne 
    Interaktion mit der aktuellen Sitzung ausgeführt wird. Die 
    Eingabeaufforderung wird sofort zurückgegeben, und Sie können die 
    Sitzung weiterhin verwenden, während der Auftrag ausgeführt wird.

    Standardmäßig werden Hintergrundaufträge auf dem lokalen Computer 
    ausgeführt. Sie können jedoch verschiedene Verfahren verwenden, um 
    Hintergrundaufträge auf Remotecomputern auszuführen. 

    In diesem Thema wird erläutert, wie ein Hintergrundauftrag auf 
    einem Remotecomputer ausgeführt wird. Informationen über das 
    Ausführen von Hintergrundaufträgen auf einem lokalen Computer 
    finden Sie unter "about_Jobs". Weitere Informationen über 
    Hintergrundaufträge finden Sie unter "about_Job_Details".


 REMOTEHINTERGRUNDAUFTRÄGE

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

    -- Starten Sie eine interaktive Sitzung mit einem Remotecomputer, 
       und starten Sie anschließend einen Auftrag in der interaktiven 
       Sitzung. Die Verfahren sind mit der Ausführung eines lokalen 
       Auftrags vergleichbar, jedoch werden alle Aktionen auf dem 
       Remotecomputer ausgeführt.

    -- Führen Sie einen Hintergrundauftrag auf einem Remotecomputer 
       aus, der die Ergebnisse an den lokalen Computer zurückgibt. 
       Verwenden Sie diese Methode, um die Ergebnisse von 
       Hintergrundaufträgen zu erfassen und an einem zentralen 
       Speicherort auf dem lokalen Computer zu verwalten.

    -- Führen Sie einen Hintergrundauftrag auf einem Remotecomputer 
       aus, der die Ergebnisse auf dem Remotecomputer verwaltet. 
       Verwenden Sie diese Methode, wenn die Verwaltung der 
       Auftragsdaten auf dem ursprünglichen Computer sicherer ist.  

 STARTEN EINES HINTERGRUNDAUFTRAGS IN EINER INTERAKTIVEN SITZUNG

    Sie können eine interaktive Sitzung mit einem Remotecomputer 
    starten und anschließend einen Hintergrundauftrag im Rahmen der 
    interaktiven Sitzung starten. Weitere Informationen über 
    interaktive Sitzungen finden Sie unter "about_Remote" und unter 
    "Enter-PSSession".

    Das Verfahren zum Starten eines Hintergrundauftrags in einer 
    interaktiven Sitzung ist mit dem Verfahren zum Starten eines 
    Hintergrundauftrags auf dem lokalen Computer nahezu identisch. 
    Alle Vorgänge werden jedoch auf dem Remotecomputer, nicht auf dem 
    lokalen Computer ausgeführt.


    SCHRITT 1: ENTER-PSSESSION

    Starten Sie eine interaktive Sitzung mit einem Remotecomputer mit 
    dem Cmdlet "Enter-PSSession". Mit dem ComputerName-Parameter von 
    Enter-PSSession können Sie eine temporäre Verbindung für die 
    interaktive Sitzung herstellen. Sie können die interaktive 
    Sitzung auch mit dem Sitzungsparameter in einer Windows 
    PowerShell-Sitzung (PSSession) ausführen. 

    Mit dem folgenden Befehl wird eine interaktive Sitzung auf dem 
    Computer "Server01" gestartet:
  
        C:\PS> Enter-PSSession -computername Server01

    Die Eingabeaufforderung ändert sich, um anzuzeigen, dass eine 
    Verbindung mit dem Computer "Server01" hergestellt wurde.

        Server01\C:>


    SCHRITT 2: START-JOB

    Starten Sie mit dem Cmdlet "Start-Job" einen Hintergrundauftrag 
    in der Sitzung.

    Der folgende Befehl führt einen Hintergrundauftrag aus, mit dem 
    die Ereignisse im Windows PowerShell-Ereignisprotokoll auf dem 
    Computer "Server01" abgerufen werden. Das Cmdlet "Start-Job" gibt 
    ein Objekt zurück, das den Auftrag darstellt. 

    Mit diesem Befehl wird das Auftragsobjekt in der Variablen "$job" 
    gespeichert. 

        Server01\C:> $job = start-job -scriptblock {get-eventlog "Windows PowerShell"}
   
    Während der Auftrag ausgeführt wird, können Sie weitere Befehle 
    einschließlich anderer Hintergrundaufträge in der interaktiven 
    Sitzung ausführen. Die interaktive Sitzung muss jedoch geöffnet 
    bleiben, bis der Auftrag abgeschlossen ist. Wenn Sie die Sitzung 
    beenden, wird der Auftrag unterbrochen, und die Ergebnisse werden 
    verworfen.



    SCHRITT 3: GET-JOB

    Zeigen Sie den Wert der Variablen "$job" an, oder rufen Sie den 
    Auftrag mit dem Cmdlet "Get-Job" ab, um herauszufinden, ob der 
    Auftrag abgeschlossen wurde. Der folgende Befehl zeigt den 
    Auftrag mit dem Cmdlet "Get-Job" an.

        Server01\C:> get-job $job

        SessionId  Name  State      HasMoreData  Location   Command
        ---------  ----  -----      -----------  --------   -------
        1          Job1  Complete   True         localhost  get-eventlog "Windows PowerShell"

   
    Die Get-Job-Ausgabe zeigt an, dass der Auftrag auf dem Computer 
    "localhost" ausgeführt wird, da der Auftrag auf dem gleichen 
    Computer gestartet wurde und ausgeführt wird (hier: "Server01").
    


    SCHRITT 4: RECEIVE-JOB

    Um die Auftragsergebnisse abzurufen, verwenden Sie das Cmdlet 
    "Receive-Job". Sie können die Ergebnisse in der interaktiven 
    Sitzung anzeigen oder in einer Datei auf dem Remotecomputer 
    speichern. Mit dem folgenden Befehl werden die Ergebnisse des 
    Auftrags in der Variablen "$job" abgerufen. Im Befehl werden die 
    Ergebnisse des Auftrags mit dem Umleitungsoperator (>) in der 
    Datei "PsLog.txt" auf dem Computer "Server01" gespeichert.

        Server01\C:> receive-job $job > c:\logs\PsLog.txt



    SCHRITT 5: EXIT-PSSESSION

    Verwenden Sie das Cmdlet "Exit-PSSession", um die interaktive 
    Sitzung zu beenden. Die Eingabeaufforderung ändert sich, um 
    wieder die ursprüngliche Sitzung auf dem lokalen Computer anzuzeigen.

        Server01\C:> Exit-PSSession
        C:\PS>
         


    SCHRITT 6: INVOKE-COMMAND GET-CONTENT
     
    Um den Inhalt der Datei "PsLog.txt" auf dem Computer "Server01" 
    jederzeit anzeigen zu können, starten Sie eine weitere 
    interaktive Sitzung, oder führen Sie einen Remotebefehl aus. 
    Dieser Befehlstyp wird am besten in einer PSSession (dauerhafte 
    Verbindung) ausgeführt, falls Sie mehrere Befehle verwenden 
    möchten, um die Daten in der Datei "PsLog.txt" zu untersuchen und 
    zu verwalten. Weitere Informationen über PSSessions finden Sie 
    unter "about_PSSessions".

    Die folgenden Befehle verwenden das Cmdlet "New-PSSession", um 
    eine PSSession zu erstellen, die mit dem Computer "Server01" 
    verbunden ist, und das Cmdlet "Invoke-Command" wird verwendet, um 
    einen Get-Content-Befehl in der PSSession auszuführen und den 
    Inhalt der Datei anzuzeigen.

        C:\PS> $s = new-pssession -computername Server01
        C:\PS> invoke-command -session $s -scriptblock {get-content c:\logs\pslog.txt}


       
 STARTEN EINES REMOTEAUFTRAGS ZUR RÜCKGABE VON ERGEBNISSEN AN DEN 
 LOKALEN COMPUTER (ASJOB)

    Verwenden Sie den AsJob-Parameter eines Cmdlet wie Invoke-Command,
     um einen Hintergrundauftrag auf einem Remotecomputer zu starten, 
     der die Ergebnisse des Befehls an den lokalen Computer zurückgibt. 

    Wenn Sie den AsJob-Parameter verwenden, wird das Auftragsobjekt 
    eigentlich auf dem lokalen Computer erstellt, obwohl der Auftrag 
    auf dem Remotecomputer ausgeführt wird. Wenn der Auftrag 
    abgeschlossen ist, werden die Ergebnisse an den lokalen Computer 
    zurückgegeben. 

    Mit den Cmdlets, die das Auftragssubstantiv (die Job-Cmdlets) 
    enthalten, können Sie alle Aufträge verwalten, die von einem 
    beliebigen Cmdlet erstellt wurden. Windows PowerShell-Remoting 
    wird von vielen Cmdlets mit AsJob-Parameter nicht verwendet. Sie 
    können daher auch auf Computern verwendet werden, die nicht für 
    Remoting konfiguriert wurden und die entsprechenden Anforderungen 
    nicht erfüllen.
 

    SCHRITT 1: INVOKE-COMMAND -ASJOB

    Der folgende Befehl startet mit dem AsJob-Parameter von 
    Invoke-Command einen Hintergrundauftrag auf dem Computer 
    "Server01". Der Auftrag führt einen Get-Eventlog-Befehl aus, mit 
    dem die Ereignisse im Systemprotokoll abgerufen werden. Mit dem 
    JobName-Parameter können Sie dem Auftrag einen Anzeigenamen zuweisen.

       invoke-command -computername Server01 -scriptblock 
       {get-eventlog system} -asjob 

    Die Ergebnisse des Befehls entsprechen in etwa der folgenden 
    Beispielausgabe.


       SessionId   Name    State      HasMoreData     Location   Command
       ---------   ----    -----      -----------     --------   -------
       1           Job1    Running    True            Server01   get-eventlog system


    Wenn der AsJob-Parameter verwendet wird, gibt Invoke-Command den 
    gleichen Typ von Auftragsobjekt zurück, der auch von Start-Job 
    zurückgegeben wird. Sie können das Auftragsobjekt in einer 
    Variablen speichern, oder Sie können mit einem Get-Job-Befehl 
    einen Auftrag abrufen.

    Beachten Sie, dass der Wert der Location-Eigenschaft anzeigt, 
    dass der Auftrag auf dem Computer "Server01" ausgeführt wurde.  


    SCHRITT 2: GET-JOB

    Um einen mit dem AsJob-Parameter des Cmdlet "Invoke-Command" 
    gestarteten Auftrag zu verwalten, verwenden Sie die Job-Cmdlets. 
    Da sich das Auftragsobjekt, das den Remoteauftrag darstellt, auf 
    dem lokalen Computer befindet, ist es nicht erforderlich, 
    Remotebefehle zur Verwaltung des Auftrags auszuführen.  

    Verwenden Sie einen Get-Job-Befehl, um zu bestimmen, ob der 
    Auftrag abgeschlossen wurde. 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, 
    wird der Auftrag mit einem lokalen Get-Job-Befehl abgerufen. Die 
    State-Eigenschaft des Auftragsobjekts zeigt an, dass der Befehl 
    erfolgreich ausgeführt wurde.
       
       SessionId   Name   State      HasMoreData     Location   Command
       ---------   ----   -----      -----------     --------   -------
       1           Job1   Completed  True            Server01   get-eventlog system


    SCHRITT 3: RECEIVE-JOB

    Um die Auftragsergebnisse abzurufen, verwenden Sie das Cmdlet 
    "Receive-Job". 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.

    Im folgenden Befehl werden die Ergebnisse des Auftrags mit dem 
    Cmdlet "Receive-Job" abgerufen. Der Auftrag wird anhand der 
    Sitzungs-ID identifiziert. Anschließend werden die Auftragsergebni
    sse in der Variablen "$results" gespeichert. Sie können die 
    Ergebnisse auch in eine Datei umleiten.

       $results = receive-job -id 1
    


 STARTEN EINES REMOTEAUFTRAGS ZUM BEIBEHALTEN DER ERGEBNISSE AUF DEM 
 REMOTECOMPUTER

    Um einen Hintergrundauftrag auf einem Remotecomputer zu starten, 
    der die Befehlsergebnisse auf dem Remotecomputer beibehält, 
    führen Sie einen Start-Job-Befehl mit dem Cmdlet "Invoke-Command" 
    auf einem Remotecomputer aus. Mit dieser Methode können Sie 
    Hintergrundaufträ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 beibehalten.
    Aus Sicht des Auftrags werden alle Vorgänge lokal ausgeführt. 
    Befehle werden nur remote ausgeführt, um einen lokalen Auftrag 
    auf dem Remotecomputer zu verwalten.


    STEP 1: INVOKE-COMMAND START-JOB

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

    Dieser Befehl erfordert eine PSSession (eine dauerhafte 
    Verbindung). Wenn Sie mit dem ComputerName-Parameter von 
    Invoke-Command eine temporäre Verbindung herstellen, wird der 
    Befehl "Invoke-Command" als abgeschlossen betrachtet, wenn das 
    Auftragsobjekt zurückgegeben wird. Die temporäre Verbindung wird 
    daraufhin geschlossen, und der Auftrag wird abgebrochen.
 
    Im folgenden Befehl wird mit dem Cmdlet "New-PSSession" eine 
    PSSession erstellt, die mit dem Computer "Server01" verbunden 
    ist. Der Befehl speichert die PSSession in der Variablen "$s".

        $s = new-pssession -computername Server01


    Der nächste Befehl verwendet das Cmdlet "Invoke-Command", um 
    einen Start-Job-Befehl in der PSSession auszuführen. Der Befehl 
    "Start-Job" und der Befehl "Get-Eventlog" werden in geschweifte 
    Klammern eingeschlossen.

       invoke-command -session $s -scriptblock {start-job 
       -scriptblock {get-eventlog system}}

    Die Ergebnisse entsprechen in etwa 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, gibt 
    Invoke-Command den gleichen Auftragsobjekttyp zurück, der von 
    Start-Job zurückgegeben wird. Sie können das Auftragsobjekt in 
    einer Variablen speichern, oder Sie können mit einem 
    Get-Job-Befehl einen Auftrag abrufen.

    Beachten Sie, dass der Wert der Location-Eigenschaft anzeigt, 
    dass der Auftrag auf dem lokalen Computer "LocalHost" ausgeführt 
    wurde, obwohl der Auftrag auf dem Computer "Server01" ausgeführt 
    wurde. Da das Auftragsobjekt auf dem Computer "Server01" erstellt 
    und der Auftrag auf dem gleichen Computer ausgeführt wird, wird 
    der Auftrag als lokaler Hintergrundauftrag angesehen.  


    STEP 2: INVOKE-COMMAND GET-JOB

    Um einen Remotehintergrundauftrag zu verwalten, verwenden Sie die 
    Job-Cmdlets. Da sich das Auftragsobjekt auf dem Remotecomputer 
    befindet, müssen Sie Remotebefehle ausführen, um die 
    Auftragsergebnisse abzurufen, zu beenden oder darauf zu warten.  

    Um zu sehen, ob der Auftrag abgeschlossen wurde, verwenden Sie 
    einen Invoke-Command-Befehl zur Ausführung eines Get-Job-Befehls 
    in der PSSession, die mit dem Computer "Server01" verbunden ist.

        invoke-command -session $s -scriptblock {get-job}

    Der Befehl gibt ein Auftragsobjekt zurück. Die State-Eigenschaft 
    des Auftragsobjekts zeigt an, dass der Befehl erfolgreich 
    ausgeführt wurde.

       SessionId       Name    State      HasMoreData     Location   Command
       ---------       ----    -----      -----------     --------   -------
       2               Job2    Completed  True            LocalHost   get-eventlog system


    STEP 3: INVOKE-COMMAND RECEIVE-JOB

    Um die Ergebnisse des Auftrags abzurufen, verwenden Sie das 
    Cmdlet "Invoke-Command", und führen Sie einen Receive-Job-Befehl 
    in der PSSession aus, die mit dem Computer "Server01" verbunden ist.

    Im folgenden Befehl werden die Ergebnisse des Auftrags mit dem 
    Cmdlet "Receive-Job" abgerufen. Der Auftrag wird anhand der 
    Sitzungs-ID identifiziert. Anschließend werden die Auftragsergebni
    sse in der Variablen "$results" gespeichert. Mit dem 
    Keep-Parameter von Receive-Job wird das Ergebnis auf dem 
    Remotecomputer im Auftragscache beibehalten.

        $results = invoke-command -session $s -scriptblock {receive-job -sessionid 2 -keep}

    Sie können die Ergebnisse auch in eine Datei auf dem lokalen 
    Computer oder auf dem Remotecomputer umleiten. Der folgende 
    Befehl speichert die Ergebnisse mit einem Umleitungsoperator in 
    einer Datei auf dem Computer "Server01".

        invoke-command -session $s -command {receive-job -sessionid 2 > c:\logs\pslog.txt}


SIEHE AUCH
    about_Jobs
    about_Job_Details
    about_Remote
    Invoke-Command
    Start-Job
    Get-Job
    Wait-Job
    Stop-Job
    Remove-Job
    New-PSSession
    Enter-PSSession
    Exit-PSSession




Inhaltsverzeichnis