Umfassender Guide zur Überwachung vom gemeinsam genutzten Hyper V-Speicherplatz mit PowerShell

Eine effektive Verwaltung des Speicherplatzes ist ein entscheidender Aspekt für die Aufrechterhaltung einer effizienten und zuverlässigen IT-Infrastruktur. Dabei sollten IT-Mitarbeiter:innen auch auf die Überwachung vom gemeinsam genutzten Hyper V-Speicherplatz Acht geben. Ein leistungsstarkes Tool für IT-Experten ist PowerShell, ein Framework zur Aufgabenautomatisierung von Microsoft. Heute werden wir uns mit einem PowerShell-Skript befassen, das zur Überwachung des freien Speicherplatzes auf gemeinsam genutzten Volumen in einer Hyper-V-Clusterumgebung entwickelt wurde. Dieses Skript ist besonders wertvoll für IT-Experten und Managed Service Provider (MSPs), die einen reibungslosen Betrieb ihrer Systeme sicherstellen und Ausfallzeiten aufgrund von Speicherproblemen vermeiden müssen.

Kontext

Die Überwachung des Speicherplatzes ist von entscheidender Bedeutung, wenn man unerwarteten Ausfällen vorbeugen und dafür sorgen will, dass Anwendungen und Dienste ohne Unterbrechung laufen. Gemeinsame Volumen in einem Hyper-V-Cluster können zahlreiche virtuelle Maschinen beherbergen, und wenn der Speicherplatz knapp wird, kann das schwerwiegende Folgen haben. Dieses PowerShell-Skript vereinfacht den Überwachungsprozess und ermöglicht es Administratoren, den freien Speicherplatz im Auge zu behalten und Maßnahmen zu ergreifen, bevor Probleme auftreten.

Das Skript zur Überwachung vom gemeinsam genutzten Hyper V-Speicherplatz:

Requires -Version 5.1

<#
.SYNOPSIS
    Hyper-V Monitor shared volume disk free space. Must be ran as a Local or Domain Admin user.
.DESCRIPTION
    Hyper-V Monitor shared volume disk free space. Must be ran as a Local or Domain Admin user.

.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
Name                       Path                  Size(GB) FreeSpace(GB) UsedSpace(GB) PercentFree
----                       ----                  -------- ------------- ------------- -----------
Cluster Virtual Disk (vd1) C:\ClusterStorage\vd1 3,068.98 168.77        2900.21       9.99

PARAMETER: -MinimumPercentage 20
    Only errors when any shared volume disk is below the specified percentage.
    Defaults to 10 percent.
.EXAMPLE
    -MinimumPercentage 20
    ## EXAMPLE OUTPUT WITH MinimumPercentage ##
Name                       Path                  Size(GB) FreeSpace(GB) UsedSpace(GB) PercentFree
----                       ----                  -------- ------------- ------------- -----------
Cluster Virtual Disk (vd1) C:\ClusterStorage\vd1 3,068.98 168.77        2900.21       9.99

PARAMETER: -MinimumFreeBytes 1073741824
    Only errors when any shared volume disk is below the specified percentage.
    Defaults to 1GB or 1073741824 bytes.
.EXAMPLE
    -MinimumFreeBytes 1073741824
    ## EXAMPLE OUTPUT WITH MinimumFreeBytes ##
Name                       Path                  Size(GB) FreeSpace(GB) UsedSpace(GB) PercentFree
----                       ----                  -------- ------------- ------------- -----------
Cluster Virtual Disk (vd1) C:\ClusterStorage\vd1 3,068.98 168.77        2900.21       9.99

PARAMETER: -ExcludeDrivesByName MyDisk
    Excludes drives that contains the text MyDisk in its name.
.EXAMPLE
    -ExcludeDrivesByName 1073741824
    ## EXAMPLE OUTPUT WITH ExcludeDrivesByName ##
Name                       Path                  Size(GB) FreeSpace(GB) UsedSpace(GB) PercentFree
----                       ----                  -------- ------------- ------------- -----------
Cluster Virtual Disk (vd1) C:\ClusterStorage\vd1 3,068.98 168.77        2900.21       9.99

PARAMETER: -ExcludeDrivesByPath C:\ClusterStorage\MyDisk
    Excludes drives that contains the text MyDisk in its name.
.EXAMPLE
    -ExcludeDrivesByPath C:\ClusterStorage\MyDisk
.EXAMPLE
    -ExcludeDrivesByPath MyDisk
    ## EXAMPLE OUTPUT WITH ExcludeDrivesByPath ##
Name                       Path                  Size(GB) FreeSpace(GB) UsedSpace(GB) PercentFree
----                       ----                  -------- ------------- ------------- -----------
Cluster Virtual Disk (vd1) C:\ClusterStorage\vd1 3,068.98 168.77        2900.21       9.99

