Start-Job

Modulo:

Microsoft.PowerShell.Core

Avvia un processo in background di PowerShell.

Sintassi

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>]

Descrizione

Il Start-Job cmdlet avvia un processo in background di PowerShell nel computer locale.

Un processo in background di PowerShell esegue un comando senza interagire con la sessione corrente. Quando si avvia un processo in background, viene restituito immediatamente un oggetto processo, anche se il completamento del processo richiede molto tempo. È possibile continuare a lavorare nella sessione senza interruzioni durante l'esecuzione del processo.

L'oggetto processo contiene informazioni utili sul processo, ma non contiene i risultati del processo. Al termine del processo, usare il Receive-Job cmdlet per ottenere i risultati del processo. Per altre informazioni sui processi in background, vedere about_Jobs.

Per eseguire un processo in background in un computer remoto, usare il parametro AsJob disponibile in molti cmdlet oppure usare il Invoke-Command cmdlet per eseguire un Start-Job comando nel computer remoto. Per altre informazioni, vedere about_Remote_Jobs.

A partire da PowerShell 3.0, Start-Job può avviare istanze di tipi di processi personalizzati, ad esempio processi pianificati. Per informazioni su come usare Start-Job per avviare processi con tipi personalizzati, vedere i documenti della Guida per la funzionalità del tipo di processo.

A partire da PowerShell 6.0, è possibile avviare i processi usando l'operatore in background e commerciale (&). La funzionalità dell'operatore in background è simile a Start-Job. Entrambi i metodi per avviare un processo creano un oggetto processo PSRemotingJob . Per altre informazioni sull'uso della e commerciale (&), vedere about_Operators.

PowerShell 7 ha introdotto il parametro WorkingDirectory che specifica la directory di lavoro iniziale di un processo in background. Se il parametro non è specificato, Start-Job il valore predefinito è la directory di lavoro corrente del chiamante che ha avviato il processo.

Nota

La creazione di un processo in background out-of-process con Start-Job non è supportata nello scenario in cui PowerShell è ospitato in altre applicazioni, ad esempio powerShell Funzioni di Azure.

Si tratta di un processo in background out-of-process, perché Start-Job dipende dal pwsh file eseguibile da rendere disponibile $PSHOME per avviare un processo in background out-of-process, ma quando un'applicazione ospita PowerShell, usa direttamente i pacchetti NuGet SDK di PowerShell e non verrà pwsh fornita.

Il sostituto in questo scenario proviene Start-ThreadJob dal modulo ThreadJob.

Esempio

Esempio 1: Avviare un processo in background

In questo esempio viene avviato un processo in background eseguito nel computer locale.

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-Jobusa il parametro ScriptBlock per l'esecuzione Get-Process come processo in background. Il parametro Name specifica di trovare i processi di PowerShell, pwsh. Le informazioni sul processo vengono visualizzate e PowerShell torna a una richiesta mentre il processo viene eseguito in background.

Per visualizzare l'output del processo, usare il Receive-Job cmdlet . Ad esempio: Receive-Job -Id 1.

Esempio 2: Usare l'operatore in background per avviare un processo in background

In questo esempio viene utilizzato l'operatore in background e commerciale (&) per avviare un processo in background nel computer locale. Il processo ottiene lo stesso risultato dell'esempio Start-Job 1.

Get-Process -Name pwsh &

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

Get-Process usa il parametro Name per specificare i processi di PowerShell, pwsh. La e commerciale (&) esegue il comando come processo in background. Le informazioni sul processo vengono visualizzate e PowerShell torna a una richiesta mentre il processo viene eseguito in background.

Per visualizzare l'output del processo, usare il Receive-Job cmdlet . Ad esempio: Receive-Job -Id 5.

Esempio 3: Avviare un processo usando Invoke-Command

Questo esempio esegue un processo in più computer. Il processo viene archiviato in una variabile e viene eseguito usando il nome della variabile nella riga di comando di PowerShell.

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

Un processo che usa Invoke-Command viene creato e archiviato nella $jobWRM variabile . Invoke-Command utilizza il parametro ComputerName per specificare i computer in cui viene eseguito il processo. Get-Content ottiene i nomi dei server dal C:\Servers.txt file.

