Cómo obtener capacidad de disco y espacio libre en la computadora remota

Tengo este de una sola línea:

get-WmiObject win32_logicaldisk -Computername remotecomputer

y la salida es esta:

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   :

¿Cómo llego Freespacey Sizede DeviceID C:? Necesito extraer solo estos dos valores sin otra información. Lo he probado con Selectcmdlet, pero sin ningún efecto.

Editar: necesito extraer solo los valores numéricos y almacenarlos en variables.

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

$disk.Size
$disk.FreeSpace

Para extraer solo los valores y asignarlos a una variable:

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

Solución mucho más simple:

Get-PSDrive C | Select-Object Used,Free

y para computadoras remotas (necesidades Powershell Remoting)

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

Solo un comando simple, dulce y limpio, pero esto solo funciona para discos locales

Get-PSDrive

Aún puede usar este comando en un servidor remoto haciendo Enter-PSSession -Computername ServerName y luego ejecutar Get-PSDrive, extraerá los datos como si los hubiera ejecutado desde el servidor.

Creé una función avanzada de PowerShell (cmdlet de script) hace un tiempo que le permite consultar varias computadoras.

El código de la función tiene un poco más de 100 líneas, por lo que puede encontrarlo aquí: Versión de PowerShell del comando df

Consulte la sección Uso para ver ejemplos. El siguiente ejemplo de uso consulta un conjunto de computadoras remotas (entrada de la canalización de PowerShell) y muestra la salida en un formato de tabla con valores numéricos en forma legible por humanos:

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

Hay dos problemas que encontré con las otras sugerencias

1) Las asignaciones de unidades no son compatibles si ejecuta PowerShell en el programador de tareas

2) Puede obtener errores de acceso denegado errores al intentar usar "get-WmiObject" en computadoras remotas (dependiendo de la configuración de su infraestructura, por supuesto)

La alternativa que no sufre estos problemas es utilizar GetDiskFreeSpaceEx con una ruta 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
    } 
}

Otra forma es lanzar una cadena a un objeto WMI:

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

También puede dividir los resultados por 1 GB o 1 MB si desea diferentes unidades:

$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 salida es: Remotecomputer C: has 252.7 GB free of 298.0 GB Total

Línea de 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

Salida:

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

línea de comando:

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

fuera:

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

línea de comando:

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

fuera:

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> 

Conozco las herramientas psExec que puede descargar desde aquí

Viene un psinfo.exe del paquete de herramientas. El uso básico es de la siguiente manera en powershell / cmd.

Sin embargo, podrías tener muchas opciones con él.

Uso: psinfo [[\ computadora [, computadora [, ..] | @file [-u usuario [-p psswd]]] [-h] [-s] [-d] [-c [-t delimitador]] [filtro]

\ computadora Ejecute el comando en la computadora remota o las computadoras especificadas. Si omite el nombre de la computadora, el comando se ejecuta en el sistema local, y si especifica un comodín (\ *), el comando se ejecuta en todas las computadoras del dominio actual.

@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 solo mostrará los datos del campo que coincida con el filtro. por ejemplo, "servicio psinfo" enumera solo el campo del paquete de servicio.

Entro de forma remota en la computadora usando Enter-PSsession pcName y luego escribo Get-PSDrive

Eso enumerará todas las unidades y el espacio utilizado y restante. Si necesita ver toda la información formateada, envíelo a FL de esta manera: Get-PSdrive | FL *

Creé esta sencilla función para ayudarme. Esto hace que mis llamadas sean mucho más fáciles de leer que tener en línea un Get-WmiObject , declaraciones 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

En caso de que desee verificar varias letras de unidad y / o filtrar entre unidades locales y de red, puede usar PowerShell para aprovechar la clase WMI Win32_LogicalDisk . Aquí tienes un ejemplo rápido:

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

Utilicé la técnica anterior para crear un script de Powershell que verifica todas las unidades y envía una alerta por correo electrónico cada vez que están por debajo de una cuota definida por el usuario. Puede obtenerlo de esta publicación en mi blog.

Diversión de PowerShell

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

Acabo de encontrar el comando Get-Volume , que regresa SizeRemaining, por lo que (Get-Volume -DriveLetter C).SizeRemaining / (1e+9)se puede usar algo como para ver que quedan Gb para el disco C. Parece que funciona más rápido que Get-WmiObject Win32_LogicalDisk.