about_Remote_Jobs

Artigo
04/13/2023

Descrição breve

Descreve como executar trabalhos em segundo plano em computadores remotos.

Descrição Detalhada

O PowerShell executa simultaneamente comandos e scripts por meio de trabalhos. Há três tipos de trabalho fornecidos pelo PowerShell para dar suporte à simultaneidade.

RemoteJob - Comandos e scripts são executados em uma sessão remota.
BackgroundJob - Comandos e scripts são executados em um processo separado na máquina local. Para obter mais informações, consulte about_Jobs.
PSTaskJob ou ThreadJob - Comandos e scripts são executados em um thread separado dentro do mesmo processo no computador local. Para obter mais informações, consulte about_Thread_Jobs.

A execução de scripts remotamente, em uma máquina separada ou em um processo separado, fornece grande isolamento. Quaisquer erros que ocorram no trabalho remoto não afetam outros trabalhos em execução ou a sessão pai que iniciou o trabalho. No entanto, a camada remota adiciona sobrecarga, incluindo a serialização de objetos. Todos os objetos são serializados e desserializados à medida que são passados entre a sessão pai e a sessão remota (trabalho). A serialização de objetos de dados grandes e complexos pode consumir grandes quantidades de recursos de computação e memória e transferir grandes quantidades de dados pela rede.

Importante

A sessão pai que criou o trabalho também monitora o status do trabalho e coleta dados do pipeline. O processo filho do trabalho é encerrado pelo processo pai quando o trabalho atinge um estado concluído. Se a sessão pai for encerrada, todos os trabalhos filho em execução serão encerrados junto com seus processos filho.

Existem duas maneiras de contornar essa situação:

Use Invoke-Command para criar trabalhos que são executados em sessões desconectadas. Consulte a seção de processos desanexados deste artigo.
Use Start-Process para criar um novo processo em vez de um trabalho. Para saber mais, confira Start-Process.

Trabalhos remotos

Você pode executar trabalhos em computadores remotos usando três métodos diferentes.

Inicie uma sessão interativa em um computador remoto. Em seguida, inicie um trabalho na sessão interativa. Os procedimentos são os mesmos da execução de um trabalho local, embora todas as ações sejam executadas no computador remoto.
Execute um trabalho em um computador remoto que retorna seus resultados para o computador local. Use esse método quando quiser coletar os resultados dos trabalhos e mantê-los em um local central no computador local.
Execute um trabalho em um computador remoto que mantenha seus resultados no computador remoto. Use esse método quando os dados do trabalho forem mantidos com mais segurança no computador de origem.

Iniciar um trabalho em uma sessão interativa

Você pode iniciar uma sessão interativa com um computador remoto e, em seguida, iniciar um trabalho durante a sessão interativa. Para obter mais informações sobre sessões interativas, consulte about_Remote e .Enter-PSSession

O procedimento para iniciar um trabalho em uma sessão interativa é quase idêntico ao procedimento para iniciar um trabalho em segundo plano no computador local. No entanto, todas as operações ocorrem no computador remoto, não no computador local.

Use o Enter-PSSession cmdlet para iniciar uma sessão interativa com um computador remoto. Você pode usar o parâmetro ComputerName de Enter-PSSession para estabelecer uma conexão temporária para a sessão interativa. Ou você pode usar o parâmetro Session para executar a sessão interativa em uma sessão do PowerShell (PSSession).

O comando a seguir inicia uma sessão interativa no computador Server01.
```
C:\PS> Enter-PSSession -computername Server01
```
O prompt de comando muda para mostrar que agora você está conectado ao computador Server01.
```
Server01\C:>
```
Para iniciar um trabalho remoto na sessão, use o Start-Job cmdlet. O comando a seguir executa um trabalho remoto que obtém os eventos no log de eventos do Windows PowerShell no computador Server01. O Start-Job cmdlet retorna um objeto que representa o trabalho.

