Invoke-Command

Invoke-Command [-ScriptBlock] <scriptblock> [[-ComputerName] <string[]>] [-ApplicationName <string>] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-CertificateThumbprint <string>] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-Port <int>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-UseSSL] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-FilePath] <string> [[-ComputerName] <string[]>] [-ApplicationName <string>] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-Port <int>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-UseSSL] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-FilePath] <string> [[-Session] <PSSession[]>] [-AsJob] [-HideComputerName] [-JobName <string>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-FilePath] <string> [[-ConnectionURI] <Uri[]>] [-AllowRedirection] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-ScriptBlock] <scriptblock> [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-ScriptBlock] <scriptblock> [[-Session] <PSSession[]>] [-AsJob] [-HideComputerName] [-JobName <string>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

Invoke-Command [-ScriptBlock] <scriptblock> [[-ConnectionURI] <Uri[]>] [-AllowRedirection] [-AsJob] [-Authentication {<Default> | <Basic> | <Negotiate> | <NegotiateWithImplicitCredential> | <Credssp> | <Digest> | <Kerberos>}] [-CertificateThumbprint <string>] [-ConfigurationName <string>] [-Credential <PSCredential>] [-HideComputerName] [-JobName <string>] [-SessionOption <PSSessionOption>] [-ThrottleLimit <int>] [-ArgumentList <Object[]>] [-InputObject <psobject>] [<CommonParameters>]

C:\PS>invoke-command -filepath c:\scripts\test.ps1 -computerName Server01

Disks: C:, D:, E:
Status: Warning, Normal, Normal

Descrizione
-----------
Con questo comando si esegue lo script Test.ps1 nel computer Server01. 

Con il comando si utilizza il parametro FilePath per specificare uno script che si trova nel computer locale. Lo script viene eseguito nel computer remoto e i risultati vengono restituiti al computer locale.

C:\PS>invoke-command -computername server01 -credential domain01\user01 -scriptblock {get-culture}

Descrizione
-----------
Questo comando esegue il comando Get-Culture nel computer remoto Server01. 

Vengono utilizzati il parametro ComputerName per specificare il nome del computer e il parametro Credential per eseguire il comando nel contesto di sicurezza di "Dominio01\Utente01", un utente con autorizzazione per l'esecuzione dei comandi. Viene utilizzato il parametro ScriptBlock per specificare il comando da eseguire nel computer remoto.

In risposta, viene visualizzata una finestra di dialogo di Windows PowerShell in cui vengono richiesti la password e un metodo di autenticazione per l'account Utente01. Successivamente, il comando viene eseguito nel computer Server01 e viene restituito il risultato.

C:\PS>$s = new-pssession -computername server02 -credential domain01\user01

C:\PS> invoke-command -session $s -scriptblock {get-culture}

Descrizione
-----------
In questo esempio viene eseguito lo stesso comando "Get-Culture" in una sessione (connessione permanente) nel computer remoto Server02. In genere, viene creata una sessione solo quando si esegue una serie di comandi nel computer remoto.

Il primo comando utilizza il cmdlet New-PSSession per creare una sessione nel computer remoto Server02. La sessione viene quindi salvata nella variabile $s.

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire il comando Get-Culture in Server02. Viene utilizzato il parametro Session per specificare la sessione salvata nella variabile $s. 

In risposta, in Windows PowerShell il comando viene eseguito nella sessione nel computer Server02.

C:\PS>invoke-command -computername Server02 -scriptblock {$p = get-process powershell}

C:\PS> invoke-command -computername Server02 -scriptblock {$p.virtualmemorysize}
C:\PS>

C:\PS> $s = new-pssession -computername Server02
C:\PS> invoke-command -session $s -scriptblock {$p = get-process powershell}
C:\PS> invoke-command -session $s -scriptblock {$p.virtualmemorysize}
17930240

Descrizione
-----------
In questo esempio vengono confrontati gli effetti dell'utilizzo dei parametri ComputerName e Session di Invoke-Command. Viene illustrato come utilizzare una sessione per eseguire una serie di comandi che condividono gli stessi dati.

Nei primi due comandi viene utilizzato il parametro ComputerName di Invoke-Command per eseguire comandi sul computer remoto Server02. Il primo comando utilizza il comando Get-Process per ottenere il processo di PowerShell nel computer remoto e salvarlo nella variabile $p. Il secondo comando consente di ottenere il valore della proprietà VirtualMemorySize del processo di PowerShell. 

Il primo comando ha esito positivo. Il secondo, invece, ha esito negativo, poiché quando si utilizza il parametro ComputerName in Windows PowerShell viene creata una connessione solo per l'esecuzione del comando. Quindi, chiude la connessione quando il comando è completo. La variabile $p è stata creata in una connessione, ma non esiste nella connessione creata per il secondo comando.

Il problema viene risolto creando una sessione (connessione permanente) nel computer remoto ed eseguendo entrambi i comandi correlati nella stessa sessione.

Il terzo comando utilizza il cmdlet New-PSSession per creare una sessione nel computer Server02. La sessione viene quindi salvata nella variabile $s. Nel quarto e nel quinto comando la serie di comandi utilizzata nel primo set viene ripetuta, ma in questo caso nel comando Invoke-Command viene utilizzato il parametro Session per eseguire entrambi i comandi nella stessa sessione. 

In questo caso, poiché entrambi i comandi vengono eseguiti nella stessa sessione, i comandi hanno esito positivo e il valore di $p rimane attivo nella sessione $s per essere utilizzato successivamente.

C:\PS>$command = { get-eventlog -log "windows powershell" | where {$_.message -like "*certificate*"} }

C:\PS> invoke-command -computername S1, S2 -scriptblock $command

Descrizione
-----------
In questo esempio viene illustrato come immettere un comando salvato in una variabile locale. 

Quando l'intero comando viene salvato in una variabile locale, è possibile specificare la variabile come valore del parametro ScriptBlock. Non è necessario utilizzare la parola chiave "param" o la variabile ArgumentList per inviare il valore della variabile locale.

Con il primo comando si salva un comando Get-Eventlog nella variabile $command. Il comando viene formattato come blocco di script.

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire il comando in $command nei computer remoti S1 e S2.

C:\PS>invoke-command -computername server01, server02, TST-0143, localhost -configurationname MySession.PowerShell -scriptblock {get-eventlog "windows powershell"}

Descrizione
-----------
In questo esempio viene illustrato come utilizzare il cmdlet Invoke-Command per eseguire un solo comando in più computer. 

Viene utilizzato il parametro ComputerName per specificare i computer. I nomi dei computer vengono presentati in un elenco separato da virgole. L'elenco di computer include il valore "localhost", che rappresenta il computer locale.

Vengono utilizzati il parametro ConfigurationName per specificare una configurazione di sessione alternativa per Windows PowerShell e il parametro ScriptBlock per specificare il comando.

In questo esempio, il comando nel blocco di script ottiene gli eventi nel registro eventi di Windows PowerShell in ogni computer remoto.

C:\PS>$version = invoke-command -computername (get-content machines.txt) -scriptblock {(get-host).version}

Descrizione
-----------
Questo comando consente di ottenere la versione dell'host di Windows PowerShell in esecuzione in 200 computer remoti. 

Poiché viene eseguito solo un comando, non è necessario creare connessioni permanenti (sessioni) a ognuno dei computer. Viene invece utilizzato il parametro ComputerName per indicare i computer.

Viene utilizzato il cmdlet Invoke-Command per eseguire un comando Get-Host. Viene utilizzata la notazione con punto per ottenere la proprietà Version dell'host di Windows PowerShell.

Per specificare i computer, viene utilizzato il cmdlet Get-Content per ottenere il contenuto del file Machine.txt, che contiene i nomi dei computer.

Questi comandi vengono eseguiti in modo sincrono (uno alla volta). Al termine dell'esecuzione dei comandi, l'output dei comandi di tutti i computer viene salvato nella variabile $version. L'output include il nome del computer da cui sono stati originati i dati.

C:\PS>$s = new-pssession -computername Server01, Server02

C:\PS> invoke-command -session $s -scriptblock {get-eventlog system} -AsJob

Id   Name    State      HasMoreData   Location           Command
---  ----    -----      -----         -----------        --------             -------
1    Job1    Running    True          Server01,Server02  get-eventlog system


C:\PS> $j = Get-Job

C:\PS> $j | format-list -property *

HasMoreData   : True
StatusMessage :
Location      : Server01,Server02
Command       : get-eventlog system
JobStateInfo  : Running
Finished      : System.Threading.ManualResetEvent
InstanceId    : e124bb59-8cb2-498b-a0d2-2e07d4e030ca
Id            : 1
Name          : Job1
ChildJobs     : {Job2, Job3}
Output        : {}
Error         : {}
Progress      : {}
Verbose       : {}
Debug         : {}
Warning       : {}
StateChanged  :

C:\PS> $results = $j | Receive-Job

Descrizione
-----------
Questi comandi consentono l'esecuzione di un processo in background in due computer remoti. Poiché il comando Invoke-Command utilizza il parametro AsJob, i comandi vengono eseguiti nei computer remoti, ma in realtà il processo si trova nel computer locale e i risultati vengono trasmessi al computer locale.

Il primo comando utilizza il cmdlet New-PSSession per creare sessioni nei computer remoti Server01 e Server02.

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire un processo in background in ciascuna sessione. Viene utilizzato il parametro AsJob per eseguire il comando come processo in background. Viene restituito un oggetto processo che contiene due oggetti processo figlio, uno per ogni processo eseguito nei due computer remoti.

Il terzo comando utilizza un comando Get-Job per salvare l'oggetto processo nella variabile di $j. 

Con il quarto comando si utilizza un operatore pipeline (|) per inviare il valore della variabile $j al cmdlet Format-List che consente di visualizzare tutte le proprietà dell'oggetto processo in un elenco.

Con il quinto comando si ottengono i risultati dei processi. L'oggetto processo in $j viene reindirizzato al cmdlet Receive-Job e i risultati vengono archiviati nella variabile $results.

C:\PS>$MWFO-LOg = Microsoft-Windows-Forwarding/Operational

C:\PS> invoke-command -computername server01 -scriptblock {param($log, $num) get-eventlog -logname $log -newest $num} -ArgumentList $MWFO-log, 10

Descrizione
-----------
In questo esempio viene illustrato come includere i valori delle variabili locali in un'esecuzione del comando in un computer remoto.

Il primo comando salva il nome del registro eventi Microsoft-Windows-Forwarding/Operational nella variabile $MWFO-Log.

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire un comando Get-EventLog nel computer remoto Server01 che ottiene i 10 eventi più recenti dal registro eventi Microsoft-Windows-Forwarding/Operational in Server01.

In questo comando viene utilizzata la parola chiave "param" per creare due variabili, $log e $num, utilizzate come segnaposto nel comando Get-EventLog. Questi segnaposto hanno nomi arbitrari che non devono necessariamente corrispondere ai nomi delle variabili locali che ne forniscono i valori.

I valori del parametro ArgumentList illustrano le due diverse modalità per specificare i valori nell'elenco di argomenti. Il valore del segnaposto $log è la variabile $MFWO-Log, definita nel primo comando. Il valore della variabile $num è 10.

Prima dell'invio del comando al computer remoto, le variabili vengono sostituite dai valori specificati.

C:\PS>invoke-command -computername S1, S2 -scriptblock {get-process powershell} 

PSComputerName    Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id   ProcessName
--------------    -------  ------    -----      ----- -----   ------     --   -----------
S1                575      15        45100      40988   200     4.68     1392 powershell
S2                777      14        35100      30988   150     3.68     67   powershell


C:\PS> invoke-command -computername S1, S2 -scriptblock {get-process powershell} -HideComputerName

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id   ProcessName
-------  ------    -----      ----- -----   ------     --   -----------
575      15        45100      40988   200     4.68     1392 powershell
777      14        35100      30988   150     3.68     67   powershell

Descrizione
-----------
In questo esempio viene illustrato l'effetto dell'utilizzo del parametro HideComputerName di Invoke-Command. 

Nei primi due comandi viene utilizzato il cmdlet Invoke-Command per eseguire un comando Get-Process per il processo di PowerShell. L'output del primo comando include la proprietà PsComputerName che contiene il nome del computer in cui viene eseguito il comando. L'output del secondo comando, che utilizza il parametro HideComputerName, non include la colonna PsComputerName.

L'utilizzo del parametro HideComputerName non modifica l'oggetto. È comunque possibile utilizzare i cmdlet Format per visualizzare la proprietà PsComputerName di qualsiasi oggetto interessato.

C:\PS>invoke-command -comp (get-content servers.txt) -filepath c:\scripts\sample.ps1 -argumentlist Process, Service

Descrizione
-----------
In questo esempio viene utilizzato il cmdlet Invoke-Command per eseguire lo script Sample.ps1 in tutti i computer elencati nel file Servers.txt. Viene utilizzato il parametro FilePath per specificare il file script. Questo comando consente di eseguire lo script nei computer remoti, anche se il file script non è accessibile a tali computer.

Quando si invia il comando, il contenuto del file Sample.ps1 viene copiato in un blocco di script il quale viene eseguito in ciascun computer remoto. Questa procedura equivale all'utilizzo del parametro ScriptBlock per inviare il contenuto dello script.

C:\PS>$LiveCred = Get-Credential

C:\PS> Invoke-Command -ConfigurationName Microsoft.Exchange `
         -ConnectionUri https://ps.exchangelabs.com/powershell `
         -Credential $LiveCred  -Authentication Basic `
         -scriptblock {Invoke-Command {Set-Mailbox dan -DisplayName "Dan Park"}

Descrizione
-----------
In questo esempio viene illustrato come eseguire un comando in un computer remoto identificato da un URI (indirizzo Internet). In questo esempio viene eseguito un comando Set-Mailbox in un server remoto di Exchange. Il carattere di apice inverso (`) nel comando è il carattere di continuazione di Windows PowerShell.

