Start-Job

Sintaxe

Start-Job
     [-Name <String>]
     [-ScriptBlock] <ScriptBlock>
     [-Credential <PSCredential>]
     [-Authentication <AuthenticationMechanism>]
     [[-InitializationScript] <ScriptBlock>]
     [-WorkingDirectory <String>]
     [-RunAs32]
     [-PSVersion <Version>]
     [-InputObject <PSObject>]
     [-ArgumentList <Object[]>]
     [<CommonParameters>]

Start-Job
     [-DefinitionName] <String>
     [[-DefinitionPath] <String>]
     [[-Type] <String>]
     [-WorkingDirectory <String>]
     [<CommonParameters>]

Start-Job
     [-Name <String>]
     [-Credential <PSCredential>]
     [-FilePath] <String>
     [-Authentication <AuthenticationMechanism>]
     [[-InitializationScript] <ScriptBlock>]
     [-WorkingDirectory <String>]
     [-RunAs32]
     [-PSVersion <Version>]
     [-InputObject <PSObject>]
     [-ArgumentList <Object[]>]
     [<CommonParameters>]

Start-Job
     [-Name <String>]
     [-Credential <PSCredential>]
     -LiteralPath <String>
     [-Authentication <AuthenticationMechanism>]
     [[-InitializationScript] <ScriptBlock>]
     [-WorkingDirectory <String>]
     [-RunAs32]
     [-PSVersion <Version>]
     [-InputObject <PSObject>]
     [-ArgumentList <Object[]>]
     [<CommonParameters>]

Description

O cmdlet Start-Job inicia um trabalho em segundo plano do PowerShell no computador local.

Um trabalho em segundo plano do PowerShell executa um comando sem interagir com a sessão atual. Quando você inicia um trabalho em segundo plano, um objeto de trabalho retorna imediatamente, mesmo que o trabalho demore muito tempo para ser concluído. Você pode continuar a trabalhar na sessão sem interrupção enquanto o trabalho é executado.

O objeto de trabalho contém informações úteis sobre o trabalho, mas não contém os resultados do trabalho. Quando o trabalho terminar, use o cmdlet Receive-Job para obter os resultados do trabalho. Para obter mais informações sobre trabalhos em segundo plano, consulte about_Jobs.

Para executar um trabalho em segundo plano em um computador remoto, use o parâmetro AsJob que está disponível em muitos cmdlets ou use o cmdlet Invoke-Command para executar um comando Start-Job no computador remoto. Para obter mais informações, consulte about_Remote_Jobs.

A partir do PowerShell 3.0, Start-Job pode iniciar instâncias de tipos de trabalho personalizados, como trabalhos agendados. Para obter informações sobre como usar Start-Job para iniciar trabalhos com tipos personalizados, consulte os documentos de ajuda para o recurso de tipo de trabalho.

A partir do PowerShell 6.0, você pode iniciar trabalhos usando o operador em segundo plano E comercial (&). A funcionalidade do operador em segundo plano é semelhante a Start-Job. Ambos os métodos para iniciar um trabalho criam um objeto de trabalho PSRemotingJob. Para obter mais informações sobre como usar o E comercial (&), consulte about_Operators.

O PowerShell 7 introduziu o parâmetro WorkingDirectory que especifica o diretório de trabalho inicial de um trabalho em segundo plano. Se o parâmetro não for especificado, Start-Job assume como padrão o diretório de trabalho atual do chamador que iniciou o trabalho.

Exemplos

Exemplo 1: Iniciar um trabalho em segundo plano

Este exemplo inicia um trabalho em segundo plano que é executado no computador local.

Start-Job -ScriptBlock { Get-Process -Name pwsh }

Id  Name   PSJobTypeName   State     HasMoreData   Location    Command
--  ----   -------------   -----     -----------   --------    -------
1   Job1   BackgroundJob   Running   True          localhost   Get-Process -Name pwsh

Start-Job usa o parâmetro ScriptBlock para executar Get-Process como um trabalho em segundo plano. O parâmetro Name especifica para localizar processos do PowerShell, pwsh. As informações do trabalho são exibidas e o PowerShell retorna a um prompt enquanto o trabalho é executado em segundo plano.

Para exibir a saída do trabalho, use o cmdlet Receive-Job. Por exemplo, Receive-Job -Id 1.

Exemplo 2: Usar o operador em segundo plano para iniciar um trabalho em segundo plano

Este exemplo usa o operador em segundo plano E comercial (&) para iniciar um trabalho em segundo plano no computador local. O trabalho obtém o mesmo resultado que Start-Job no Exemplo 1.

