about_Remote_Jobs

Aggiornamento: maggio 2014

Si applica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0

ARGOMENTO

about_Remote_Jobs

DESCRIZIONE BREVE

Descrive come eseguire processi in background in computer remoti.

DESCRIZIONE DETTAGLIATA

Un processo in background è un comando che viene eseguito in modo asincrono, senza interazioni con la sessione corrente. Viene restituito immediatamente il prompt dei comandi ed è possibile continuare a usare la sessione durante l'esecuzione del processo.

Per impostazione predefinita, i processi in background vengono eseguiti nel computer locale. Tuttavia, è possibile usare varie procedure diverse per l'esecuzione di processi in background nei computer remoti.

Questo argomento illustra come eseguire un processo in background in un computer remoto. Per informazioni sull'esecuzione di processi in background in un computer locale, vedere about_Jobs. Per altre informazioni sui processi in background, vedere about_Job_Details.

PROCESSI IN BACKGROUND REMOTI

È possibile eseguire processi in background in computer remoti con tre metodi diversi.

-- Avviare una sessione interattiva con un computer remoto e avviare un processo nella sessione interattiva. Le procedure sono identiche a quelle relative all'esecuzione di un processo locale, anche se tutte le azioni vengono eseguite nel computer remoto.

-- Eseguire un processo in background in un computer remoto che restituisce i risultati nel computer locale. Usare questo metodo se si desidera raccogliere i risultati dei processi in background e mantenerli in una posizione centrale nel computer locale.

-- Eseguire un processo in background in un computer remoto che mantiene i risultati nel computer remoto. Usare questo metodo se i dati dei processi vengono mantenuti in modo più sicuro nel computer di origine.

AVVIARE UN PROCESSO IN BACKGROUND IN UNA SESSIONE INTERATTIVA

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

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

PASSAGGIO 1: ENTER-PSSESSION

Usare il cmdlet Enter-PSSession per avviare una sessione interattiva con un computer remoto. Usare 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 Windows PowerShell® (PSSession).

Il comando seguente avvia una sessione interattiva nel computer Server01.

        C:\PS> Enter-PSSession -computername Server01

Il prompt dei comandi cambia per mostrare che l'utente è connesso al computer Server01.

        Server01\C:>

PASSAGGIO 2: START-JOB

Per avviare un processo in background nella sessione, usare il cmdlet Start-Job.

Il comando seguente esegue un processo in background che ottiene gli eventi nel registro eventi di Windows PowerShell nel computer Server01. Il cmdlet Start-job restituisce un oggetto che rappresenta il processo.

Salva l'oggetto processo nella variabile $job.

        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 in background. Tuttavia, è necessario mantenere la sessione interattiva aperta fino al completamento del processo. Se la sessione viene terminata, il processo viene interrotto e i risultati vengono persi.

PASSAGGIO 3: GET-JOB

Per scoprire se il processo è stato completato, visualizzare il valore della variabile $job oppure usare il cmdlet Get-Job per ottenere il processo. Il comando seguente usa il cmdlet Get-Job per visualizzare il processo.

        Server01\C:> get-job $job

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

L'output di Get-Job indica che il processo è in esecuzione nel computer "localhost" perché il processo è stato avviato e viene eseguito nello stesso computer (in questo caso, Server01).

PASSAGGIO 4: RECEIVE-JOB

Per ottenere i risultati del processo, usare il cmdlet Receive-Job. È 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

PASSAGGIO 5: EXIT-PSSESSION

Per terminare la sessione interattiva, usare il cmdlet Exit-PSSession. Il prompt dei comandi cambia per indicare che l'utente è di nuovo nella sessione originale nel computer locale.

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

PASSAGGIO 6: INVOKE-COMMAND: GET-CONTENT

Per visualizzare il contenuto del file PsLog.txt nel computer Server01 in qualsiasi momento, avviare un'altra sessione interattiva o eseguire un comando remoto. È consigliabile eseguire questo tipo di comando in PSSession (una connessione permanente) se si desidera usare diversi comandi per analizzare e gestire i dati nel file PsLog.txt. Per altre informazioni sulle sessioni PSSession, vedere about_PSSessions.

I comandi seguenti usano il cmdlet New-PSSession per creare una sessione PSSession connessa al computer Server01 e il cmdlet Invoke-Command per eseguire un comando Get-Content in PSSession per visualizzare il contenuto del file.

        C:\PS> $s = new-pssession -computername Server01
        C:\PS> 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 background in un computer remoto che restituisce i risultati del comando al computer locale, usare il parametro AsJob di un cmdlet come Invoke-Command.

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 nel computer locale.

