powershellscripts.com

Tutorials  PowerShell Cmdlet Help for Invoke-Command



NAME
Invoke-Command

SYNOPSIS
Runs commands on local and remote computers.

SYNTAX
Invoke-Command [-ScriptBlock] [[-ComputerName] ] [-ApplicationName ] [-AsJob] [-Aut
hentication {Default | Basic | Negotiate | NegotiateWithImplicitCredential | Credssp | Digest | Kerberos}] [-Certif
icateThumbprint ] [-ConfigurationName ] [-Credential ] [-HideComputerName] [-JobName
] [-Port ] [-SessionOption ] [-ThrottleLimit ] [-UseSSL] [-ArgumentList ]>] [-InputObject ] []

Invoke-Command [-FilePath] [[-ComputerName] ] [-ApplicationName ] [-AsJob] [-Authenticat
ion {Default | Basic | Negotiate | NegotiateWithImplicitCredential | Credssp | Digest | Kerberos}] [-ConfigurationN
ame ] [-Credential ] [-HideComputerName] [-JobName ] [-Port ] [-SessionOption SSessionOption>] [-ThrottleLimit ] [-UseSSL] [-ArgumentList ] [-InputObject ] [ meters>]

Invoke-Command [-FilePath] [[-Session] ] [-AsJob] [-HideComputerName] [-JobName ] [-T
hrottleLimit ] [-ArgumentList ] [-InputObject ] []

Invoke-Command [-FilePath] [[-ConnectionURI] ] [-AllowRedirection] [-AsJob] [-Authentication {Defau
lt | Basic | Negotiate | NegotiateWithImplicitCredential | Credssp | Digest | Kerberos}] [-ConfigurationName g>] [-Credential ] [-HideComputerName] [-JobName ] [-SessionOption ] [-Throt
tleLimit ] [-ArgumentList ] [-InputObject ] []

Invoke-Command [-ScriptBlock] [-ArgumentList ] [-InputObject ] [ >]

Invoke-Command [-ScriptBlock] [[-Session] ] [-AsJob] [-HideComputerName] [-JobName ng>] [-ThrottleLimit ] [-ArgumentList ] [-InputObject ] []

Invoke-Command [-ScriptBlock] [[-ConnectionURI] ] [-AllowRedirection] [-AsJob] [-Authenticatio
n {Default | Basic | Negotiate | NegotiateWithImplicitCredential | Credssp | Digest | Kerberos}] [-CertificateThumb
print ] [-ConfigurationName ] [-Credential ] [-HideComputerName] [-JobName ]
[-SessionOption ] [-ThrottleLimit ] [-ArgumentList ] [-InputObject ] [ mmonParameters>]


DESCRIPTION
The Invoke-Command cmdlet runs commands on a local or remote computer and returns all output from the commands, inc
luding errors. With a single Invoke-Command command, you can run commands on multiple computers.

To run a single command on a remote computer, use the ComputerName parameter. To run a series of related commands t
hat share data, create a PSSession (a persistent connection) on the remote computer, and then use the Session param
eter of Invoke-Command to run the command in the PSSession.

You can also use Invoke-Command on a local computer to evaluate or run a string in a script block as a command. Win
dows PowerShell converts the script block to a command and runs the command immediately in the current scope, inste
ad of just echoing the string at the command line.

Before using Invoke-Command to run commands on a remote computer, read about_Remote.


PARAMETERS
-AllowRedirection []
Allows redirection of this connection to an alternate URI.

When you use the ConnectionURI parameter, the remote destination can return an instruction to redirect to a dif
ferent URI. By default, Windows PowerShell does not redirect connections, but you can use the AllowRedirection
parameter to allow it to redirect the connection.

