Utilizzare PowerShell per analizzare le dimensioni delle cartelle: massimizzare l’efficienza dello spazio di archiviazione

Punti chiave

• Lo script PowerShell calcola e riporta in modo efficiente le dimensioni delle cartelle in ambienti Windows.
• È adattabile, e permette agli utenti di specificare un percorso, la profondità della cartella e la soglia di dimensione minima.
• Lo script per analizzare le dimensioni delle cartelle supporta una serie di unità di dimensione (KB, MB, GB, ecc.) per definire la dimensione minima delle cartelle.
• Lo script per analizzare le dimensioni delle cartelle è ideale per i professionisti IT e gli MSP che necessitano di una rapida panoramica dell’utilizzo dello spazio su disco.
• Include funzioni per gestire i problemi di autorizzazione e fornire risultati più accurati.
• Utilizza un output di facile utilizzo, visualizzando i percorsi delle cartelle e le loro dimensioni corrispondenti.
• Lo script per analizzare le dimensioni delle cartelle è utile in scenari quali la manutenzione dei server, l’ottimizzazione dello storage e la pulizia dei dati.
• Offre un’alternativa personalizzabile e basata su script ai tradizionali strumenti di analisi del disco.

 

Una gestione efficiente dei dati è un aspetto fondamentale delle operazioni IT, dove le informazioni sulla distribuzione e l’archiviazione dei dati svolgono un ruolo cruciale. PowerShell, con le sue versatili capacità di scripting, è uno strumento potente per i professionisti IT. Uno script in grado di elencare e misurare le dimensioni delle cartelle non è solo una questione di comodità, ma una necessità per mantenere prestazioni e gestione dello storage ottimali in vari ambienti IT.

Background

Lo script PowerShell per analizzare le dimensioni delle cartelle risponde a un’esigenza essenziale del settore IT: la comprensione e la gestione delle dimensioni delle cartelle all’interno di un sistema. Per i professionisti IT e i fornitori di servizi gestiti (MSP), si tratta di qualcosa di più di un’operazione di routine. In un’epoca in cui la quantità di dati cresce in modo esponenziale, tenere sotto controllo le cartelle che consumano più spazio può portare a decisioni più consapevoli sull’allocazione delle risorse, sull’ottimizzazione del sistema e sui criteri di gestione dei dati. Questo script per analizzare le dimensioni delle cartelle risponde in modo specifico a queste esigenze, consentendo un’analisi dettagliata delle dimensioni delle cartelle.

Lo script per analizzare le dimensioni delle cartelle:

#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 {
    
    
    
}

 

Analisi dettagliata

Lo script per analizzare le dimensioni delle cartelle funziona come segue:

• Inizializzazione dei parametri: Lo script per analizzare le dimensioni delle cartelle inizia definendo parametri come Path, Depth e MinSize. Questi parametri consentono di specificare la directory di ricerca, la profondità dell’albero delle directory da analizzare e la dimensione minima delle cartelle da segnalare.
• Funzione di conversione delle dimensioni (Get-Size): Questa funzione converte le diverse unità di misura (KB, MB, GB, ecc.) in byte, garantendo l’uniformità della misurazione delle dimensioni.
• Controllo delle variabili d’ambiente: Lo script per analizzare le dimensioni delle cartelle controlla e si adatta alle variabili ambientali, se impostate, consentendo configurazioni dinamiche di percorso, profondità e dimensione.
• Verifica degli account di sistema e di quelli con privilegi elevati: Esamina se lo script per analizzare le dimensioni delle cartelle viene eseguito con privilegi elevati o con un account di sistema, fondamentale per accedere a determinate directory e garantire la precisione.
• Calcolo delle dimensioni della cartella (Get-SizeInfo): Questa funzione ricorsiva attraversa la gerarchia delle cartelle, sommando le dimensioni dei file e delle cartelle fino alla profondità specificata.
• Formattazione dei risultati (Write-Results): I dati raccolti vengono quindi formattati in una struttura leggibile, mostrando il percorso e le dimensioni delle cartelle che superano la dimensione minima specificata.
• Esecuzione (Get-SubFolderSize): La funzione principale che collega tutti i componenti e che esegue il calcolo delle dimensioni e la formattazione dei risultati.
• Output: Infine, lo script per analizzare le dimensioni delle cartelle produce i dati, concentrandosi sulle cartelle più grandi della dimensione minima impostata dall’utente.

Casi d’uso potenziali

Immagina che l’amministratore IT di un’azienda si accorga che lo spazio di archiviazione dei server si sta esaurendo. Grazie a questo script per analizzare le dimensioni delle cartelle, può identificare rapidamente le cartelle di grandi dimensioni, in particolare quelle cresciute inaspettatamente. Questa analisi potrebbe rivelare dati ridondanti, file di log insolitamente grandi o aree in cui l’archiviazione potrebbe liberare spazio significativo.

Confronti

I metodi alternativi per analizzare le dimensioni delle cartelle includono l’utilizzo di strumenti di terze parti o controlli manuali. Gli strumenti di terze parti possono essere più semplici da usare, ma potrebbero non offrire lo stesso livello di personalizzazione. I controlli manuali, pur essendo semplici, sono lunghi e poco pratici per i sistemi di grandi dimensioni.

Domande frequenti

• D: Questo script per analizzare le dimensioni delle cartelle può analizzare le unità di rete?
  R: Sì, a condizione che l’utente disponga delle autorizzazioni necessarie e che l’unità sia accessibile.
• D: Lo script per analizzare le dimensioni delle cartelle richiede privilegi amministrativi?
  R: Sebbene non sia sempre necessario, l’esecuzione dello script come amministratore garantisce un accesso completo a tutte le cartelle.
• D: Come posso modificare la dimensione minima delle cartelle?
  R: Modificando il parametro MinSize con la soglia desiderata.

Oltre alla gestione dello storage, il risultato dello script può avere implicazioni positive per la sicurezza informatica. File grandi e inaspettati potrebbero essere un segno di violazioni della sicurezza, come i data dump. Un monitoraggio regolare tramite script come questo può essere parte di una strategia di sicurezza proattiva.

Raccomandazioni

• Esegui regolarmente lo script per una gestione proattiva dello storage.
• Combina l’output dello script con altri strumenti di monitoraggio del sistema per ottenere informazioni complete.
• Fai attenzione al carico del sistema quando esegui questo script su server con directory estese.

Considerazioni finali

Nel contesto di soluzioni basate sui dati come NinjaOne, script PowerShell come questo integrano strategie di gestione IT più ampie. Automatizzando e semplificando attività complesse, come l’analisi delle dimensioni delle cartelle, i professionisti IT possono concentrarsi su questioni più strategiche, garantendo che i sistemi non siano solo operativi, ma anche ottimizzati e sicuri. Grazie alle capacità di integrazione di NinjaOne, script come questo possono far parte di un kit di strumenti più ampio per una gestione IT efficiente.