Optimiser l’efficacité du stockage : utilisation de PowerShell pour analyser et connaître la taille des dossiers

Principaux points à retenir

• Le script PowerShell calcule et communique la taille des dossiers dans les environnements Windows.
• Il est adaptable, permettant aux utilisateurs de spécifier un chemin d’accès, une profondeur de dossier et un seuil de taille minimum.
• Le script prend en charge une série d’unités de taille (Ko, Mo, Go, etc.) pour définir la taille minimale des dossiers.
• Idéal pour les professionnels de l’informatique et les entreprises MSP qui ont besoin d’un aperçu rapide de l’utilisation de l’espace disque.
• Il comprend des fonctions permettant de gérer les problèmes d’autorisation et de fournir des résultats plus précis.
• Utilise une sortie conviviale, affichant les chemins d’accès aux dossiers et leurs tailles respectives.
• Utile pour les tâches telles que la maintenance des serveurs, l’optimisation du stockage et le nettoyage des données.
• Offre une alternative plus personnalisée et basée sur des scripts aux outils traditionnels d’analyse de disque.

 

La gestion efficace des données est un pilier des opérations informatiques, où la connaissance de la distribution et du stockage des données joue un rôle crucial. PowerShell, avec ses capacités de script polyvalentes, est un outil très utile pour les professionnels de l’informatique. Un script capable de répertorier et de connaître la taille des dossiers n’est pas seulement une commodité, c’est une nécessité pour maintenir des performances optimales et gérer le stockage dans divers environnements informatiques.

Contexte

Le script PowerShell fourni répond à un besoin essentiel dans le secteur informatique : comprendre et gérer la taille des dossiers au sein d’un système. Pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP), il ne s’agit pas d’une simple question de gestion. En notre époque où les données augmentent de façon exponentielle, le fait de savoir quels dossiers consomment le plus d’espace permet de prendre des décisions plus éclairées en matière d’allocation des ressources, d’optimisation du système et de stratégies de gestion des données. Ce script répond exactement à ces besoins en permettant d’analyser et de connaître la taille des dossiers.

Le script :

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

 

Description détaillée

Le script fonctionne comme suit :

• Initialisation des paramètres : Il commence par définir des paramètres tels que Path, Depth et MinSize. Ces paramètres permettent aux utilisateurs de spécifier le répertoire de recherche, la profondeur de l’arborescence à analyser et la taille minimale du dossier à signaler.
• Fonction de conversion de taille (Get-Size) : Cette fonction convertit les différentes unités de taille (KB, MB, GB, etc.) en octets, ce qui garantit l’uniformité de la mesure de la taille.
• Contrôle des variables d’environnement : Le script vérifie et s’adapte aux variables environnementales, si elles sont définies, ce qui permet des configurations dynamiques en termes de chemin, de profondeur et de taille.
• Élévation et vérification des comptes du système : Il vérifie si le script s’exécute avec des privilèges élevés ou un compte système, ce qui est essentiel pour accéder à certains répertoires et garantir l’exactitude des données.
• Calcul de la taille du dossier (Get-SizeInfo) : Cette fonction récursive parcourt la hiérarchie des dossiers, en accumulant la taille des fichiers et des dossiers jusqu’à la profondeur spécifiée.
• Formatage des résultats (Write-Results) : Les données recueillies sont ensuite formatées en une structure lisible, indiquant le chemin d’accès et la taille des dossiers qui dépassent la taille minimale spécifiée.
• Exécution (Get-SubFolderSize) : La fonction centrale qui relie tous les composants entre eux, exécute le calcul de la taille et le formatage des résultats.
• Résultat : Enfin, le script génère les données, en se concentrant sur les dossiers dont la taille est supérieure à la taille minimale définie par l’utilisateur.

Cas d’utilisation potentiels

Imaginez qu’un administrateur informatique d’une entreprise constate que la capacité de stockage de son serveur diminue. Grâce à ce script, ils peuvent rapidement identifier les dossiers volumineux, en particulier ceux qui présentent une augmentation inattendue. Cette analyse peut révéler des données redondantes, des fichiers journaux anormalement volumineux ou des zones où l’archivage pourrait libérer un grand espace.

Comparaisons

Les méthodes alternatives comprennent l’utilisation d’outils tiers ou des vérifications manuelles. Les outils tiers peuvent être plus conviviaux, mais n’offrent pas toujours le même niveau de personnalisation. Les contrôles manuels, bien que simples, prennent beaucoup de temps et ne sont pas pratiques pour les grands systèmes.

FAQ

• Q : Ce script peut-il analyser les lecteurs réseau ?
  R : Oui, à condition que l’utilisateur dispose des autorisations nécessaires et que le disque soit accessible.
• Q : Le script nécessite-t-il des droits d’administrateur ?
  R : Bien que cela ne soit pas toujours nécessaire, l’exécution du script en tant qu’administrateur garantit un accès complet à tous les dossiers.
• Q : Comment puis-je modifier la taille minimale d’un dossier ?
  R : Modifiez le paramètre MinSize pour qu’il corresponde au seuil souhaité.

Au-delà de la gestion du stockage, le résultat du script peut avoir des implications pour la sécurité informatique. Des fichiers volumineux et inattendus peuvent être le signe de failles de sécurité, telles que des décharges de données. Une surveillance régulière à l’aide de ces scripts peut faire partie d’une stratégie de sécurité proactive.

Recommandations

• Exécutez régulièrement le script pour assurer une gestion proactive du stockage.
• Combinez les résultats du script avec d’autres outils de surveillance du système pour obtenir des informations complètes.
• Soyez prudent quant à la charge du système lorsque vous exécutez ce script sur des serveurs comportant de nombreux répertoires.

Conclusion

Dans le contexte de solutions basées sur les données comme NinjaOne, les scripts PowerShell comme ceux-ci complètent des stratégies de gestion informatique plus larges. En automatisant et en simplifiant les tâches complexes, telles que l’analyse pour connaître la taille des dossiers, les professionnels de l’informatique peuvent se concentrer sur des initiatives plus stratégiques, en veillant à ce que les systèmes ne soient pas seulement opérationnels, mais aussi optimisés et sécurisés. Grâce aux capacités d’intégration de NinjaOne, des scripts comme celui-ci peuvent faire partie d’une boîte à outils plus complète pour permettre une gestion efficace de l’informatique.