PARAMETER: -CustomFieldParam "ReplaceMeWithAnyMultilineCustomField"
    Saves the results to a multi-line string custom field.
.EXAMPLE
    -CustomFieldParam "ReplaceMeWithAnyMultilineCustomField"
    ## EXAMPLE OUTPUT WITH CustomFieldParam ##
Name                       Path                  Size(GB) FreeSpace(GB) UsedSpace(GB) PercentFree
----                       ----                  -------- ------------- ------------- -----------
Cluster Virtual Disk (vd1) C:\ClusterStorage\vd1 3,068.98 168.77        2900.21       9.99
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows Server 2016
    Release Notes: Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#>

[CmdletBinding()]
param (
    [int]$MinimumPercentage = 10,
    $MinimumFreeBytes = 1GB,
    [String]$ExcludeDrivesByName,
    [String]$ExcludeDrivesByPath,
    [string]$CustomFieldParam
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }
    function Test-IsSystem {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        return $id.Name -like "NT AUTHORITY*" -or $id.IsSystem
    }
    function Get-FriendlySize {
        param($Bytes)
        # Converts Bytes to the highest matching unit
        $Sizes = 'Bytes,KB,MB,GB,TB,PB,EB,ZB' -split ','
        for ($i = 0; ($Bytes -ge 1kb) -and ($i -lt $Sizes.Count); $i++) { $Bytes /= 1kb }
        $N = 2
        if ($i -eq 0) { $N = 0 }
        if ($Bytes) { "$([System.Math]::Round($Bytes,$N)) $($Sizes[$i])" }else { "0 B" }
    }
    function Get-Size {
        param (
            [string]$String,
            [ValidateSet("PB", "TB", "GB", "MB", "KB", "B", "Bytes")][string]$DefaultSize = "GB"
        )
        switch -wildcard ($String) {
            '*PB' { [int64]$($String -replace '[^\d+]+') * 1PB; break }
            '*TB' { [int64]$($String -replace '[^\d+]+') * 1TB; break }
            '*GB' { [int64]$($String -replace '[^\d+]+') * 1GB; break }
            '*MB' { [int64]$($String -replace '[^\d+]+') * 1MB; break }
            '*KB' { [int64]$($String -replace '[^\d+]+') * 1KB; break }
            '*B' { [int64]$($String -replace '[^\d+]+') * 1; break }
            '*Bytes' { [int64]$($String -replace '[^\d+]+') * 1; break }
            Default { Get-Size -String "$String $DefaultSize" }
        }
    }
    function Invoke-FilterDisks {
        [CmdletBinding()]
        param(
            [parameter(ValueFromPipeline = $true)]
            $Disks
        )
        process {
            $Disks | ForEach-Object {
                # Check if exclude by name is needed
                if ($([string]::IsNullOrEmpty($ExcludeDrivesByName) -or [string]::IsNullOrWhiteSpace($ExcludeDrivesByName))) {
                    $_
                }
                else {
                    if (
                        $_.Name -like "*$ExcludeDrivesByName*"
                    ) {
                        # Output Nothing
                    }
                    else {
                        $_
                    }
                }
            } | ForEach-Object {
                # Check if exclude by name is needed
                if ($([string]::IsNullOrEmpty($ExcludeDrivesByPath) -or [string]::IsNullOrWhiteSpace($ExcludeDrivesByPath))) {
                    $_
                }
                else {
                    if (
                        $_.Path -like "*$ExcludeDrivesByPath*"
                    ) {
                        # Output Nothing
                    }
                    else {
                        $_
                    }
                }
            }
        }
    }
    if ($env:MinimumPercentage) {
        $MinimumPercentage = $env:MinimumPercentage
    }
    if ($env:minimumFreeSpace) {
        $MinimumFreeBytes = Get-Size -String $env:minimumFreeSpace
    }
    if ($env:ExcludeDrivesByName) {
        $ExcludeDrivesByName = $env:ExcludeDrivesByName
    }
    if ($env:ExcludeDrivesByPath) {
        $ExcludeDrivesByPath = $env:ExcludeDrivesByPath
    }
    if ($env:CustomFieldParam) {
        $CustomFieldParam = $env:CustomFieldParam
    }
}
process {
    if (Test-IsSystem) {
        Write-Error -Message "Access Denied. Please run with a Domain Account or a Local Account that has permissions to access this node."
        exit 1
    }

    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    Import-Module FailoverClusters -ErrorAction SilentlyContinue

    if (-not $(Get-Command -Name "Get-Cluster" -ErrorAction SilentlyContinue)) {
        Write-Error "[Error] Must run this script on a server that is apart of a Cluster or can communicate with a Cluster."
        exit 1
    }

    try {
        Get-ClusterNode -ErrorAction Stop | Out-Null
    }
    catch {
        Write-Error "[Error] Failed to get Cluster Nodes."
        exit 1
    }

    # Get Cluster Shared Volume Info
    $Volumes = foreach ( $csv in $(Get-ClusterSharedVolume) ) {
        foreach ( $csvinfo in $($csv | Select-Object -Property Name -ExpandProperty SharedVolumeInfo) ) {
            [PSCustomObject]@{
                Name        = $csv.Name
                Path        = $csvinfo.FriendlyVolumeName
                Size        = $csvinfo.Partition.Size
                FreeSpace   = $csvinfo.Partition.FreeSpace
                UsedSpace   = $csvinfo.Partition.UsedSpace
                PercentFree = $csvinfo.Partition.PercentFree
            }
        }
    }

    # Prep Format-Table substitutions
    $Size = @{ Label = "Size(GB)" ; Expression = { (Get-FriendlySize -Bytes $_.Size) } }
    $FreeSpace = @{ Label = "FreeSpace(GB)" ; Expression = { (Get-FriendlySize -Bytes $_.FreeSpace) } }
    $UsedSpace = @{ Label = "UsedSpace(GB)" ; Expression = { (Get-FriendlySize -Bytes $_.UsedSpace) } }
    $PercentFree = @{ Label = "PercentFree" ; Expression = { ($_.PercentFree) } }
    # Sort disks by FreeSpace
    $Disks = $Volumes | Sort-Object FreeSpace
    # Save results as a string
    $DisksFormattedString = $Disks | Format-Table -AutoSize Name, Path, $Size, $FreeSpace, $UsedSpace, $PercentFree | Out-String

    # If using a custom field sent that to the specified custom field, should be a multi-line
    if ($CustomFieldParam) {
        Ninja-Property-Set -Name $CustomFieldParam -Value $DisksFormattedString
    }

    # Loop through each disk
    $DiskUnderPercentage = $Disks | Invoke-FilterDisks | Where-Object { $_.PercentFree -lt $MinimumPercentage }
    $DiskUnderFreeBytes = $Disks | Invoke-FilterDisks | Where-Object { $_.FreeSpace -lt $MinimumFreeBytes }

    if ($DiskUnderPercentage -or $DiskUnderFreeBytes) {
        if ($DiskUnderPercentage) {
            Write-Host "[Issue] One or more Disks under $MinimumPercentage % free!"
        }
        if ($DiskUnderFreeBytes) {
            Write-Host "[Issue] One or more Disks under $(Get-FriendlySize -Bytes $MinimumFreeBytes) free!"
        }
        $DisksFormattedString | Write-Host
        exit 1
    }

    # List all shared volumes
    if (-not $DiskUnderPercentage) {
        Write-Host "[Info] One or more Disks over $MinimumPercentage % free."
    }
    if (-not $DiskUnderFreeBytes) {
        Write-Host "[Info] One or more Disks over $(Get-FriendlySize -Bytes $MinimumFreeBytes) free."
    }
    $DisksFormattedString | Write-Host
    exit 0
}
end {
    
    
    
}

 