Get-Process -Name pwsh &

Id    Name   PSJobTypeName   State       HasMoreData     Location      Command
--    ----   -------------   -----       -----------     --------      -------
5     Job5   BackgroundJob   Running     True            localhost     Microsoft.PowerShell.Man...

Get-Process usa o parâmetro Name para especificar processos do PowerShell, pwsh. O E comercial (&) executa o comando como um trabalho em segundo plano. As informações do trabalho são exibidas e o PowerShell retorna a um prompt enquanto o trabalho é executado em segundo plano.

Para exibir a saída do trabalho, use o cmdlet Receive-Job. Por exemplo, Receive-Job -Id 5.

Exemplo 3: Iniciar um trabalho usando o Invoke-Command

Este exemplo executa um trabalho em vários computadores. O trabalho é armazenado em uma variável e é executado usando o nome da variável na linha de comando do PowerShell.

$jobWRM = Invoke-Command -ComputerName (Get-Content -Path C:\Servers.txt) -ScriptBlock {
   Get-Service -Name WinRM } -JobName WinRM -ThrottleLimit 16 -AsJob

Um trabalho que usa Invoke-Command é criado e armazenado na variável $jobWRM. Invoke-Command usa o parâmetro ComputerName para especificar os computadores onde o trabalho é executado. Get-Content obtém os nomes dos servidores do arquivo C:\Servers.txt.

O parâmetro ScriptBlock especifica um comando que Get-Service obtém o serviço WinRM. O parâmetro JobName especifica um nome amigável para o trabalho, WinRM. O parâmetro ThrottleLimit limita o número de comandos simultâneos a 16. O parâmetro AsJob inicia um trabalho em segundo plano que executa o comando nos servidores.

Exemplo 4: Obter informações sobre o emprego

Este exemplo obtém informações sobre um trabalho e exibe os resultados de um trabalho concluído que foi executado no computador local.

$j = Start-Job -ScriptBlock { Get-WinEvent -Log System } -Credential Domain01\User01
$j | Select-Object -Property *

State         : Completed
HasMoreData   : True
StatusMessage :
Location      : localhost
Command       : Get-WinEvent -Log System
JobStateInfo  : Completed
Finished      : System.Threading.ManualResetEvent
InstanceId    : 27ce3fd9-40ed-488a-99e5-679cd91b9dd3
Id            : 18
Name          : Job18
ChildJobs     : {Job19}
PSBeginTime   : 8/8/2019 14:41:57
PSEndTime     : 8/8/2019 14:42:07
PSJobTypeName : BackgroundJob
Output        : {}
Error         : {}
Progress      : {}
Verbose       : {}
Debug         : {}
Warning       : {}
Information   : {}

usa o parâmetro ScriptBlock para executar um comando que especifica obter o log de do sistema . O parâmetro Credential especifica uma conta de usuário de domínio com permissão para executar o trabalho no computador. O objeto de trabalho é armazenado na variável $j.

O objeto na variável $j é enviado pelo pipeline para Select-Object. O parâmetro Property especifica um asterisco (*) para exibir todas as propriedades do objeto de trabalho.

Exemplo 5: Executar um script como um trabalho em segundo plano

Neste exemplo, um script no computador local é executado como um trabalho em segundo plano.

Start-Job -FilePath C:\Scripts\Sample.ps1

Start-Job usa o parâmetro FilePath para especificar um arquivo de script armazenado no computador local.

Exemplo 6: Obter um processo usando um trabalho em segundo plano

Este exemplo usa um trabalho em segundo plano para obter um processo especificado pelo nome.

Start-Job -Name PShellJob -ScriptBlock { Get-Process -Name PowerShell }

Start-Job usa o parâmetro Name para especificar um nome de trabalho amigável, PShellJob. O parâmetro ScriptBlock especifica Get-Process obter processos com o nome PowerShell.

Exemplo 7: Coletar e salvar dados usando um trabalho em segundo plano

Este exemplo inicia um trabalho que coleta uma grande quantidade de dados de mapa e os salva em um arquivo .tif.

Start-Job -Name GetMappingFiles -InitializationScript {Import-Module -Name MapFunctions} -ScriptBlock {
   Get-Map -Name * | Set-Content -Path D:\Maps.tif }

Start-Job usa o parâmetro Name para especificar um nome de trabalho amigável, GetMappingFiles. O parâmetro InitializationScript executa um bloco de script que importa o módulo MapFunctions. O parâmetro ScriptBlock é executado Get-Map e Set-Content salva os dados no local especificado pelo parâmetro Path.