You can also limit the number of times that the connection is redirected by setting the MaximumConnectionRedire
ctionCount property of the $PSSessionOption preference variable, or the MaximumConnectionRedirectionCount prope
rty of the value of the SessionOption parameter. The default value is 5. For more information, see the descript
ion of the SessionOption parameter and the help topic for the New-PSSessionOption cmdlet.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-ApplicationName
Specifies the application name segment of the connection URI. Use this parameter to specify the application nam
e when you are not using the ConnectionURI parameter in the command.

The default value is the value of the $PSSessionApplicationName preference variable on the local computer. If t
his preference variable is not defined, the default value is WSMAN. This value is appropriate for most uses. Fo
r more information, see about_Preference_Variables.

The WinRM service uses the application name to select a listener to service the connection request. The value o
f this parameter should match the value of the URLPrefix property of a listener on the remote computer.

Required? false
Position? named
Default value WSMAN
Accept pipeline input? true (ByPropertyName)
Accept wildcard characters? false

-ArgumentList
Supplies the values of local variables in the command. The variables in the command are replaced by these value
s before the command is run on the remote computer. Enter the values in a comma-separated list. Values are asso
ciated with variables in the order that they are listed. The alias for ArgumentList is "Args".

The values in ArgumentList can be actual values, such as "1024", or they can be references to local variables,
such as "$max".

To use local variables in a command, use the following command format:
{param($[, $]...) } -ArgumentList

The "param" keyword lists the local variables that are used in the command. The ArgumentList parameter supplies
the values of the variables, in the order that they are listed.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-AsJob []
Runs the command as a background job on a remote computer. Use this parameter to run commands that take an exte
nsive time to complete.

When you use AsJob, the command returns an object that represents the job, and then displays the command prompt
. You can continue to work in the session while the job completes. To manage the job, use the Job cmdlets. To
get the job results, use Receive-Job.

The AsJob parameter is similar to using Invoke-Command to run a Start-Job command remotely. However, with AsJob
, the job is created on the local computer, even though the job runs on a remote computer, and the results of t
he remote job are automatically returned to the local computer.

For more information about Windows PowerShell background jobs, see about_Jobs and about_Remote_Jobs.

Required? false
Position? named
Default value None
Accept pipeline input? false
Accept wildcard characters? false

-Authentication
Specifies the mechanism that is used to authenticate the user's credentials. Valid values are Default, Basic,
Credssp, Digest, Kerberos, Negotiate, and NegotiateWithImplicitCredential. The default value is Default.

CredSSP authentication is available only in Windows Vista, Windows Server 2008, and later versions of Windows.

For information about the values of this parameter, see the description of the System.Management.Automation.Run
spaces.AuthenticationMechanism enumeration in MSDN.

CAUTION: Credential Security Service Provider (CredSSP) authentication, in which the user's credentials are pas
sed to a remote computer to be authenticated, is designed for commands that require authentication on more than
one resource, such as accessing a remote network share. This mechanism increases the security risk of the remo
te operation. If the remote computer is compromised, the credentials that are passed to it can be used to contr
ol the network session.

Required? false
Position? named
Default value Default
Accept pipeline input? false
Accept wildcard characters? false

-CertificateThumbprint
Specifies the digital public key certificate (X509) of a user account that has permission to perform this actio
n. Enter the certificate thumbprint of the certificate.

Certificates are used in client certificate-based authentication. They can only be mapped to local user account
s; they do not work with domain accounts.

To get a certificate thumbprint, use the Get-Item or Get-ChildItem commands in the Windows PowerShell Cert: dri
ve.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-ComputerName
Specifies the computers on which the command runs. The default is the local computer.

When you use the ComputerName parameter, Windows PowerShell creates a temporary connection that is used only to
run the specified command and is then closed. If you need a persistent connection, use the Session parameter.

Type the NETBIOS name, IP address, or fully-qualified domain name of one or more computers in a comma-separated
list. To specify the local computer, type the computer name, "localhost", or a dot (.).