Esse comando salva o objeto de trabalho na $job variável.
```
Server01\C:> $job = Start-Job -scriptblock {
  Get-Eventlog "Windows PowerShell"
}
```
Enquanto o trabalho é executado, você pode usar a sessão interativa para executar outros comandos, incluindo outros trabalhos. No entanto, você deve manter a sessão interativa aberta até que o trabalho seja concluído. Se você encerrar a sessão, o trabalho será interrompido e os resultados serão perdidos.
Para descobrir se o trabalho foi concluído, exiba o $job valor da variável ou use o Get-Job cmdlet para obter o trabalho. O comando a seguir usa o Get-Job cmdlet para exibir o trabalho.
```
Server01\C:> Get-Job $job

SessionId  Name  State      HasMoreData  Location   Command
---------  ----  -----      -----------  --------   -------
1          Job1  Complete   True         localhost  Get-Eventlog "Windows...
```
A Get-Job saída mostra que o trabalho está em execução no computador "localhost" porque o trabalho foi iniciado e está em execução no mesmo computador (nesse caso, Server01).
Para obter os resultados do trabalho, use o Receive-Job cmdlet. Você pode exibir os resultados na sessão interativa ou salvá-los em um arquivo no computador remoto. O comando a seguir obtém os resultados do trabalho na variável $job. O comando usa o operador de redirecionamento (>) para salvar os resultados do trabalho no arquivo PsLog.txt no computador Server01.
```
Server01\C:> Receive-Job $job > c:\logs\PsLog.txt
```
Para encerrar a sessão interativa, use o Exit-PSSession cmdlet. O prompt de comando é alterado para mostrar que você está de volta à sessão original no computador local.
```
Server01\C:> Exit-PSSession
C:\PS>
```
Para exibir o PsLog.txt conteúdo do arquivo no computador Server01 a qualquer momento, inicie outra sessão interativa ou execute um comando remoto. Esse tipo de comando é melhor executado em um PSSession (uma conexão persistente) caso você queira usar vários comandos para investigar e gerenciar os PsLog.txt dados no arquivo. Para obter mais informações sobre PSSessions, consulte about_PSSessions.

Os comandos a seguir usam o New-PSSession cmdlet para criar um PSSession conectado ao computador Server01 e usam o Invoke-Command cmdlet para executar um Get-Content comando no PSSession para exibir o conteúdo do arquivo.
```
$s = New-PSSession -computername Server01
Invoke-Command -session $s -scriptblock {
  Get-Content c:\logs\pslog.txt}
```

Iniciar um trabalho remoto que retorna os resultados para o computador local (AsJob)

Para iniciar um trabalho em um computador remoto que retorna os resultados do comando para o computador local, use o parâmetro AsJob de um cmdlet como o Invoke-Command cmdlet.

Quando você usa o parâmetro AsJob , o objeto de trabalho é realmente criado no computador local, mesmo que o trabalho seja executado no computador remoto. Quando o trabalho é concluído, os resultados são retornados ao computador local.

Você pode usar os cmdlets que contêm o substantivo Job (os cmdlets Job) para gerenciar qualquer trabalho criado por qualquer cmdlet. Muitos dos cmdlets que têm parâmetros AsJob não usam a comunicação remota do PowerShell, portanto, você pode usá-los mesmo em computadores que não estão configurados para comunicação remota e que não atendem aos requisitos de comunicação remota.

O comando a seguir usa o parâmetro AsJob de Invoke-Command para iniciar um trabalho no computador Server01. O trabalho executa um Get-Eventlog comando que obtém os eventos no log do sistema. Você pode usar o parâmetro JobName para atribuir um nome de exibição ao trabalho.
```
Invoke-Command -computername Server01 -scriptblock {
  Get-Eventlog system} -AsJob
```
Os resultados do comando são semelhantes à saída de exemplo a seguir.
```
SessionId   Name   State    HasMoreData   Location   Command
---------   ----   -----    -----------   --------   -------
1           Job1   Running  True          Server01   Get-Eventlog system
```
Quando o parâmetro AsJob é usado, Invoke-Command retorna o mesmo tipo de objeto de trabalho que Start-Job retorna. Você pode salvar o objeto de trabalho em uma variável ou pode usar um Get-Job comando para obter o trabalho.

Observe que o valor da propriedade Location mostra que o trabalho foi executado no computador Server01.
Para gerenciar um trabalho iniciado usando o parâmetro AsJob do Invoke-Command cmdlet, use os cmdlets Job. Como o objeto de trabalho que representa o trabalho remoto está no computador local, você não precisa executar comandos remotos para gerenciar o trabalho.

Para determinar se o trabalho foi concluído, use um Get-Job comando. O comando a seguir obtém todos os trabalhos que foram iniciados na sessão atual.
```
Get-Job
```
Como o trabalho remoto foi iniciado na sessão atual, um comando local Get-Job obtém o trabalho. A propriedade State do objeto de trabalho mostra que o comando foi concluído com êxito.
```
SessionId   Name   State      HasMoreData   Location   Command
---------   ----   -----      -----------   --------   -------
1           Job1   Completed  True          Server01   Get-Eventlog system
```
Para obter os resultados do trabalho, use o Receive-Job cmdlet. Como os resultados do trabalho são retornados automaticamente ao computador em que o objeto de trabalho reside, você pode obter os resultados com um comando local Receive-Job .

O comando a seguir usa o Receive-Job cmdlet para obter os resultados do trabalho. Ele usa a ID da sessão para identificar o trabalho. Esse comando salva os resultados do trabalho na variável $results. Você também pode redirecionar os resultados para um arquivo.
```
$results = Receive-Job -id 1
```

Iniciar um trabalho remoto que mantém os resultados no computador remoto

