Compartilhar via


about_Remote_Output

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