Commande “Top” de Linux pour Windows Powershell?

Je recherche une applet de commande PowerShell pouvant fournir des fonctionnalités similaires à l'application Linux Top. Quelque chose qui actualise à un intervalle donné et affiche la liste des processus avec% d'utilisation du processeur.

J'ai vu des scripts répertoriant le pourcentage d'utilisation du processeur dans une boucle, mais quelque chose comme top serait beaucoup plus pratique car nous avons configuré l'accès SSH / Powershell pour la gestion (je préfère toujours un shell putty!)

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

Il s’agit d’un simple support qui maintiendra également les étiquettes en haut.

Cela fonctionne parce que le formatage de la table sans aucun paramètre ne dessine que la table par défaut. autosize est utilisé pour ajuster automatiquement la largeur de la colonne afin que toutes les données puissent tenir à l'écran.

Voici un aperçu des commandes abrégées utilisées

• select -f est un raccourci pour -first
• ft est un raccourci pour Format-Table
• -a est un raccourci pour -autosize
• sommeil utilise par défaut les secondes

Je ne connais rien de cela sous forme d'applet de commande unique, mais comme vous le dites, il est facile d'écrire des scripts pour imiter top.

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

Une solution similaire aux autres solutions, mais en utilisant Get-Counter au lieu de Get-Process.

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

Exemple de sortie:

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

J'ai trouvé que la plupart des autres solutions présentées ici, à l'aide de get-process, signalent le temps CPU total écoulé depuis le début du processus. Cela n'a pas été utile sur mon serveur qui reste actif 24 heures sur 24, 7 jours sur 7, où le résultat final a toujours été juste svchostet systemà des millions de secondes. Un topéquivalent ou un gestionnaire de tâches équivalent donnerait un instantané de l'utilisation du processeur enregistrée récemment sur une durée déterminée, et Get-Counter le fournit. Étant donné que ce message de superutilisateur est toujours le meilleur résultat de Google pour "powershell top", j’ai pensé que cette alternative méritait d’être enrichie.

Ma commande est basée sur l'exemple 13 des documents Get-Counter: https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Diagnostics/Get-Counter .
Voici une ventilation du one-liner afin que vous puissiez plus facilement l'adapter à vos besoins:

