Comment obtenir la capacité du disque et l'espace libre de l'ordinateur distant

J'ai ce one-liner:

get-WmiObject win32_logicaldisk -Computername remotecomputer

et la sortie est la suivante:

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   :

Comment puis-je obtenir Freespaceet Sizede DeviceID C:? J'ai besoin d'extraire juste ces deux valeurs sans autres informations. Je l'ai essayé avec l' Selectapplet de commande, mais sans effet.

Edit: J'ai besoin d'extraire les valeurs numériques uniquement et de les stocker dans des variables.

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

$disk.Size
$disk.FreeSpace

Pour extraire uniquement les valeurs et les affecter à une variable:

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

Solution beaucoup plus simple:

Get-PSDrive C | Select-Object Used,Free

et pour les ordinateurs distants (besoins Powershell Remoting)

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

Juste une commande simple douce et propre mais cela ne fonctionne que pour les disques locaux

Get-PSDrive

Vous pouvez toujours utiliser cette commande sur un serveur distant en effectuant un Enter-PSSession -Computername ServerName, puis exécutez Get-PSDrive, il extraira les données comme si vous les exécutiez à partir du serveur.

J'ai créé il y a quelque temps une fonction avancée PowerShell (cmdlet de script) qui vous permet d'interroger plusieurs ordinateurs.

Le code de la fonction fait un peu plus de 100 lignes, vous pouvez donc le trouver ici: Version PowerShell de la commande df

Consultez la section Utilisation pour des exemples. L'exemple d'utilisation suivant interroge un ensemble d'ordinateurs distants (entrée du pipeline PowerShell) et affiche la sortie dans un format de table avec des valeurs numériques sous une forme lisible par l'homme:

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

J'ai rencontré deux problèmes avec les autres suggestions

1) Les mappages de lecteur ne sont pas pris en charge si vous exécutez le PowerShell sous le planificateur de tâches

2) Vous pouvez obtenir des erreurs d' accès refusé en essayant d'utiliser "get-WmiObject" sur des ordinateurs distants (en fonction de la configuration de votre infrastructure, bien sûr)

L'alternative qui ne souffre pas de ces problèmes est d'utiliser GetDiskFreeSpaceEx avec un chemin 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
    } 
}

Une autre méthode consiste à convertir une chaîne en un objet WMI:

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

Vous pouvez également diviser les résultats par 1 Go ou 1 Mo si vous souhaitez des unités différentes:

$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

La sortie est: Remotecomputer C: has 252.7 GB free of 298.0 GB Total

Ligne de commande:

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

Production:

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

ligne de commande:

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

en dehors:

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

ligne de commande:

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

en dehors:

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> 

Je connais les outils psExec que vous pouvez télécharger ici

Il existe un psinfo.exe du package d'outils. L'utilisation de base est de la manière suivante dans PowerShell / cmd.

Cependant, vous pourriez avoir beaucoup d'options avec

Utilisation: psinfo [[\ ordinateur [, ordinateur [, ..] | @file [-u utilisateur [-p psswd]]] [-h] [-s] [-d] [-c [-t délimiteur]] [filtre]

\ computer Exécutez la commande sur l'ordinateur ou les ordinateurs distants spécifiés. Si vous omettez le nom de l'ordinateur, la commande s'exécute sur le système local et si vous spécifiez un caractère générique (\ *), la commande s'exécute sur tous les ordinateurs du domaine actuel.

@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.

filter Psinfo n'affichera que les données du champ correspondant au filtre. Par exemple, "psinfo service" répertorie uniquement le champ du service pack.

Je distant dans l'ordinateur en utilisant Enter-PSsession pcName puis je tape Get-PSDrive

Cela listera tous les lecteurs et l'espace utilisé et restant. Si vous avez besoin de voir toutes les informations formatées, dirigez-les vers FL comme ceci: Get-PSdrive | FL *

J'ai créé cette fonction simple pour m'aider. Cela rend mes appels beaucoup plus faciles à lire que d'avoir en ligne un Get-WmiObject , des instructions Where-Object , etc.

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

Si vous souhaitez vérifier plusieurs lettres de lecteur et / ou filtrer entre les lecteurs locaux et réseau, vous pouvez utiliser PowerShell pour tirer parti de la classe WMI Win32_LogicalDisk . Voici un exemple rapide:

$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");
  }
}

J'ai utilisé la technique ci-dessus pour créer un script Powershell qui vérifie tous les lecteurs et envoie une alerte e-mail chaque fois qu'ils passent en dessous d'un quota défini par l'utilisateur. Vous pouvez l'obtenir à partir de ce post sur mon blog.

Amusement PowerShell

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

Je viens de trouver la commande Get-Volume , qui retourne SizeRemaining, donc quelque chose comme (Get-Volume -DriveLetter C).SizeRemaining / (1e+9)peut être utilisé pour voir resté Gb pour le disque C. Semble fonctionner plus rapidement que Get-WmiObject Win32_LogicalDisk.