Il parametro ScriptBlock specifica un comando che Get-Service ottiene il servizio WinRM . Il parametro JobName specifica un nome descrittivo per il processo, WinRM. Il parametro ThrottleLimit limita il numero di comandi simultanei a 16. Il parametro AsJob avvia un processo in background che esegue il comando nei server.

Esempio 4: Ottenere informazioni sul processo

In questo esempio vengono recuperate informazioni su un processo e vengono visualizzati i risultati di un processo completato eseguito nel computer locale.

$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 il parametro ScriptBlock per eseguire un comando che specifica Get-WinEvent per ottenere il log di sistema . Il parametro Credential specifica un account utente di dominio con l'autorizzazione per eseguire il processo nel computer. L'oggetto processo viene archiviato nella $j variabile .

L'oggetto nella $j variabile viene inviato alla pipeline a Select-Object. Il parametro Property specifica un asterisco (*) per visualizzare tutte le proprietà dell'oggetto processo.

Esempio 5: Eseguire uno script come processo in background

In questo esempio viene eseguito uno script nel computer locale come processo in background.

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

Start-Job usa il parametro FilePath per specificare un file di script archiviato nel computer locale.

Esempio 6: Ottenere un processo usando un processo in background

In questo esempio viene usato un processo in background per ottenere un processo specificato in base al nome.

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

Start-Job usa il parametro Name per specificare un nome descrittivo del processo, PShellJob. Il parametro ScriptBlock specifica Get-Process di ottenere processi con il nome PowerShell.

Esempio 7: Raccogliere e salvare i dati usando un processo in background

In questo esempio viene avviato un processo che raccoglie una grande quantità di dati della mappa e quindi lo salva in un .tif file.

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

Start-Job usa il parametro Name per specificare un nome descrittivo del processo, GetMappingFiles. Il parametro InitializationScript esegue un blocco di script che importa il modulo MapFunctions . Il parametro ScriptBlock viene eseguito Get-Map e Set-Content salva i dati nel percorso specificato dal parametro Path .

Esempio 8: Passare l'input a un processo in background

In questo esempio viene utilizzata la $input variabile automatica per elaborare un oggetto di input. Usare Receive-Job per visualizzare l'output del processo.

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

Server01
Server02
Server03
Server04

Start-Jobusa il parametro ScriptBlock per l'esecuzione Get-Content con la $input variabile automatica. La $input variabile ottiene oggetti dal parametro InputObject . Receive-Job usa il parametro Name per specificare il processo e restituisce i risultati. Il parametro Keep salva l'output del processo in modo che possa essere visualizzato di nuovo durante la sessione di PowerShell.

Esempio 9: Impostare la directory di lavoro per un processo in background

WorkingDirectory consente di specificare una directory alternativa per un processo da cui è possibile eseguire script o aprire file. In questo esempio, il processo in background specifica una directory di lavoro diversa da quella corrente.

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

Path
----
C:\Test\Scripts

La directory di lavoro corrente di questo esempio è C:\Test. Start-Job usa il parametro WorkingDirectory per specificare la directory di lavoro del processo. Il parametro ScriptBlock usa $PWD per visualizzare la directory di lavoro del processo. Receive-Job visualizza l'output del processo in background. AutoRemoveJob elimina il processo e Wait elimina il prompt dei comandi fino a quando non vengono ricevuti tutti i risultati.

Esempio 10: Usare il parametro ArgumentList per specificare una matrice

In questo esempio viene utilizzato il parametro ArgumentList per specificare una matrice di argomenti. La matrice è un elenco delimitato da virgole di nomi di processo.

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

Il Start-Job cmdlet usa il parametro ScriptBlock per eseguire un comando. Get-Process usa il parametro Name per specificare la variabile $argsautomatica . Il parametro ArgumentList passa la matrice di nomi di processo a $args. I nomi dei processi powershell, pwsh e Blocco note sono processi in esecuzione nel computer locale.

Per visualizzare l'output del processo, usare il Receive-Job cmdlet . Ad esempio: Receive-Job -Id 1.

Esempio 11: Eseguire un processo in windows PowerShell 5.1

Questo esempio usa il parametro PSVersion con valore 5.1 per eseguire il processo in una sessione di 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

Parametri

-ArgumentList

Specifica una matrice di argomenti o valori di parametro per lo script specificato dal parametro FilePath o un comando specificato con il parametro ScriptBlock .