È possibile usare i cmdlet che contengono il sostantivo Job (cmdlet Job) per gestire i processi creati da qualsiasi cmdlet. Molti cmdlet che dispongono di parametri AsJob non usano la comunicazione remota di Windows PowerShell. Pertanto, è possibile usarli anche in computer che non sono configurati per la comunicazione remota e che non soddisfano i requisiti per tale connessione.

PASSAGGIO 1: INVOKE-COMMAND -ASJOB

Il comando seguente usa il parametro AsJob di Invoke-Command per avviare un processo in background nel computer Server01. Il processo esegue un comando che ottiene gli eventi nel registro 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 saranno simili all'output di esempio riportato di seguito.

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

Quando viene usato il parametro AsJob, Invoke-Command restituisce lo stesso tipo di oggetto processo restituito da Start-Job. È possibile salvare l'oggetto processo in una variabile oppure usare un comando Get-Job per ottenere il processo.

Si noti che il valore della proprietà Location indica che il processo è stato eseguito nel computer Server01.

PASSAGGIO 2: GET-JOB

Per gestire un processo avviato tramite il parametro AsJob del cmdlet Invoke-Command, usare i cmdlet Job. Poiché l'oggetto processo che rappresenta il processo remoto si trova nel computer locale, non è necessario eseguire i comandi remoti per gestire il processo.

Per determinare se il processo è stato completato, usare un comando Get-Job. Il comando seguente ottiene tutti i processi avviati nella sessione corrente.

        get-job

Poiché il processo remoto è stato avviato nella sessione corrente, un comando Get-Job locale ottiene il processo. La proprietà State dell'oggetto processo indica che il comando è stato completato in modo corretto.

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

PASSAGGIO 3: RECEIVE-JOB

Per ottenere i risultati del processo, usare il cmdlet Receive-Job. Poiché i risultati del processo vengono restituiti automaticamente nel computer in cui risiede l'oggetto processo, è possibile ottenere i risultati con un comando Receive-Job locale.

Il comando seguente usa il cmdlet Receive-Job per ottenere i risultati del processo. Usa l'ID della sessione per identificare il processo e 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 background in un computer remoto che mantiene i risultati del comando nel computer remoto, usare il cmdlet Invoke-Command per eseguire un comando Start-Job in un computer remoto. È possibile usare questo metodo per eseguire processi in background in più computer.

Quando si esegue un comando Start-Job in remoto, l'oggetto processo viene creato nel computer remoto e i risultati del processo vengono mantenuti nel computer remoto. Dalla prospettiva del processo, tutte le operazioni vengono svolte in locale. Vengono semplicemente eseguiti comandi in remoto per gestire un processo locale nel computer remoto.

PASSAGGIO 1: INVOKE-COMMAND START-JOB

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

Questo comando richiede PSSession (una connessione permanente). Se si usa il parametro ComputerName di Invoke-Command per stabilire una connessione temporanea, il comando Invoke-Command 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 cmdlet New-PSSession per creare una sessione PSSession connessa al computer Server01. Il comando salva la sessione PSSession nella variabile $s.

        $s = new-pssession -computername Server01

Il comando successivo usa il cmdlet Invoke-Command per eseguire un comando Start-Job in PSSession. Il comando Start-Job e il comando Get-Eventlog sono racchiusi tra parentesi graffe.

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

I risultati saranno simili all'output di esempio riportato di seguito.

       Id       Name    State      HasMoreData     Location   Command
       --       ----    -----      -----------     --------   -------
       2        Job2    Running    True            Localhost  get-eventlog system

Quando si esegue un comando Start-Job in remoto, Invoke-Command restituisce lo stesso tipo di oggetto processo restituito da Start-Job. È possibile salvare l'oggetto processo in una variabile oppure usare un comando Get-Job 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 come un processo in background locale.

PASSAGGIO 2: INVOKE-COMMAND GET-JOB

Per gestire un processo in background remoto, usare i cmdlet Job. Poiché l'oggetto processo si trova nel computer remoto, è necessario eseguire i comandi remoti per ottenere, arrestare, attendere o recuperare i risultati del processo.

Per verificare se il processo è stato completato, usare un comando Invoke-Command per eseguire un comando Get-Job 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 in modo corretto.

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

PASSAGGIO 3: INVOKE-COMMAND RECEIVE-JOB

Per ottenere i risultati del processo, usare il cmdlet Invoke-Command per eseguire un comando Receive-Job nella sessione PSSession connessa al computer Server01.

Il comando seguente usa il cmdlet Receive-Job per ottenere i risultati del processo. Usa l'ID della sessione per identificare il processo e salva i risultati del processo nella variabile $results. 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 in quello 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}

VEDERE ANCHE

about_Jobs

about_Job_Details

about_Remote

about_Remote_Variables

Invoke-Command

Start-Job

Get-Job

Wait-Job

Stop-Job

Remove-Job

New-PSSession

Enter-PSSession

Exit-PSSession