about_Remote_Jobs

Articolo
04/13/2023

Descrizione breve

Viene descritto come eseguire processi in background nei computer remoti.

Descrizione dettagliata

PowerShell esegue contemporaneamente comandi e script tramite processi. Esistono tre tipi di processi forniti da PowerShell per supportare la concorrenza.

RemoteJob - Comandi e script eseguiti in una sessione remota.
BackgroundJob - Comandi e script eseguiti in un processo separato nel computer locale. Per altre informazioni, vedere About Jobs (Informazioni sui processi).
PSTaskJob oppure ThreadJob - I comandi e gli script vengono eseguiti in un thread separato all'interno dello stesso processo nel computer locale. Per altre informazioni, vedere about_Thread_Jobs.

L'esecuzione di script in remoto, in un computer separato o in un processo separato, offre un isolamento ottimale. Eventuali errori che si verificano nel processo remoto non influiscono su altri processi in esecuzione o sulla sessione padre che ha avviato il processo. Tuttavia, il livello di comunicazione remota aggiunge overhead, inclusa la serializzazione degli oggetti. Tutti gli oggetti vengono serializzati e deserializzati man mano che vengono passati tra la sessione padre e la sessione remota (processo). La serializzazione di oggetti dati complessi di grandi dimensioni può utilizzare grandi quantità di risorse di calcolo e memoria e trasferire grandi quantità di dati in rete.

Importante

La sessione padre che ha creato il processo monitora anche lo stato del processo e raccoglie i dati della pipeline. Il processo figlio del processo viene terminato dal processo padre dopo che il processo raggiunge uno stato completato. Se la sessione padre viene terminata, tutti i processi figlio in esecuzione vengono terminati insieme ai processi figlio.

Esistono due modi per ovviare a questa situazione:

Usare Invoke-Command per creare processi eseguiti in sessioni disconnesse. Vedere la sezione relativa ai processi scollegati di questo articolo.
Usare Start-Process per creare un nuovo processo anziché un processo. Per altre informazioni, vedere Start-Process.

Processi remoti

È possibile eseguire processi in computer remoti usando tre metodi diversi.

Avviare una sessione interattiva in un computer remoto. Avviare quindi un processo nella sessione interattiva. Le procedure sono le stesse dell'esecuzione di un processo locale, anche se tutte le azioni vengono eseguite nel computer remoto.
Eseguire un processo in un computer remoto che restituisce i risultati al computer locale. Utilizzare questo metodo quando si desidera raccogliere i risultati dei processi e gestirli in una posizione centrale nel computer locale.
Eseguire un processo in un computer remoto che mantiene i risultati nel computer remoto. Utilizzare questo metodo quando i dati del processo vengono mantenuti in modo più sicuro nel computer di origine.

Avviare un processo in una sessione interattiva

È possibile avviare una sessione interattiva con un computer remoto e quindi avviare un processo durante la sessione interattiva. Per altre informazioni sulle sessioni interattive, vedere about_Remote e vedere Enter-PSSession.

La procedura per avviare un processo in una sessione interattiva è quasi identica alla procedura per avviare un processo in background nel computer locale. Tuttavia, tutte le operazioni si verificano nel computer remoto, non nel computer locale.

Usare il Enter-PSSession cmdlet per avviare una sessione interattiva con un computer remoto. È possibile utilizzare il parametro ComputerName di Enter-PSSession per stabilire una connessione temporanea per la sessione interattiva. In alternativa, è possibile usare il parametro Session per eseguire la sessione interattiva in una sessione di PowerShell (PSSession).

Il comando seguente avvia una sessione interattiva nel computer Server01.
```
C:\PS> Enter-PSSession -computername Server01
```
Il prompt dei comandi cambia per indicare che si è connessi al computer Server01.
```
Server01\C:>
```
Per avviare un processo remoto nella sessione, usare il Start-Job cmdlet . Il comando seguente esegue un processo remoto che ottiene gli eventi nel registro eventi di Windows PowerShell nel computer Server01. Il Start-Job cmdlet restituisce un oggetto che rappresenta il processo.