Gli argomenti devono essere passati a ArgumentList come argomento matrice a dimensione singola. Ad esempio, un elenco delimitato da virgole. Per altre informazioni sul comportamento di ArgumentList, vedere about_Splatting.

Tipo:	Object[]
Alias:	Args
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Authentication

Specifica il meccanismo utilizzato per autenticare le credenziali utente.

I valori accettabili per questo parametro sono i seguenti:

• Predefiniti
• Di base
• Credssp
• Digest
• Kerberos
• Negotiate
• NegotiateWithImplicitCredential

Il valore predefinito è Default.

L'autenticazione CredSSP è disponibile solo in Windows Vista, Windows Server 2008 e versioni successive del sistema operativo Windows.

Per altre informazioni sui valori di questo parametro, vedere AuthenticationMechanism.

Attenzione

L'autenticazione credSSP (Credential Security Support Provider), in cui le credenziali dell'utente vengono passate a un computer remoto da autenticare, è progettato per i comandi che richiedono l'autenticazione su più di una risorsa, ad esempio l'accesso a una condivisione di rete remota. Questo meccanismo aumenta il rischio per la sicurezza dell'operazione remota. Se infatti il computer remoto viene compromesso, le credenziali che gli vengono passate possono essere usate per controllare la sessione di rete.

Tipo:	AuthenticationMechanism
Valori accettati:	Default, Basic, Negotiate, NegotiateWithImplicitCredential, Credssp, Digest, Kerberos
Posizione:	Named
Valore predefinito:	Default
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Credential

Specifica un account utente che dispone delle autorizzazioni per eseguire questa azione. Se il parametro Credential non è specificato, il comando usa le credenziali dell'utente corrente.

Digitare un nome utente, ad esempio User01 o Domain01\User01, oppure immettere un oggetto PSCredential generato dal Get-Credential cmdlet. Se si digita un nome utente, viene richiesto di immettere la password.

Le credenziali vengono archiviate in un oggetto PSCredential e la password viene archiviata come SecureString.

Nota

Per altre informazioni sulla protezione dei dati SecureString , vedere How secure is SecureString?.

Tipo:	PSCredential
Posizione:	Named
Valore predefinito:	Current user
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-DefinitionName

Specifica il nome della definizione del processo avviato da questo cmdlet. Usare questo parametro per avviare tipi di processo personalizzati che hanno un nome di definizione, come i processi pianificati.

Quando si usa Start-Job per avviare un'istanza di un processo pianificato, il processo viene avviato immediatamente, indipendentemente dai trigger di processo o dalle opzioni del processo. L'istanza del processo risultante è un processo pianificato, ma non viene salvato su disco come i processi pianificati attivati. Non è possibile usare il parametro ArgumentList di Start-Job per fornire valori per i parametri degli script eseguiti in un processo pianificato.

Questo parametro è stato introdotto in PowerShell 3.0.

Tipo:	String
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-DefinitionPath

Specifica il percorso della definizione per il processo avviato da questo cmdlet. Immettere il percorso della definizione. La concatenazione dei valori dei parametri DefinitionPath e DefinitionName è il percorso completo della definizione del processo. Usare questo parametro per avviare tipi di processo personalizzati che hanno un percorso di definizione, come i processi pianificati.

Per i processi pianificati, il valore del parametro DefinitionPath è $HOME\AppData\Local\Windows\PowerShell\ScheduledJob.

Questo parametro è stato introdotto in PowerShell 3.0.

Tipo:	String
Posizione:	1
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-FilePath

Specifica uno script locale eseguito Start-Job come processo in background. Immettere il percorso e il nome file dello script oppure usare la pipeline per inviare un percorso di script a Start-Job. Lo script deve trovarsi nel computer locale o in una cartella a cui il computer locale può accedere.

Quando si usa questo parametro, PowerShell converte il contenuto del file di script specificato in un blocco di script ed esegue il blocco di script come processo in background.

Tipo:	String
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-InitializationScript

Specifica i comandi da eseguire prima dell'avvio del processo. Per creare un blocco di script, racchiudere i comandi tra parentesi graffe ({}).

Usare questo parametro per preparare la sessione in cui deve essere eseguito il processo. Ad esempio, è possibile usarlo per aggiungere funzioni, snap-in e moduli alla sessione.

Tipo:	ScriptBlock
Posizione:	1
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-InputObject

Specifica l'input del comando. Immettere una variabile che contiene gli oggetti o digitare un comando o un'espressione che genera gli oggetti.

