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’était pas utile sur mon serveur qui reste actif 24 heures sur 24, 7 jours sur 7, où le meilleur résultat était toujours juste svchost et system à des millions de secondes. Une valeur vraie top ou équivalente dans le Gestionnaire des tâches donnerait un instantané de l’utilisation de la CPU enregistrée récemment sur une durée déterminée, ce que Get-Counter 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 le modifier selon vos besoins:
While(1) {le boucleget-counter '\Process(*)\% Processor Time'sélectionne les données% CPU. Cette commande semble prendre beaucoup de temps, donc inutile desleepclsclair pour la nouvelle tablesort -des CookedValueCookedValue est le champ dans lequel nous nous intéressons, triez pour placer le plus grand en hautselect -f 15affiche les 15 premiersft -aaffichage dans un tableau formaté
Fournit les en-têtes Nice 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 Russinovichde 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
Ce commentaire de Mark devrait faire l’objet de plus de recommandations, car il décrit presque exactement la question et fonctionne:
Fournit les en-têtes Nice 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 frappe ici, il est impossible de commenter ou de créer une note sans 50 karma ou plus.
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 exemples Get-Counter et générera les ProcessId,ProcessName,ProcessorUsage et WorkingSet. Cet échantillon de compteur pourrait encore être amélioré pour inclure User, CommandLine dans la sortie, mais je n'ai pas encore trouvé de moyen performant de le faire.
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.
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.
Enregistrez les éléments suivants dans un fichier appelé mytop.ps1 dans un dossier qui se trouve dans votre variable d’environnement PATH. Utilisez ensuite l’un des éléments suivants à partir de n’importe quelle console PowerShell:
mytop- pour utiliser le tri par défaut de la colonne 'Mémoire' et afficher les 30 premières lignes.mytop CPU 50- pour trier selon la colonne "CPU" et afficher les 50 premières lignes.While(1) {$p = myTop Memory 50; cls; $p}- pour qu'il soit actualisé 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 à:
Si vous souhaitez filtrer par processus, utilisez findstr
while (1) { ps | findstr Explorer | sort -desc cpu | select -first 30; sleep -seconds 2; cls }
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 la ligne de commande :
- - C Utilisez un jeu de couleurs monochrome.
- - h Afficher les informations d'aide.
- - p PID, PID ... Affiche uniquement les PID donnés.
- - s COLUMN Trier par cette colonne.
- - u USERNAME Affiche uniquement 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 Aller en haut de la liste des processus.
- G Aller au bas de la liste des processus.
- Espace Marquer un processus sélectionné.
- U Supprimez tous les processus étiquetés.
- K Élimine tous les processus marqués.
- I Inverse l'ordre de tri.
- F Processus suivant: 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 Quittez NTop.
- /PATTERN,: search PATTERN Effectue une recherche.
- : sort COLUMN Trier la liste de processus après la colonne donnée.
- : tree Afficher l'arborescence des processus.
Les binaires précompilés peuvent être téléchargés ici
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}}"
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).