To use an IP address in the value of the ComputerName parameter, the command must include the Credential parame
ter. Also, the computer must be configured for HTTPS transport or the IP address of the remote computer must be
included in the WinRM TrustedHosts list on the local computer. For instructions for adding a computer name to
the TrustedHosts list, see "How to Add a Computer to the Trusted Host List" in about_Remote_Troubleshooting.

Note: On Windows Vista, and later versions of Windows, to include the local computer in the value of the Compu
terName parameter, you must open Windows PowerShell with the "Run as administrator" option.

Required? false
Position? 1
Default value
Accept pipeline input? true (ByPropertyName)
Accept wildcard characters? false

-ConfigurationName
Specifies the session configuration that is used for the new PSSession.

Enter a configuration name or the fully qualified resource URI for a session configuration. If you specify only
the configuration name, the following schema URI is prepended: http://schemas.microsoft.com/powershell.

The session configuration for a session is located on the remote computer. If the specified session configurati
on does not exist on the remote computer, the command fails.

The default value is the value of the $PSSessionConfigurationName preference variable on the local computer. If
this preference variable is not set, the default is Microsoft.PowerShell. For more information, see about_pref
erence_variables.

Required? false
Position? named
Default value http://Schemas.Microsoft.com/PowerShell/Microsoft.PowerShell
Accept pipeline input? true (ByPropertyName)
Accept wildcard characters? false

-ConnectionURI
Specifies a Uniform Resource Identifier (URI) that defines the connection endpoint. The URI must be fully quali
fied.

The format of this string is:
://:/

The default value is:
http://localhost:80/WSMAN

Valid values for the Transport segment of the URI are HTTP and HTTPS. If you do not specify a ConnectionURI, yo
u can use the UseSSL, ComputerName, Port, and ApplicationName parameters to specify the URI values.

If the destination computer redirects the connection to a different URI, Windows PowerShell prevents the redire
ction unless you use the AllowRedirection parameter in the command.

Required? false
Position? 1
Default value http://localhost:80/wsman
Accept pipeline input? true (ByPropertyName)
Accept wildcard characters? false

-Credential
Specifies a user account that has permission to perform this action. The default is the current user.

Type a user name, such as "User01" or "Domain01\User01", or enter a variable that contains a PSCredential objec
t, such as one generated by the Get-Credential cmdlet. When you type a user name, you will be prompted for a pa
ssword.

Required? false
Position? named
Default value
Accept pipeline input? true (ByPropertyName)
Accept wildcard characters? false

-FilePath
Runs the specified local script on one or more remote computers. Enter the path and file name of the script, or
pipe a script path to Invoke-Command. The script must reside on the local computer or in a directory that the
local computer can access. Use the ArgumentList parameter to specify the values of parameters in the script.

When you use this parameter, Windows PowerShell converts the contents of the specified script file to a script
block, transmits the script block to the remote computer, and runs it on the remote computer.

Required? true
Position? 2
Default value
Accept pipeline input? false
Accept wildcard characters? false

-HideComputerName []
Omits the computer name of each object from the output display. By default, the name of the computer that gener
ated the object appears in the display.

This parameter affects only the output display. It does not change the object.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-InputObject
Specifies input to the command. Enter a variable that contains the objects or type a command or expression that
gets the objects.

When using InputObject, use the $input automatic variable in the value of the ScriptBlock parameter to represen
t the input objects.

Required? false
Position? named
Default value
Accept pipeline input? true (ByValue)
Accept wildcard characters? false

-JobName
Specifies a friendly name for the background job. By default, jobs are named "Job", where is an ordinal
number. This parameter is valid only with the AsJob parameter.

If you use the JobName parameter in a command, the command is run as a job, and Invoke-Command returns a job ob
ject, even if you do not include the AsJob parameter in the command.

For more information about Windows PowerShell background jobs, see about_Jobs.

Required? false
Position? named
Default value Job
Accept pipeline input? false
Accept wildcard characters? false

