À propos des travaux distants

Article
06/21/2023

Description courte

Décrit comment exécuter des travaux sur des ordinateurs distants.

Description détaillée

PowerShell exécute simultanément des commandes et des scripts via des travaux. Il existe trois types de travaux fournis par PowerShell pour prendre en charge l’accès concurrentiel.

RemoteJob - Les commandes et les scripts s’exécutent dans une session distante.
BackgroundJob - Les commandes et les scripts s’exécutent dans un processus distinct sur l’ordinateur local. Pour plus d’informations, consultez à propos des_tâches.
PSTaskJob ou ThreadJob - Les commandes et les scripts s’exécutent dans un thread distinct dans le même processus sur l’ordinateur local. Pour plus d’informations, consultez about_Thread_Jobs.

L’exécution de scripts à distance, sur un ordinateur distinct ou dans un processus distinct, offre une grande isolation. Les erreurs qui se produisent dans le travail distant n’affectent pas d’autres travaux en cours d’exécution ou la session parente qui a démarré le travail. Toutefois, la couche de communication à distance ajoute une surcharge, y compris la sérialisation d’objets. Tous les objets sont sérialisés et désérialisés, car ils sont passés entre la session parente et la session distante (travail). La sérialisation d’objets de données complexes volumineux peut consommer de grandes quantités de ressources de calcul et de mémoire et transférer de grandes quantités de données sur le réseau.

Important

La session parente qui a créé le travail surveille également l’état du travail et collecte les données de pipeline. Le processus enfant du travail est arrêté par le processus parent une fois que le travail atteint un état terminé. Si la session parente est arrêtée, tous les travaux enfants en cours d’exécution sont arrêtés avec leurs processus enfants.

Il existe deux façons de contourner cette situation :

Permet Invoke-Command de créer des travaux qui s’exécutent dans des sessions déconnectées. Consultez la section processus détachés de cet article.
Permet Start-Process de créer un processus plutôt qu’un travail. Pour plus d’informations, consultez Start-Process.

Travaux distants

Vous pouvez exécuter des travaux sur des ordinateurs distants à l’aide de trois méthodes différentes.

Démarrez une session interactive sur un ordinateur distant. Démarrez ensuite un travail dans la session interactive. Les procédures sont identiques à l’exécution d’un travail local, bien que toutes les actions soient effectuées sur l’ordinateur distant.
Exécutez un travail sur un ordinateur distant qui retourne ses résultats à l’ordinateur local. Utilisez cette méthode lorsque vous souhaitez collecter les résultats des travaux et les conserver dans un emplacement central sur l’ordinateur local.
Exécutez un travail sur un ordinateur distant qui conserve ses résultats sur l’ordinateur distant. Utilisez cette méthode lorsque les données du travail sont plus sécurisées sur l’ordinateur d’origine.

Démarrer un travail dans une session interactive

Vous pouvez démarrer une session interactive avec un ordinateur distant, puis démarrer un travail pendant la session interactive. Pour plus d’informations sur les sessions interactives, consultez about_Remote et voir Enter-PSSession.

La procédure de démarrage d’un travail dans une session interactive est presque identique à la procédure de démarrage d’un travail en arrière-plan sur l’ordinateur local. Toutefois, toutes les opérations se produisent sur l’ordinateur distant, et non sur l’ordinateur local.

Utilisez l’applet Enter-PSSession de commande pour démarrer une session interactive avec un ordinateur distant. Vous pouvez utiliser le paramètre ComputerName pour Enter-PSSession établir une connexion temporaire pour la session interactive. Vous pouvez également utiliser le paramètre Session pour exécuter la session interactive dans une session PowerShell (PSSession).

La commande suivante démarre une session interactive sur l’ordinateur Server01.
```
C:\PS> Enter-PSSession -computername Server01
```
L’invite de commandes change pour montrer que vous êtes maintenant connecté à l’ordinateur Server01.
```
Server01\C:>
```
Pour démarrer un travail distant dans la session, utilisez l’applet Start-Job de commande. La commande suivante exécute un travail distant qui obtient les événements dans le journal des événements Windows PowerShell sur l’ordinateur Server01. L’applet Start-Job de commande retourne un objet qui représente le travail.

