Invoke-Command

Sintaxe

Invoke-Command
      [-ScriptBlock] <ScriptBlock>
      [-NoNewScope]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-Session] <PSSession[]>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-Session] <PSSession[]>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-ComputerName] <String[]>]
      [-Credential <PSCredential>]
      [-Port <Int32>]
      [-UseSSL]
      [-ConfigurationName <String>]
      [-ApplicationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-InDisconnectedSession]
      [-SessionName <String[]>]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      [[-ComputerName] <String[]>]
      [-Credential <PSCredential>]
      [-Port <Int32>]
      [-UseSSL]
      [-ConfigurationName <String>]
      [-ApplicationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-InDisconnectedSession]
      [-SessionName <String[]>]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-CertificateThumbprint <String>]
      [<CommonParameters>]

Invoke-Command
      [-Credential <PSCredential>]
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [[-ConnectionUri] <Uri[]>]
      [-AsJob]
      [-InDisconnectedSession]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-AllowRedirection]
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-CertificateThumbprint <String>]
      [<CommonParameters>]

Invoke-Command
      [-Credential <PSCredential>]
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [[-ConnectionUri] <Uri[]>]
      [-AsJob]
      [-InDisconnectedSession]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-AllowRedirection]
      [-SessionOption <PSSessionOption>]
      [-Authentication <AuthenticationMechanism>]
      [-EnableNetworkAccess]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-ScriptBlock] <ScriptBlock>
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-VMId] <Guid[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-ScriptBlock] <ScriptBlock>
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -VMName <String[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      [-VMId] <Guid[]>
      [<CommonParameters>]

Invoke-Command
      -Credential <PSCredential>
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-FilePath] <String>
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -VMName <String[]>
      [<CommonParameters>]

Invoke-Command
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-ScriptBlock] <ScriptBlock>
      [-RunAsAdministrator]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -ContainerId <String[]>
      [<CommonParameters>]

Invoke-Command
      [-ConfigurationName <String>]
      [-ThrottleLimit <Int32>]
      [-AsJob]
      [-HideComputerName]
      [-JobName <String>]
      [-FilePath] <String>
      [-RunAsAdministrator]
      [-InputObject <PSObject>]
      [-ArgumentList <Object[]>]
      -ContainerId <String[]>
      [<CommonParameters>]

Description

O Invoke-Command cmdlet executa comandos em um computador local ou remoto e retorna toda a saída dos comandos, incluindo erros. Usando um único Invoke-Command comando, você pode executar comandos em vários computadores.

Para executar um único comando em um computador remoto, use o parâmetro ComputerName . Para executar uma série de comandos relacionados que compartilham dados, use o New-PSSession cmdlet para criar um PSSession (uma conexão persistente) no computador remoto e, em seguida, use o parâmetro Session de Invoke-Command para executar o comando no PSSession. Para executar um comando em uma sessão desconectada, use o parâmetro InDisconnectedSession . Para executar um comando em um trabalho em segundo plano, use o parâmetro AsJob .

Você também pode usar Invoke-Command em um computador local para executar um bloco de script como um comando. O PowerShell executa o bloco de script imediatamente em um escopo filho do escopo atual.

Antes de usar Invoke-Command para executar comandos em um computador remoto, leia about_Remote.

Alguns exemplos de código usam splatting para reduzir o comprimento da linha. Para obter mais informações, consulte about_Splatting.

Exemplos

Exemplo 1: Executar um script em um servidor

Este exemplo executa o Test.ps1 script no computador Server01.

Invoke-Command -FilePath c:\scripts\test.ps1 -ComputerName Server01

O parâmetro FilePath especifica um script localizado no computador local. O script é executado no computador remoto e os resultados são retornados ao computador local.

Exemplo 2: Executar um comando em um servidor remoto

Este exemplo executa um Get-Culture comando no computador remoto Server01.

Invoke-Command -ComputerName Server01 -Credential Domain01\User01 -ScriptBlock {
    Get-Culture
}

O parâmetro ComputerName especifica o nome do computador remoto. O parâmetro Credential é usado para executar o comando no contexto de segurança de Domain01\User01, um usuário que tem permissão para executar comandos. O parâmetro ScriptBlock especifica o comando a ser executado no computador remoto.

Em resposta, o PowerShell solicita a senha e um método de autenticação para a conta User01. Em seguida, ele executa o comando no computador Server01 e retorna o resultado.

Exemplo 3: Executar um comando em uma conexão persistente

