Receive-PSSession

Receive-PSSession
    [-Session] <PSSession>
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    [-Id] <Int32>
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    [-ComputerName] <String>
    -Name <String>
    [-ApplicationName <String>]
    [-ConfigurationName <String>]
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-Credential <PSCredential>]
    [-Authentication <AuthenticationMechanism>]
    [-CertificateThumbprint <String>]
    [-Port <Int32>]
    [-UseSSL]
    [-SessionOption <PSSessionOption>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    [-ComputerName] <String>
    -InstanceId <Guid>
    [-ApplicationName <String>]
    [-ConfigurationName <String>]
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-Credential <PSCredential>]
    [-Authentication <AuthenticationMechanism>]
    [-CertificateThumbprint <String>]
    [-Port <Int32>]
    [-UseSSL]
    [-SessionOption <PSSessionOption>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    [-ConnectionUri] <Uri>
    -InstanceId <Guid>
    [-ConfigurationName <String>]
    [-AllowRedirection]
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-Credential <PSCredential>]
    [-Authentication <AuthenticationMechanism>]
    [-CertificateThumbprint <String>]
    [-SessionOption <PSSessionOption>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    [-ConnectionUri] <Uri>
    -Name <String>
    [-ConfigurationName <String>]
    [-AllowRedirection]
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-Credential <PSCredential>]
    [-Authentication <AuthenticationMechanism>]
    [-CertificateThumbprint <String>]
    [-SessionOption <PSSessionOption>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    -InstanceId <Guid>
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Receive-PSSession
    -Name <String>
    [-OutTarget <OutTarget>]
    [-JobName <String>]
    [-WhatIf]
    [-Confirm]
    [<CommonParameters>]

Das Cmdlet Receive-PSSession ruft die Ergebnisse von Befehlen ab, die in Windows PowerShell-Sitzungen (PSSession) ausgeführt wurden, deren Verbindung getrennt wurde. Wenn die Sitzung derzeit verbunden ist, ruft Receive-PSSession die Ergebnisse von Befehlen ab, die ausgeführt wurden, als die Sitzung getrennt wurde. Wenn die Sitzung weiterhin getrennt ist, stellt Receive-PSSession eine Verbindung mit der Sitzung her, setzt alle angehaltenen Befehle fort und ruft die Ergebnisse der in der Sitzung ausgeführten Befehle ab.

Sie können eine Receive-PSSession zusätzlich zu oder anstelle eines Connect-PSSession Befehls verwenden. Receive-PSSession kann eine Verbindung zu jeder getrennten oder wiederhergestellten Sitzung herstellen. Dazu gehören auch solche, die in anderen Sitzungen oder auf anderen Computern gestartet wurden.

Receive-PSSession funktioniert für PSSessions , die absichtlich getrennt wurden, z. B. durch die Verwendung des Cmdlets Disconnect-PSSession oder des Parameters InDisconnectedSession des Cmdlets Invoke-Command, oder unbeabsichtigt, z. B. durch eine Netzwerkunterbrechung.

Wenn Sie das Cmdlet Receive-PSSession verwenden, um eine Verbindung mit einer Sitzung herzustellen, in der keine Befehle ausgeführt oder angehalten werden, stellt Receive-PSSession eine Verbindung mit der Sitzung her, gibt jedoch keine Ausgabe oder Fehler zurück.

Weitere Informationen über die Funktion Disconnected Sessions finden Sie unter about_Remote_Disconnected_Sessions.

Dieses Cmdlet wurde in Windows PowerShell 3.0 eingeführt.

PS C:\> Receive-PSSession -ComputerName Server01 -Name ITTask

Dieser Befehl verwendet das Cmdlet Receive-PSSession , um eine Verbindung mit der ITTask-Sitzung auf dem Computer Server01 herzustellen und die Ergebnisse von Befehlen abzurufen, die in der Sitzung ausgeführt wurden.

Da der OutTarget-Parameter nicht im Befehl verwendet wird, werden die Ergebnisse in der Befehlszeile angezeigt.

PS C:\> Get-PSSession -ComputerName Server01, Server02 | Receive-PSSession

Mit diesem Befehl werden die Ergebnisse aller Befehle abgerufen, die in allen getrennten Sitzungen auf den Computern Server01 und Server02 ausgeführt werden.

Wenn eine Sitzung nicht getrennt wurde oder keine Befehle ausgeführt werden, stellt Receive-PSSession keine Verbindung mit der Sitzung her und gibt keine Ausgabe oder Fehler zurück.

PS C:\> Receive-PSSession -ComputerName Server01 -Name ITTask -OutTarget Job -JobName ITTaskJob01 -Credential Domain01\Admin01
Id     Name            State         HasMoreData     Location
--     ----            -----         -----------     --------
16     ITTaskJob01     Running       True            Server01

Mit diesem Befehl wird das Cmdlet Receive-PSSession verwendet, um die Ergebnisse eines Skripts abzurufen, das in der ITTask-Sitzung auf dem Computer Server01 ausgeführt wurde.

Der Befehl verwendet die parameter ComputerName und Name Parameter, um die getrennte Sitzung zu identifizieren. Er verwendet den OutTarget-Parameter mit dem Wert Job, um Receive-PSSession anzuweisen, die Ergebnisse als Auftrag zurückzugeben, und den JobName-Parameter , um einen Namen für den Auftrag in der wiederhergestellten Sitzung anzugeben.

Der Befehl verwendet den Parameter Credential , um den Befehl Receive-PSSession mit den Berechtigungen eines Domänenadministrators auszuführen.

Die Ausgabe zeigt, dass Receive-PSSession die Ergebnisse als Auftrag in der aktuellen Sitzung zurückgegeben hat. Um die Auftragsergebnisse abzurufen, verwenden Sie den Befehl Receive-Job

The first command uses the New-PSSession cmdlet to create a session on the Server01 computer. The command saves the session in the $s variable.The second command gets the session in the $s variable. Notice that the **State** is Opened and the **Availability** is Available. These values indicate that you are connected to the session and can run commands in the session.
PS C:\> $s = New-PSSession -ComputerName Server01 -Name AD -ConfigurationName ADEndpoint
PS C:\> $s

Id Name    ComputerName    State         ConfigurationName     Availability
 -- ----    ------------    -----         -----------------     ------------
  8 AD      Server01        Opened        ADEndpoint            Available

The third command uses the Invoke-Command cmdlet to run a script in the session in the $s variable.The script begins to run and return data, but a network outage occurs that interrupts the session. The user has to exit the session and restart the local computer.
PS> Invoke-Command -Session $s -FilePath \\Server12\Scripts\SharedScripts\New-ADResolve.ps1
 Running "New-ADResolve.ps1"

# Network outage
# Restart local computer
# Network access is not re-established within 4 minutes

When the computer restarts, the user starts Windows PowerShell and runs a Get-PSSession command to get sessions on the Server01 computer. The output shows that the AD session still exists on the Server01 computer. The **State** indicates that it is disconnected and the **Availability** value, None, indicates that it is not connected to any client sessions.
PS C:\> Get-PSSession -ComputerName Server01

 Id Name    ComputerName    State         ConfigurationName     Availability
 -- ----    ------------    -----         -----------------     ------------
  1 Backup  Server01        Disconnected  Microsoft.PowerShell          None
  8 AD      Server01        Disconnected  ADEndpoint                   None


The fifth command uses the **Receive-PSSession** cmdlet to reconnect to the AD session and get the results of the script that ran in the session. The command uses the *OutTarget* parameter to request the results in a job named ADJob.The command returns a job object. The output indicates that the script is still running.
PS C:\> Receive-PSSession -ComputerName Server01 -Name AD -OutTarget Job -JobName AD
Job Id     Name      State         HasMoreData     Location
--     ----      -----         -----------     --------
16     ADJob     Running       True            Server01

The sixth command uses the Get-PSSession cmdlet to check the job state. The output confirms that, in addition to resuming script execution and getting the script results, the **Receive-PSSession** cmdlet reconnected to the AD session, which is now open and available for commands.
PS C:\> Get-PSSession -ComputerName Server01
Id Name    ComputerName    State         ConfigurationName     Availability
-- ----    ------------    -----         -----------------     ------------
 1 Backup  Server01        Disconnected  Microsoft.PowerShell          Busy
 8 AD      Server01        Opened        ADEndpoint                Available

In diesem Beispiel wird das Cmdlet Receive-PSSession verwendet, um die Ergebnisse eines Auftrags abzurufen, nachdem eine Sitzungsverbindung durch einen Netzwerkausfall unterbrochen wurde. Windows PowerShell versucht automatisch, die Verbindung zwischen der Sitzung in den nächsten vier Minuten einmal pro Sekunde wiederherzustellen, und bricht den Versuch nur ab, wenn alle Versuche im Vier-Minuten-Intervall fehlschlagen.

The first command uses the Invoke-Command cmdlet to run a script on the three remote computers. Because the scripts gathers and summarize data from multiple databases, it often takes the script an extended time to finish. The command uses the *InDisconnectedSession* parameter, which starts the scripts and then immediately disconnects the sessions.The command uses the *SessionOption* parameter to extend the **IdleTimeout** value of the disconnected session. Disconnected sessions are considered to be idle from the moment they are disconnected, so it is important to set the idle time-out for long enough that the commands can complete and you can reconnect to the session, if necessary. You can set the **IdleTimeout** only when you create the **PSSession** and change it only when you disconnect from it. You cannot change the **IdleTimeout** value when you connect to a **PSSession** or receiving its results.After running the command, the user exits Windows PowerShell and closes the computer .
PS C:\> Invoke-Command -InDisconnectedSession -ComputerName Server01, Server02, Server30 -FilePath \\Server12\Scripts\SharedScripts\Get-BugStatus.ps1 -Name BugStatus -SessionOption @{IdleTimeout = 86400000} -ConfigurationName ITTasks# Exit

# Start Windows PowerShell on a different computer.

On the next day, the user resumes Windows and starts Windows PowerShell. The second command uses the Get-PSSession cmdlet to get the sessions in which the scripts were running. The command identifies the sessions by the computer name, session name, and the name of the session configuration and saves the sessions in the $s variable.The third command displays the value of the $s variable. The output shows that the sessions are disconnected, but not busy, as expected.
PS C:\> $s = Get-PSSession -ComputerName Server01, Server02, Server30 -Name BugStatus
 PS C:\> $s
Id Name    ComputerName    State         ConfigurationName     Availability
 -- ----    ------------    -----         -----------------     ------------
  1 ITTask  Server01        Disconnected  ITTasks                       None
  8 ITTask  Server02        Disconnected  ITTasks                       None
  2 ITTask  Server30        Disconnected  ITTasks                       None


The fourth command uses the **Receive-PSSession** cmdlet to connect to the sessions in the $s variable and get their results. The command saves the results in the $Results variable.Another display of the $s variable shows that the sessions are connected and available for commands.
PS C:\> $Results = Receive-PSSession -Session $s
PS C:\> $s
 Id Name    ComputerName    State         ConfigurationName     Availability
-- ----    ------------    -----         -----------------     ------------
 1 ITTask  Server01        Opened        ITTasks                  Available
 8 ITTask  Server02        Opened        ITTasks                  Available
 2 ITTask  Server30        Opened        ITTasks                  Available


The fifth command displays the script results in the $Results variable. If any of the results are unexpected, the user can run commands in the sessions to investigate.
PS C:\> $Results
Bug Report - Domain 01
----------------------
ComputerName          BugCount          LastUpdated
--------------        ---------         ------------
Server01              121               Friday, December 30, 2011 5:03:34 PM

In diesem Beispiel wird das Cmdlet Receive-PSSession verwendet, um die Verbindung mit Sitzungen wiederherzustellen, die absichtlich getrennt wurden, und um die Ergebnisse von Aufträgen abzurufen, die in den Sitzungen ausgeführt wurden.

The first command uses the New-PSSession cmdlet to create the Test session on the Server01 computer. The command saves the session in the $s variable.
PS C:\> $s = New-PSSession -ComputerName Server01 -Name Test

The second command uses the Invoke-Command cmdlet to run a command in the session in the $s variable. The command uses the *AsJob* parameter to run the command as a job and to create the job object in the current session. The command returns a job object, which is saved in the $j variable.The third command displays the job object in the $j variable.
PS C:\> $j = Invoke-Command -Session $s { 1..1500 | Foreach-Object {"Return $_"; sleep 30}} -AsJob

PS C:\> $j
Id     Name           State         HasMoreData     Location
--     ----           -----         -----------     --------
16     Job1           Running       True            Server01

The fourth command disconnects the session in the $s variable.
PS C:\> $s | Disconnect-PSSession
Id Name   ComputerName    State         ConfigurationName     Availability
-- ----   ------------    -----         -----------------     ------------
1  Test   Server01        Disconnected  Microsoft.PowerShell  None

The fifth command shows the effect of disconnecting on the job object in the $j variable. The job state is now Disconnected.
PS C:\> $j
Id     Name           State         HasMoreData     Location
--     ----           -----         -----------     --------
16     Job1           Disconnected  True            Server01

The sixth command runs a Receive-Job command on the job in the $j variable. The output shows that the job began to return output before the session and the job were disconnected.
PS C:\> Receive-Job $j -Keep
Return 1
Return 2

The seventh command is run in the same client session. The command uses the Connect-PSSession cmdlet to reconnect to the Test session on the Server01 computer and saves the session in the $s2 variable.
PS C:\> $s2 = Connect-PSSession -ComputerName Server01 -Name Test

The eighth command uses the **Receive-PSSession** cmdlet to get the results of the job that was running in the session. Because the command is run in the same session, **Receive-PSSession** returns the results as a job by default and reuses the same job object. The command saves the job in the $j2 variable.The ninth command uses the **Receive-Job** cmdlet to get the results of the job in the $j variable.
PS C:\> $j2 = Receive-PSSession -ComputerName Server01 -Name Test

PS C:\> Receive-Job $j
Return 3
Return 4

Dieses Beispiel zeigt, was mit einem Auftrag geschieht, der in einer getrennten Sitzung ausgeführt wird.

Dieses Cmdlet unterstützt die allgemeinen Parameter -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction und -WarningVariable. Weitere Informationen findest du unter about_CommonParameters.

Sie können Sitzungsobjekte, z. B. solche, die vom Cmdlet Get-PSSession zurückgegeben werden, über die Pipeline an dieses Cmdlet übergeben.

Sie können Sitzungs-IDs über die Pipeline an dieses Cmdlet übergeben.

Mit diesem Cmdlet können Sie die Instanz-IDs von Sitzungen über die Pipeline übergeben.

Sie können Sitzungsnamen an dieses Cmdlet weiterleiten.

Dieses Cmdlet gibt die Ergebnisse von Befehlen zurück, die in der getrennten Sitzung ausgeführt wurden, falls vorhanden. Wenn der Wert oder Standardwert des OutTarget-Parameters Job ist, gibt Receive-PSSession ein Job-Objekt zurück. Andernfalls werden Objekte zurückgegeben, die diese Befehlsergebnisse darstellen.

• Receive-PSSession ruft nur Ergebnisse von Sitzungen ab, die getrennt wurden. Nur Sitzungen, die mit Computern verbunden sind, auf denen Windows PowerShell 3.0 oder höher ausgeführt wird, können getrennt und wieder verbunden werden.

• Wenn die Befehle, die in der getrennten Sitzung ausgeführt wurden, keine Ergebnisse generiert haben oder wenn die Ergebnisse bereits an eine andere Sitzung zurückgegeben wurden, generiert Receive-PSSession keine Ausgabe.

• Der Ausgabepuffermodus einer Sitzung bestimmt, wie Befehle in der Sitzung die Ausgabe verwalten, wenn die Sitzung getrennt wird. Wenn der Wert der Option OutputBufferingMode der Sitzung Drop lautet und der Ausgabepuffer voll ist, beginnt der Befehl, die Ausgabe zu löschen. Receive-PSSession kann diese Ausgabe nicht wiederherstellen. Weitere Informationen zur Option für den Ausgabepuffermodus finden Sie in den Hilfethemen zu den Cmdlets New-PSSessionOption und New-PSTransportOption.

• Sie können den Wert für das Leerlauftimeout einer PSSession nicht ändern, wenn Sie eine Verbindung mit der PSSession herstellen oder Ergebnisse empfangen. Der SessionOption-Parameter von Receive-PSSession akzeptiert ein SessionOption-Objekt mit einem IdleTimeout-Wert . Der IdleTimeout-Wert des SessionOption-Objekts und der IdleTimeout-Wert der Variablen $PSSessionOption werden jedoch ignoriert, wenn eine Verbindung mit einer PSSession hergestellt wird oder Ergebnisse empfangen werden.

  Sie können das Leerlauftimeout einer PSSession festlegen und ändern, wenn Sie die PSSession erstellen, die Cmdlets New-PSSession oder Invoke-Command verwenden und die Verbindung zur PSSession trennen.

  Die IdleTimeout- Eigenschaft eines PSSession- ist wichtig für getrennte Sitzungen, da sie bestimmt, wie lange eine getrennte Sitzung auf dem Remotecomputer verwaltet wird. Getrennte Sitzungen gelten vom Moment ihrer Trennung an als im Leerlauf, selbst wenn Befehle in der getrennten Sitzung ausgeführt werden.

• Wenn Sie einen Auftrag in einer Remotesitzung starten, indem Sie den AsJob-Parameter des Cmdlets Invoke-Command verwenden, wird das Auftragsobjekt in der aktuellen Sitzung erstellt, auch wenn der Auftrag in der Remotesitzung ausgeführt wird. Wenn Sie die Remotesitzung trennen, wird das Auftragsobjekt in der aktuellen Sitzung jetzt vom Auftrag getrennt. Das Auftragsobjekt enthält weiterhin alle Ergebnisse, die an das Objekt zurückgegeben wurden, aber es erhält keine neuen Ergebnisse vom Auftrag in der getrennten Sitzung.

  Wenn ein anderer Client eine Verbindung mit der Sitzung herstellt, die den ausgeführten Auftrag enthält, sind die Ergebnisse, die in der ursprünglichen Sitzung an das ursprüngliche Auftragsobjekt übermittelt wurden, in der neu verbundenen Sitzung nicht verfügbar. Nur Ergebnisse, die nicht an das ursprüngliche Auftragsobjekt übermittelt wurden, sind in der erneut verbundenen Sitzung verfügbar.

  Wenn Sie ein Skript in einer Sitzung starten und dann die Verbindung zur Sitzung trennen, sind alle Ergebnisse, die das Skript vor dem Trennen der Verbindung an die Sitzung übermittelt, für einen anderen Client, der eine Verbindung mit der Sitzung herstellt, nicht verfügbar.

  Um Datenverluste in Sitzungen zu verhindern, die Sie trennen möchten, verwenden Sie den Parameter InDisconnectedSession des Cmdlets Invoke-Command . Da dieser Parameter verhindert, dass Ergebnisse an die aktuelle Sitzung zurückgegeben werden, sind alle Ergebnisse verfügbar, wenn die Sitzung erneut verbunden wird.

  Sie können Datenverluste auch verhindern, indem Sie mit dem Cmdlet Invoke-Command einen Start-Job Befehl in der Remotesitzung ausführen. In diesem Fall wird das Auftragsobjekt in der Remotesitzung erstellt. Sie können das Cmdlet Receive-PSSession nicht verwenden, um die Auftragsergebnisse abzurufen. Verwenden Sie stattdessen das Cmdlet Connect-PSSession , um eine Verbindung mit der Sitzung herzustellen, und verwenden Sie dann das Cmdlet Invoke-Command , um einen Receive-Job Befehl in der Sitzung auszuführen.

• Wenn eine Sitzung, die einen ausgeführten Auftrag enthält, getrennt und dann wieder verbunden wird, wird das ursprüngliche Auftragsobjekt nur dann wiederverwendet, wenn der Auftrag getrennt und wieder mit derselben Sitzung verbunden wird und der Befehl zum Wiederherstellen der Verbindung keinen neuen Auftragsnamen angibt. Wenn die Sitzung wieder mit einer anderen Clientsitzung verbunden wird oder ein neuer Auftragsname angegeben wird, erstellt Windows PowerShell ein neues Auftragsobjekt für die neue Sitzung.

• Wenn Sie eine PSSession trennen, ist der Status der Sitzung Disconnected und die Verfügbarkeit ist None.

  Der Wert der eigenschaft State ist relativ zur aktuellen Sitzung. Daher bedeutet der Wert Disconnected, dass die PSSession nicht mit der aktuellen Sitzung verbunden ist. Es bedeutet jedoch nicht, dass die PSSession- von allen Sitzungen getrennt ist. Möglicherweise ist sie mit einer anderen Sitzung verbunden. Um festzustellen, ob Sie eine Verbindung mit der Sitzung herstellen oder erneut herstellen können, verwenden Sie die Eigenschaft Availability.

  Ein Availability Wert "None" gibt an, dass Sie eine Verbindung mit der Sitzung herstellen können. Ein Wert von Beschäftigt gibt an, dass Sie keine Verbindung mit der PSSession herstellen können, da sie mit einer anderen Sitzung verbunden ist.

  Weitere Informationen zu den Werten der State-Eigenschaft von Sitzungen finden Sie unter RunspaceState-Enumeration in der MSDN-Bibliothek.

  Weitere Informationen zu den Werten der Availability-Eigenschaft von Sitzungen finden Sie unter RunspaceAvailability Enumeration.