Cette commande enregistre l’objet de travail dans la $job variable.
```
Server01\C:> $job = Start-Job -scriptblock {
  Get-Eventlog "Windows PowerShell"
}
```
Pendant que le travail s’exécute, vous pouvez utiliser la session interactive pour exécuter d’autres commandes, y compris d’autres travaux. Toutefois, vous devez conserver la session interactive ouverte jusqu’à ce que le travail soit terminé. Si vous terminez la session, le travail est interrompu et les résultats sont perdus.
Pour savoir si le travail est terminé, affichez la valeur de la $job variable ou utilisez l’applet Get-Job de commande pour obtenir le travail. La commande suivante utilise l’applet Get-Job de commande pour afficher le travail.
```
Server01\C:> Get-Job $job

SessionId  Name  State      HasMoreData  Location   Command
---------  ----  -----      -----------  --------   -------
1          Job1  Complete   True         localhost  Get-Eventlog "Windows...
```
La Get-Job sortie indique que le travail s’exécute sur l’ordinateur « localhost » car le travail a été démarré et s’exécute sur le même ordinateur (dans ce cas, Server01).
Pour obtenir les résultats du travail, utilisez l’applet Receive-Job de commande. Vous pouvez afficher les résultats de la session interactive ou les enregistrer dans un fichier sur l’ordinateur distant. La commande suivante obtient les résultats du travail dans la variable $job. La commande utilise l’opérateur de redirection (>) pour enregistrer les résultats du travail dans le fichier PsLog.txt sur l’ordinateur Server01.
```
Server01\C:> Receive-Job $job > c:\logs\PsLog.txt
```
Pour terminer la session interactive, utilisez l’applet de Exit-PSSession commande. L’invite de commandes change pour indiquer que vous revenez dans la session d’origine sur l’ordinateur local.
```
Server01\C:> Exit-PSSession
C:\PS>
```
Pour afficher le contenu du PsLog.txt fichier sur l’ordinateur Server01 à tout moment, démarrez une autre session interactive ou exécutez une commande distante. Ce type de commande est le mieux exécuté dans une session PSSession (connexion persistante) si vous souhaitez utiliser plusieurs commandes pour examiner et gérer les données dans le PsLog.txt fichier. Pour plus d’informations sur PSSessions, consultez about_PSSessions.

Les commandes suivantes utilisent l’applet New-PSSession de commande pour créer une session PSSession connectée à l’ordinateur Server01, et elles utilisent l’applet Invoke-Command de commande pour exécuter une Get-Content commande dans PSSession pour afficher le contenu du fichier.
```
$s = New-PSSession -computername Server01
Invoke-Command -session $s -scriptblock {
  Get-Content c:\logs\pslog.txt}
```

Démarrez un travail distant qui retourne les résultats sur l’ordinateur local (AsJob)

Pour démarrer un travail sur un ordinateur distant qui retourne les résultats de la commande sur l’ordinateur local, utilisez le paramètre AsJob d’une applet de commande telle que l’applet Invoke-Command de commande.

Lorsque vous utilisez le paramètre AsJob , l’objet de travail est en fait créé sur l’ordinateur local, même si le travail s’exécute sur l’ordinateur distant. Une fois le travail terminé, les résultats sont retournés à l’ordinateur local.

Vous pouvez utiliser les applets de commande qui contiennent le nom de travail (applets de commande Job) pour gérer n’importe quel travail créé par n’importe quelle applet de commande. La plupart des applets de commande qui ont des paramètres AsJob n’utilisent pas la communication à distance PowerShell. Vous pouvez donc les utiliser même sur les ordinateurs qui ne sont pas configurés pour la communication à distance et qui ne répondent pas aux exigences relatives à la communication à distance.

