TÓPICO

about_Remote_Output

DESCRIÇÃO RESUMIDA
Descreve como interpretar e formatar a saída dos comandos remotos.

DESCRIÇÃO LONGA
A saída de um comando que foi executado em um computador remoto
possivelmente se assemelhará à saída do mesmo comando executado
em um computador local, mas com algumas diferenças.

Este tópico explica como interpretar, formatar e exibir a saída

dos comandos executados nos computadores remotos.

EXIBINDO O NOME DO COMPUTADOR

Quando você usar o cmdlet Invoke-Command para executar um comando

em um computador remoto, o comando retornará um objeto que inclui
o nome do computador que gerou os dados. O computador remoto
é armazenado na propriedade PSComputerName.

Para muitos comandos, o PSComputerName é exibido por padrão.

Por exemplo, o comando a seguir executa um comando Get-Culture
em dois computadores remotos, Server01 e Server02. A saída, que
aparece abaixo, inclui os nomes dos computadores remotos em que
o comando foi executado.

C:\PS> invoke-command -script {get-culture} -comp Server01, Server02

LCID Name DisplayName PSComputerName

---- ---- ----------- --------------
1033 en-US English (United States)) Server01
1033 es-AR Spanish (Argentina) Server02

Você pode usar o parâmetro HideComputerName de Invoke-Command

para ocultar a propriedade PSComputerName. Esse parâmetro foi
projetado para comandos que coletam dados apenas de um computador
remoto.

O comando a seguir executa um comando Get-Culture no computador

remoto Server01. Ele usa o parâmetro HideComputerName para
ocultar a propriedade PSComputerName e as propriedades relacionadas.

C:\PS> invoke-command -scr {get-culture} -comp Server01 -HideComputerName

LCID Name DisplayName

---- ---- -----------
1033 en-US English (United States))

Você também poderá exibir a propriedade PSComputerName se ela

não for exibida por padrão.

Por exemplo, os comandos a seguir usam o cmdlet Format-Table

para adicionar a propriedade PSComputerName à saída de um
 comando Get-Date remoto.

C:\PS> $dates = invoke-command -script {get-date} -computername Server01,

Server02
C:\PS> $dates | format-table DateTime, PSComputerName -auto

DateTime PSComputerName
-------- --------------
Segunda-feira, 21 de julho de 2008 19:16:58 Server01
Segunda-feira, 21 de julho de 2008 19:16:58 Server02

EXIBINDO A PROPRIEDADE MACHINENAME

Vários cmdlets, incluindo Get-Process, Get-Service e Get-EventLog,

têm um parâmetro ComputerName que permite a obtenção de objetos em
um computador remoto. Esses cmdlets não usam a comunicação remota
do Windows PowerShell, portanto, você pode usá-los até mesmo em
computadores que não estejam configurados para comunicação remota
no Windows PowerShell.

Os objetos retornados por esses cmdlets armazenam o nome do

computador remoto na propriedade MachineName. (Esses objetos não
têm uma propriedade PSComputerName.)

Por exemplo, esse comando obtém o processo do PowerShell nos

computadores remotos Server01 e Server02. A exibição padrão não
inclui a propriedade MachineName.

C:\PS> get-process powershell -computername server01, server02

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName

------- ------ ----- ----- ----- ------ -- -----------
920 38 97524 114504 575 9.66 2648 powershell
194 6 24256 32384 142 3020 powershell
352 27 63472 63520 577 3.84 4796 powershell

Você pode usar o cmdlet Format-Table para exibir a propriedade

MachineName dos objetos de processo.

Por exemplo, o comando a seguir salva os processos na variável $p

e usa um operador de pipeline (|) para enviar os processos de $p
ao comando Format-Table. O comando usa o parâmetro Property de
Format-Table para incluir a propriedade MachineName na exibição.

C:\PS> $p = get-process powershell -comp Server01, Server02

C:\PS> $P | format-table -property ID, ProcessName, MachineName -auto

Id ProcessName MachineName
-- ----------- -----------
2648 powershell Server02
3020 powershell Server01
4796 powershell Server02

