Come ottenere la capacità del disco e lo spazio libero del computer remoto

Ho questa battuta:

get-WmiObject win32_logicaldisk -Computername remotecomputer

e l'output è questo:

DeviceID     : A:
DriveType    : 2
ProviderName :
FreeSpace    :
Size         :
VolumeName   :

DeviceID     : C:
DriveType    : 3
ProviderName :
FreeSpace    : 20116508672
Size         : 42842714112
VolumeName   :

DeviceID     : D:
DriveType    : 5
ProviderName :
FreeSpace    :
Size         :
VolumeName   :

Come ottengo Freespacee Sizedi DeviceID C:? Devo estrarre solo questi due valori senza altre informazioni. L'ho provato con Selectcmdlet, ma senza alcun effetto.

Modifica: ho bisogno di estrarre solo i valori numerici e memorizzarli nelle variabili.

$disk = Get-WmiObject Win32_LogicalDisk -ComputerName remotecomputer -Filter "DeviceID='C:'" |
Select-Object Size,FreeSpace

$disk.Size
$disk.FreeSpace

Per estrarre solo i valori e assegnarli a una variabile:

$disk = Get-WmiObject Win32_LogicalDisk -ComputerName remotecomputer -Filter "DeviceID='C:'" |
Foreach-Object {$_.Size,$_.FreeSpace}

Soluzione molto più semplice:

Get-PSDrive C | Select-Object Used,Free

e per computer remoti (esigenze Powershell Remoting)

Invoke-Command -ComputerName SRV2 {Get-PSDrive C} | Select-Object PSComputerName,Used,Free

Solo un comando semplice, dolce e pulito, ma funziona solo per i dischi locali

Get-PSDrive

È ancora possibile utilizzare questo comando su un server remoto eseguendo Enter-PSSession -Computername ServerName e quindi eseguire Get-PSDrive che estrarrà i dati come se lo avessi eseguito dal server.

Qualche tempo fa ho creato una funzione avanzata di PowerShell (cmdlet di script) che consente di eseguire query su più computer.

Il codice per la funzione è lungo poco più di 100 righe, quindi puoi trovarlo qui: Versione PowerShell del comando df

Consulta la sezione Utilizzo per esempi. L'esempio di utilizzo seguente esegue una query su un set di computer remoti (input dalla pipeline di PowerShell) e visualizza l'output in un formato tabella con valori numerici in formato leggibile dall'uomo:

PS> $cred = Get-Credential -Credential 'example\administrator'
PS> 'db01','dc01','sp01' | Get-DiskFree -Credential $cred -Format | Format-Table -GroupBy Name -AutoSize

   Name: DB01

Name Vol Size  Used  Avail Use% FS   Type
---- --- ----  ----  ----- ---- --   ----
DB01 C:  39.9G 15.6G 24.3G   39 NTFS Local Fixed Disk
DB01 D:  4.1G  4.1G  0B     100 CDFS CD-ROM Disc


   Name: DC01

Name Vol Size  Used  Avail Use% FS   Type
---- --- ----  ----  ----- ---- --   ----
DC01 C:  39.9G 16.9G 23G     42 NTFS Local Fixed Disk
DC01 D:  3.3G  3.3G  0B     100 CDFS CD-ROM Disc
DC01 Z:  59.7G 16.3G 43.4G   27 NTFS Network Connection


   Name: SP01

Name Vol Size   Used   Avail Use% FS   Type
---- --- ----   ----   ----- ---- --   ----
SP01 C:  39.9G  20G    19.9G   50 NTFS Local Fixed Disk
SP01 D:  722.8M 722.8M 0B     100 UDF  CD-ROM Disc

Ci sono due problemi che ho riscontrato con gli altri suggerimenti

1) Le mappature delle unità non sono supportate se si esegue PowerShell con l'utilità di pianificazione

2) È possibile che l' accesso venga negato errori errori nel tentativo di utilizzare "get-WmiObject" su computer remoti (a seconda della configurazione dell'infrastruttura, ovviamente)

L'alternativa che non soffre di questi problemi è utilizzare GetDiskFreeSpaceEx con un percorso UNC:

function getDiskSpaceInfoUNC($p_UNCpath, $p_unit = 1tb, $p_format = '{0:N1}')
{
    # unit, one of --> 1kb, 1mb, 1gb, 1tb, 1pb
    $l_typeDefinition = @' 
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
        [return: MarshalAs(UnmanagedType.Bool)] 
        public static extern bool GetDiskFreeSpaceEx(string lpDirectoryName, 
            out ulong lpFreeBytesAvailable, 
            out ulong lpTotalNumberOfBytes, 
            out ulong lpTotalNumberOfFreeBytes); 
'@
    $l_type = Add-Type -MemberDefinition $l_typeDefinition -Name Win32Utils -Namespace GetDiskFreeSpaceEx -PassThru

    $freeBytesAvailable     = New-Object System.UInt64 # differs from totalNumberOfFreeBytes when per-user disk quotas are in place
    $totalNumberOfBytes     = New-Object System.UInt64
    $totalNumberOfFreeBytes = New-Object System.UInt64

    $l_result = $l_type::GetDiskFreeSpaceEx($p_UNCpath,([ref]$freeBytesAvailable),([ref]$totalNumberOfBytes),([ref]$totalNumberOfFreeBytes)) 

    $totalBytes     = if($l_result) { $totalNumberOfBytes    /$p_unit } else { '' }
    $totalFreeBytes = if($l_result) { $totalNumberOfFreeBytes/$p_unit } else { '' }

    New-Object PSObject -Property @{
        Success   = $l_result
        Path      = $p_UNCpath
        Total     = $p_format -f $totalBytes
        Free      = $p_format -f $totalFreeBytes
    } 
}

Un altro modo è trasmettere una stringa a un oggetto WMI:

$size = ([wmi]"\\remotecomputer\root\cimv2:Win32_logicalDisk.DeviceID='c:'").Size
$free = ([wmi]"\\remotecomputer\root\cimv2:Win32_logicalDisk.DeviceID='c:'").FreeSpace

Inoltre puoi dividere i risultati per 1 GB o 1 MB se desideri unità diverse:

$disk = ([wmi]"\\remotecomputer\root\cimv2:Win32_logicalDisk.DeviceID='c:'")
"Remotecomputer C: has {0:#.0} GB free of {1:#.0} GB Total" -f ($disk.FreeSpace/1GB),($disk.Size/1GB) | write-output

L'output è: Remotecomputer C: has 252.7 GB free of 298.0 GB Total

Riga di comando:

powershell gwmi Win32_LogicalDisk -ComputerName remotecomputer -Filter "DriveType=3" ^|
select Name, FileSystem,FreeSpace,BlockSize,Size ^| % {$_.BlockSize=
(($_.FreeSpace)/($_.Size))*100;$_.FreeSpace=($_.FreeSpace/1GB);$_.Size=($_.Size/1GB);$_}
^| Format-Table Name, @{n='FS';e={$_.FileSystem}},@{n='Free, Gb';e={'{0:N2}'-f
$_.FreeSpace}}, @{n='Free,%';e={'{0:N2}'-f $_.BlockSize}},@{n='Capacity ,Gb';e={'{0:N3}'
-f $_.Size}} -AutoSize

Produzione:

Name FS   Free, Gb Free,% Capacity ,Gb

---- --   -------- ------ ------------

C:   NTFS 16,64    3,57   465,752

D:   NTFS 43,63    9,37   465,759

I:   NTFS 437,59   94,02  465,418

N:   NTFS 5,59     0,40   1 397,263

O:   NTFS 8,55     0,96   886,453

P:   NTFS 5,72     0,59   976,562

riga di comando:

wmic logicaldisk where DriveType="3" get caption, VolumeName, VolumeSerialNumber, Size, FileSystem, FreeSpace

su:

Caption  FileSystem  FreeSpace     Size           VolumeName  VolumeSerialNumber

C:       NTFS        17864343552   500096991232   S01         EC641C36

D:       NTFS        46842589184   500104687616   VM1         CAF2C258

I:       NTFS        469853536256  499738734592   V8          6267CDCC

N:       NTFS        5998840832    1500299264512  Vm-1500     003169D1

O:       NTFS        9182349312    951821143552   DT01        A8FC194C

P:       NTFS        6147043840    1048575144448  DT02        B80A0F40

riga di comando:

wmic logicaldisk where Caption="C:" get caption, VolumeName, VolumeSerialNumber, Size, FileSystem, FreeSpace

su:

Caption  FileSystem  FreeSpace    Size          VolumeName  VolumeSerialNumber

C:       NTFS        17864327168  500096991232  S01         EC641C36

command-line:

dir C:\ /A:DS | find "free"

out:
               4 Dir(s)  17 864 318 976 bytes free

dir C:\ /A:DS /-C | find "free"

