Partager via

Get-Counter

  • Référence
Module:
Microsoft.PowerShell.Diagnostics

Obtient les données du compteur de performances des ordinateurs locaux et distants.

Syntaxe

Get-Counter
   [[-Counter] <String[]>]
   [-SampleInterval <Int32>]
   [-MaxSamples <Int64>]
   [-Continuous]
   [-ComputerName <String[]>]
   [<CommonParameters>]
Get-Counter
   [-ListSet] <String[]>
   [-ComputerName <String[]>]
   [<CommonParameters>]

Description

Cette applet de commande est disponible uniquement sur la plateforme Windows.

L’applet de commande Get-Counter obtient des données de compteur de performances directement à partir de l’instrumentation d’analyse des performances dans la famille de systèmes d’exploitation Windows. Get-Counter obtient des données de performances à partir d’un ordinateur local ou d’ordinateurs distants.

Vous pouvez utiliser les paramètres Get-Counter pour spécifier un ou plusieurs ordinateurs, répertorier les jeux de compteurs de performances et les instances qu’ils contiennent, définir les intervalles d’échantillonnage et spécifier le nombre maximal d’échantillons. Sans paramètres, Get-Counter obtient des données de compteur de performances pour un ensemble de compteurs système.

De nombreux jeux de compteurs sont protégés par des listes de contrôle d’accès (ACL). Pour afficher tous les jeux de compteurs, ouvrez PowerShell avec l’option Exécuter en tant qu’administrateur.

Cette applet de commande a été réintroduite dans PowerShell 7.

Remarque

Les noms des compteurs de performances sont localisés. Les exemples présentés ici utilisent les noms anglais des objets, compteurs et instances de performances. Les noms seront différents sur un système qui utilise une autre langue. Utilisez la commande Get-Counter -ListSet pour afficher les noms localisés.

Exemples

Exemple 1 : Obtenir la liste des ensembles de compteurs

Cet exemple obtient la liste des jeux de compteurs de l’ordinateur local.

Get-Counter -ListSet *

CounterSetName     : Processor
MachineName        : .
CounterSetType     : MultiInstance
Description        : The Processor performance object consists of counters that measure aspects ...
                     computer that performs arithmetic and logical computations, initiates ...
                     computer can have multiple processors.  The processor object represents ...
