Comando "Top" do Linux para Windows Powershell?

Estou procurando um cmdlet do PowerShell que possa fornecer funcionalidade semelhante ao aplicativo Linux Top. Algo que é atualizado em um determinado intervalo e exibe a lista de processos com CPU% util.

Eu vi scripts que listam a utilização da CPU% em um loop, mas algo como top seria muito mais útil, pois configuramos o acesso SSH / Powershell para gerenciamento (ainda prefiro um shell de massa!)

While(1) {ps | sort -des cpu | select -f 15 | ft -a; sleep 1; cls}

Este é um revestimento simples que também manterá os rótulos na parte superior.

Isso funciona porque a formatação da tabela sem nenhum parâmetro apenas desenha a tabela padrão. O tamanho automático é usado para ajustar automaticamente a largura da coluna para que todos os dados possam caber na tela.

Aqui está um detalhamento dos comandos abreviados usados

• selecione -f é um atalho para -first
• ft é um atalho para Format-Table
• -a é um atalho para -autosize
• padrões de sono para usar segundos

Não sei nada sobre isso na forma de cmdlet único, mas, como você diz, é fácil escrever scripts para emular o top.

while (1) { ps | sort -desc cpu | select -first 30; sleep -seconds 2; cls }

Uma solução semelhante às outras, mas usando Get-Counter em vez de Get-Process.

While(1) { $p = get-counter '\Process(*)\% Processor Time'; cls; $p.CounterSamples | sort -des CookedValue | select -f 15 | ft -a}

Saída de amostra:

Path                                                      InstanceName              CookedValue
----                                                      ------------              -----------
\\server_name\process(_total)\% processor time                 _total               4806.03969127454
\\server_name\process(idle)\% processor time                   idle                 1103.7573538257
\\server_name\process(program#2)\% processor time              program              749.692930701698
\\server_name\process(program#5)\% processor time              program              563.424255927765
\\server_name\process(program#1)\% processor time              program              535.714866291973
\\server_name\process(program#6)\% processor time              program              455.665518455242
\\server_name\process(program#3)\% processor time              program              426.416718284128
\\server_name\process(program)\% processor time                program              395.628507577693
\\server_name\process(program#4)\% processor time              program              335.591496700144
\\server_name\process(microsoftedgecp#2)\% processor time      microsoftedgecp      129.310484967028
\\server_name\process(system)\% processor time                 system               80.0493478367316
\\server_name\process(chrome#8)\% processor time               chrome               1.53941053532176

Encontrei a maioria das outras soluções aqui usando o relatório get-process, o tempo total da CPU desde o início do processo. Isso não foi útil no meu servidor, que permanece ativo 24 horas por dia, 7 dias por semana, onde o resultado principal era sempre justo svchoste systemem milhões de segundos. Um topequivalente verdadeiro ou um Gerenciador de tarefas forneceria uma captura instantânea do uso da CPU gravado recentemente em um período fixo e o Get-Counter fornece isso. Como esta postagem de superusuário ainda é o principal resultado do Google para "powershell top", achei que vale a pena contribuir com essa alternativa.

Meu comando é baseado no exemplo 13 dos documentos do Get-Counter: https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Diagnostics/Get-Counter .
Aqui está um detalhamento do one-liner para que você possa modificá-lo mais facilmente de acordo com suas necessidades:

• While(1) { apenas dá laços
• get-counter '\Process(*)\% Processor Time'seleciona os dados da CPU%. Esse comando parece levar uma quantidade significativa de tempo para retornar, portanto, não é necessáriosleep
• cls claro para a nova tabela
• sort -des CookedValue CookedValue é o campo em que somos testados, classificar para colocar o maior no topo
• select -f 15 exibir primeiro 15
• ft -a exibir na tabela formatada

Fornece os títulos legais no topo com todas as atualizações sem a necessidade de limpar o console inteiro.

$saveY = [console]::CursorTop
$saveX = [console]::CursorLeft      

while ($true) {
    Get-Process | Sort -Descending CPU | Select -First 30;
    Sleep -Seconds 2;
    [console]::setcursorposition($saveX,$saveY+3)
}

Não conheço um cmdlet do PowerShell que ofereça a funcionalidade. Há um comando externo de freeware que faz sobre o que você deseja. Olhe de Mark Russinovich pslist da suíte Sysinternals. O Pslist fornece uma lista de processos em execução em uma exibição configurável. "pslist -s" fornece o tipo de atualização contínua desejada, com uma taxa de atualização padrão de uma vez por segundo.

Prefiro usar o GUI Process Explorer de Mark, mas o pslist é útil para sessões de console.

A home page da Sysinternals está aqui: http://technet.microsoft.com/en-us/sysinternals

Dennis

while (1) {ps | sort -desc cpu | select -first 30; 
sleep -seconds 2; cls; 
write-host "Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName"; 
write-host "-------  ------    -----      ----- -----   ------     -- -----------"}

Esta é apenas uma maneira um pouco mais agradável, pois você sempre vê os títulos no topo

Além disso, quero ressaltar que, se você deseja um ambiente Linux para Windows, pode usar o Cygwin. Traz o ambiente Linux para o Windows. Você pode usar quase todos os comandos. Não tenho certeza de como isso é útil para você.

http://www.cygwin.com/

Isso também pode fazer o truque:

function htopish {
  Param (
    [Parameter(Position=1)] [Alias("l")]
    [int]$TotalList=24,
    [Parameter(Position=2)] [Alias("r")]
    [int]$Invertal=1
  )
  Begin {}
  Process {
    While ($true) {
      $CounterSamples = Get-Counter '\Process(*)\ID Process','\Process(*)\% Processor Time','\Process(*)\Working Set' | Select-Object -Expand CounterSamples
      Clear-Host
      $CounterSamples | Group-Object { Split-Path $_.Path } | Where-Object {$_.Group[1].InstanceName -notmatch "^Idle|_Total|System$"} | Sort-Object -Property {$_.Group[1].CookedValue} -Descending | Select-Object -First $TotalList | Format-Table @{Name="ProcessId";Expression={$_.Group[0].CookedValue}},@{Name="ProcessorUsage";Expression={[System.Math]::Round($_.Group[1].CookedValue/100/$env:NUMBER_OF_PROCESSORS,4)}},@{Name="ProcessName";Expression={$_.Group[1].InstanceName}},@{Name="WorkingSet";Expression={[System.Math]::Round($_.Group[2].CookedValue/1MB,4)}}
      Sleep -Seconds $Invertal
    }
  }
  End {}
}

A função depende das Get-Counteramostras e produzirá o ProcessId,ProcessName,ProcessorUsagee WorkingSet. Esta amostra contrária poderia ainda ser melhorado para incluir User, CommandLinena saída, mas eu não ter trabalhado fora ainda uma maneira performance para fazê-lo.

Esse comentário de Mark deve receber mais recomendações, porque faz quase exatamente qual era a pergunta e funciona:

Fornece os títulos legais no topo com todas as atualizações sem a necessidade de limpar o console inteiro.

$saveY = [console]::CursorTop
$saveX = [console]::CursorLeft      

while ($true) {
    Get-Process | Sort -Descending CPU | Select -First 30;
    Sleep -Seconds 2;
    [console]::setcursorposition($saveX,$saveY+3)
}

(link para comentar: https://superuser.com/a/770455/989044 )

Você deve criar um módulo simples para ele e hospedar no github ou fornecer choco. Eu acho que deveria ser um módulo padrão em primeiro lugar, porque é muito pesquisado no google e existem todos os tipos de soluções alternativas, mas nenhuma delas é tão elegante e próxima ao comando top do linux.

Desculpe por publicá-lo desta forma, mas por causa das regras aqui contidas, é impossível comentar ou fazer uma anotação sem 50 karma ou mais.

Para executar o top diretamente do cmd, você precisará criar o arquivo% WINDIR% \ top.bat com este código:

@echo off && cls && @echo TOP Program initialisation. Please Wait...
powershell -ExecutionPolicy unrestricted -command "& {cls; While(1) {ps | sort -des cpu | select -f 35 | ft -a; sleep 2; cls}}"

Se você deseja filtrar por processo, use findstr

while (1) { ps | findstr explorer | sort -desc cpu | select -first 30; sleep -seconds 2; cls }

Convém iniciar o monitor de recursos do powershell com:

PS C:\>resmon

Você sempre pode fechar o aplicativo com Alt + F4 e isso deve mudar o foco novamente para a janela do PowerShell.

Você pode tentar o htop-alternative para windows - NTop

monitor de sistema tipo htop com emulação de Vi para Windows. Porque o uso do Gerenciador de Tarefas não é legal o suficiente.

NTop como no Windows NT-op ou NukeTop. O que você preferir (o último obviamente).

Opções de linha de comando :

• -C Use esquema de cores monocromático.
• -h Exibir informações de ajuda.
• -p PID, PID ... Mostra apenas os PIDs fornecidos.
• -s COLUMN Classifique por esta coluna.
• -u USERNAME Exibe apenas processos pertencentes a este usuário.
• -v Versão para impressão.

Comandos interativos:

• Setas para cima e para baixo, PgUp e PgDown, j e k Role a lista de processos.
• CTRL + Setas esquerda e direita Altere a coluna de classificação do processo.
• g Vá para o topo da lista de processos.
• G Vá para o final da lista de processos.
• Espaço Identifique um processo selecionado.
• U Desmarque todos os processos marcados.
• K Mate todos os processos marcados.
• Eu inverto a ordem de classificação.
• F Seguir processo: se a ordem de classificação fizer com que o processo atualmente selecionado seja movido na lista, faça a barra de seleção segui-lo. Mover o cursor manualmente desativa automaticamente esse recurso.
• n Avançar na pesquisa.
• N Anterior na pesquisa.

Comandos do Vi :

• : exec CMD Executa o comando do Windows fornecido.
• : mata PID (s) Mate todos os processos.
• : q ,: saia do NTop.
• / PATTERN,: pesquisa PATTERN Faça uma pesquisa.
• : sort COLUMN Classifica a lista de processos após a coluna especificada.
• : árvore Exibir a árvore do processo.

Os binários pré-compilados podem ser baixados aqui

Salve o seguinte em um arquivo chamado mytop.ps1em uma pasta que esteja na sua PATHvariável de ambiente. Em seguida, use um dos seguintes itens em qualquer console do PowerShell:

1. mytop - para usar a classificação padrão na coluna 'Memória' e mostrar as 30 primeiras linhas.
2. mytop CPU 50 - para classificar pela coluna 'CPU' e mostrar as 50 primeiras linhas.
3. While(1) {$p = myTop Memory 50; cls; $p} - para atualizar a cada segundo.

mytop.ps1 conteúdo:

##################################################
#  Linux top equivalent in PowerShell
##################################################
if ($args[0] -eq $null) {
    $SortCol = "Memory"
} else {
    $SortCol = $args[0]    
}

if ($args[1] -eq $null) {
    $Top = 30
} else {
    $Top = $args[1]   
}


$LogicalProcessors = (Get-WmiObject -class Win32_processor `
    -Property NumberOfLogicalProcessors).NumberOfLogicalProcessors;

function myTopFunc ([string]$SortCol = "Memory", [int]$Top = 30) {
    ## Check user level of PowerShell 
    if (
        ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent() 
        ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
    )
    {
        $procTbl = get-process -IncludeUserName | select ID, Name, UserName, Description, MainWindowTitle
    } else {
        $procTbl = get-process | select ID, Name, Description, MainWindowTitle
    }

    Get-Counter `
        '\Process(*)\ID Process',`
        '\Process(*)\% Processor Time',`
        '\Process(*)\Working Set - Private'`
        -ea SilentlyContinue |
    foreach CounterSamples |
    where InstanceName -notin "_total","memory compression" |
    group { $_.Path.Split("\\")[3] } |
    foreach {
        $procIndex = [array]::indexof($procTbl.ID, [Int32]$_.Group[0].CookedValue)
        [pscustomobject]@{
            Name = $_.Group[0].InstanceName;
            ID = $_.Group[0].CookedValue;
            User = $procTbl.UserName[$procIndex]
            CPU = if($_.Group[0].InstanceName -eq "idle") {
                $_.Group[1].CookedValue / $LogicalProcessors 
                } else {
                $_.Group[1].CookedValue 
                };
            Memory = $_.Group[2].CookedValue / 1KB;
            Description = $procTbl.Description[$procIndex];
            Title = $procTbl.MainWindowTitle[$procIndex];
        }
    } |
    sort -des $SortCol |
    select -f $Top @(
        "Name", "ID", "User",
        @{ n = "CPU"; e = { ("{0:N1}%" -f $_.CPU) } },
        @{ n = "Memory"; e = { ("{0:N0} K" -f $_.Memory) } },
        "Description", "Title"
        ) | ft -a
}

myTopFunc -SortCol $SortCol -top $Top

Exemplo de saída:

Name                               ID User                         CPU   Memory       Description
----                               -- ----                         ---   ------       -----------
sqlservr                         7776 NT SERVICE\MSSQLSERVER       0.0%  19,001,488 K SQL Server Windows NT - 64 Bit
python                          12872 NA\user1                     0.0%  2,159,796 K  Python
svchost                          3328 NT AUTHORITY\SYSTEM          1.6%  1,022,080 K  Host Process for Windows Services
onedrive                        11872 NA\user1                     0.0%  423,396 K    Microsoft OneDrive
python                          13764 NA\user1                     0.0%  304,608 K    Python
chrome                          21188 NA\user1                     0.0%  250,624 K    Google Chrome
python                          28144 NA\user2                     0.0%  225,824 K    Python
code                            21384 NA\user1                     0.0%  211,160 K    Visual Studio Code
code                            27412 NA\user2                     0.0%  185,892 K    Visual Studio Code
ssms                            18288 NA\user1                     29.5% 155,452 K    SSMS
chrome                           7536 NA\user1                     0.0%  154,124 K    Google Chrome
code                            21652 NA\user1                     0.0%  149,900 K    Visual Studio Code
explorer                         3204 NA\user1                     0.0%  134,340 K    Windows Explorer
python                          11712 NA\user1                     0.0%  130,624 K    Python
chrome                          21588 NA\user1                     0.0%  107,448 K    Google Chrome
code                            10152 NA\user1                     0.0%  100,880 K    Visual Studio Code
code                            20232 NA\user2                     0.0%  99,124 K     Visual Studio Code
python                          22184 NA\user1                     0.0%  94,800 K     Python
code                            14828 NA\user1                     0.0%  84,872 K     Visual Studio Code
searchui                        13344 NA\user1                     0.0%  78,260 K     Search and Cortana application
com.docker.service              10644 NT AUTHORITY\SYSTEM          0.0%  77,332 K     Docker.Service

Crédito adicional para:

1. rokumaru para https://stackoverflow.com/a/55698377/5060792
2. LotPings para https://stackoverflow.com/a/55680398/5060792
3. DBADon para https://stackoverflow.com/a/55697007/5060792

Outra coisa a se olhar é:

https://docs.microsoft.com/en-us/sysinternals/downloads/process-utilities

Existe uma ferramenta de linha de comando para despejar todos os processos (e, é claro, Process Monitor ou Process Explorer).

Use o comando abaixo: ele fornecerá as 10 principais utilizações da CPU e a saída será atualizada a cada 5 segundos

while (1) {ps | CPU de objeto de classificação - propriedade - descendente | selecione -Primeiro 10; a saída do host de gravação "será atualizada em 5 segundos nn Identifica o (s) ID (s) de CPU (s) de CPU (s) NPM (K) PM (K) WS (K) Id SI ProcessName"; sono - segundos 5}