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 Start-Job cmdlet 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, obtém imediatamente como retorno um objeto de trabalho, mesmo que o trabalho demore muito tempo para ser finalizado. É possível 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 for concluído, use o Receive-Job cmdlet 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 Invoke-Command cmdlet para executar um Start-Job comando 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 o para iniciar trabalhos com tipos personalizados, consulte os documentos de ajuda do 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 ao 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 o padrão será 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 ser executado Get-Process como um trabalho em segundo plano. O parâmetro Name especifica a localização de 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 Receive-Job cmdlet. 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 do Start-Job 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 Receive-Job cmdlet. Por exemplo, Receive-Job -Id 5.

Exemplo 3: Iniciar um trabalho usando 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 $jobWRM variável. Invoke-Command usa o parâmetro ComputerName para especificar os computadores em que o trabalho é executado. Get-Content obtém os nomes dos servidores do C:\Servers.txt arquivo.

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 de trabalho

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   : {}

Start-Job usa o parâmetro ScriptBlock para executar um comando que especifica Get-WinEvent para obter o log 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 $j variável.

O objeto na $j variável é 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 por 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 para 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 .tif arquivo.

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 entrada para um trabalho em segundo plano

Este exemplo usa a $input variável automática 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 ser executado Get-Content com a $input variável automática. A $input variável obtém objetos do parâmetro InputObject . Receive-Job usa o parâmetro Name para especificar o trabalho e gera os resultados. O parâmetro Keep salva a saída do trabalho para que ela possa ser exibida novamente durante a sessão do PowerShell.

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

O WorkingDirectory permite que você especifique 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 é usado $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: Usar 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 Start-Job cmdlet usa o parâmetro ScriptBlock para executar um comando. Get-Process usa o parâmetro Name para especificar a variável $argsautomática . O parâmetro ArgumentList passa a matriz de nomes de processo para $args. Os nomes de processo powershell, pwsh e bloco de notas são processos em execução no computador local.

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

Exemplo 11: Executar trabalho em um Windows PowerShell 5.1

Este exemplo usa o parâmetro PSVersion com o 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 esse cmdlet. Por exemplo, você pode canalizar um objeto FileInfo do Get-ChildItem.

Saídas

System.Management.Automation.PSRemotingJob

Esse cmdlet retorna um objeto PSRemotingJob que representa o trabalho que ele iniciou.

Observações

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 Invoke-Command cmdlet para executar um Start-Job comando em uma sessão em um computador remoto, o é Start-Job executado em uma sessão na sessão remota.

Links Relacionados

• 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