> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/it/automazione/jobs.md). # Job I job sono il risultato dell'esecuzione di uno script. I job vengono conservati in base alle impostazioni a livello di script e di server. ## Visualizzazione dei job I job possono essere visualizzati facendo clic sulla pagina Automation / Jobs. Faccia clic sul pulsante View per accedere al job. È possibile anche annullare i job in corso.

Elenco dei job

### Visualizzare l'output del job Gli stream standard di PowerShell, come information, host, error, warning e verbose, sono mostrati nel riquadro di output.

Output dello stream del job

### Visualizzare l'output della pipeline del job {% hint style="info" %} L'archiviazione di grandi quantità di output della pipeline può influire negativamente sulle prestazioni. È possibile eliminare l'output della pipeline impostando l'impostazione Discard Pipeline sugli script. {% endhint %} Anche l'output della pipeline dei job viene archiviato in PowerShell Universal. Qualsiasi oggetto scritto nella pipeline viene archiviato come CliXml ed è disponibile per la visualizzazione nella scheda Pipeline Output. È possibile espandere la vista ad albero per vedere gli oggetti e le proprietà della pipeline.

Output della pipeline del job

### Visualizzazione degli errori Eventuali errori scritti nello stream degli errori saranno disponibili nella scheda Error all'interno della pagina del job.

Output di errore del job

## Stato I job restituiranno stati diversi a seconda della configurazione e del risultato dell'esecuzione. Le impostazioni che possono influire sullo stato del job includono: * ErrorActionPreference * WarningActionPreference La tabella seguente descrive come PowerShell Universal tratta gli stati. | Stato | Descrizione | Soppressione | | ------------------- | --------------------------------------------------- | ----------------------------------------------------- | | Error | Uno script ha avuto un errore non terminante. | Impostare ErrorActionPreference su SilentlyContinue | | Warning | Uno script ha avuto un avviso. | Impostare WarningActionPreference su SilentlyContinue | | Failed | Uno script ha avuto un errore terminante. | Gestire l'errore terminante o intercettarlo. | | Waiting on Feedback | Uno script è in attesa di feedback, come Read-Host. | Evitare callback utente come read-host. | | Running | Lo script è attualmente in esecuzione. | N\A | | Queued | Lo script è attualmente in coda per l'esecuzione. | N\A | ## Feedback Alcuni job richiederanno feedback. Qualsiasi script che contiene una chiamata `Read-Host` attenderà finché non ci sarà interazione dell'utente con quel job. Il job sarà nello stato Waiting for Feedback ed è possibile rispondere a tale feedback facendo clic sul pulsante Response to Feedback nella pagina del job.

Job in attesa di feedback