• While(1) { juste le boucle
• get-counter '\Process(*)\% Processor Time'sélectionne les données% CPU. Cette commande semble prendre beaucoup de temps pour revenir, donc pas besoin desleep
• cls clair pour la nouvelle table
• sort -des CookedValue CookedValue est le domaine dans lequel nous nous intéressons, triez pour placer le plus grand sur le dessus
• select -f 15 afficher les 15 premiers
• ft -a afficher dans un tableau formaté

Fournit les belles en-têtes en haut de chaque mise à jour sans avoir à effacer toute la console.

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

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

Je ne connais pas d'applet de commande PowerShell fournissant ces fonctionnalités. Il existe une commande externe gratuite qui fait ce que vous voulez. Regardez la pslist de Mark Russinovich de la suite Sysinternals. Pslist fournit une liste des processus en cours d'exécution dans une vue configurable. "pslist -s" fournit le type de mise à jour continue que vous souhaitez, avec une fréquence d'actualisation par défaut d'une fois par seconde.

Je préfère utiliser Mark's Process Explorer, l'interface graphique de Mark, mais pslist est pratique pour les sessions de console.

La page d'accueil de Sysinternals est ici: 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 "-------  ------    -----      ----- -----   ------     -- -----------"}

C’est juste une façon un peu plus agréable de voir les titres en haut à chaque fois

Je tiens également à souligner que si vous souhaitez un environnement Windows semblable à Linux, vous pouvez utiliser Cygwin. Il apporte l'environnement Linux à Windows. Vous pouvez utiliser presque toutes les commandes. Je ne sais pas si cela vous est utile.

http://www.cygwin.com/

Cela peut aussi faire l'affaire:

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

La fonction s'appuie sur les Get-Counteréchantillons et générera le ProcessId,ProcessName,ProcessorUsageet WorkingSet. Cet échantillon de compteur pourrait encore être amélioré pour inclure User, CommandLinedans la sortie, mais je n'ai pas encore trouvé de moyen performant de le faire.

Ce commentaire de Mark devrait faire l’objet de plus de recommandations, car il répond presque exactement à la question et fonctionne:

Fournit les belles en-têtes en haut de chaque mise à jour sans avoir à effacer toute la console.

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

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

(lien vers le commentaire: https://superuser.com/a/770455/989044 )

Vous devriez en faire un module simple et l'héberger sur github ou lui fournir choco. Je pense que cela devrait être un module standard en premier lieu, car il est très recherché sur Google et il y a toutes sortes de solutions de contournement, mais aucune d'entre elles n'est aussi élégante et proche de la commande top linux.

Désolé de l'avoir posté comme ça, mais à cause des règles de strikt ici, il est impossible de commenter ou de faire une note sans 50 karma ou plus.

Pour exécuter top directement à partir de cmd, vous devez créer le fichier% WINDIR% \ top.bat avec ce code:

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

Si vous souhaitez filtrer par processus, utilisez findstr

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

Vous voudrez peut-être lancer le moniteur de ressources à partir de powershell avec:

PS C:\>resmon

Vous pouvez toujours fermer l'application avec Alt + F4, ce qui devrait permettre de revenir au focus sur la fenêtre Powershell.

Vous pouvez essayer htop-alternative pour Windows - NTop

Moniteur système de type htop avec émulation de Vi pour Windows. Parce que l'utilisation du Gestionnaire des tâches n'est pas assez cool.

NTop comme dans Windows NT-op ou NukeTop. Quoi que vous préfériez (ce dernier évidemment).

Options de ligne de commande :

• -C Utilisez un jeu de couleurs monochrome.
• -h Affiche les informations d'aide.
• -p PID, PID ... Affiche uniquement les PID donnés.
• -s COLUMN Tri par cette colonne.
• -u USERNAME N'affiche que les processus appartenant à cet utilisateur.
• -v Version imprimée.

Commandes interactives:

• Flèches haut et bas, PgUp et PgDown, j et k Faites défiler la liste des processus.
• CTRL + Flèches Gauche et Droite Change la colonne de tri du processus.
• g Allez en haut de la liste des processus.
• G Allez au bas de la liste des processus.
• Balise d' espace un processus sélectionné.
• U Décollez tous les processus marqués.
• K Tuez tous les processus marqués.
• Je inverser l'ordre de tri.
• F Suivre le processus: si l'ordre de tri entraîne le déplacement du processus actuellement sélectionné dans la liste, faites-le suivre par la barre de sélection. Le déplacement manuel du curseur désactive automatiquement cette fonctionnalité.
• n Suivant dans la recherche.
• N Précédent dans la recherche.

Commandes Vi :

• : exec CMD Exécute la commande Windows donnée.
• : kill PID (s) Tue tous les processus donnés.
• : q ,: quit Quit NTop.
• / PATTERN,: search PATTERN Effectue une recherche.
• : sort COLUMN Trier la liste de processus après la colonne donnée.
• : tree Voir l'arborescence de processus.

Les binaires précompilés peuvent être téléchargés ici

Enregistrez les éléments suivants dans un fichier appelé mytop.ps1dans un dossier de votre PATHvariable d’environnement. Utilisez ensuite l’un des éléments suivants à partir de n’importe quelle console PowerShell:

1. mytop - utiliser le tri par défaut de la colonne 'Mémoire' et afficher les 30 premières lignes.
2. mytop CPU 50 - trier par la colonne 'CPU' et afficher les 50 premières lignes.
3. While(1) {$p = myTop Memory 50; cls; $p} - de le rafraîchir toutes les secondes environ.

mytop.ps1 Contenu:

##################################################
#  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

Exemple de sortie:

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édit supplémentaire à:

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

Autre chose à regarder est:

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

Il existe un outil de ligne de commande pour vider tous les processus (et bien sûr, Process Monitor ou Process Explorer).

Utilisez la commande ci-dessous, elle vous donnera le top 10 d'utilisation du processeur et la sortie sera actualisée toutes les 5 secondes.

tandis que (1) {ps | Sort-Object -Property cpu -Descending | la sortie select-First 10; Write-Host "sera régénérée dans les secondes de 5 secondes. nHandle NPM (K) PM (K) WS (K) CPU (s) Id SI ProcessName"; sommeil-secondes 5}