Questo comando salva l'oggetto processo nella $job variabile .
```
Server01\C:> $job = Start-Job -scriptblock {
  Get-Eventlog "Windows PowerShell"
}
```
Durante l'esecuzione del processo, è possibile usare la sessione interattiva per eseguire altri comandi, inclusi altri processi. Tuttavia, è necessario mantenere aperta la sessione interattiva fino al completamento del processo. Se si termina la sessione, il processo viene interrotto e i risultati vengono persi.
Per verificare se il processo è completo, visualizzare il valore della $job variabile o usare il Get-Job cmdlet per ottenere il processo. Il comando seguente usa il Get-Job cmdlet per visualizzare il processo.
```
Server01\C:> Get-Job $job

SessionId  Name  State      HasMoreData  Location   Command
---------  ----  -----      -----------  --------   -------
1          Job1  Complete   True         localhost  Get-Eventlog "Windows...
```
L'output Get-Job mostra che il processo è in esecuzione nel computer "localhost" perché il processo è stato avviato ed è in esecuzione nello stesso computer (in questo caso Server01).
Per ottenere i risultati del processo, usare il Receive-Job cmdlet . È possibile visualizzare i risultati nella sessione interattiva o salvarli in un file nel computer remoto. Il comando seguente ottiene i risultati del processo nella variabile $job. Il comando usa l'operatore di reindirizzamento (>) per salvare i risultati del processo nel file PsLog.txt nel computer Server01.
```
Server01\C:> Receive-Job $job > c:\logs\PsLog.txt
```
Per terminare la sessione interattiva, usare il Exit-PSSession cmdlet . Il prompt dei comandi cambia per indicare che si è di nuovo nella sessione originale nel computer locale.
```
Server01\C:> Exit-PSSession
C:\PS>
```
Per visualizzare il contenuto del PsLog.txt file nel computer Server01 in qualsiasi momento, avviare un'altra sessione interattiva o eseguire un comando remoto. Questo tipo di comando è l'esecuzione migliore in una sessione PSSession (una connessione permanente) nel caso in cui si voglia usare diversi comandi per analizzare e gestire i dati nel PsLog.txt file. Per altre informazioni sulle sessioni PSSession, vedere about_PSSessions.

I comandi seguenti usano il New-PSSession cmdlet per creare una SESSIONE PSSession connessa al computer Server01 e usano il Invoke-Command cmdlet per eseguire un Get-Content comando in PSSession per visualizzare il contenuto del file.
```
$s = New-PSSession -computername Server01
Invoke-Command -session $s -scriptblock {
  Get-Content c:\logs\pslog.txt}
```

Avviare un processo remoto che restituisce i risultati al computer locale (AsJob)

Per avviare un processo in un computer remoto che restituisce i risultati del comando al computer locale, utilizzare il parametro AsJob di un cmdlet, ad esempio il Invoke-Command cmdlet .

Quando si usa il parametro AsJob , l'oggetto processo viene effettivamente creato nel computer locale anche se il processo viene eseguito nel computer remoto. Al termine del processo, i risultati vengono restituiti al computer locale.

È possibile usare i cmdlet che contengono il sostantivo Job (cmdlet Job) per gestire qualsiasi processo creato da qualsiasi cmdlet. Molti dei cmdlet con parametri AsJob non usano la comunicazione remota di PowerShell, quindi è possibile usarli anche nei computer non configurati per la comunicazione remota e che non soddisfano i requisiti per la comunicazione remota.

Il comando seguente usa il parametro AsJob di Invoke-Command per avviare un processo nel computer Server01. Il processo esegue un Get-Eventlog comando che ottiene gli eventi nel log di sistema. È possibile usare il parametro JobName per assegnare un nome visualizzato al processo.
```
Invoke-Command -computername Server01 -scriptblock {
  Get-Eventlog system} -AsJob
```
I risultati del comando sono simili all'output di esempio seguente.
```
SessionId   Name   State    HasMoreData   Location   Command
---------   ----   -----    -----------   --------   -------
1           Job1   Running  True          Server01   Get-Eventlog system
```
Quando viene utilizzato il parametro AsJob , Invoke-Command restituisce lo stesso tipo di oggetto processo restituito Start-Job . È possibile salvare l'oggetto processo in una variabile oppure usare un Get-Job comando per ottenere il processo.

Si noti che il valore della proprietà Location indica che il processo è stato eseguito nel computer Server01.
Per gestire un processo avviato usando il parametro AsJob del Invoke-Command cmdlet , usare i cmdlet Job. Poiché l'oggetto processo che rappresenta il processo remoto si trova nel computer locale, non è necessario eseguire comandi remoti per gestire il processo.

Per determinare se il processo è stato completato, usare un Get-Job comando . Il comando seguente ottiene tutti i processi avviati nella sessione corrente.
```
Get-Job
```
Poiché il processo remoto è stato avviato nella sessione corrente, un comando locale Get-Job ottiene il processo. La proprietà State dell'oggetto processo indica che il comando è stato completato correttamente.
```
SessionId   Name   State      HasMoreData   Location   Command
---------   ----   -----      -----------   --------   -------
1           Job1   Completed  True          Server01   Get-Eventlog system
```
Per ottenere i risultati del processo, usare il Receive-Job cmdlet . Poiché i risultati del processo vengono restituiti automaticamente al computer in cui si trova l'oggetto processo, è possibile ottenere i risultati con un comando locale Receive-Job .

Il comando seguente usa il Receive-Job cmdlet per ottenere i risultati del processo. Usa l'ID sessione per identificare il processo. Questo comando salva i risultati del processo nella variabile $results. È anche possibile reindirizzare i risultati a un file.
```
$results = Receive-Job -id 1
```

Avviare un processo remoto che mantiene i risultati nel computer remoto