La commande suivante utilise le paramètre AsJob pour Invoke-Command démarrer un travail sur l’ordinateur Server01. Le travail exécute une Get-Eventlog commande qui obtient les événements dans le journal système. Vous pouvez utiliser le paramètre JobName pour attribuer un nom complet au travail.
```
Invoke-Command -computername Server01 -scriptblock {
  Get-Eventlog system} -AsJob
```
Les résultats de la commande ressemblent à l’exemple de sortie suivant.
```
SessionId   Name   State    HasMoreData   Location   Command
---------   ----   -----    -----------   --------   -------
1           Job1   Running  True          Server01   Get-Eventlog system
```
Lorsque le paramètre AsJob est utilisé, Invoke-Command retourne le même type d’objet de travail qui Start-Job retourne. Vous pouvez enregistrer l’objet de travail dans une variable ou utiliser une Get-Job commande pour obtenir le travail.

Notez que la valeur de la propriété Location indique que le travail s’est exécuté sur l’ordinateur Server01.
Pour gérer un travail démarré à l’aide du paramètre AsJob de l’applet Invoke-Command de commande, utilisez les applets de commande Job. Étant donné que l’objet de travail qui représente le travail distant se trouve sur l’ordinateur local, vous n’avez pas besoin d’exécuter de commandes distantes pour gérer le travail.

Pour déterminer si le travail est terminé, utilisez une Get-Job commande. La commande suivante obtient tous les travaux démarrés dans la session active.
```
Get-Job
```
Étant donné que le travail distant a été démarré dans la session active, une commande locale Get-Job obtient le travail. La propriété State de l’objet de travail indique que la commande a été terminée avec succès.
```
SessionId   Name   State      HasMoreData   Location   Command
---------   ----   -----      -----------   --------   -------
1           Job1   Completed  True          Server01   Get-Eventlog system
```
Pour obtenir les résultats du travail, utilisez l’applet Receive-Job de commande. Étant donné que les résultats du travail sont automatiquement retournés à l’ordinateur où réside l’objet de travail, vous pouvez obtenir les résultats avec une commande locale Receive-Job .

La commande suivante utilise l’applet Receive-Job de commande pour obtenir les résultats du travail. Il utilise l’ID de session pour identifier le travail. Cette commande enregistre les résultats du travail dans la variable $results. Vous pouvez également rediriger les résultats vers un fichier.
```
$results = Receive-Job -id 1
```

Démarrer un travail distant qui conserve les résultats sur l’ordinateur distant

Pour démarrer un travail sur un ordinateur distant qui conserve les résultats de la commande sur l’ordinateur distant, utilisez l’applet Invoke-Command de commande pour exécuter une Start-Job commande sur un ordinateur distant. Vous pouvez utiliser cette méthode pour exécuter des travaux sur plusieurs ordinateurs.

Lorsque vous exécutez une Start-Job commande à distance, l’objet de travail est créé sur l’ordinateur distant et les résultats du travail sont conservés sur l’ordinateur distant. Du point de vue du travail, toutes les opérations sont locales. Vous exécutez simplement des commandes à distance pour gérer un travail local sur l’ordinateur distant.

Utilisez l’applet Invoke-Command de commande pour exécuter une Start-Job commande sur un ordinateur distant.

Cette commande nécessite une session PSSession (connexion persistante). Si vous utilisez le paramètre ComputerName de Invoke-Command pour établir une connexion temporaire, la Invoke-Command commande est considérée comme terminée lorsque l’objet de travail est retourné. Par conséquent, la connexion temporaire est fermée et le travail est annulé.