-Port
Specifies the network port on the remote computer used for this command. The default is port 80 (the HTTP port
).

Before using an alternate port, you must configure the WinRM listener on the remote computer to listen at that
port. To configure the listener, type the following two commands at the Windows PowerShell prompt:

remove-item -path wsman:\Localhost\listener\listener* -recurse
new-item -path wsman:\Localhost\listener -Transport http -Address * -port

Do not use the Port parameter unless you must. The Port set in the command applies to all computers or sessions
on which the command runs. An alternate port setting might prevent the command from running on all computers.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-ScriptBlock
Specifies the commands to run. Enclose the commands in curly braces ( { } ) to create a script block. This para
meter is required.

By default, any variables in the command are evaluated on the remote computer. To include local variables in th
e command, use the ArgumentList parameter.

Required? true
Position? 1
Default value
Accept pipeline input? false
Accept wildcard characters? false

-Session
Runs the command in the specified Windows PowerShell sessions (PSSessions). Enter a variable that contains the
PSSessions or a command that creates or gets the PSSessions, such as a New-PSSession or Get-PSSession command.

When you create a PSSession, Windows PowerShell establishes a persistent connection to the remote computer. Use
a PSSession to run a series of related commands that share data. To run a single command or a series of unrela
ted commands, use the ComputerName parameter.

To create a PSSession, use the New-PSSession cmdlet. For more information, see about_PSSessions.

Required? false
Position? 1
Default value
Accept pipeline input? true (ByPropertyName)
Accept wildcard characters? false

-SessionOption
Sets advanced options for the session. Enter a SessionOption object that you create by using the New-PSSessionO
ption cmdlet.

The default values for the options are determined by the value of the $PSSessionOption preference variable, if
it is set. Otherwise, the session uses the system defaults.

For a description of the session options, including the default values, see the help topic for the New-PSSessio
nOption cmdlet. For information about the $PSSessionOption preference variable, see about_Preference_Variables.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-ThrottleLimit
Specifies the maximum number of concurrent connections that can be established to run this command. If you omit
this parameter or enter a value of 0, the default value, 32, is used.

The throttle limit applies only to the current command, not to the session or to the computer.

Required? false
Position? named
Default value 32
Accept pipeline input? false
Accept wildcard characters? false

-UseSSL []
Uses the Secure Sockets Layer (SSL) protocol to establish a connection to the remote computer. By default, SSL
is not used.

WS-Management encrypts all Windows PowerShell content transmitted over the network. UseSSL is an additional pro
tection that sends the data across an HTTPS, instead of HTTP.

If you use this parameter, but SSL is not available on the port used for the command, the command fails.

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false


This cmdlet supports the common parameters: Verbose, Debug,
ErrorAction, ErrorVariable, WarningAction, WarningVariable,
OutBuffer and OutVariable. For more information, type,
"get-help about_commonparameters".

INPUTS
System.Management.Automation.ScriptBlock
You can pipe a command in a script block to Invoke-Command. Use the $input automatic variable to represent the
input objects in the command.


OUTPUTS
System.Management.Automation.PSRemotingJob or the output of the invoked command
When you use the AsJob parameter, Invoke-Command returns a job object. Otherwise, it returns the output of the
invoked command (the value of the ScriptBlock parameter).


NOTES


-- On Windows Vista, and later versions of Windows, to use the ComputerName parameter of Invoke-Command to run
a command on the local computer, you must open Windows PowerShell with the "Run as administrator" option.

-- When you run commands on multiple computers, Windows PowerShell connects to the computers in the order in wh
ich they appear in the list. However, the command output is displayed in the order that it is received from the
remote computers, which might be different.

-- Errors that result from the command that Invoke-Command runs are included in the command results. Errors tha
t would be terminating errors in a local command are treated as non-terminating errors in a remote command. Thi
s strategy ensures that terminating errors on one computer do not terminate the command on all computers on whi
ch it is run. This practice is used even when a remote command is run on a single computer.