Este exemplo executa o mesmo Get-Culture comando em uma sessão, usando uma conexão persistente, no computador remoto chamado Server02.

$s = New-PSSession -ComputerName Server02 -Credential Domain01\User01
Invoke-Command -Session $s -ScriptBlock { Get-Culture }

O New-PSSession cmdlet cria uma sessão no computador remoto Server02 e a salva na $s variável. Normalmente, você cria uma sessão somente quando executa uma série de comandos no computador remoto.

O Invoke-Command cmdlet executa o Get-Culture comando no Server02. O parâmetro Session especifica a sessão salva na $s variável.

Em resposta, o PowerShell executa o comando na sessão no computador Server02.

Exemplo 4: Usar uma sessão para executar uma série de comandos que compartilham dados

Este exemplo compara os efeitos do uso dos parâmetros ComputerName e Session do Invoke-Command. Ele mostra como utilizar uma sessão para executar uma série de comandos que compartilham os mesmos dados.

Invoke-Command -ComputerName Server02 -ScriptBlock { $p = Get-Process PowerShell }
Invoke-Command -ComputerName Server02 -ScriptBlock { $p.VirtualMemorySize }
$s = New-PSSession -ComputerName Server02
Invoke-Command -Session $s -ScriptBlock { $p = Get-Process PowerShell }
Invoke-Command -Session $s -ScriptBlock { $p.VirtualMemorySize }

17930240

Os dois primeiros comandos usam o parâmetro ComputerName de Invoke-Command para executar comandos no computador remoto Server02. O primeiro comando usa o Get-Process cmdlet para obter o processo do PowerShell no computador remoto e salvá-lo na $p variável. O segundo comando obtém o valor da propriedade VirtualMemorySize do processo do PowerShell.

Quando você usa o parâmetro ComputerName, o PowerShell cria uma nova sessão para executar o comando. A sessão é fechada quando o comando é concluído. A $p variável foi criada em uma conexão, mas não existe na conexão criada para o segundo comando.

O problema é resolvido criando uma sessão persistente no computador remoto e, em seguida, executando os dois comandos na mesma sessão.

O New-PSSession cmdlet cria uma sessão persistente no computador Server02 e salva a $s sessão na variável. As Invoke-Command linhas a seguir usam o parâmetro Session para executar os dois comandos na mesma sessão. Como ambos os comandos são executados na mesma sessão, o $p valor permanece ativo.

Exemplo 5: Invocar um comando com um bloco de script armazenado em uma variável

Este exemplo mostra como executar um comando armazenado como um bloco de script em uma variável. Quando o bloco de script é salvo em uma variável, você pode especificar a variável como o valor do parâmetro ScriptBlock .

$command = {
    Get-EventLog -LogName 'Windows PowerShell' |
        Where-Object { $_.Message -like '*certificate*' }
}
Invoke-Command -ComputerName S1, S2 -ScriptBlock $command

A $command variável armazena o Get-EventLog comando formatado como um bloco de script. O Invoke-Command executa o comando armazenado nos $command computadores remotos S1 e S2.

Exemplo 6: Executar um único comando em vários computadores

Este exemplo demonstra como usar Invoke-Command para executar um único comando em vários computadores.

$parameters = @{
  ComputerName      = 'Server01', 'Server02', 'TST-0143', 'localhost'
  ConfigurationName = 'MySession.PowerShell'
  ScriptBlock = { Get-EventLog 'Windows PowerShell' }
}
Invoke-Command @parameters

O parâmetro ComputerName especifica uma lista separada por vírgulas de nomes de computador. A lista de computadores inclui o valor localhost, que representa o computador local. O parâmetro ConfigurationName especifica uma configuração de sessão alternativa. O parâmetro ScriptBlock é executado Get-EventLog para obter os logs de eventos do Windows PowerShell de cada computador.

Exemplo 7: Obter a versão do programa host em vários computadores

Este exemplo obtém a versão do programa host do PowerShell em execução em 200 computadores remotos.

$version = Invoke-Command -ComputerName (Get-Content Machines.txt) -ScriptBlock {
    (Get-Host).Version
}

Como apenas um comando é executado, você não precisa criar conexões persistentes com cada um dos computadores. Em vez disso, o comando usa o parâmetro ComputerName para indicar os computadores. Para especificar os computadores, ele usa o Get-Content cmdlet para obter o conteúdo do arquivo Machine.txt, um arquivo de nomes de computador.