Per avviare un processo in un computer remoto che mantiene i risultati del comando nel computer remoto, usare il Invoke-Command cmdlet per eseguire un Start-Job comando in un computer remoto. È possibile usare questo metodo per eseguire processi in più computer.

Quando si esegue un Start-Job comando in remoto, l'oggetto processo viene creato nel computer remoto e i risultati del processo vengono mantenuti nel computer remoto. Dal punto di vista del processo, tutte le operazioni sono locali. Si stanno semplicemente eseguendo comandi in remoto per gestire un processo locale nel computer remoto.

Usare il Invoke-Command cmdlet per eseguire un Start-Job comando in un computer remoto.

Questo comando richiede una sessione PSSession (una connessione permanente). Se si utilizza il parametro ComputerName di Invoke-Command per stabilire una connessione temporanea, il Invoke-Command comando viene considerato completo quando viene restituito l'oggetto processo. Di conseguenza, la connessione temporanea viene chiusa e il processo viene annullato.

Il comando seguente usa il New-PSSession cmdlet per creare una sessione PSSession connessa al computer Server01. Il comando salva la sessione PSSession nella $s variabile .
```
$s = New-PSSession -computername Server01
```
Il comando successivo usa il Invoke-Command cmdlet per eseguire un Start-Job comando nella sessione PSSession. Il Start-Job comando e il Get-Eventlog comando sono racchiusi tra parentesi graffe.
```
Invoke-Command -session $s -scriptblock {
  Start-Job -scriptblock {Get-Eventlog system}}
```
I risultati sono simili all'output di esempio seguente.
```
Id       Name    State      HasMoreData     Location   Command
--       ----    -----      -----------     --------   -------
2        Job2    Running    True            Localhost  Get-Eventlog system
```
Quando si esegue un Start-Job comando in modalità remota, Invoke-Command restituisce lo stesso tipo di oggetto processo restituito Start-Job . È possibile salvare l'oggetto processo in una variabile oppure usare un Get-Job comando per ottenere il processo.

Si noti che il valore della proprietà Location indica che il processo è stato eseguito nel computer locale, noto come "LocalHost", anche se il processo è stato eseguito nel computer Server01. Poiché l'oggetto processo viene creato nel computer Server01 e il processo viene eseguito nello stesso computer, viene considerato un processo in background locale.
Per gestire un processo remoto, usare i cmdlet Job . Poiché l'oggetto processo si trova nel computer remoto, è necessario eseguire comandi remoti per ottenere, arrestare, attendere o recuperare i risultati del processo.

Per verificare se il processo è completo, usare un Invoke-Command comando per eseguire un Get-Job comando nella sessione PSSession connessa al computer Server01.
```
Invoke-Command -session $s -scriptblock {Get-Job}
```
Il comando restituisce un oggetto processo. La proprietà State dell'oggetto processo indica che il comando è stato completato correttamente.
```
SessionId   Name  State      HasMoreData   Location   Command
---------   ----  -----      -----------   --------   -------
2           Job2  Completed  True          LocalHost   Get-Eventlog system
```
Per ottenere i risultati del processo, usare il Invoke-Command cmdlet per eseguire un Receive-Job comando nella sessione PSSession connessa al computer Server01.

Il comando seguente usa il Receive-Job cmdlet per ottenere i risultati del processo. Usa l'ID sessione per identificare il processo. Questo comando salva i risultati del $results processo nella variabile . Usa il parametro Keep di Receive-Job per mantenere il risultato nella cache dei processi nel computer remoto.
```
$results = Invoke-Command -session $s -scriptblock {
  Receive-Job -SessionId 2 -Keep
}
```
È anche possibile reindirizzare i risultati a un file nel computer locale o remoto. Il comando seguente usa un operatore di reindirizzamento per salvare i risultati in un file nel computer Server01.
```
Invoke-Command -session $s -command {
  Receive-Job -SessionId 2 > c:\logs\pslog.txt
}
```

Come eseguire come processo scollegato

Come accennato in precedenza, quando la sessione padre viene terminata, tutti i processi figlio in esecuzione vengono terminati insieme ai processi figlio. È possibile usare la comunicazione remota nel computer locale per eseguire processi non collegati alla sessione corrente di PowerShell.

Creare una nuova sessione di PowerShell nel computer locale. Invoke-Command Utilizzo per avviare un processo in questa sessione. Invoke-Command consente di disconnettere una sessione remota e terminare la sessione padre. Successivamente, è possibile avviare una nuova sessione di PowerShell e connettersi alla sessione disconnessa in precedenza per riprendere il monitoraggio del processo. Tuttavia, tutti i dati restituiti alla sessione originale di PowerShell vengono persi quando la sessione viene terminata. Solo i nuovi oggetti dati generati dopo la disconnessione vengono restituiti durante la riconnessa.

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

Per questo esempio, i processi sono ancora collegati a una sessione padre di PowerShell. Tuttavia, la sessione padre non è la sessione di PowerShell originale in cui Invoke-Command è stata eseguita.