Detailansicht

Lassen Sie uns das Skript Schritt für Schritt aufschlüsseln, um seine Funktionen zu verstehen und zu erfahren, wie es effektiv eingesetzt werden kann.

1. Voraussetzungen und Ersteinrichtung Das Skript erfordert PowerShell Version 5.1 und muss mit Administratorrechten ausgeführt werden. Sie beginnt mit der Definition verschiedener Parameter wie ‚MinimumPercentage‘, ‚MinimumFreeBytes‘, ‚ExcludeDrivesByName‘, ‚ExcludeDrivesByPath‘ und ‚CustomFieldParam‘.

2. Funktionen für Privilegienüberprüfungen und Größenberechnungen

• ‚Test-IsElevated‘ prüft, ob das Skript mit Administratorrechten ausgeführt wird.

• ‚Test-IsSystem‘ stellt sicher, dass das Skript nicht unter einem Systemkonto ausgeführt wird.

• ‚Get-FriendlySize‘ und ‚Get-Size‘ konvertieren Byte-Werte in besser lesbare Einheiten wie Kilo-, Mega-, Gigabytes, usw.

3. Filterung und Umgebungsvariablen Das Skript richtet Funktionen zum Herausfiltern von Laufwerken auf der Grundlage von angegebenen Namen oder Pfaden ein. Es prüft auch, ob Umgebungsvariablen vorhanden sind, die die Parameter des Skripts überschreiben könnten.