La commande suivante utilise l’applet New-PSSession de commande pour créer une session PSSession connectée à l’ordinateur Server01. La commande enregistre la session PSSession dans la $s variable.
```
$s = New-PSSession -computername Server01
```
La commande suivante utilise l’applet Invoke-Command de commande pour exécuter une Start-Job commande dans la session PSSession. La Start-Job commande et la Get-Eventlog commande sont placées entre accolades.
```
Invoke-Command -session $s -scriptblock {
  Start-Job -scriptblock {Get-Eventlog system}}
```
Les résultats ressemblent à l’exemple de sortie suivant.
```
Id       Name    State      HasMoreData     Location   Command
--       ----    -----      -----------     --------   -------
2        Job2    Running    True            Localhost  Get-Eventlog system
```
Lorsque vous exécutez une Start-Job commande à distance, Invoke-Command retourne le même type d’objet de travail que celui qui Start-Job retourne. Vous pouvez enregistrer l’objet de travail dans une variable ou utiliser une Get-Job commande pour obtenir le travail.

Notez que la valeur de la propriété Location indique que le travail s’est exécuté sur l’ordinateur local, appelé « LocalHost », même si le travail s’est exécuté sur l’ordinateur Server01. Étant donné que l’objet de travail est créé sur l’ordinateur Server01 et que le travail s’exécute sur le même ordinateur, il est considéré comme un travail en arrière-plan local.
Pour gérer un travail distant, utilisez les applets de commande Job . Étant donné que l’objet de travail se trouve sur l’ordinateur distant, vous devez exécuter des commandes distantes pour obtenir, arrêter, attendre ou récupérer les résultats du travail.

Pour voir si le travail est terminé, utilisez une Invoke-Command commande pour exécuter une Get-Job commande dans la session PSSession connectée à l’ordinateur Server01.
```
Invoke-Command -session $s -scriptblock {Get-Job}
```
La commande retourne un objet de traitement. La propriété State de l’objet de travail indique que la commande a été effectuée avec succès.
```
SessionId   Name  State      HasMoreData   Location   Command
---------   ----  -----      -----------   --------   -------
2           Job2  Completed  True          LocalHost   Get-Eventlog system
```
Pour obtenir les résultats du travail, utilisez l’applet Invoke-Command de commande pour exécuter une Receive-Job commande dans la session PSSession connectée à l’ordinateur Server01.

La commande suivante utilise l’applet Receive-Job de commande pour obtenir les résultats du travail. Il utilise l’ID de session pour identifier le travail. Cette commande enregistre les résultats du travail dans la $results variable. Il utilise le paramètre Keep pour Receive-Job conserver le résultat dans le cache de travaux sur l’ordinateur distant.
```
$results = Invoke-Command -session $s -scriptblock {
  Receive-Job -SessionId 2 -Keep
}
```
Vous pouvez également rediriger les résultats vers un fichier sur l’ordinateur local ou distant. La commande suivante utilise un opérateur de redirection pour enregistrer les résultats dans un fichier sur l’ordinateur Server01.
```
Invoke-Command -session $s -command {
  Receive-Job -SessionId 2 > c:\logs\pslog.txt
}
```

Comment s’exécuter en tant que processus détaché

Comme mentionné précédemment, lorsque la session parente est terminée, tous les travaux enfants en cours d’exécution sont arrêtés avec leurs processus enfants. Vous pouvez utiliser la communication à distance sur l’ordinateur local pour exécuter des travaux qui ne sont pas attachés à la session PowerShell active.

Créez une session PowerShell sur l’ordinateur local. Utilisation Invoke-Command pour démarrer un travail dans cette session. Invoke-Command vous permet de déconnecter une session distante et de mettre fin à la session parente. Plus tard, vous pouvez démarrer une nouvelle session PowerShell et vous connecter à la session précédemment déconnectée pour reprendre la surveillance du travail. Toutefois, toutes les données retournées à la session PowerShell d’origine sont perdues lorsque cette session est terminée. Seuls les nouveaux objets de données générés après la déconnexion sont retournés lors de la nouvelle connexion.

# 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
...

Pour cet exemple, les travaux sont toujours attachés à une session PowerShell parente. Toutefois, la session parente n’est pas la session PowerShell d’origine où Invoke-Command a été exécutée.