Condividi tramite


Get-Counter

Ottiene i dati dei contatori delle prestazioni da computer locali e remoti.

Sintassi

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

Descrizione

Questo cmdlet è disponibile solo nella piattaforma Windows.

Il Get-Counter cmdlet ottiene i dati dei contatori delle prestazioni direttamente dalla strumentazione del monitoraggio delle prestazioni nella famiglia di sistemi operativi Windows. Get-Counter ottiene i dati sulle prestazioni da un computer locale o da computer remoti.

È possibile usare i Get-Counter parametri per specificare uno o più computer, elencare i set di contatori delle prestazioni e le istanze che contengono, impostare gli intervalli di esempio e specificare il numero massimo di campioni. Senza parametri, Get-Counter ottiene i dati del contatore delle prestazioni per un set di contatori di sistema.

Molti insiemi di contatori sono protetti da elenchi di controllo di accesso (ACL). Per visualizzare tutti i set di contatori, aprire PowerShell con l'opzione Esegui come amministratore .

Questo cmdlet è stato reintrodotto in PowerShell 7.

Nota

I nomi dei contatori delle prestazioni vengono localizzati. Gli esempi illustrati di seguito usano i nomi in inglese degli oggetti prestazioni, dei contatori e delle istanze. I nomi saranno diversi in un sistema che usa un'altra lingua. Usare il Get-Counter -ListSet comando per visualizzare i nomi localizzati.

Esempio

Esempio 1: Ottenere l'elenco dei contatori

In questo esempio viene visualizzato l'elenco di insiemi di contatori del computer locale.

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 usa il parametro ListSet con un asterisco (*) per ottenere l'elenco di insiemi di contatori. Il punto (.) nella colonna MachineName rappresenta il computer locale.

Esempio 2: Specificare SampleInterval e MaxSamples

In questo esempio vengono visualizzati i dati del contatore per tutti i processori nel computer locale. I dati vengono raccolti a intervalli di due secondi fino a quando non sono presenti tre campioni.

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 utilizza il parametro Counter per specificare il percorso \Processor(_Total)\% Processor Timedel contatore . Il parametro SampleInterval imposta un intervallo di due secondi per controllare il contatore. MaxSamples determina che tre è il numero massimo di volte per controllare il contatore.

Esempio 3: Ottenere campioni continui di un contatore

Questo esempio ottiene campioni continui per un contatore ogni secondo. Per arrestare il comando, premere CTRL+C. Per specificare un intervallo più lungo tra campioni, usare il parametro 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 utilizza il parametro Counter per specificare il \Processor\% Processor Time contatore. Il parametro Continuous specifica di ottenere campioni ogni secondo finché il comando non viene arrestato con CTRL+C.

Esempio 4: Elenco alfabetico di insiemi di contatori

In questo esempio viene usata la pipeline per ottenere il set di elenchi di contatori e quindi ordinare l'elenco in ordine alfabetico.

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 usa il parametro ListSet con un asterisco (*) per ottenere un elenco completo di insiemi di contatori. Gli oggetti CounterSet vengono inviati nella pipeline. Sort-Object utilizza il parametro Property per specificare che gli oggetti vengono ordinati in base a CounterSetName. Gli oggetti vengono inviati alla pipeline a Format-Table. Il parametro AutoSize regola la larghezza della colonna per ridurre al minimo il troncamento.

Il punto (.) nella colonna MachineName rappresenta il computer locale.

Esempio 5: Eseguire un processo in background per ottenere i dati dei contatori

In questo esempio Start-Job viene eseguito un Get-Counter comando come processo in background nel computer locale. Per visualizzare l'output del contatore delle prestazioni dal processo, usare il Receive-Job cmdlet .

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 usa il parametro ScriptBlock per eseguire un Get-Counter comando. Get-Counter utilizza il parametro Counter per specificare il percorso \LogicalDisk(_Total)\% Free Spacedel contatore . Il parametro MaxSamples consente di ottenere 1000 campioni del contatore.

Esempio 6: Recuperare i dati dei contatori da più computer

In questo esempio viene usata una variabile per ottenere i dati del contatore delle prestazioni da due computer.

$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 $DiskReads variabile archivia il percorso del \LogicalDisk(C:)\Disk Reads/sec contatore. La $DiskReads variabile viene inviata alla pipeline a Get-Counter. Il contatore è il primo parametro di posizione e accetta il percorso archiviato in $DiskReads. ComputerName specifica i due computer e MaxSamples specifica per ottenere 10 campioni da ogni computer.

Esempio 7: Ottenere i valori di istanza di un contatore da più computer casuali

Questo esempio ottiene il valore di un contatore delle prestazioni su 50 computer remoti casuali nell'organizzazione. Il parametro ComputerName usa nomi di computer casuali archiviati in una variabile. Per aggiornare i nomi dei computer nella variabile, ricreare la variabile.

Un'alternativa per i nomi dei server nel parametro ComputerName consiste nell'usare un file di testo. Ad esempio:

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