4. Abruf von Cluster- und Volumen-Informationen Das Skript importiert das Modul ‚FailoverClusters‘ und überprüft, ob es auf einem Server ausgeführt wird, der Teil eines Clusters ist. Anschließend werden Informationen über die gemeinsam genutzten Volumen im Cluster abgerufen, einschließlich Größe, freien und belegten Speicherplatzes und Prozentsatzes des freien Speicherplatzes.

5. Formatierung und Ausgabe Das Skript formatiert die Festplatteninformationen so, dass sie lesbar sind, und prüft, ob Volumen unter den angegebenen Schwellenwerten für freien Speicherplatz liegen. Werden Probleme festgestellt, gibt es die Details aus und beendet sich mit einem Fehlerstatus. Andernfalls wird bestätigt, dass alle Volumen über ausreichend freien Speicherplatz verfügen.

Potenzielle Anwendungsfälle

Stellen Sie sich einen IT-Administrator vor, der für einen Hyper-V-Cluster verantwortlich ist, der wichtige virtuelle Maschinen hostet. Der Administrator kann das Skript verwenden, um die Überwachung des Speicherplatzes zu automatisieren und sicherzustellen, dass er benachrichtigt wird, bevor der Speicherplatz auf einem Volumen kritisch knapp wird. Dieser proaktive Ansatz ermöglicht es ihm, zusätzlichen Speicherplatz zuzuweisen oder überflüssige Dateien zu bereinigen, um mögliche Ausfälle zu verhindern und die Systemleistung aufrechtzuerhalten.

Vergleiche

Im Vergleich zur manuellen Überwachung oder der Verwendung einfacher integrierter Tools bietet dieses Skript eine automatisierte und detailliertere Herangehensweise. Es prüft nicht nur, ob freier Speicherplatz vorhanden ist, sondern ermöglicht auch die Anpassung auf der Grundlage von Volumen-Namen, Pfaden und spezifischen Anforderungen an den freien Speicherplatz. Andere Methoden, wie z. B. Überwachungs-Tools von Drittanbietern, können ähnliche Funktionen bieten, sind aber oft mit höheren Kosten verbunden und erfordern eine zusätzliche Einrichtung.

FAQs

F: Kann dieses Skript auf jeder Version von Windows Server ausgeführt werden?

A: Das Skript unterstützt Windows Server 2016 und höhere Versionen aufgrund der Anforderungen des Moduls ‚FailoverCluster‘.

F: Welche Berechtigungen sind für die Ausführung dieses Skripts erforderlich?

A: Das Skript muss als lokaler oder Domain-Administrator ausgeführt werden, um auf die erforderlichen Cluster-Informationen zugreifen zu können.

F: Wie kann ich bestimmte Volumen von der Überwachung ausschließen?

A: Sie können die Parameter ‚ExcludeDrivesByName‘ oder ‚ExcludeDrivesByPath‘ verwenden, um bestimmte Volumen auf der Grundlage ihrer Namen oder Pfade herauszufiltern.

Folgen

Die Ergebnisse dieses Skripts können erhebliche Auswirkungen auf den IT-Betrieb haben. Durch die Identifizierung von Volumen mit unzureichendem freien Speicherplatz können Administrator:innen vorbeugende Maßnahmen ergreifen, um Dienstunterbrechungen zu vermeiden. Diese proaktive Überwachung verbessert auch die allgemeine Systemzuverlässigkeit und -leistung und trägt so zu einer stabileren IT-Umgebung bei.

Empfehlungen

Beachten Sie bei der Verwendung dieses Skripts die folgenden Best Practices:

• Planen Sie das Skript so, dass es in regelmäßigen Abständen mit dem Taskplaner oder ähnlichen Tools ausgeführt wird.

• Passen Sie die Parameter basierend auf den spezifischen Anforderungen Ihrer Umgebung an.

• Vergewissern Sie sich, dass Sie über die notwendigen Berechtigungen verfügen und das Skript auf den entsprechenden Servern ausführen.

Abschließende Überlegungen

PowerShell-Skripte wie dieses sind für IT-Experten und MSPs von unschätzbarem Wert und bieten leistungsstarke Automatisierungsfunktionen für die Verwaltung und Überwachung wichtiger Systeme. Durch die Integration solcher Skripte in ihre Arbeitsabläufe können Administrator:innen eine bessere Kontrolle über ihre Infrastruktur behalten, eine optimale Leistung sicherstellen und potenzielle Probleme verhindern, bevor sie eskalieren.

NinjaOne, eine führende IT-Betriebssoftware, kann diesen Prozess weiter rationalisieren, indem es die Skriptausführung mit seinen Überwachungs- und Verwaltungsfunktionen integriert und so eine umfassende Lösung für das IT-Infrastruktur-Management bietet.