-- If the remote computer is not in a domain that the local computer trusts, the computer might not be able to
authenticate the user's credentials. To add the remote computer to the list of "trusted hosts" in WS-Management
, use the following command in the WSMAN provider, where is the name of the remote compu
ter:
set-item -path wsman:\Localhost\Client\TrustedHosts -value .


-------------------------- EXAMPLE 1 --------------------------

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

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


Description
-----------
This command runs the Test.ps1 script on the Server01 computer.

The command uses the FilePath parameter to specify a script that is located on the local computer. The script runs
on the remote computer and the results are returned to the local computer.





-------------------------- EXAMPLE 2 --------------------------

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


Description
-----------
This command runs a Get-Culture command on the Server01 remote computer.

It uses the ComputerName parameter to specify the computer name and the Credential parameter to run the command in
the security context of "Domain01\User01," a user with permission to run commands. It uses the ScriptBlock paramete
r to specify the command to be run on the remote computer.

In response, Windows PowerShell displays a dialog box that requests the password and an authentication method for t
he User01 account. It then runs the command on the Server01 computer and returns the result.





-------------------------- EXAMPLE 3 --------------------------

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

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


Description
-----------
This example runs the same "Get-Culture" command in a session (a persistent connection) on the Server02 remote comp
uter. Typically, you create a session only when you are running a series of commands on the remote computer.

The first command uses the New-PSSession cmdlet to create a session on the Server02 remote computer. Then, it saves
the session in the $s variable.

The second command uses the Invoke-Command cmdlet to run the Get-Culture command on Server02. It uses the Session p
arameter to specify the session saved in the $s variable.

In response, Windows PowerShell runs the command in the session on the Server02 computer.





-------------------------- EXAMPLE 4 --------------------------

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


Description
-----------
This example compares the effects of using ComputerName and Session parameters of Invoke-Command. It shows how to u
se a session to run a series of commands that share the same data.

The first two commands use the ComputerName parameter of Invoke-Command to run commands on the Server02 remote comp
uter. The first command uses the Get-Process command to get the PowerShell process on the remote computer and to sa
ve it in the $p variable. The second command gets the value of the VirtualMemorySize property of the PowerShell pro
cess.

The first command succeeds. But, the second command fails because when you use the ComputerName parameter, Windows
PowerShell creates a connection just to run the command. Then, it closes the connection when the command is complet
e. The $p variable was created in one connection, but it does not exist in the connection created for the second co
mmand.

The problem is solved by creating a session (a persistent connection) on the remote computer and by running both of
the related commands in the same session.

The third command uses the New-PSSession cmdlet to create a session on the Server02 computer. Then it saves the ses
sion in the $s variable. The fourth and fifth commands repeat the series of commands used in the first set, but in
this case, the Invoke-Command command uses the Session parameter to run both of the commands in the same session.

In this case, because both commands run in the same session, the commands succeed, and the $p value remains active
in the $s session for later use.





-------------------------- EXAMPLE 5 --------------------------

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

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


Description
-----------
This example shows how to enter a command that is saved in a local variable.

When the entire command is saved in a local variable, you can specify the variable as the value of the ScriptBlock
parameter. You do not have to use the "param" keyword or the ArgumentList variable to submit the value of the local
variable.

The first command saves a Get-Eventlog command in the $command variable. The command is formatted as a script block
.

The second command uses the Invoke-Command cmdlet to run the command in $command on the S1 and S2 remote computers.





-------------------------- EXAMPLE 6 --------------------------

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


Description
-----------
This example demonstrates how to use the Invoke-Command cmdlet to run a single command on multiple computers.

The command uses the ComputerName parameter to specify the computers. The computer names are presented in a comma-s
eparated list. The list of computers includes the "localhost" value, which represents the local computer.

The command uses the ConfigurationName parameter to specify an alternate session configuration for Windows PowerShe
ll and the ScriptBlock parameter to specify the command.