O Invoke-Command cmdlet executa um Get-Host comando nos computadores remotos. Ele usa a notação de ponto para obter a propriedade Version do host do PowerShell.

Esses comandos são executados um de cada vez. Quando os comandos são concluídos, a saída dos comandos de todos os computadores é salva na $version variável. A saída inclui o nome do computador de origem de dados.

Exemplo 8: Executar um trabalho em segundo plano em vários computadores remotos

Este exemplo executa um comando em dois computadores remotos. O Invoke-Command comando usa o parâmetro AsJob para que o comando seja executado como um trabalho em segundo plano. Os comandos são executados nos computadores remotos, mas o trabalho existe no computador local. Os resultados são transmitidos para o computador local.

$s = New-PSSession -ComputerName Server01, Server02
Invoke-Command -Session $s -ScriptBlock { Get-EventLog system } -AsJob

Id   Name    State      HasMoreData   Location           Command
---  ----    -----      -----         -----------        ---------------
1    Job1    Running    True          Server01,Server02  Get-EventLog system

$j = Get-Job
$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  :

$results = $j | Receive-Job

O New-PSSession cmdlet cria sessões nos computadores remotos Server01 e Server02. O Invoke-Command cmdlet executa um trabalho em segundo plano em cada uma das sessões. O comando usa o parâmetro AsJob para executar o comando como um trabalho em segundo plano. Esse comando retorna um objeto de trabalho que contém dois objetos de trabalho filho, um para cada um dos trabalhos executados nos dois computadores remotos.

O Get-Job comando salva o objeto de trabalho na $j variável. A $j variável é então canalizada para o Format-List cmdlet para exibir todas as propriedades do objeto de trabalho em uma lista. O último comando obtém os resultados dos trabalhos. Ele canaliza o objeto $j de trabalho para o Receive-Job cmdlet e armazena os $results resultados na variável.

Exemplo 9: Incluir variáveis locais em um comando executado em um computador remoto

Este exemplo mostra como incluir os valores das variáveis locais em um comando executado em um computador remoto. O comando usa o Using modificador de escopo para identificar uma variável local em um comando remoto. Por padrão, todas as variáveis devem ser definidas na sessão remota. O Using modificador de escopo foi introduzido no PowerShell 3.0. Para obter mais informações sobre o modificador de Using escopo, consulte about_Remote_Variables e about_Scopes.

$Log = 'Windows PowerShell'
Invoke-Command -ComputerName Server01 -ScriptBlock {
    Get-EventLog -LogName $Using:Log -Newest 10
}

A $Log variável armazena o nome do log de eventos, Windows PowerShell. O Invoke-Command cmdlet é executado Get-EventLog no Server01 para obter os dez eventos mais recentes do log de eventos. O valor do parâmetro LogName é a $Log variável, que é prefixada Using pelo modificador de escopo para indicar que ela foi criada na sessão local, não na sessão remota.

Exemplo 10: Ocultar o nome do computador

Este exemplo mostra o efeito do uso do parâmetro HideComputerName do Invoke-Command. HideComputerName não altera o objeto retornado por esse cmdlet. Ele altera apenas a exibição. Você ainda pode usar os cmdlets Format para exibir a propriedade PsComputerName de qualquer um dos objetos afetados.

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

Invoke-Command -ComputerName S1, S2 -HideComputerName -ScriptBlock {
    Get-Process PowerShell
}

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

Os dois primeiros comandos são usados Invoke-Command para executar um Get-Process comando para o processo do PowerShell. A saída do primeiro comando inclui a propriedade PsComputerName , que contém o nome do computador no qual o comando foi executado. A saída do segundo comando, que usa HideComputerName, não inclui a coluna PsComputerName .

Exemplo 11: Usar a palavra-chave Param em um bloco de script

A Param palavra-chave e o parâmetro ArgumentList são usados para passar valores de variáveis para parâmetros nomeados em um bloco de script. Este exemplo exibe nomes de arquivos que começam com a letra a e têm a .pdf extensão.

Para obter mais informações sobre a palavra-chave, consulte about_Language_KeywordsParam.

$parameters = @{
    ComputerName = 'Server01'
    ScriptBlock  = {
        Param ($param1, $param2)
        Get-ChildItem -Name $param1 -Include $param2
    }
    ArgumentList = 'a*', '*.pdf'
}
Invoke-Command @parameters

aa.pdf
ab.pdf
ac.pdf
az.pdf

