Compartilhar via


about_Remote_Jobs

TÓPICO
    about_Remote_Jobs

DESCRIÇÃO RESUMIDA
    Descreve como executar trabalhos em segundo plano em computadores 
    remotos.

DESCRIÇÃO DETALHADA
    Um trabalho em segundo plano é um comando executado de modo 
    assíncrono sem interagir com a sessão atual. O prompt de comando 
    é retornado imediatamente e você pode continuar usando a sessão 
    enquanto o trabalho é executado.

    Por padrão, trabalhos em segundo plano são executados no 
    computador local. No entanto, você pode usar vários procedimentos 
    diferentes para executar trabalhos em segundo plano nos 
    computadores remotos. 

    Este tópico explica como executar um trabalho em segundo plano em 
    um computador remoto. Para obter informações sobre como executar 
    trabalhos em segundo plano em um computador local, consulte 
    about_Jobs. Para obter mais informações sobre trabalhos em 
    segundo plano, consulte about_Job_Details.


 TRABALHOS EM SEGUNDO PLANO

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

    -- Inicie uma sessão interativa com um computador remoto e inicie 
       um trabalho na sessão interativa. Os procedimentos são os 
       mesmos executados durante a execução de um trabalho local, 
       embora todas as ações sejam executadas no computador remoto.

    -- Execute um trabalho em segundo plano em um computador remoto 
       que retorne seus resultados ao computador local. Use este 
       método quando você quiser coletar os resultados de trabalhos 
       em segundo plano e mantê-los em um local central no computador 
       local.

    -- Execute um trabalho em segundo plano em um computador remoto 
       que mantenha seus resultados nesse computador. Use este método 
       quando os dados do trabalho forem mantidos com mais segurança 
       no computador de origem.  

 INICIAR UM TRABALHO EM SEGUNDO PLANO EM UMA SESSÃO INTERATIVA

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

    O procedimento para iniciar um trabalho em segundo plano 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, e não no 
    computador local.


    ETAPA 1: ENTER-PSSESSION

    Use o cmdlet Enter-PSSession 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. Você pode usar o parâmetro Session para 
    executar a sessão interativa em uma sessão do Windows PowerShell 
    (PSSession). 

    O comando a seguir inicia uma sessão interativa no computador 
    Server01.
  
        C:\PS> Enter-PSSession -computername Server01

    O prompt de comando é alterado para indicar que agora você está 
    conectado ao computador Server01.

        Server01\C:>


    ETAPA 2: START-JOB

    Para iniciar um trabalho em segundo plano na sessão, use o cmdlet 
    Start-Job.

    O comando a seguir executa um trabalho em segundo plano que 
    insere os eventos no log de eventos do Windows PowerShell no 
    computador Server01. O cmdlet Start-Job retorna um objeto que 
    representa o trabalho. 

    Esse comando salva o objeto de trabalho na variável $job. 

        Server01\C:> $job = start-job -scriptblock {get-eventlog "Windows PowerShell"}
           
    Enquanto o trabalho estiver em execução, você poderá usar 
    a sessão interativa para executar outros comandos, inclusive outros 
    trabalhos em segundo plano. 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.



    ETAPA 3: GET-JOB

    Para descobrir se o trabalho foi concluído, exiba o valor da 
    variável $job ou use o cmdlet Get-Job para obter o trabalho. 
    O comando a seguir usa o cmdlet Get-Job para exibir o trabalho.

        Server01\C:> get-job $job

        SessionId  Name  State      HasMoreData  Location   Command
        ---------  ----  -----      -----------  --------   -------
        1          Job1  Complete   True         localhost  get-eventlog "Windows PowerShell"
        
   
    A saída de Get-Job mostra que o trabalho está sendo executado no 
    computador "localhost" porque o trabalho foi iniciado e estava em 
    execução no mesmo computador (neste caso, Server01).
    


    ETAPA 4: RECEIVE-JOB

    Para obter os resultados do trabalho, use o cmdlet Receive-Job. 
    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



    ETAPA 5: EXIT-PSSESSION

    Para encerrar a sessão interativa, use o cmdlet Exit-PSSession. 
    O prompt de comando é alterado para indicar que você está novamente 
    na sessão original no computador local.

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


    ETAPA 6: INVOKE-COMMAND: OBTER CONTEÚDO
     
    Para exibir o conteúdo do arquivo PsLog.txt no computador 
    Server01 a qualquer momento, inicie outra sessão interativa ou 
    execute um comando remoto. Este tipo de comando é melhor 
    executado em uma PSSession (uma conexão persistente) caso você 
    queira usar vários comandos para investigar e gerenciar os dados 
    no arquivo PsLog.txt. Para obter mais informações sobre as 
    PSSessions, consulte about_PSSessions.

    Os comandos a seguir usam o cmdlet New-PSSession para criar uma 
    PSSession conectada ao computador Server01 e usam o cmdlet 
    Invoke-Command para executar o comando Get-Content na PSSession 
    a fim de exibir o conteúdo do arquivo.

        C:\PS> $s = new-pssession -computername Server01
        C:\PS> invoke-command -session $s -scriptblock {get-content c:\logs\pslog.txt}
        

      
 INICIAR UM TRABALHO REMOTO QUE RETORNE OS RESULTADOS AO COMPUTADOR 
 LOCAL (ASJOB)

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

    Quando você usar o parâmetro AsJob, o objeto de trabalho será 
    criado no computador local, mesmo que o trabalho seja executado 
    no computador remoto. Quando o trabalho for concluído, os 
    resultados serão retornados ao computador local. 

    Você pode usar os cmdlets que contêm a palavra Job (os cmdlets 
    Job) para gerenciar qualquer trabalho criado por qualquer cmdlet. 
    Vários cmdlets que têm os parâmetros AsJob não usam a comunicação 
    remota do Windows PowerShell, portanto, você pode usá-los até 
    mesmo em computadores que não estejam configurados para comunicação 
    remota e que não atendam aos requisitos dessa comunicação.
 

    ETAPA 1: INVOKE-COMMAND -ASJOB

    O comando a seguir usa o parâmetro AsJob de Invoke-Command para 
    iniciar um trabalho em segundo plano no computador Server01. 
    O trabalho executa um comando Get-Eventlog que obtém os eventos no 
    log do sistema. Você pode usar o parâmetro JobName para atribuir 
    um nome para exibição ao trabalho.

       invoke-command -computername Server01 -scriptblock {get-eventlog system} -asjob 
       

    Os resultados do comando se assemelham à 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 for usado, Invoke-Command retornará 
    o mesmo tipo de objeto de trabalho que Start-Job. Você pode salvar 
    o objeto de trabalho em uma variável ou pode usar um comando 
    Get-Job para obter o trabalho.

    Observe que o valor da propriedade Location mostra que o trabalho 
    foi executado no computador Server01.  


    ETAPA 2: GET-JOB

    Para gerenciar um trabalho iniciado com o parâmetro AsJob do 
    cmdlet Invoke-Command, use os cmdlets Job. Como o objeto de 
    trabalho que representa o trabalho remoto está no computador 
    local, você não precisa executar os comandos remotos para 
    gerenciar o trabalho.  

    Para determinar se o trabalho foi concluído, use um comando Get-Job. 
    O comando a seguir obtém todos os trabalho iniciados na sessão atual. 
    
        get-job

    Como o trabalho remoto foi iniciado na sessão atual, um comando 
    Get-Job local obtém o trabalho. A propriedade State do objeto de 
    trabalho indica que o comando foi concluído com êxito.
       
       SessionId   Name   State      HasMoreData     Location   Command
       ---------   ----   -----      -----------     --------   -------
       1           Job1   Completed  True            Server01   get-eventlog system
       


    ETAPA 3: RECEIVE-JOB

    Para obter os resultados do trabalho, use o cmdlet Receive-Job. 
    Como os resultados do trabalho são automaticamente retornados ao 
    computador em que o objeto de trabalho reside, você pode obter os 
    resultados com um comando Receive-Job local.

    O comando a seguir usa o cmdlet Receive-Job para obter os 
    resultados do trabalho. Ele usa a ID da sessão para identificar 
    o trabalho e 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 MANTENHA OS RESULTADOS NO COMPUTADOR 
 REMOTO

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

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


    ETAPA 1: INVOKE-COMMAND START-JOB

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

    Esse comando requer uma PSSession (uma conexão persistente). 
    Se você usar o parâmetro ComputerName de Invoke-Command para 
    estabelecer uma conexão temporária, o comando Invoke-Command será 
    considerado concluído quando o objeto de trabalho for retornado. 
    Como resultado, a conexão temporária será fechada e o trabalho, 
    cancelado.
 
    O comando a seguir usa o cmdlet New-PSSession para criar uma 
    PSSession que esteja conectada ao computador Server01. O comando 
    salva a PSSession na variável $s.

        $s = new-pssession -computername Server01


    O comando a seguir usa o cmdlet Invoke-Command para executar um 
    comando Start-Job na PSSession. Os comandos Start-Job e Get-Eventlog 
    são colocados entre chaves.

       invoke-command -session $s -scriptblock {start-job -scriptblock {get-eventlog system}}
       
    Os resultados se assemelham à saída de exemplo a seguir.


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

    Quando você executar um comando Start-Job remotamente, 
    Invoke-Command retornará o mesmo tipo de objeto de trabalho que 
    Start-Job. Você pode salvar o objeto de trabalho em uma variável 
    ou pode usar um comando Get-Job para obter o trabalho.

    Observe que o valor da propriedade Location indica 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 foi criado no computador Server01 e o 
    trabalho foi executado no mesmo computador, ele é considerado um 
    trabalho em segundo plano local.  


    ETAPA 2: INVOKE-COMMAND GET-JOB

    Para gerenciar um trabalho em segundo plano, use os cmdlets Job. 
    Como o objeto de trabalho está no computador remoto, você não 
    precisa executar os comandos remotos para obter, interromper, 
    aguardar ou recuperar os resultados do trabalho.  

    Para verificar se o trabalho foi concluído, use um comando 
    Invoke-Command para executar um comando Get-Job na PSSession 
    conectada ao computador Server01.

        invoke-command -session $s -scriptblock {get-job}

    O comando retorna um objeto de trabalho. A propriedade State do 
    objeto de trabalho 

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

    ETAPA 3: INVOKE-COMMAND RECEIVE-JOB

    Para obter os resultados do trabalho, use o cmdlet Invoke-Command 
    para executar um comando Receive-Job na PSSession conectada ao 
    computador Server01.

    O comando a seguir usa o cmdlet Receive-Job para obter os 
    resultados do trabalho. Ele usa a ID da sessão para identificar 
    o trabalho e salva os resultados do trabalho na variável $results. 
    Ele usa o parâmetro Keep de Receive-Job para manter o resultado 
    no cache de 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}
        

CONSULTE TAMBÉM
    about_Jobs
    about_Job_Details
    about_Remote
    Invoke-Command
    Start-Job
    Get-Job
    Wait-Job
    Stop-Job
    Remove-Job
    New-PSSession
    Enter-PSSession
    Exit-PSSession