Maximierung der Speichereffizienz: Analyse der Ordnergröße mit Powershell

Hauptmerkmale

• Das PowerShell-Skript berechnet und meldet effizient die Ordnergrößen in Windows-Umgebungen.
• Es ist anpassungsfähig und erlaubt es dem Benutzer, einen Pfad, eine Ordnertiefe und eine Mindestgröße anzugeben.
• Das Skript unterstützt eine Reihe von Größeneinheiten (KB, MB, GB usw.) zur Definition der Mindestgröße von Ordnern.
• Ideal für IT-Experten und MSPs, die einen schnellen Überblick über die Speicherplatznutzung benötigen.
• Enthält Funktionen für den Umgang mit Berechtigungsproblemen und liefert genauere Ergebnisse.
• Verwendet eine benutzerfreundliche Ausgabe, die Ordnerpfade und ihre entsprechenden Größen anzeigt.
• Nützlich in Szenarien wie Serverwartung, Speicheroptimierung und Datenbereinigung.
• Bietet eine eher skriptbasierte, anpassbare Alternative zu herkömmlichen Festplattenanalyse-Tools.

 

Eine effiziente Datenverwaltung ist ein Eckpfeiler des IT-Betriebs, bei dem Einblicke in die Datenverteilung und -speicherung eine entscheidende Rolle spielen. PowerShell ist mit seinen vielseitigen Skriptfunktionen ein mächtiges Werkzeug für IT-Experten. Ein Skript, das Ordnergrößen auflisten und messen kann, ist nicht nur praktisch, sondern eine Notwendigkeit für die Aufrechterhaltung einer optimalen Leistung und Speicherverwaltung in verschiedenen IT-Umgebungen.

Hintergrund

Das bereitgestellte PowerShell-Skript zielt auf ein wesentliches Bedürfnis im IT-Sektor ab: das Verständnis und die Verwaltung von Ordnergrößen innerhalb eines Systems. Für IT-Fachleute und Managed Service Provider (MSPs) ist dies mehr als nur eine Frage der Haushaltsführung. In einer Zeit, in der Daten exponentiell wachsen, kann ein Überblick darüber, welche Ordner den meisten Speicherplatz verbrauchen, zu fundierteren Entscheidungen über Ressourcenzuweisung, Systemoptimierung und Datenverwaltungsrichtlinien führen. Dieses Skript geht speziell auf diese Bedürfnisse ein, indem es eine detaillierte Analyse der Ordnergrößen ermöglicht.

Das Skript:

#Requires -Version 5.1

<#
.SYNOPSIS
    Get a tree list of folder sizes for a given path with folders that meet a minimum folder size.
.DESCRIPTION
    Get a tree list of folder sizes for a given path with folders that meet a minimum folder size.
    Be default this looks at C:, with a folder depth of 3, and filters out any folder under 500 MB.
.EXAMPLE
    (No Parameters)
    Gets folder sizes under C: for a depth of 3 folders and displays folder larger than 500 MB.
.EXAMPLE
    -Path C:
    -Path C: -MinSize 1GB
    -Path C:Users -Depth 4

PARAMETER: -Path C:
    Gets folder sizes under C:.

PARAMETER: -Path C: -MinSize 1GB
    Gets folder sizes under C:, but only returns folder larger than 1 GB.
    Don't use quotes around 1GB as PowerShell won't be able to expand it to 1073741824.

PARAMETER: -Path C:Users -Depth 4
    Gets folder sizes under C:Users with a depth of 4.

.OUTPUTS
    String[] or PSCustomObject[]
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Renamed script and added Script Variable support
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 (
    [String]$Path = "C:",
    [int]$Depth = 3,
    $MinSize = 500MB
)