In this example, the command in the script block gets the events in the Windows PowerShell event log on each remote
computer.





-------------------------- EXAMPLE 7 --------------------------

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


Description
-----------
This command gets the version of the Windows PowerShell host running on 200 remote computers.

Because only one command is run, it is not necessary to create persistent connections (sessions) to each of the com
puters. Instead, the command uses the ComputerName parameter to indicate the computers.

The command uses the Invoke-Command cmdlet to run a Get-Host command. It uses dot notation to get the Version prope
rty of the Windows PowerShell host.

To specify the computers, it uses the Get-Content cmdlet to get the contents of the Machine.txt file, a file of com
puter names.

These commands run synchronously (one at a time). When the commands complete, the output of the commands from all o
f the computers is saved in the $version variable. The output includes the name of the computer from which the data
originated.





-------------------------- EXAMPLE 8 --------------------------

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


Description
-----------
These commands run a background job on two remote computers. Because the Invoke-Command command uses the AsJob para
meter, the commands run on the remote computers, but the job actually resides on the local computer and the results
are transmitted to the local computer.

The first command uses the New-PSSession cmdlet to create sessions on the Server01 and Server02 remote computers.

The second command uses the Invoke-Command cmdlet to run a background job in each of the sessions. The command uses
the AsJob parameter to run the command as a background job. This command returns a job object that contains two ch
ild job objects, one for each of the jobs run on the two remote computers.

The third command uses a Get-Job command to save the job object in the $j variable.

The fourth command uses a pipeline operator (|) to send the value of the $j variable to the Format-List cmdlet, whi
ch displays all properties of the job object in a list.

The fifth command gets the results of the jobs. It pipes the job object in $j to the Receive-Job cmdlet and stores
the results in the $results variable.





-------------------------- EXAMPLE 9 --------------------------

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

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


Description
-----------
This example shows how to include the values of local variables in a command run on a remote computer.

The first command saves the name of the Microsoft-Windows-Forwarding/Operational event log in the $MWFO-Log variabl
e.

The second command uses the Invoke-Command cmdlet to run a Get-EventLog command on the Server01 remote computer tha
t gets the 10 newest events from the Microsoft-Windows-Forwarding/Operational event log on Server01.

This command uses the "param" keyword to create two variables, $log and $num, that are used as placeholders in the
Get-EventLog command. These placeholders have arbitrary names that do not need to match the names of the local vari
ables that supply their values.

The values of the ArgumentList parameter demonstrate the two different ways to specify values in the argument list.
The value of the $log placeholder is the $MFWO-Log variable, which is defined in the first command. The value of t
he $num variable is 10.

Before the command is sent to the remote computer, the variables are replaced with the specified values.





-------------------------- EXAMPLE 10 --------------------------

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


Description
-----------
This example shows the effect of using the HideComputerName parameter of Invoke-Command.

The first two commands use the Invoke-Command cmdlet to run a Get-Process command for the PowerShell process. The o
utput of the first command includes the PsComputerName property, which contains the name of the computer on which t
he command ran. The output of the second command, which uses the HideComputerName parameter, does not include the P
sComputerName column.

Using the HideComputerName parameter does not change the object. You can still use the Format cmdlets to display th
e PsComputerName property of any of the affected objects.





-------------------------- EXAMPLE 11 --------------------------

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


Description
-----------
This example uses the Invoke-Command cmdlet to run the Sample.ps1 script on all of the computers listed in the Serv
ers.txt file. The command uses the FilePath parameter to specify the script file. This command allows you to run th
e script on the remote computers, even if the script file is not accessible to the remote computers.

When you submit the command, the content of the Sample.ps1 file is copied into a script block and the script block
is run on each of the remote computers. This procedure is equivalent to using the ScriptBlock parameter to submit t
he contents of the script.





-------------------------- EXAMPLE 12 --------------------------

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"}