Il percorso del contatore include un asterisco (*) nel nome dell'istanza per ottenere i dati per ognuno dei processori del computer remoto.

$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

Il Get-Random cmdlet usa per selezionare 50 nomi casuali Get-Content di computer dal Servers.txt file. I nomi dei computer remoti vengono archiviati nella $Servers variabile . Il \Processor(*)\% Processor Time percorso del contatore viene archiviato nella $Counter variabile . Get-Counter usa il parametro Counter per specificare i contatori nella $Counter variabile. Il parametro ComputerName specifica i nomi dei computer nella $Servers variabile.

Esempio 8: Usare la proprietà Path per ottenere nomi di percorso formattati

In questo esempio viene utilizzata la proprietà Path di un insieme di contatori per trovare i nomi di percorso formattati per i contatori delle prestazioni.

La pipeline viene usata con il Where-Object cmdlet per trovare un subset dei nomi dei percorsi. Per trovare un elenco completo dei percorsi dei contatori, rimuovere la pipeline (|) e Where-Object il comando .

$_ è una variabile automatica per l'oggetto corrente nella pipeline. Per altre informazioni, vedere about_Automatic_Variables.

(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 utilizza il parametro ListSet per specificare il set di contatori memoria . Il comando è racchiuso tra parentesi in modo che la proprietà Paths restituisca ogni percorso come stringa. Gli oggetti vengono inviati alla pipeline a Where-Object. Where-Object usa la variabile $_ per elaborare ogni oggetto e usa l'operatore -like per trovare corrispondenze per la stringa *Cache*. Gli asterischi (*) sono caratteri jolly per qualsiasi carattere.

Esempio 9: Utilizzare la proprietà PathsWithInstances per ottenere nomi di percorso formattati

Questo esempio ottiene i nomi di percorso formattati che includono le istanze per i contatori delle prestazioni 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 utilizza il parametro ListSet per specificare il set di contatori PhysicalDisk . Il comando è racchiuso tra parentesi in modo che la proprietà PathsWithInstances restituisca ogni istanza di percorso come stringa.

Esempio 10: Ottenere un singolo valore per ogni contatore in un insieme di contatori

In questo esempio viene restituito un singolo valore per ogni contatore delle prestazioni nel set di contatori Memoria del computer locale.

$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 utilizza il parametro ListSet per specificare il set di contatori memoria . Il comando è racchiuso tra parentesi in modo che la proprietà Paths restituisca ogni percorso come stringa. I percorsi vengono archiviati nella $MemCounters variabile . Get-Counter utilizza il parametro Counter per specificare i percorsi dei contatori nella $MemCounters variabile.

Esempio 11: Visualizzare i valori delle proprietà di un oggetto

I valori delle proprietà nell'oggetto PerformanceCounterSample rappresentano ogni esempio di dati. In questo esempio vengono usate le proprietà dell'oggetto CounterSamples per esaminare, selezionare, ordinare e raggruppare i dati.

$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

Il percorso del contatore viene archiviato nella $Counter variabile . Get-Counter ottiene un campione dei valori del contatore e archivia i risultati nella $Data variabile. La $Data variabile usa la proprietà CounterSamples per ottenere le proprietà dell'oggetto. L'oggetto viene inviato alla pipeline a Format-List. Il parametro Property usa un carattere jolly asterisco (*) per selezionare tutte le proprietà.

Esempio 12: Valori della matrice dei contatori delle prestazioni

In questo esempio una variabile archivia ogni contatore delle prestazioni. La proprietà CounterSamples è una matrice in grado di visualizzare valori di contatore specifici.

Per visualizzare ogni esempio di contatore, usare $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 utilizza il parametro Counter per specificare il contatore \Processor(*)\% Processor Time. I valori vengono archiviati nella $Counter variabile . $Counter.CounterSamples[0] visualizza il valore della matrice per il primo valore del contatore.

Esempio 13: Confrontare i valori dei contatori delle prestazioni

In questo esempio viene trovata la quantità di tempo del processore usata da ogni processore nel computer locale. La proprietà CounterSamples viene utilizzata per confrontare i dati del contatore con un valore specificato.

Per visualizzare ogni esempio di contatore, usare $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 utilizza il parametro Counter per specificare il contatore \Processor(*)\% Processor Time. I valori vengono archiviati nella $Counter variabile . Gli oggetti archiviati in $Counter.CounterSamples vengono inviati nella pipeline. Where-Object usa un blocco di script per confrontare ogni valore di oggetti con un valore specificato di 20. $_.CookedValue è una variabile per l'oggetto corrente nella pipeline. Vengono visualizzati i contatori con cookedValue minore di 20.

Esempio 14: Ordinare i dati del contatore delle prestazioni

In questo esempio viene illustrato come ordinare i dati dei contatori delle prestazioni. Nell'esempio vengono trovati i processi nel computer che utilizzano la maggior parte del tempo del processore durante l'esempio.

$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 utilizza il parametro Counter per specificare il \Process(*)\% Processor Time contatore per tutti i processi nel computer locale. Il risultato viene archiviato nella variabile $Procs. La $Procs variabile con la proprietà CounterSamples invia gli oggetti PerformanceCounterSample nella pipeline. Sort-Object usa il parametro Property per ordinare gli oggetti in base a CookedValue in ordine decrescente . Format-Table usa il parametro Property per selezionare le colonne per l'output. Il parametro AutoSize regola la larghezza della colonna per ridurre al minimo il troncamento.

Parametri

-ComputerName

Specifica un nome computer o una matrice delimitata da virgole di nomi di computer remoti . Usare il nome NetBIOS, un indirizzo IP o il nome di dominio completo del computer.

Per ottenere i dati del contatore delle prestazioni dal computer locale , escludere il parametro ComputerName . Per l'output, ad esempio un oggetto ListSet che contiene la colonna MachineName , un punto (.) indica il computer locale.

Get-Counter non si basa sulla comunicazione remota di PowerShell. È possibile usare il parametro ComputerName anche se il computer non è configurato per l'esecuzione di comandi remoti.

Type:String[]
Aliases:Cn
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-Continuous

Quando si specifica Continuous, Get-Counter ottiene campioni fino a quando non si preme CTRL+C. I campioni vengono ottenuti ogni secondo per ogni contatore delle prestazioni specificato. Usare il parametro SampleInterval per aumentare l'intervallo tra campioni continui.

Type:SwitchParameter
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-Counter

Specifica il percorso di uno o più percorsi dei contatori. I percorsi sono input come matrice delimitata da virgole, una variabile o valori di un file di testo. È possibile inviare le stringhe di percorso del contatore verso il basso nella pipeline a Get-Counter.

I percorsi dei contatori usano la sintassi seguente:

\\ComputerName\CounterSet(Instance)\CounterName

\CounterSet(Instance)\CounterName

Ad esempio:

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

\Processor(*)\% User Time

\\ComputerName è facoltativo in un percorso del contatore delle prestazioni. Se il percorso del contatore non include il nome del computer, Get-Counter usa il computer locale.

Un asterisco (*) nell'istanza è un carattere jolly per ottenere tutte le istanze del contatore.

Type:String[]
Position:0
Default value:None
Required:False
Accept pipeline input:True
Accept wildcard characters:True

-ListSet

Elenca i set di contatori delle prestazioni nei computer. Usare un asterisco (*) per specificare tutti i set di contatori. Immettere un nome o una stringa delimitata da virgole di nomi dei set di contatori. È possibile inviare i nomi del set di contatori verso il basso nella pipeline.

Per ottenere un insieme di contatori formattati, utilizzare il parametro ListSet . Le proprietà Paths e PathsWithInstances di ogni insieme di contatori contengono i singoli percorsi dei contatori formattati come stringa.

È possibile salvare le stringhe di percorso del contatore in una variabile o usare la pipeline per inviare la stringa a un altro Get-Counter comando.

Ad esempio, per inviare ogni percorso del contatore processore a Get-Counter:

Get-Counter -ListSet Processor | Get-Counter

Nota

In PowerShell 7 Get-Counter non è possibile recuperare la proprietà Description del set di contatori. La descrizione è impostata su $null.

Type:String[]
Position:0
Default value:None
Required:True
Accept pipeline input:True
Accept wildcard characters:True

-MaxSamples

Specifica il numero di campioni da ottenere da ogni contatore delle prestazioni specificato. Per ottenere un flusso costante di esempi, usare il parametro Continuous .

Se il parametro MaxSamples non è specificato, Get-Counter ottiene solo un campione per ogni contatore specificato.

Per raccogliere un set di dati di grandi dimensioni, eseguire Get-Counter come processo in background di PowerShell. Per altre informazioni, vedere About Jobs (Informazioni sui processi).

Type:Int64
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-SampleInterval

Specifica il numero di secondi tra i campioni per ogni contatore delle prestazioni specificato. Se il parametro SampleInterval non è specificato, Get-Counter usa un intervallo di un secondo.

Type:Int32
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

Input

String[]

Get-Counter accetta l'input della pipeline per i percorsi dei contatori e i nomi dei set di contatori.

Output

CounterSet

Con il parametro ListSet , questo cmdlet restituisce oggetti CounterSet .

PerformanceCounterSampleSet

Per impostazione predefinita e con il parametro Counter , questo cmdlet restituisce oggetti PerformanceCounterSampleSet .

Note

Se non vengono specificati parametri, Get-Counter ottiene un campione per ogni contatore delle prestazioni specificato. Usare i parametri MaxSamples e Continuous per ottenere altri esempi.

Get-Counter utilizza un intervallo di un secondo tra i campioni. Usare il parametro SampleInterval per aumentare l'intervallo.

I valori MaxSamples e SampleInterval si applicano a tutti i contatori in ogni computer del comando. Per impostare valori diversi per contatori diversi, immettere comandi separati Get-Counter .

In PowerShell 7, quando si usa il parametro ListSet , Get-Counter non è possibile recuperare la proprietà Description del set di contatori. La descrizione è impostata su $null.