begin {
    function Get-Size {
        param ([string]$String)
        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 { [int64]$($String -replace '[^d+]+') * 1 }
        }
    }

    $Path = if ($env:rootPath) { Get-Item -Path $env:rootPath }else { Get-Item -Path $Path }
    if ($env:Depth) { $Depth = [System.Convert]::ToInt32($env:Depth) }
    $MinSize = if ($env:MinSize) { Get-Size $env:MinSize }else { Get-Size $MinSize }

    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
    }

    if (!(Test-IsElevated) -and !(Test-IsSystem)) {
        Write-Host "[Warning] Not running as SYSTEM account, results might be slightly inaccurate."
    }
    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) { "{0:N$($N)} {1}" -f $Bytes, $Sizes[$i] }else { "0 B" }
    }
    function Get-SizeInfo {
        param(
            [parameter(mandatory = $true, position = 0)][string]$TargetFolder,
            #defines the depth to which individual folder data is provided
            [parameter(mandatory = $true, position = 1)][int]$DepthLimit
        )
        $obj = New-Object PSObject -Property @{Name = $targetFolder; Size = 0; Subs = @() }
        # Are we at the depth limit? Then just do a recursive Get-ChildItem
        if ($DepthLimit -eq 1) {
            $obj.Size = (Get-ChildItem $targetFolder -Recurse -Force -File -ErrorAction SilentlyContinue | Measure-Object -Sum -Property Length).Sum
            return $obj
        }
        # We are not at the depth limit, keep recursing
        $obj.Subs = foreach ($S in Get-ChildItem $targetFolder -Force -ErrorAction SilentlyContinue) {
            if ($S.PSIsContainer) {
                $tmp = Get-SizeInfo $S.FullName ($DepthLimit - 1)
                $obj.Size += $tmp.Size
                Write-Output $tmp
            }
            else {
                $obj.Size += $S.length
            }
        }
        return $obj
    }
    function Write-Results {
        param(
            [parameter(mandatory = $true, position = 0)]$Data,
            [parameter(mandatory = $true, position = 1)][int]$IndentDepth,
            [parameter(mandatory = $true, position = 2)][int]$MinSize
        )
    
        [PSCustomObject]@{
            Path     = "$((' ' * ($IndentDepth + 2)) + $Data.Name)"
            Size     = Get-FriendlySize -Bytes $Data.Size
            IsLarger = $Data.Size -ge $MinSize
        }

        foreach ($S in $Data.Subs) {
            Write-Results $S ($IndentDepth + 1) $MinSize
        }
    }
    function Get-SubFolderSize {
        [CmdletBinding()]
        param(
            [parameter(mandatory = $true, position = 0)]
            [string]$targetFolder,
    
            [int]$DepthLimit = 3,
            [int]$MinSize = 500MB
        )
        if (-not (Test-Path $targetFolder)) {
            Write-Error "The target [$targetFolder] does not exist"
            exit
        }
        $Data = Get-SizeInfo $targetFolder $DepthLimit
    
        #returning $data will provide a useful PS object rather than plain text
        # return $Data
    
        #generate a human friendly listing
        Write-Results $Data 0 $MinSize
    }
}
process {
    Get-SubFolderSize -TargetFolder $Path -DepthLimit $Depth -MinSize $MinSize | Where-Object { $_.IsLarger } | Select-Object -Property Path, Size
}
end {
    
    
    
}

 

Detailansicht

Das Skript funktioniert wie folgt:

• Initialisierung der Parameter: Es beginnt mit der Definition von Parametern wie Path, Depth und MinSize. Mit diesen Parametern können die Benutzer das Suchverzeichnis, die Tiefe des zu analysierenden Verzeichnisbaums und die Mindestgröße der zu meldenden Ordner angeben.
• Funktion zur Größenumwandlung (Get-Size): Diese Funktion wandelt verschiedene Größeneinheiten (KB, MB, GB usw.) in Bytes um und gewährleistet so eine einheitliche Größenmessung.
• Überprüfung der Umgebungsvariablen: Das Skript prüft die Umgebungsvariablen und passt sich ihnen an, wenn sie gesetzt sind, und ermöglicht so dynamische Konfigurationen für Pfad, Tiefe und Größe.
• Überprüfen von Berechtigungen und Systemkonten: Es prüft, ob das Skript mit erhöhten Rechten oder unter einem Systemkonto ausgeführt wird, was für den Zugriff auf bestimmte Verzeichnisse und die Gewährleistung der Genauigkeit entscheidend ist.
• Berechnung der Ordnergröße (Get-SizeInfo): Diese rekursive Funktion durchläuft die Ordnerhierarchie und sammelt die Größe von Dateien und Ordnern bis zur angegebenen Tiefe.
• Ergebnisformatierung (Write-Results): Die gesammelten Daten werden dann in eine lesbare Struktur formatiert, die den Pfad und die Größe von Ordnern anzeigt, die die angegebene Mindestgröße überschreiten.
• Ausführung (Get-SubFolderSize): Die Kernfunktion, die alle Komponenten miteinander verbindet und die Größenberechnung und Ergebnisformatierung durchführt.
• Output: Schließlich gibt das Skript die Daten aus, wobei es sich auf Ordner konzentriert, die größer sind als die vom Benutzer festgelegte Mindestgröße.

Potenzielle Anwendungsfälle

Stellen Sie sich vor, ein IT-Administrator in einem Unternehmen stellt fest, dass der Serverspeicher knapp wird. Mit diesem Skript können sie schnell große Ordner identifizieren, insbesondere solche, die unerwartet gewachsen sind. Diese Analyse könnte redundante Daten, ungewöhnlich große Protokolldateien oder Bereiche aufdecken, in denen durch die Archivierung erheblicher Speicherplatz freigesetzt werden könnte.

Vergleiche

Zu den alternativen Methoden gehören die Verwendung von Drittanwendungen oder manuelle Prüfungen. Tools von Drittanbietern können benutzerfreundlicher sein, bieten aber möglicherweise nicht das gleiche Maß an Anpassungsmöglichkeiten. Manuelle Kontrollen sind zwar einfach, aber zeitaufwändig und bei großen Systemen unpraktisch.

FAQs

• F: Kann dieses Skript Netzlaufwerke analysieren?
  A: Ja, vorausgesetzt, der Benutzer verfügt über die erforderlichen Berechtigungen und das Laufwerk ist zugänglich.
• F: Benötigt das Skript Administratorrechte?
  A: Es ist zwar nicht immer notwendig, das Skript als Administrator auszuführen, aber es gewährleistet umfassenden Zugriff auf alle Ordner.
• F: Wie kann ich die Mindestgröße des Ordners ändern?
  A: Ändern Sie den Parameter MinSize auf den von Ihnen gewünschten Schwellenwert.

Neben der Speicherverwaltung kann die Ausgabe des Skripts auch Auswirkungen auf die IT-Sicherheit haben. Große, unerwartete Dateien könnten ein Anzeichen für Sicherheitsverletzungen sein, wie z. B. Daten-Dumps. Eine regelmäßige Überwachung mit Hilfe solcher Skripte kann Teil einer proaktiven Sicherheitsstrategie sein.

Empfehlungen

• Führen Sie das Skript regelmäßig für eine proaktive Speicherverwaltung aus.
• Kombinieren Sie die Ausgabe des Skripts mit anderen Systemüberwachungsprogrammen, um einen umfassenden Einblick zu erhalten.
• Seien Sie vorsichtig mit der Systembelastung, wenn Sie dieses Skript auf Servern mit umfangreichen Verzeichnissen ausführen.

Abschließende Überlegungen

Im Zusammenhang mit datengesteuerten Lösungen wie NinjaOne ergänzen PowerShell-Skripte wie diese umfassendere IT-Managementstrategien. Durch die Automatisierung und Vereinfachung komplexer Aufgaben, wie z. B. der Analyse von Ordnergrößen, können sich IT-Experten auf strategischere Initiativen konzentrieren und sicherstellen, dass die Systeme nicht nur betriebsbereit, sondern auch optimiert und sicher sind. Mit den Integrationsmöglichkeiten von NinjaOne können Skripte wie dieses Teil eines umfassenderen Toolkits für effizientes IT-Management sein.