Invoke-Command usa o parâmetro ScriptBlock que define duas variáveis $param1 e $param2. Get-ChildItem usa os parâmetros nomeados, Name e Include com os nomes das variáveis. O ArgumentList passa os valores para as variáveis.

Exemplo 12: Usar a variável automática $args em um bloco de script

A $args variável automática e o parâmetro ArgumentList são usados para passar valores de matriz para posições de parâmetro em um bloco de script. Este exemplo exibe o conteúdo do diretório de arquivos de .txt um servidor. O Get-ChildItem parâmetro Path é a posição 0 e o parâmetro Filter é a posição 1.

Para obter mais informações sobre a variável, consulte about_Automatic_Variables $args

$parameters = @{
    ComputerName = 'Server01'
    ScriptBlock  = { Get-ChildItem $args[0] $args[1] }
    ArgumentList = 'C:\Test', '*.txt*'
}
Invoke-Command @parameters

Directory: C:\Test

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---           6/12/2019    15:15            128 alog.txt
-a---           7/27/2019    15:16            256 blog.txt
-a---           9/28/2019    17:10             64 zlog.txt

Invoke-Command usa um parâmetro ScriptBlock e Get-ChildItem especifica os valores de $args[0] matriz e $args[1] . O ArgumentList passa os valores da $args matriz para as posições de Get-ChildItem parâmetro para Path e Filter.

Exemplo 13: Executar um script em todos os computadores listados em um arquivo de texto

Este exemplo usa o Invoke-Command cmdlet para executar o Sample.ps1 script em todos os computadores listados no Servers.txt arquivo. O comando usa o parâmetro FilePath para especificar o arquivo de script. Esse comando permite executar o script nos computadores remotos, mesmo que o arquivo de script não esteja acessível aos computadores remotos.

$parameters = @{
    ComputerName = (Get-Content Servers.txt)
    FilePath     = 'C:\Scripts\Sample.ps1'
    ArgumentList = 'Process', 'Service'
}
Invoke-Command @parameters

Quando você envia o comando, o Sample.ps1 conteúdo do arquivo é copiado em um bloco de script e o bloco de script é executado em cada um dos computadores remotos. Esse procedimento é equivalente a usar o parâmetro ScriptBlock para enviar o conteúdo do script.

Exemplo 14: Executar um comando em um computador remoto usando um URI

Este exemplo mostra como executar um comando em um computador remoto identificado por um URI (Uniform Resource Identifier). Este exemplo específico executa um Set-Mailbox comando em um servidor Exchange remoto.

$LiveCred = Get-Credential
$parameters = @{
  ConfigurationName = 'Microsoft.Exchange'
  ConnectionUri     = 'https://ps.exchangelabs.com/PowerShell'
  Credential        = $LiveCred
  Authentication    = 'Basic'
  ScriptBlock       = { Set-Mailbox Dan -DisplayName 'Dan Park' }
}
Invoke-Command @parameters

A primeira linha usa o Get-Credential cmdlet para armazenar credenciais do Windows Live ID na $LiveCred variável. O PowerShell solicita que o usuário insira as credenciais do Windows Live ID.

A $parameters variável é uma tabela de hash que contém os parâmetros a serem passados para o Invoke-Command cmdlet. O Invoke-Command cmdlet executa um Set-Mailbox comando usando a configuração de sessão Microsoft.Exchange . O parâmetro ConnectionURI especifica a URL do ponto de extremidade do servidor Exchange. O parâmetro Credential especifica as credenciais armazenadas na $LiveCred variável. O parâmetro AuthenticationMechanism especifica o uso da autenticação básica. O parâmetro ScriptBlock especifica um bloco de script que contém o comando.

Exemplo 15: Usar uma opção de sessão

Este exemplo mostra como criar e usar um parâmetro SessionOption .

$so = New-PSSessionOption -SkipCACheck -SkipCNCheck -SkipRevocationCheck
$parameters = @{
    ComputerName  = 'server01'
    UseSSL        = $true
    ScriptBlock   = { Get-HotFix }
    SessionOption = $so
    Credential    = 'server01\user01'
}
Invoke-Command @parameters

O New-PSSessionOption cmdlet cria um objeto de opção de sessão que faz com que a extremidade remota não verifique a Autoridade de Certificação, o Nome Canônico e as Listas de Revogação ao avaliar a conexão HTTPS de entrada. O objeto SessionOption é salvo na $so variável.