out:
               4 Dir(s)     17864318976 bytes free

Get-PSDrive C | Select-Object @{ E={$_.Used/1GB}; L='Used' }, @{ E={$_.Free/1GB}; L='Free' }

PS> Get-CimInstance -ComputerName bobPC win32_logicaldisk | where caption -eq "C:" | foreach-object {write " $($_.caption) $('{0:N2}' -f ($_.Size/1gb)) GB total, $('{0:N2}' -f ($_.FreeSpace/1gb)) GB free "}  
C: 117.99 GB total, 16.72 GB free 

PS> 

Conosco strumenti psExec che puoi scaricare da qui

Viene fornito un psinfo.exe dal pacchetto degli strumenti. L'utilizzo di base è nel modo seguente in powershell / cmd.

Tuttavia potresti avere molte opzioni con esso

Utilizzo: psinfo [[\ computer [, computer [, ..] | @file [-u utente [-p psswd]]] [-h] [-s] [-d] [-c [-t delimitatore]] [filtro]

\ computer Esegue il comando sul computer remoto o sui computer specificati. Se si omette il nome del computer, il comando viene eseguito sul sistema locale e se si specifica un carattere jolly (\ *), il comando viene eseguito su tutti i computer nel dominio corrente.

@file   Run the command on each computer listed in the text file specified.
-u  Specifies optional user name for login to remote computer.
-p  Specifies optional password for user name. If you omit this you will be prompted to enter a hidden password.
-h  Show list of installed hotfixes.
-s  Show list of installed applications.
-d  Show disk volume information.
-c  Print in CSV format.
-t  The default delimiter for the -c option is a comma, but can be overriden with the specified character.

filtro Psinfo mostrerà solo i dati per il campo che corrisponde al filtro. es. "servizio psinfo" elenca solo il campo del service pack.

Ho accesso remoto al computer utilizzando Enter-PSsession pcName, quindi digito Get-PSDrive

Questo elencherà tutte le unità e lo spazio utilizzato e rimanente. Se hai bisogno di vedere tutte le informazioni formattate, collegalo a FL in questo modo: Get-PSdrive | FL *

Ho creato questa semplice funzione per aiutarmi. Questo rende le mie chiamate molto più facili da leggere che avere inline un Get-WmiObject , istruzioni Where-Object , ecc.

function GetDiskSizeInfo($drive) {
    $diskReport = Get-WmiObject Win32_logicaldisk
    $drive = $diskReport | Where-Object { $_.DeviceID -eq $drive}

    $result = @{
        Size = $drive.Size
        FreeSpace = $drive.Freespace
    }
    return $result
}

$diskspace = GetDiskSizeInfo "C:"
write-host $diskspace.FreeSpace " " $diskspace.Size

Nel caso in cui desideri controllare più lettere di unità e / o filtrare tra unità locali e di rete, puoi utilizzare PowerShell per sfruttare la classe WMI Win32_LogicalDisk . Ecco un rapido esempio:

$localVolumes = Get-WMIObject win32_volume;

foreach ($vol in $localVolumes) {
  if ($vol.DriveLetter -ne $null ) {
    $d = $vol.DriveLetter[0];
    if ($vol.DriveType -eq 3) {
      Write-Host ("Drive " + $d + " is a Local Drive");
    }
    elseif ($vol.DriveType -eq 4) {
      Write-Host ("Drive" + $d + " is a Network Drive");
    }
    else {
      // ... and so on
    }

    $drive = Get-PSDrive $d;
    Write-Host ("Used space on drive " + $d + ": " + $drive.Used + " bytes. `r`n");
    Write-Host ("Free space on drive " + $d + ": " + $drive.Free + " bytes. `r`n");
  }
}

Ho utilizzato la tecnica sopra per creare uno script Powershell che controlla tutte le unità e invia un avviso e-mail ogni volta che scendono al di sotto di una quota definita dall'utente. Puoi ottenerlo da questo post sul mio blog.

Divertimento con PowerShell

Get-WmiObject win32_logicaldisk -Computername <ServerName> -Credential $(get-credential) | Select DeviceID,VolumeName,FreeSpace,Size | where {$_.DeviceID -eq "C:"}

Ho appena trovato il comando Get-Volume , che restituisce SizeRemaining, quindi qualcosa come (Get-Volume -DriveLetter C).SizeRemaining / (1e+9)può essere usato per vedere i GB rimasti per il disco C. Sembra che funzioni più velocemente di Get-WmiObject Win32_LogicalDisk.