O comando mais complexo seguinte adiciona a propriedade

 MachineName à exibição padrão do processo. Usa tabelas de hash
para especificar as propriedades calculadas. Felizmente, você não
precisa entendê-las para utilizá-las.
(Observe que a crase (`) é o caractere de continuação.)

C:\PS> $p = get-process powershell -comp Server01, Server02

C:\PS> $p | format-table -property Handles, `

@{Label="NPM(K)";Expression={[int]($_.NPM/1024)}}, `
@{Label="PM(K)";Expression={[int]($_.PM/1024)}}, `
@{Label="WS(K)";Expression={[int]($_.WS/1024)}}, `
@{Label="VM(M)";Expression={[int]($_.VM/1MB)}}, `
@{Label="CPU(s)";Expression={if ($_.CPU -ne $())
{ $_.CPU.ToString("N")}}}, `
Id, ProcessName, MachineName -auto

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName MachineName

------- ------ ----- ----- ----- ------ -- ----------- -----------
920 38 97560 114532 576 2648 powershell Server02
192 6 24132 32028 140 3020 powershell Server01
438 26 48436 59132 565 4796 powershell Server02

OBJETOS DESSERIALIZADOS
Quando você executar comandos remotos que geram saída, a saída do
comando será transmitida pela rede ao computador local.

Como a maioria dos objetos ao vivo do Microsoft .NET Framework

(como os objetos retornados pelos cmdlets do Windows PowerShell)
não pode ser transmitida pela rede, os objetos ao vivo são
"serializados". Em outras palavras, os objetos ao vivo são
convertidos em representações XML do objeto e de suas respectivas
propriedades. Em seguida, o objeto serializado baseado em XML
será transmitido pela rede.

No computador local, o Windows PowerShell recebe o objeto

serializado baseado em XML e "desserializa-o", convertendo-o em
um objeto de .NET Framework padrão.

No entanto, o objeto desserializado não é um objeto ao vivo. É um

instantâneo do objeto no momento em que ele foi serializado, que
inclui propriedades mas nenhum método. Você pode usar e gerenciar
esses objetos no Windows PowerShell, inclusive transmiti-los em
pipelines, exibir as propriedades selecionadas e formatá-los.

A maioria dos objetos desserializados é formatada automaticamente

para ser exibida por entradas nos arquivos Types.ps1xml ou
Format.ps1xml. No entanto, o computador local possivelmente não
terá arquivos de formatação para todos os objetos desserializados
gerados em um computador remoto. Quando os objetos não são
formatados, todas as propriedades de cada objeto aparecem no
console em uma lista contínua.

Quando os objetos não forem formatados automaticamente, você

poderá usar os cmdlets de formatação, como Format-Table ou
Format-List, para formatar e exibir as propriedades selecionadas.
Você pode usar o cmdlet Out-GridView para exibir os objetos em
uma tabela.
 Além disso, se você executar um comando em um computador remoto
que use cmdlets que você não tenha em seu computador local, os
objetos retornados pelo comando possivelmente não serão
formatados corretamente porque você não tem os arquivos de
formatação desses objetos em seu computador. Para obter dados de
formatação de outro computador, use os cmdlets Get-FormatData e
Export-FormatData.

Alguns tipos de objeto, como DirectoryInfo e GUIDs, são

convertidos novamente em objetos ao vivo quando são recebidos.
Esses objetos não precisam de nenhum tratamento ou formatação
especial.

ORDENANDO OS RESULTADOS
A ordem dos nomes de computador no parâmetro ComputerName dos
cmdlets determina a ordem em que o Windows PowerShell se conecta
aos computadores remotos. No entanto, os resultados aparecem na
ordem em que o computador local os recebe, que pode ser uma ordem
diferente.

Para alterar a ordem dos resultados, use o cmdlet Sort-Object.

Você pode fazer a classificação com base na propriedade
PSComputerName ou MachineName. Você também fazê-la com base em
outra propriedade do objeto, para que os resultados de
computadores diferentes sejam intercalados.

CONSULTE TAMBÉM
about_Remote
Format-Table
Get-EventLog
Get-Process
Get-Service
Get-WmiObject
Invoke-Command
Out-GridView
Select-Object