Exemplo 8: Passar a entrada para um trabalho em segundo plano

Este exemplo usa a variável automática $input para processar um objeto de entrada. Use Receive-Job para exibir a saída do trabalho.

Start-Job -ScriptBlock { Get-Content -Path $input } -InputObject "C:\Servers.txt"
Receive-Job -Name Job45 -Keep

Server01
Server02
Server03
Server04

Start-Job usa o parâmetro ScriptBlock para executar Get-Content com a variável automática $input. A variável $input obtém objetos do parâmetro InputObject. Receive-Job usa o parâmetro Name para especificar o trabalho e produz os resultados. O parâmetro Keep salva a saída do trabalho para que ele possa ser exibido novamente durante a sessão do PowerShell.

Exemplo 9: Definir o diretório de trabalho para um trabalho em segundo plano

O WorkingDirectory permite especificar um diretório alternativo para um trabalho a partir do qual você pode executar scripts ou abrir arquivos. Neste exemplo, o trabalho em segundo plano especifica um diretório de trabalho diferente do local do diretório atual.

PS C:\Test> Start-Job -WorkingDirectory C:\Test\Scripts { $PWD } | Receive-Job -AutoRemoveJob -Wait

Path
----
C:\Test\Scripts

O diretório de trabalho atual deste exemplo é C:\Test. Start-Job usa o parâmetro WorkingDirectory para especificar o diretório de trabalho do trabalho. O parâmetro ScriptBlock usa $PWD para exibir o diretório de trabalho do trabalho. Receive-Job exibe a saída do trabalho em segundo plano. AutoRemoveJob exclui o trabalho e Wait suprime o prompt de comando até que todos os resultados sejam recebidos.

Exemplo 10: Use o parâmetro ArgumentList para especificar uma matriz

Este exemplo usa o parâmetro ArgumentList para especificar uma matriz de argumentos. A matriz é uma lista separada por vírgulas de nomes de processos.

Start-Job -ScriptBlock { Get-Process -Name $args } -ArgumentList powershell, pwsh, notepad

Id     Name      PSJobTypeName   State       HasMoreData     Location     Command
--     ----      -------------   -----       -----------     --------     -------
1      Job1      BackgroundJob   Running     True            localhost    Get-Process -Name $args

O cmdlet Start-Job usa o parâmetro ScriptBlock para executar um comando. Get-Process usa o parâmetro Name para especificar a variável automática $args. O parâmetro ArgumentList passa a matriz de nomes de processo para $args. Os nomes de processo powershell, pwsh e notepad são processos em execução no computador local.

Para exibir a saída do trabalho, use o cmdlet Receive-Job. Por exemplo, Receive-Job -Id 1.

Exemplo 11: Executar trabalho em um Windows PowerShell 5.1

Este exemplo usa o parâmetro PSVersion com valor 5.1 para executar o trabalho em uma sessão do Windows PowerShell 5.1.

$PSVersionTable.PSVersion

Major  Minor  Patch  PreReleaseLabel BuildLabel
-----  -----  -----  --------------- ----------
7      0      0      rc.1

$job = Start-Job -ScriptBlock { $PSVersionTable.PSVersion } -PSVersion 5.1
Receive-Job -Job $job

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  3383

Parâmetros

-ArgumentList

-Authentication

-Credential

-DefinitionName

-DefinitionPath

-FilePath

-InitializationScript

-InputObject

-LiteralPath

-Name

-PSVersion

-RunAs32

-ScriptBlock

-Type

-WorkingDirectory

Entradas

String

Você pode canalizar um objeto com a propriedade Name para o parâmetro Name para este cmdlet. Por exemplo, você pode canalizar um objeto FileInfo de Get-ChildItem.

Saídas

System.Management.Automation.PSRemotingJob

Este cmdlet retorna um objeto PSRemotingJob que representa o trabalho iniciado.

Notas

O PowerShell inclui os seguintes aliases para Start-Job:

• Todas as plataformas:
  • sajb

Para ser executado em segundo plano, Start-Job é executado em sua própria sessão na sessão atual. Quando você usa o cmdlet Invoke-Command para executar um comando Start-Job em uma sessão em um computador remoto, Start-Job é executado em uma sessão na sessão remota.

Ligações Relacionadas

• about_Arrays
• about_Automatic_Variables
• about_Jobs
• about_Job_Details
• about_Remote_Jobs
• Get-Job
• Invoke-Command
• Receive-Job
• Remove-Job
• Stop-Job
• Wait-Job