Per accettare una `SecureString` con un campo di input della password, è possibile utilizzare il parametro `-AsSecureString` di `Read-Host`. ## Richiamare i job da PowerShell È possibile utilizzare `Invoke-PSUScript` per richiamare i job dalla riga di comando. Per farlo sarà necessario un [App Token](/powershell-universal/it/sicurezza/security.md#app-tokens) valido. I parametri sono definiti utilizzando parametri dinamici sul cmdlet `Invoke-PSUScript`. ```powershell Invoke-PSUScript -Script 'Script1.ps1' -RequiredParameter 'Hello' ``` ### Chiamare script da altri script È inoltre possibile chiamare script UA da script UA. Quando si esegue un job in UA, non è necessario definire manualmente un app token o il nome del computer. Questi saranno definiti automaticamente. È sufficiente chiamare `Invoke-PSUScript` all'interno dello script per avviare un altro script. Entrambi i job verranno mostrati nell'interfaccia utente. Se desidera attendere il completamento dello script, utilizzi `Wait-PSUJob`. ### Attendere il completamento di uno script È possibile utilizzare il cmdlet `Wait-PSUJob` per attendere il completamento di un job. Reindirizzi il valore restituito di `Invoke-PSUScript` a `Wait-UAJob` per attendere il completamento del job. `Wait-PSUJob` attenderà indefinitamente a meno che non venga specificato il parametro `-Timeout`. ```powershell Invoke-PSUScript -Script 'Script1.ps1' -RequiredParameter 'Hello' | Wait-PSUJob ``` ### Restituire i dati della pipeline È possibile utilizzare il cmdlet `Get-PSUJobPipelineOutput` per restituire l'output della pipeline prodotto da un job. Questo output della pipeline sarà costituito da oggetti deserializzati che sono stati scritti nella pipeline durante il job. È possibile accedere a questi dati da dove si ha accesso alla PowerShell Universal Management API. ```powershell Get-PSUJobPipelineOutput -JobId 10 ``` ### Restituire l'output dell'ultimo job Potrebbe essere necessario restituire l'output dell'ultima esecuzione del job di uno script. Per farlo, sarà necessario utilizzare una combinazione di cmdlet per recuperare lo script, l'ID dell'ultimo job e quindi restituire l'output della pipeline o dell'host. ```powershell $Job = Get-PSUScript -Name 'Script.ps1' | Get-PSUJob -OrderDirection Descending -First 1 Get-PSUJobPipelineOutput -Job $Job Get-PSUJobOutput -Job $Job ``` ### Restituisce l'output dell'ultimo job come oggetto Per impostazione predefinita, `Get-PSUJobOutput` restituirà l'output come stringa. Per restituire l'output come oggetto con informazioni sull'output, utilizzi `-AsObject`. ```powershell $Job = Get-PSUScript -Name 'Script.ps1' | Get-PSUJob -OrderDirection Descending -First 1 Get-PSUJobOutput -Job $Job -AsObject ``` ### Richiamare uno script e attendere l'output È possibile utilizzare il parametro `-Wait` di `Invoke-PSUScript` per ottenere questo risultato. ```powershell $Output = Invoke-PSUScript -Script 'Script1.ps1' -RequiredParameter 'Hello' -Wait ``` Inoltre, l'esempio seguente richiama uno script, archivia l'oggetto job in una variabile `$job`, attende il completamento del job e quindi restituisce l'output della pipeline e dell'host. ```powershell Invoke-PSUScript -Script 'Script1.ps1' -RequiredParameter 'Hello' | Tee-Object -Variable job | Wait-PSUJob $Output = Get-PSUJobPipelineOutput -Job $Job Get-PSUJobOutput -Job $Job ``` ### Modalità integrata La modalità integrata consente di chiamare questi cmdlet dall'interno di PowerShell Universal senza un App Token o un Computer Name. Utilizza il canale RPC interno per comunicare. È possibile impostare il parametro `-Integrated` per passare alla modalità integrata. Questo parametro non funziona al di fuori di PowerShell Universal. ```powershell Invoke-PSUScript -Script 'Script.ps1' -Integrated ``` I cmdlet seguenti supportano la modalità integrata. * Get-PSUScript * Invoke-PSUScript * Get-PSUJob * Get-PSUJobOutput * Get-PSUJobPipelineOutput * Get-PSUJobFeedback * Set-PSUJobFeedback * Wait-PSUJob ## Richiamare i job con REST È possibile chiamare i job tramite REST utilizzando la management API di PowerShell Universal. Per richiamare i job sarà necessario un app token valido. ### Chiamare script con REST Per chiamare uno script, si effettua una HTTP POST all'endpoint dello script con l'ID dello script che si desidera eseguire. ```powershell Invoke-RestMethod http://localhost:5000/api/v1/script/7 -Method POST -Body "" -Headers @{ Authorization = "Bearer appToken" } -ContentType 'application/json' ``` ### Fornire i parametri È possibile fornire i parametri al job tramite una query string. I parametri saranno forniti allo script come stringhe. ```powershell $Parameters = @{ Uri = "http://localhost:5000/api/v1/script/path/PNP.ps1?Server=tester&Domain=test" Method = "POST" Headers = @{Authorization = "Bearer $Apptoken"} ContentType = 'application/json' Body = '{}' } Invoke-RestMethod @Parameters ``` ### Impostare l'ambiente È possibile impostare l'ambiente passando la proprietà environment al contesto del job. La proprietà deve essere il nome di un ambiente definito all'interno della sua istanza PSU. ```powershell $JobContext = @{ Environment = "PowerShell 7" } | ConvertTo-Json Invoke-RestMethod http://localhost:5000/api/v1/script/7 -Method POST -Body $JobContext -Headers @{ Authorization = "Bearer appToken" } -ContentType 'application/json' ``` ### Impostare l'account Run As È possibile impostare l'account run as passando il nome di una variabile PSCredential alla proprietà Credential. ```powershell $JobContext = @{ Credential = "MyUser" } | ConvertTo-Json Invoke-RestMethod http://localhost:5000/api/v1/script/7 -Method POST -Body $JobContext -Headers @{ Authorization = "Bearer appToken" } -ContentType 'application/json' ``` ## Richiamare i job dalle app È possibile utilizzare gli stessi cmdlet che utilizza in altri script PowerShell per eseguire script nelle app. Potrebbe desiderare un'esperienza più interattiva nel farlo. Di seguito sono riportati alcuni esempi su come ottenerlo utilizzando l'app framework. ### Visualizzare l'output È possibile utilizzare i cmdlet `Invoke-PSUScript` e `Get-PSUJobOutput` per creare un elemento dell'interfaccia utente che si aggiorna durante l'esecuzione dello script. Supponga di avere uno script come quello seguente. Scrive semplicemente nello stream Information ogni 100 millisecondi per 100 volte. ```powershell 1..100 | % { Write-Output "Hello $_" Start-Sleep -Milliseconds 100 } ``` All'interno della sua app, è possibile avviare lo script in base a qualche interazione dell'utente e quindi aggiornare un elemento durante l'esecuzione dello script. L'esempio seguente crea un pulsante e un elemento tag `pre` che funge da destinazione per l'output dello script. Quando l'utente fa clic sul pulsante, viene avviato il job e si attende il suo completamento. All'interno del ciclo, recupera l'output dello script e quindi aggiorna l'elemento `pre` con il contenuto dell'output. Infine, recupera uno stato aggiornato del job e attende 100 millisecondi prima di eseguire nuovamente. ```powershell New-UDApp -Content { New-UDButton -Text "Run Script" -OnClick { $Job = Invoke-PSUScript -Name "AppExample.ps1" -Integrated while($Job.Status -eq 'Queued' -or $Job.Status -eq 'Running') { $Output = Get-PSUJobOutput -Job $Job Set-UDElement -Id 'output' -Content { $Output | ForEach-Object { $_ + [Environment]::NewLine } } $Job = Get-PSUJob -Id $Job.Id Start-Sleep -Milliseconds 100 } } -ShowLoading New-UDElement -Tag 'pre' -Id 'output' } ``` ### Visualizzare l'avanzamento L'host PowerShell dell'app framework si interfaccerà automaticamente con le funzionalità di PowerShell, come `Write-Progress`. Se utilizza il parametro `-Wait` di `Invoke-PSUScript` , l'avanzamento dello script verrà visualizzato automaticamente in una finestra di dialogo nella sua app. Supponga di avere uno script definito come di seguito. Questo script scrive l'avanzamento ogni 100 millisecondi. ```powershell 1..100 | % { Write-Progress -Activity "Working..." -PercentComplete $_ Start-Sleep -Milliseconds 100 } ``` All'interno della nostra app, possiamo semplicemente chiamare lo script con il parametro `-Wait`. Quando l'utente fa clic sul pulsante, l'avanzamento verrà visualizzato nell'app. ```powershell New-UDApp -Content { New-UDButton -Text "Run Script" -OnClick { Invoke-PSUScript -Name "AppExample.ps1" -Integrated -Wait } -ShowLoading } ```
### Richiedere input L'host PowerShell dell'app framework si interfaccerà automaticamente con le funzionalità di PowerShell, come `Read-Host`. Se utilizza il parametro `-Wait` di `Invoke-PSUScript` , verrà richiesto automaticamente l'input all'utente quando viene incontrato il comando `Read-Host`. Supponga di avere uno script che richiede l'input dell'utente utilizzando `Read-Host`. ```powershell Read-Host -Prompt "What should I say?" ``` Nella sua app, chiami semplicemente lo script con il parametro `-Wait`. ```powershell New-UDApp -Content { New-UDButton -Text "Run Script" -OnClick { Invoke-PSUScript -Name "AppExample.ps1" -Integrated -Wait } -ShowLoading } ``` All'utente verrà quindi richiesto l'input durante l'esecuzione dello script.
## Variabili definite nei job Le variabili definite nei job sono disponibili nella [pagina delle variabili](/powershell-universal/it/piattaforma/variables.md#scripts). ## Job Run ID Il comportamento predefinito di PowerShell Universal è tracciare i job in base a un ID basato su int64 con incremento automatico. Ogni volta che viene eseguito un nuovo job, l'ID del job è superiore di uno rispetto all'ultimo. A causa di questo comportamento, è facile indovinare altri ID di job e ciò può potenzialmente comportare un rischio per la sicurezza. Per evitare questo problema, è possibile abilitare la funzionalità sperimentale `JobRunID`. Sebbene internamente il sistema continui a creare job con ID numerici crescenti, non è possibile accedere ai job in base a tali ID. Viene invece utilizzato un nuovo campo chiamato `RunID`. `RunID` utilizza un `GUID` anziché un ID per le ricerche. Questo riduce notevolmente la possibilità per un utente malintenzionato di indovinare l'ID di un job. Sarà necessario abilitare questa funzionalità per utilizzarla. ```powershell Set-PSUSetting -JobRunId ``` ## API * [Invoke-PSUScript](/powershell-universal/it/comandi-powershell/invoke-psuscript.md) * [Get-PSUJob](/powershell-universal/it/comandi-powershell/get-psujob.md) * [Get-PSUJobFeedback](/powershell-universal/it/comandi-powershell/get-psujobfeedback.md) * [Get-PSUJobOutput](/powershell-universal/it/comandi-powershell/get-psujoboutput.md) * [Get-PSUJobPipelineOutput](/powershell-universal/it/comandi-powershell/get-psujobpipelineoutput.md) * [Wait-PSUJob](/powershell-universal/it/comandi-powershell/wait-psujob.md) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.devolutions.net/powershell-universal/it/automazione/jobs.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.