Description
-----------
This example shows how to run a command on a remote computer that is identified by a URI (Internet address). This p
articular example runs a Set-Mailbox command on a remote Exchange server. The backtick (`) in the command is the Wi
ndows PowerShell continuation character.

The first command uses the Get-Credential cmdlet to store Windows Live ID credentials in the $LiveCred variab the c
redentials dialog box appears, enter Windows Live ID credentials.

The second command uses the Invoke-Command cmdlet to run a Set-Mailbox command. The command uses the ConfigurationN
ame parameter to specify that the command should run in a session that uses the Microsoft.Exchange session configur
ation. The ConnectionURI parameter specifies the URL of the Exchange server endpoint.

The credential parameter specifies tle. Whenhe Windows Live credentials stored in the $LiveCred variable. The Authe
nticationMechanism parameter specifies the use of basic authentication. The ScriptBlock parameter specifies a scrip
t block that contains the command.





-------------------------- EXAMPLE 13 --------------------------

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


Description
-----------
This command shows how to use the AllowRedirection and SessionOption parameters to manage URI redirection in a remo
te command.

The first command uses the New-PSSessionOption cmdlet to create a PSSessionOpption object that it saves in the $max
variable. The command uses the MaximumRedirection parameter to set the MaximumConnectionRedirectionCount property
of the PSSessionOption object to 1.

The second command uses the Invoke-Command cmdlet to run a Get-Mailbox command on a remote server running Microsoft
Exchange Server. The command uses the AllowRedirection parameter to provide explicit permission to redirect the co
nnection to an alternate endpoint. It also uses the SessionOption parameter to specify the session object in the $m
ax variable.

As a result, if the remote computer specified by the ConnectionURI parameter returns a redirection message, Windows
PowerShell will redirect the connection, but if the new destination returns another redirection message, the redir
ection count value of 1 is exceeded, and Invoke-Command returns a non-terminating error.





-------------------------- EXAMPLE 14 --------------------------

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

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


Description
-----------
This example shows how to create and use a SessionOption parameter.

The first command uses the New-PSSessionOption cmdlet to create a session option. It saves the resulting SessionOpt
ion object in the $so parameter.

The second command uses the Invoke-Command cmdlet to run a Get-Hotfix command remotely. The value of the SessionOpt
ion parameter is the SessionOption object in the $so variable.





-------------------------- EXAMPLE 15 --------------------------

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 -credenti
al domain01\admin01


Description
-----------
This example shows how to access a network share from within a remote session.

The command requires that CredSSP delegation be enabled in the client settings on the local computer and in the ser
vice settings on the remote computer. To run the commands in this example, you must be a member of the Administrato
rs group on the local computer and the remote computer.

The first command uses the Enable-WSManCredSSP cmdlet to enable CredSSP delegation from the Server01 local computer
to the Server02 remote computer. This configures the CredSSP client setting on the local computer.

The second command uses the Connect-WSman cmdlet to connect to the Server02 computer. This action adds a node for t
he Server02 computer to the WSMan: drive on the local computer, allowing you to view and change the WS-Management s
ettings on the Server02 computer.

The third command uses the Set-Item cmdlet to change the value of the CredSSP item in the Service node of the Serve
r02 computer to True. This action enables CredSSP in the service settings on the remote computer.

The fourth command uses the New-PSSession cmdlet to create a PSSession on the Server02 computer. It saves the PSSes
sion in the $s variable.

The fifth command uses the Invoke-Command cmdlet to run a Get-Item command in the session in $s that gets a script
from the Net03\Scripts network share. The command uses the Credential parameter and it uses the Authentication para
meter with a value of CredSSP.






RELATED LINKS
Online version: http://go.microsoft.com/fwlink/?LinkID=135225
about_Remote
about_PSSessions
New-PSSession
Get-PSSession
Remove-PSSession
Enter-PSSession
Exit-PSSession
WS-Management Provider