Nel valore del parametro ScriptBlock usare la $input variabile automatica per rappresentare gli oggetti di input.

Tipo:	PSObject
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	True
Accettare caratteri jolly:	False

-LiteralPath

Specifica uno script locale eseguito da questo cmdlet come processo in background. Immettere il percorso di uno script nel computer locale.

Start-Job usa il valore del parametro LiteralPath esattamente come viene tipizzato. Nessun carattere viene interpretato come carattere jolly. Se il percorso include caratteri di escape, racchiuderlo tra virgolette singole. Le virgolette singole indicano a PowerShell di non interpretare alcun carattere come sequenze di escape.

Tipo:	String
Alias:	PSPath, LP
Posizione:	Named
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Name

Specifica un nome descrittivo per il nuovo processo. È possibile usare il nome per identificare il processo con altri cmdlet di processo, ad esempio il Stop-Job cmdlet .

Il nome descrittivo predefinito è Job#, dove # è un numero ordinale incrementato per ogni processo.

Tipo:	String
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	True
Accettare caratteri jolly:	False

-PSVersion

Specifica una versione di PowerShell da usare per l'esecuzione del processo. Quando il valore di PSVersion è 5.1 Il processo viene eseguito in una sessione di Windows PowerShell 5.1. Per qualsiasi altro valore, il processo viene eseguito usando la versione corrente di PowerShell.

Questo parametro è stato aggiunto in PowerShell 7 e funziona solo in Windows.

Tipo:	Version
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-RunAs32

A partire da PowerShell 7, il parametro RunAs32 non funziona in PowerShell a 64 bit (pwsh). Se RunAs32 è specificato in PowerShell a 64 bit, Start-Job genera un errore di eccezione irreversibile. Per avviare un processo di PowerShell a 32 bit (pwsh) con RunAs32, è necessario che PowerShell a 32 bit sia installato.

In PowerShell a 32 bit RunAs32 forza l'esecuzione del processo in un processo a 32 bit, anche in un sistema operativo a 64 bit.

Nelle versioni a 64 bit di Windows 7 e Windows Server 2008 R2, quando il Start-Job comando include il parametro RunAs32 , non è possibile usare il parametro Credential per specificare le credenziali di un altro utente.

Tipo:	SwitchParameter
Posizione:	Named
Valore predefinito:	False
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-ScriptBlock

Specifica i comandi da eseguire nel processo in background. Per creare un blocco di script, racchiudere i comandi tra parentesi graffe ({}). Usare la $input variabile automatica per accedere al valore del parametro InputObject . Questo parametro è obbligatorio.

Tipo:	ScriptBlock
Alias:	Command
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Type

Specifica il tipo personalizzato per i processi avviati da Start-Job. Immettere un nome di tipo di processo personalizzato, ad esempio PSScheduledJob per i processi pianificati o PSWorkflowJob per i processi dei flussi di lavoro. Questo parametro non è valido per i processi in background standard.

Questo parametro è stato introdotto in PowerShell 3.0.

Tipo:	String
Posizione:	2
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-WorkingDirectory

Specifica la directory di lavoro iniziale del processo in background. Se il parametro non è specificato, il processo viene eseguito dal percorso predefinito. Il percorso predefinito è la directory di lavoro corrente del chiamante che ha avviato il processo.

Questo parametro è stato introdotto in PowerShell 7.

Tipo:	String
Posizione:	Named
Valore predefinito:	$HOME on Unix (macOS, Linux) and $HOME\Documents on Windows
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

Input

String

È possibile inviare tramite pipe un oggetto con la proprietà Name al parametro Name a questo cmdlet. Ad esempio, è possibile inviare tramite pipe un oggetto FileInfo da Get-ChildItem.

Output

System.Management.Automation.PSRemotingJob

Questo cmdlet restituisce un oggetto PSRemotingJob che rappresenta il processo avviato.

Note

PowerShell include gli alias seguenti per Start-Job:

• Tutte le piattaforme:
  • sajb

Per l'esecuzione in background, Start-Job viene eseguita nella propria sessione nella sessione corrente. Quando si usa il Invoke-Command cmdlet per eseguire un Start-Job comando in una sessione in un computer remoto, Start-Job viene eseguito in una sessione nella sessione remota.

Collegamenti correlati

• 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