Con il primo comando si utilizza il cmdlet Get-Credential per archiviare le credenziali di Windows Live ID nella variabile $LiveCred. Quando viene visualizzata la finestra di dialogo delle credenziali, immettere le credenziali di Windows Live ID.

Con il secondo comando si utilizza il cmdlet Invoke-Command per eseguire un comando Set-Mailbox. Viene utilizzato il parametro ConfigurationName per indicare che il comando deve essere eseguito in una sessione che utilizza la configurazione di sessione Microsoft.Exchange. Il parametro ConnectionURI specifica l'URL dell'endpoint del server di Exchange. 

Il parametro delle credenziali specifica le credenziali di Windows Live archiviate nella variabile $LiveCred. Il parametro AuthenticationMechanism specifica l'utilizzo dell'autenticazione di base. Il parametro ScriptBlock specifica un blocco di script che contiene il comando.

C:\PS>$max = New-PSSessionOption -MaximumRedirection 1

C:\PS> Invoke-Command -ConnectionUri https://ps.exchangelabs.com/powershell `
         -scriptblock {Invoke-Command {Get-Mailbox dan} `
         -AllowRedirection -SessionOption $max

Descrizione
-----------
Con questo comando viene illustrato come utilizzare i parametri AllowRedirection e SessionOption per gestire il reindirizzamento dell'URI in un comando remoto.

Con il primo comando si utilizza il cmdlet New-PSSessionOption per creare un oggetto PSSessionOption che viene salvato nella variabile $max. Con il comando si utilizza il parametro MaximumRedirection per impostare la proprietà MaximumConnectionRedirectionCount dell'oggetto PSSessionOption su 1. 

Con il secondo comando si utilizza il cmdlet Invoke-Command per eseguire il comando Get-Mailbox in un server remoto in cui viene eseguito Microsoft Exchange Server. Viene utilizzato il parametro AllowRedirection per fornire un'autorizzazione esplicita per il reindirizzamento della connessione a un endpoint alternativo. Viene inoltre utilizzato il parametro SessionOption per specificare l'oggetto sessione nella variabile $max.

Di conseguenza, se il computer remoto specificato dal parametro ConnectionURI restituisce un messaggio di reindirizzamento, in Windows PowerShell la connessione verrà reindirizzata, ma se la nuova destinazione restituisce un altro messaggio di reindirizzamento, verrà superato il valore del conteggio di reindirizzamento pari a 1 e Invoke-Command restituirà un errore non fatale.

C:\PS>$so = New-PSSessionOption -SkipCACheck

PS C:\> invoke-command $s { get-hotfix } -SessionOption $so -credential server01\user01

Descrizione
-----------
In questo esempio viene illustrato come creare e utilizzare un parametro SessionOption. 

Il primo comando utilizza il cmdlet New-PSSessionOption per creare un'opzione di sessione. L'oggetto SessionOption risultante viene salvato nel parametro $so.

Il secondo comando utilizza il cmdlet Invoke-Command per eseguire un comando Get-Hotfix in remoto. Il valore del parametro SessionOption è l'oggetto SessionOption presente nella variabile $so.

C:\PS>enable-wsmanCredSSP -delegate server02

C:\PS> connect-wsman Server02

C:\PS> set-item wsman:\server02*\service\auth\credSSP -value $true

C:\PS> $s = new-pssession server02

C:\PS> invoke-command -session $s -script {get-item \\Net03\Scripts\LogFiles.ps1} -authentication credssp -credential domain01\admin01

Descrizione
-----------
In questo esempio viene illustrato come accedere a una condivisione di rete dall'interno di una sessione remota. 

Per questo comando è necessario che la delega CredSSP sia abilitata nelle impostazioni del client del computer locale e nelle impostazioni del servizio nel computer remoto. Per eseguire i comandi in questo esempio, è necessario essere un membro del gruppo Administrators nel computer locale e nel computer remoto.

Con il primo comando si utilizza il cmdlet Enable-WSManCredSSP per abilitare la delega CredSSP dal computer locale Server01 al computer remoto Server02. L'impostazione client CredSSP viene configurata nel computer locale.

Con il secondo comando si utilizza il cmdlet Connect-WSman per la connessione al computer Server02. Questa azione consente di aggiungere un nodo per il computer Server02 all'unità WSMan: nel computer locale, consentendo la visualizzazione e la modifica delle impostazioni di WS-Management nel computer Server02.

Nel terzo comando viene utilizzato il cmdlet Set-Item per modificare il valore dell'elemento CredSSP nel nodo Service del computer Server02 in True. Questa azione consente di abilitare CredSSP nelle impostazioni servizio nel computer remoto.

Con il quarto comando si utilizza il cmdlet New-PSSession per creare una sessione PSSession nel computer Server02. La sessione PSSession viene quindi salvata nella variabile $s.

Con il quinto comando si utilizza il cmdlet Invoke-Command per eseguire un comando Get-Item nella sessione in $s che ottiene uno script dalla condivisione di rete Net03\Scripts. Vengono utilizzati il parametro Credential e il parametro Authentication con un valore di CredSSP.