O Invoke-Command cmdlet executa um Get-HotFix comando remotamente. O parâmetro SessionOption recebe a $so variável.

Exemplo 16: Gerenciar o redirecionamento de URI em um comando remoto

Este exemplo mostra como usar os parâmetros AllowRedirection e SessionOption para gerenciar o redirecionamento de URI em um comando remoto.

$max = New-PSSessionOption -MaximumRedirection 1
$parameters = @{
  ConnectionUri    = 'https://ps.exchangelabs.com/PowerShell'
  ScriptBlock      = { Get-Mailbox dan }
  AllowRedirection = $true
  SessionOption    = $max
}
Invoke-Command @parameters

O New-PSSessionOption cmdlet cria um objeto PSSessionOption que é salvo na $max variável. O comando usa o parâmetro MaximumRedirection para definir a propriedade MaximumConnectionRedirectionCount do objeto PSSessionOption como 1.

O Invoke-Command cmdlet executa um Get-Mailbox comando em um Microsoft Exchange Server remoto. O parâmetro AllowRedirection fornece permissão explícita para redirecionar a conexão para um ponto de extremidade alternativo. O parâmetro SessionOption usa o objeto de sessão armazenado na $max variável.

Como resultado, se o computador remoto especificado por ConnectionURI retornar uma mensagem de redirecionamento, o PowerShell redirecionará a conexão, mas se o novo destino retornar outra mensagem de redirecionamento, o valor de contagem de redirecionamento de 1 será excedido e Invoke-Command retornará um erro de não encerramento.

Exemplo 17: Acessar um compartilhamento de rede em uma sessão remota

Este exemplo mostra como acessar um compartilhamento de rede de uma sessão remota. Três computadores são usados para demonstrar o exemplo. Server01 é o computador local, Server02 é o computador remoto e Net03 contém o compartilhamento de rede. O Server01 se conecta ao Server02 e, em seguida, o Server02 faz um segundo salto para o Net03 para acessar o compartilhamento de rede. Para obter mais informações sobre como a Comunicação Remota do PowerShell dá suporte a saltos entre computadores, consulte Fazendo o segundo salto na Comunicação Remota do PowerShell.

A delegação necessária do CredSSP (Provedor de Suporte à Segurança de Credenciais) está habilitada nas configurações do cliente no computador local e nas configurações de serviço no computador remoto. Para executar os comandos neste exemplo, você deve ser membro do grupo Administradores no computador local e no computador remoto.

Enable-WSManCredSSP -Role Client -DelegateComputer Server02
$s = New-PSSession Server02
Invoke-Command -Session $s -ScriptBlock { Enable-WSManCredSSP -Role Server -Force }
$parameters = @{
  Session        = $s
  ScriptBlock    = { Get-Item \\Net03\Scripts\LogFiles.ps1 }
  Authentication = 'CredSSP'
  Credential     = 'Domain01\Admin01'
}
Invoke-Command @parameters

O Enable-WSManCredSSP cmdlet habilita a delegação do CredSSP do computador local Server01 para o computador remoto Server02. O parâmetro Role especifica Client para definir a configuração do cliente CredSSP no computador local.

New-PSSession cria um objeto PSSession para Server02 e armazena o $s objeto na variável.

O Invoke-Command cmdlet usa a $s variável para se conectar ao computador remoto, Server02. O parâmetro ScriptBlock é executado Enable-WSManCredSSP no computador remoto. O parâmetro Role especifica Server para definir a configuração do servidor CredSSP no computador remoto.

A $parameters variável contém os valores de parâmetro para se conectar ao compartilhamento de rede. O Invoke-Command cmdlet executa um Get-Item comando na sessão no $s. Esse comando obtém um script do \\Net03\Scripts compartilhamento de rede. O comando usa o parâmetro Authentication com um valor de CredSSP e o parâmetro Credential com um valor de Domain01\Admin01.

Exemplo 18: Iniciar scripts em muitos computadores remotos

Este exemplo executa um script em mais de cem computadores. Para minimizar o impacto no computador local, ele se conecta a cada computador, inicia o script e, em seguida, desconecta de cada computador. O script continuará a ser executado nas sessões desconectadas.

$parameters = @{
  ComputerName          = (Get-Content -Path C:\Test\Servers.txt)
  InDisconnectedSession = $true
  FilePath              = '\\Scripts\Public\ConfigInventory.ps1'
  SessionOption         = @{
      OutputBufferingMode = 'Drop'
      IdleTimeout         = [timespan]::FromHours(12)
  }
}
Invoke-Command @parameters