Para iniciar um trabalho em um computador remoto que mantém os resultados do comando no computador remoto, use o Invoke-Command cmdlet para executar um Start-Job comando em um computador remoto. Você pode usar esse método para executar trabalhos em vários computadores.

Quando você executa um Start-Job comando remotamente, o objeto de trabalho é criado no computador remoto e os resultados do trabalho são mantidos no computador remoto. Do ponto de vista do trabalho, todas as operações são locais. Você está apenas executando comandos remotamente para gerenciar um trabalho local no computador remoto.

Use o Invoke-Command cmdlet para executar um Start-Job comando em um computador remoto.

Este comando requer um PSSession (uma conexão persistente). Se você usar o parâmetro ComputerName de para estabelecer uma conexão temporária, o Invoke-Command comando será considerado concluído quando o objeto de Invoke-Command trabalho for retornado. Como resultado, a conexão temporária é fechada e o trabalho é cancelado.

O comando a seguir usa o New-PSSession cmdlet para criar um PSSession conectado ao computador Server01. O comando salva o PSSession na $s variável.
```
$s = New-PSSession -computername Server01
```
O próximo comando usa o Invoke-Command cmdlet para executar um Start-Job comando no PSSession. O Start-Job comando e o Get-Eventlog comando estão entre chaves.
```
Invoke-Command -session $s -scriptblock {
  Start-Job -scriptblock {Get-Eventlog system}}
```
Os resultados são semelhantes aos seguintes exemplos de saída.
```
Id       Name    State      HasMoreData     Location   Command
--       ----    -----      -----------     --------   -------
2        Job2    Running    True            Localhost  Get-Eventlog system
```
Quando você executa um Start-Job comando remotamente, Invoke-Command retorna o mesmo tipo de objeto de trabalho que Start-Job retorna. Você pode salvar o objeto de trabalho em uma variável ou pode usar um Get-Job comando para obter o trabalho.

Observe que o valor da propriedade Location mostra que o trabalho foi executado no computador local, conhecido como "LocalHost", mesmo que o trabalho tenha sido executado no computador Server01. Como o objeto de trabalho é criado no computador Server01 e o trabalho é executado no mesmo computador, ele é considerado um trabalho em segundo plano local.
Para gerenciar um trabalho remoto, use os cmdlets Job . Como o objeto de trabalho está no computador remoto, você precisa executar comandos remotos para obter, parar, aguardar ou recuperar os resultados do trabalho.

Para ver se o trabalho foi concluído, use um Invoke-Command comando para executar um Get-Job comando no PSSession que está conectado ao computador Server01.
```
Invoke-Command -session $s -scriptblock {Get-Job}
```
O comando retorna um objeto de trabalho. A propriedade State do objeto de trabalho mostra que o comando foi concluído com êxito.
```
SessionId   Name  State      HasMoreData   Location   Command
---------   ----  -----      -----------   --------   -------
2           Job2  Completed  True          LocalHost   Get-Eventlog system
```
Para obter os resultados do trabalho, use o Invoke-Command cmdlet para executar um Receive-Job comando no PSSession que está conectado ao computador Server01.

O comando a seguir usa o Receive-Job cmdlet para obter os resultados do trabalho. Ele usa a ID da sessão para identificar o trabalho. Esse comando salva os resultados do $results trabalho na variável. Ele usa o parâmetro Keep de para manter o resultado no cache de Receive-Job trabalho no computador remoto.
```
$results = Invoke-Command -session $s -scriptblock {
  Receive-Job -SessionId 2 -Keep
}
```
Você também pode redirecionar os resultados para um arquivo no computador local ou remoto. O comando a seguir usa um operador de redirecionamento para salvar os resultados em um arquivo no computador Server01.
```
Invoke-Command -session $s -command {
  Receive-Job -SessionId 2 > c:\logs\pslog.txt
}
```

Como executar como um processo desanexado

Como mencionado anteriormente, quando a sessão pai é encerrada, todos os trabalhos filho em execução são encerrados junto com seus processos filho. Você pode usar a comunicação remota no computador local para executar trabalhos que não estão anexados à sessão atual do PowerShell.

Crie uma nova sessão do PowerShell no computador local. O uso Invoke-Command para iniciar um trabalho nesta sessão. Invoke-Command Permite desconectar uma sessão remota e encerrar a sessão pai. Posteriormente, você pode iniciar uma nova sessão do PowerShell e conectar-se à sessão desconectada anteriormente para retomar o monitoramento do trabalho. No entanto, todos os dados que foram retornados para a sessão original do PowerShell são perdidos quando essa sessão é encerrada. Somente novos objetos de dados gerados após a desconexão são retornados quando reconectados.

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

Para este exemplo, os trabalhos ainda estão anexados a uma sessão pai do PowerShell. No entanto, a sessão pai não é a sessão original do PowerShell em que Invoke-Command foi executada.

Compartilhar via