Paths              : {\Processor(*)\% Processor Time, \Processor(*)\% User Time, ...
PathsWithInstances : {\Processor(0)\% Processor Time, \Processor(1)\% Processor Time, ...
Counter            : {\Processor(*)\% Processor Time, \Processor(*)\% User Time, ...

Get-Counter utilise le paramètre ListSet avec un astérisque (*) pour obtenir la liste des jeux de compteurs. Le point (.) dans la colonne MachineName représente l’ordinateur local.

Exemple 2 : Spécifier sampleInterval et MaxSamples

Cet exemple obtient les données de compteur pour tous les processeurs sur l’ordinateur local. Les données sont collectées à intervalles de deux secondes jusqu’à ce qu’il y ait trois échantillons.

Get-Counter -Counter "\Processor(_Total)\% Processor Time" -SampleInterval 2 -MaxSamples 3

Timestamp                 CounterSamples
---------                 --------------
6/18/2019 14:39:56        \\Computer01\processor(_total)\% processor time :
                          20.7144271584086

6/18/2019 14:39:58        \\Computer01\processor(_total)\% processor time :
                          10.4391790575511

6/18/2019 14:40:01        \\Computer01\processor(_total)\% processor time :
                          37.5968799396998

Get-Counter utilise le paramètre compteur pour spécifier le chemin d’accès du compteur \Processor(_Total)\% Processor Time. Le paramètre SampleInterval définit un intervalle de deux secondes pour vérifier le compteur. MaxSamples détermine que trois sont le nombre maximal de fois pour vérifier le compteur.

Exemple 3 : Obtenir des exemples continus d’un compteur

Cet exemple obtient des exemples continus pour un compteur toutes les secondes. Pour arrêter la commande, appuyez sur Ctrl+C. Pour spécifier un intervalle plus long entre les exemples, utilisez le paramètre SampleInterval.

Get-Counter -Counter "\Processor(_Total)\% Processor Time" -Continuous

Timestamp                 CounterSamples
---------                 --------------
6/19/2019 15:35:03        \\Computer01\processor(_total)\% processor time :
                          43.8522842937022

6/19/2019 15:35:04        \\Computer01\processor(_total)\% processor time :
                          29.7896844697383

6/19/2019 15:35:05        \\Computer01\processor(_total)\% processor time :
                          29.4962645638135

6/19/2019 15:35:06        \\Computer01\processor(_total)\% processor time :
                          25.5901500127408

Get-Counter utilise le paramètre compteur de pour spécifier le compteur \Processor\% Processor Time. Le paramètre de continu spécifie d’obtenir des exemples toutes les secondes jusqu’à ce que la commande soit arrêtée avec ctrl+C.

Exemple 4 : Liste alphabétique des jeux de compteurs

Cet exemple utilise le pipeline pour obtenir le jeu de listes de compteurs, puis trier la liste par ordre alphabétique.

Get-Counter -ListSet * |
  Sort-Object -Property CounterSetName |
    Format-Table CounterSetName, CounterSetType -AutoSize

CounterSetName                        CounterSetType
--------------                        --------------
.NET CLR Data                         SingleInstance
.NET Data Provider for SqlServer      SingleInstance
AppV Client Streamed Data Percentage  SingleInstance
Authorization Manager Applications    SingleInstance
BitLocker                             MultiInstance
Bluetooth Device                      SingleInstance
Cache                                 SingleInstance
Client Side Caching                   SingleInstance

Get-Counter utilise le paramètre ListSet avec un astérisque (*) pour obtenir une liste complète des jeux de compteurs. Les objets CounterSet sont envoyés vers le bas du pipeline. Sort-Object utilise le paramètre Property pour spécifier que les objets sont triés par CounterSetName. Les objets sont envoyés dans le pipeline vers Format-Table. Le paramètre AutoSize ajuste les largeurs de colonne pour réduire la troncation.

Le point (.) dans la colonne MachineName représente l’ordinateur local.

Exemple 5 : Exécuter un travail en arrière-plan pour obtenir des données de compteur

Dans cet exemple, Start-Job exécute une commande Get-Counter en tant que travail en arrière-plan sur l’ordinateur local. Pour afficher la sortie du compteur de performances à partir du travail, utilisez l’applet de commande Receive-Job.

Start-Job -ScriptBlock {
    Get-Counter -Counter "\LogicalDisk(_Total)\% Free Space" -MaxSamples 1000
}

Id     Name  PSJobTypeName   State    HasMoreData  Location   Command
--     ----  -------------   -----    -----------  --------   -------
1      Job1  BackgroundJob   Running  True         localhost  Get-Counter -Counter

Start-Job utilise le paramètre ScriptBlock pour exécuter une commande Get-Counter. Get-Counter utilise le paramètre compteur pour spécifier le chemin d’accès du compteur \LogicalDisk(_Total)\% Free Space. Le paramètre MaxSamples spécifie pour obtenir 1 000 exemples du compteur.

Exemple 6 : Obtenir des données de compteur à partir de plusieurs ordinateurs

Cet exemple utilise une variable pour obtenir des données de compteur de performances à partir de deux ordinateurs.

$DiskReads = "\LogicalDisk(C:)\Disk Reads/sec"
$DiskReads | Get-Counter -ComputerName Server01, Server02 -MaxSamples 10

Timestamp                 CounterSamples
---------                 --------------
6/21/2019 10:51:04        \\Server01\logicaldisk(c:)\disk reads/sec :
                          0

                          \\Server02\logicaldisk(c:)\disk reads/sec :
                          0.983050344269146

La variable $DiskReads stocke le chemin du compteur \LogicalDisk(C:)\Disk Reads/sec. La variable $DiskReads est envoyée au pipeline vers Get-Counter. Counter est le premier paramètre de position et accepte le chemin stocké dans $DiskReads. ComputerName spécifie les deux ordinateurs et MaxSamples spécifie pour obtenir 10 échantillons de chaque ordinateur.

Exemple 7 : Obtenir les valeurs d’instance d’un compteur à partir de plusieurs ordinateurs aléatoires

Cet exemple obtient la valeur d’un compteur de performances sur 50 ordinateurs distants aléatoires dans l’entreprise. Le paramètre ComputerName utilise des noms d’ordinateurs aléatoires stockés dans une variable. Pour mettre à jour les noms d’ordinateurs dans la variable, recréez la variable.

Une alternative pour les noms de serveur dans le paramètre ComputerName consiste à utiliser un fichier texte. Par exemple:

-ComputerName (Get-Random (Get-Content -Path C:\Servers.txt) -Count 50)

Le chemin du compteur inclut un astérisque (*) dans le nom de l’instance pour obtenir les données de chacun des processeurs de l’ordinateur distant.

$Servers = Get-Random (Get-Content -Path C:\Servers.txt) -Count 50
$Counter = "\Processor(*)\% Processor Time"
Get-Counter -Counter $Counter -ComputerName $Servers

Timestamp                 CounterSamples
---------                 --------------
6/20/2019 12:20:35        \\Server01\processor(0)\% processor time :
                          6.52610319637854

                          \\Server01\processor(1)\% processor time :
                          3.41030663625782

                          \\Server01\processor(2)\% processor time :
                          9.64189975649925

                          \\Server01\processor(3)\% processor time :
                          1.85240835619747

                          \\Server01\processor(_total)\% processor time :
                          5.35768447160776

L’applet de commande Get-Random utilise Get-Content pour sélectionner 50 noms d’ordinateurs aléatoires dans le fichier Servers.txt. Les noms d’ordinateur distants sont stockés dans la variable $Servers. Le chemin d’accès du compteur \Processor(*)\% Processor Time est stocké dans la variable $Counter. Get-Counter utilise le paramètre compteur de pour spécifier les compteurs dans la variable $Counter. Le paramètre ComputerName spécifie les noms d’ordinateurs dans la variable $Servers.

Exemple 8 : Utiliser la propriété Path pour obtenir des noms de chemin mis en forme

Cet exemple utilise la propriété Path d’un jeu de compteurs pour rechercher les noms de chemin d’accès mis en forme pour les compteurs de performances.

Le pipeline est utilisé avec l’applet de commande Where-Object pour rechercher un sous-ensemble des noms de chemins d’accès. Pour rechercher une liste complète des ensembles de compteurs, supprimez le pipeline (|) et Where-Object commande.

La $_ est une variable automatique pour l’objet actuel dans le pipeline. Pour plus d'informations, consultez à propos des variables automatiques.

(Get-Counter -ListSet Memory).Paths | Where-Object { $_ -like "*Cache*" }

\Memory\Cache Faults/sec
\Memory\Cache Bytes
\Memory\Cache Bytes Peak
\Memory\System Cache Resident Bytes
\Memory\Standby Cache Reserve Bytes
\Memory\Standby Cache Normal Priority Bytes
\Memory\Standby Cache Core Bytes
\Memory\Long-Term Average Standby Cache Lifetime (s)

Get-Counter utilise le paramètre ListSet pour spécifier le jeu de compteurs de mémoire . La commande est placée entre parenthèses afin que la propriété Paths retourne chaque chemin sous forme de chaîne. Les objets sont envoyés dans le pipeline vers Where-Object. Where-Object utilise la variable $_ pour traiter chaque objet et utilise l’opérateur -like pour rechercher des correspondances pour la chaîne *Cache*. Les astérisques (*) sont des caractères génériques pour tous les caractères.

Exemple 9 : Utiliser la propriété PathWithInstances pour obtenir les noms de chemins mis en forme

Cet exemple obtient les noms de chemin d’accès mis en forme qui incluent les instances des compteurs de performances PhysicalDisk.

(Get-Counter -ListSet PhysicalDisk).PathsWithInstances

\PhysicalDisk(0 C:)\Current Disk Queue Length
\PhysicalDisk(_Total)\Current Disk Queue Length
\PhysicalDisk(0 C:)\% Disk Time
\PhysicalDisk(_Total)\% Disk Time
\PhysicalDisk(0 C:)\Avg. Disk Queue Length
\PhysicalDisk(_Total)\Avg. Disk Queue Length
\PhysicalDisk(0 C:)\% Disk Read Time
\PhysicalDisk(_Total)\% Disk Read Time

Get-Counter utilise le paramètre ListSet pour spécifier le jeu de compteurs PhysicalDisk. La commande est placée entre parenthèses afin que la propriété PathsWithInstances retourne chaque instance de chemin d’accès sous forme de chaîne.

Exemple 10 : Obtenir une valeur unique pour chaque compteur d’un jeu de compteurs

Dans cet exemple, une valeur unique est retournée pour chaque compteur de performances dans le jeu de compteurs de mémoire de mémoire de l’ordinateur local.

$MemCounters = (Get-Counter -ListSet Memory).Paths
Get-Counter -Counter $MemCounters

Timestamp                 CounterSamples
---------                 --------------
6/19/2019 12:05:00        \\Computer01\memory\page faults/sec :
                          868.772077545597

                          \\Computer01\memory\available bytes :
                          9031176192

                          \\Computer01\memory\committed bytes :
                          8242982912

                          \\Computer01\memory\commit limit :
                          19603333120

Get-Counter utilise le paramètre ListSet pour spécifier le jeu de compteurs de mémoire . La commande est placée entre parenthèses afin que la propriété Paths retourne chaque chemin sous forme de chaîne. Les chemins d’accès sont stockés dans la variable $MemCounters. Get-Counter utilise le paramètre Counter pour spécifier les chemins d’accès du compteur dans la variable $MemCounters.

Exemple 11 : Afficher les valeurs de propriété d’un objet

Les valeurs de propriété dans l’objet PerformanceCounterSample représentent chaque exemple de données. Dans cet exemple, nous utilisons les propriétés de l’objet CounterSamples pour examiner, sélectionner, trier et regrouper les données.

$Counter = "\\Server01\Process(Idle)\% Processor Time"
$Data = Get-Counter $Counter
$Data.CounterSamples | Format-List -Property *

Path             : \\Server01\process(idle)\% processor time
InstanceName     : idle
CookedValue      : 198.467899571389
RawValue         : 14329160321003
SecondValue      : 128606459528326201
MultipleCount    : 1
CounterType      : Timer100Ns
Timestamp        : 6/19/2019 12:20:49
Timestamp100NSec : 128606207528320000
Status           : 0
DefaultScale     : 0
TimeBase         : 10000000

Le chemin du compteur est stocké dans la variable $Counter. Get-Counter obtient un exemple de valeurs de compteur et stocke les résultats dans la variable $Data. La variable $Data utilise la propriété CounterSamples pour obtenir les propriétés de l’objet. L’objet est envoyé vers le bas du pipeline pour Format-List. Le paramètre Property utilise un caractère générique astérisque (*) pour sélectionner toutes les propriétés.

Exemple 12 : Valeurs du tableau de compteurs de performances

Dans cet exemple, une variable stocke chaque compteur de performances. La propriété CounterSamples est un tableau qui peut afficher des valeurs de compteur spécifiques.

Pour afficher chaque exemple de compteur, utilisez $Counter.CounterSamples.

$Counter = Get-Counter -Counter "\Processor(*)\% Processor Time"
$Counter.CounterSamples[0]

Path                                         InstanceName        CookedValue
----                                         ------------        -----------
\\Computer01\processor(0)\% processor time   0              1.33997091699662

Get-Counter utilise le paramètre compteur de pour spécifier le \Processor(*)\% Processor Timedu compteur. Les valeurs sont stockées dans la variable $Counter. $Counter.CounterSamples[0] affiche la valeur de tableau pour la première valeur de compteur.

Exemple 13 : Comparer les valeurs du compteur de performances

Cet exemple recherche la durée du processeur utilisée par chaque processeur sur l’ordinateur local. La propriété CounterSamples est utilisée pour comparer les données de compteur par rapport à une valeur spécifiée.

Pour afficher chaque exemple de compteur, utilisez $Counter.CounterSamples.

$Counter = Get-Counter -Counter "\Processor(*)\% Processor Time"
$Counter.CounterSamples | Where-Object { $_.CookedValue -lt "20" }

Path                                         InstanceName        CookedValue
----                                         ------------        -----------
\\Computer01\processor(0)\% processor time   0              12.6398025240208
\\Computer01\processor(1)\% processor time   1              15.7598095767344

Get-Counter utilise le paramètre compteur de pour spécifier le \Processor(*)\% Processor Timedu compteur. Les valeurs sont stockées dans la variable $Counter. Les objets stockés dans $Counter.CounterSamples sont envoyés vers le bas du pipeline. Where-Object utilise un bloc de script pour comparer chaque valeur d’objet à une valeur spécifiée de 20. La $_.CookedValue est une variable pour l’objet actuel dans le pipeline. Compteurs avec un CookedValue inférieur à 20 sont affichés.

Exemple 14 : Trier les données du compteur de performances

Cet exemple montre comment trier les données du compteur de performances. L’exemple recherche les processus sur l’ordinateur qui utilisent le plus de temps processeur pendant l’exemple.

$Procs = Get-Counter -Counter "\Process(*)\% Processor Time"
$Procs.CounterSamples | Sort-Object -Property CookedValue -Descending |
   Format-Table -Property Path, InstanceName, CookedValue -AutoSize

Path                                                         InstanceName             CookedValue
----                                                         ------------             -----------
\\Computer01\process(_total)\% processor time                _total              395.464129650573
\\Computer01\process(idle)\% processor time                  idle                389.356575524695
\\Computer01\process(mssense)\% processor time               mssense             3.05377706293879
\\Computer01\process(csrss#1)\% processor time               csrss               1.52688853146939
\\Computer01\process(microsoftedgecp#10)\% processor time    microsoftedgecp     1.52688853146939
\\Computer01\process(runtimebroker#5)\% processor time       runtimebroker                      0
\\Computer01\process(settingsynchost)\% processor time       settingsynchost                    0
\\Computer01\process(microsoftedgecp#16)\% processor time    microsoftedgecp                    0

Get-Counter utilise le paramètre Counter pour spécifier le compteur \Process(*)\% Processor Time pour tous les processus sur l’ordinateur local. Le résultat est stocké dans la variable $Procs. La variable $Procs avec les CounterSamples propriété envoie les objets PerformanceCounterSample vers le bas du pipeline. Sort-Object utilise le paramètre Property pour trier les objets par CookedValue dans 'ordre de décroissant. Format-Table utilise le paramètre Property pour sélectionner les colonnes de la sortie. Le paramètre AutoSize ajuste les largeurs de colonne pour réduire la troncation.

Paramètres

-ComputerName

Spécifie un nom d’ordinateur ou un tableau séparé par des virgules de noms d’ordinateurs distants. Utilisez le nom NetBIOS, une adresse IP ou le nom de domaine complet de l’ordinateur.

Pour obtenir des données de compteur de performances à partir de l’ordinateur local, excluez le paramètre ComputerName. Pour obtenir une sortie telle qu’une ListSet qui contient la colonne MachineName, un point (.) indique l’ordinateur local.

Get-Counter ne s’appuie pas sur la communication à distance PowerShell. Vous pouvez utiliser le paramètre ComputerName même si votre ordinateur n’est pas configuré pour exécuter des commandes distantes.

Type:String[]
Alias:Cn
Position:Named
Valeur par défaut:None
Obligatoire:False
Accepter l'entrée de pipeline:False
Accepter les caractères génériques:False

-Continuous

Lorsque continu est spécifié, Get-Counter obtient des exemples jusqu’à ce que vous appuyiez sur Ctrl+C. Les échantillons sont obtenus toutes les secondes pour chaque compteur de performances spécifié. Utilisez le paramètre SampleInterval pour augmenter l’intervalle entre les échantillons continus.

Type:SwitchParameter
Position:Named
Valeur par défaut:None
Obligatoire:False
Accepter l'entrée de pipeline:False
Accepter les caractères génériques:False

-Counter

Spécifie le chemin d’accès à un ou plusieurs chemins de compteur. Les chemins d’accès sont des entrées sous la forme d’un tableau séparé par des virgules, d’une variable ou de valeurs d’un fichier texte. Vous pouvez envoyer des chaînes de chemin d’accès de compteur vers le bas du pipeline pour Get-Counter.

Les chemins d’accès des compteurs utilisent la syntaxe suivante :

\\ComputerName\CounterSet(Instance)\CounterName

\CounterSet(Instance)\CounterName

Par exemple:

\\Server01\Processor(*)\% User Time

\Processor(*)\% User Time

Le \\ComputerName est facultatif dans un chemin de compteur de performances. Si le chemin du compteur n’inclut pas le nom de l’ordinateur, Get-Counter utilise l’ordinateur local.

Un astérisque (*) dans l’instance est un caractère générique pour obtenir toutes les instances du compteur.

Type:String[]
Position:0
Valeur par défaut:None
Obligatoire:False
Accepter l'entrée de pipeline:True
Accepter les caractères génériques:True

-ListSet

Répertorie les jeux de compteurs de performances sur les ordinateurs. Utilisez un astérisque (*) pour spécifier tous les jeux de compteurs. Entrez un nom ou une chaîne séparée par des virgules de noms de jeu de compteurs. Vous pouvez envoyer des noms de compteurs vers le bas du pipeline.

Pour obtenir un ensemble de compteurs mis en forme, utilisez le paramètre ListSet. Les chemins d’accès et PathsWithInstances propriétés de chaque jeu de compteurs contiennent les chemins d’accès individuels au compteur mis en forme sous forme de chaîne.

Vous pouvez enregistrer les chaînes de chemin d’accès du compteur dans une variable ou utiliser le pipeline pour envoyer la chaîne à une autre commande Get-Counter.

Par exemple, pour envoyer chaque chemin de compteur processeur de à Get-Counter:

Get-Counter -ListSet Processor | Get-Counter

Remarque

Dans PowerShell 7, Get-Counter ne pouvez pas récupérer la propriété Description du jeu de compteurs. La Description est définie sur $null.

Type:String[]
Position:0
Valeur par défaut:None
Obligatoire:True
Accepter l'entrée de pipeline:True
Accepter les caractères génériques:True

-MaxSamples

Spécifie le nombre d’exemples à obtenir à partir de chaque compteur de performances spécifié. Pour obtenir un flux constant d’exemples, utilisez le paramètre de continu.

Si le paramètre MaxSamples n’est pas spécifié, Get-Counter obtient un seul exemple pour chaque compteur spécifié.

Pour collecter un jeu de données volumineux, exécutez Get-Counter en tant que travail en arrière-plan PowerShell. Pour plus d’informations, consultez à propos des_tâches.

Type:Int64
Position:Named
Valeur par défaut:None
Obligatoire:False
Accepter l'entrée de pipeline:False
Accepter les caractères génériques:False

-SampleInterval

Spécifie le nombre de secondes entre les échantillons pour chaque compteur de performances spécifié. Si le paramètre SampleInterval n’est pas spécifié, Get-Counter utilise un intervalle d’une seconde.

Type:Int32
Position:Named
Valeur par défaut:None
Obligatoire:False
Accepter l'entrée de pipeline:False
Accepter les caractères génériques:False

Entrées

String[]

Get-Counter accepte l’entrée de pipeline pour les chemins d’accès de compteur et les noms des ensembles de compteurs.

Sorties

CounterSet

Avec le paramètre ListSet, cette applet de commande retourne objets CounterSet.

PerformanceCounterSampleSet

Par défaut et avec le paramètre Counter, cette applet de commande retourne objets PerformanceCounterSampleSet.

Notes

Si aucun paramètre n’est spécifié, Get-Counter obtient un exemple pour chaque compteur de performances spécifié. Utilisez les paramètres MaxSamples et continus pour obtenir plus d’exemples.

Get-Counter utilise un intervalle d’une seconde entre les échantillons. Utilisez le paramètre SampleInterval pour augmenter l’intervalle.

Les valeurs MaxSamples et SampleInterval s’appliquent à tous les compteurs sur chaque ordinateur de la commande. Pour définir différentes valeurs pour différents compteurs, entrez des commandes Get-Counter distinctes.

Dans PowerShell 7, lors de l’utilisation du paramètre ListSet, Get-Counter ne peut pas récupérer la propriété Description du jeu de compteurs. La Description est définie sur $null.