O comando usa Invoke-Command para executar o script. O valor do parâmetro ComputerName é um Get-Content comando que obtém os nomes dos computadores remotos de um arquivo de texto. O parâmetro InDisconnectedSession desconecta as sessões assim que inicia o comando. O valor do parâmetro FilePath é o script executado Invoke-Command em cada computador.

O valor de SessionOption é uma tabela de hash. O valor OutputBufferingMode é definido como Drop e o valor IdleTimeout é definido como 12 horas.

Para obter os resultados de comandos e scripts executados em sessões desconectadas, use o Receive-PSSession cmdlet.

Parâmetros

-AllowRedirection

-ApplicationName

-ArgumentList

-AsJob

-Authentication

-CertificateThumbprint

-ComputerName

-ConfigurationName

-ConnectionUri

-ContainerId

-Credential

-EnableNetworkAccess

-FilePath

-HideComputerName

-InDisconnectedSession

-InputObject

-JobName

-NoNewScope

-Port

-RunAsAdministrator

-ScriptBlock

-Session

-SessionName

-SessionOption

-ThrottleLimit

-UseSSL

-VMId

-VMName

Entradas

ScriptBlock

Você pode canalizar um comando em um bloco de script para Invoke-Command. Use a $Input variável automática para representar os objetos de entrada no comando.

Saídas

System.Management.Automation.PSRemotingJob

Se você usar o parâmetro AsJob , esse cmdlet retornará um objeto de trabalho.

PSSession

Se você usar o parâmetro InDisconnectedSession , esse cmdlet retornará um objeto PSSession .

Object

Por padrão, esse cmdlet retorna a saída do comando invocado, que é o valor do parâmetro ScriptBlock .

Observações

O Windows PowerShell inclui os seguintes aliases para Invoke-Command:

• icm

No Windows Vista e em versões posteriores do sistema operacional Windows, para usar o parâmetro ComputerName de Invoke-Command para executar um comando no computador local, você deve executar o PowerShell usando a opção Executar como administrador .

Quando você executa comandos em vários computadores, o PowerShell se conecta aos computadores na ordem em que eles aparecem na lista. No entanto, a saída do comando é exibida na ordem em que é recebida dos computadores remotos, o que pode ser diferente.

Os erros resultantes do comando executado Invoke-Command são incluídos nos resultados do comando. Erros que poderiam ser erros de finalização em um comando local são tratados como erros de não finalização em um comando remoto. Essa estratégia garante que os erros de encerramento em um computador não fechem o comando em todos os computadores nos quais ele é executado. Essa prática é utilizada mesmo quando um comando remoto é executado em um único computador.

Se o computador remoto não estiver em um domínio em que o computador local confie, talvez ele não consiga autenticar as credenciais do usuário. Para adicionar o computador remoto à lista de hosts confiáveis no WS-Management, use o WSMAN seguinte comando no provedor, onde <Remote-Computer-Name> está o nome do computador remoto:

Set-Item -Path WSMan:\Localhost\Client\TrustedHosts -Value \<Remote-Computer-Name\>

Quando você desconecta um PSSession usando o parâmetro InDisconnectedSession , o estado da sessão é Desconectado e a disponibilidade é Nenhuma. O valor da propriedade State é relativo à sessão atual. Um valor de Disconnected significa que o PSSession não está conectado à sessão atual. No entanto, isso não significa que o PSSession esteja desconectado de todas as sessões . Ela pode ser conectada a uma sessão diferente. Para determinar se você pode se conectar ou reconectar à sessão, use a propriedade Disponibilidade .

Um valor de Disponibilidade de Nenhum indica que você pode se conectar à sessão. Um valor de Ocupado indica que você não pode se conectar ao PSSession porque ele está conectado a outra sessão. Para obter mais informações sobre os valores da propriedade State das sessões, consulte RunspaceState. Para obter mais informações sobre os valores da propriedade Availability das sessões, consulte RunspaceAvailability.

Links Relacionados

• about_PSSessions
• about_Remote
• about_Remote_Disconnected_Sessions
• about_Remote_Troubleshooting
• about_Remote_Variables
• about_Scopes
• ENTER-PSSession
• Exit-PSSession
• Get-PSSession
• Invoke-Item
• New-PSSession
• Remove-PSSession
• Provedor WSMan