Principais conclusões
- O script do PowerShell calcula e informa com eficiência o tamanho das pastas em ambientes Windows.
- Ele é adaptável, permitindo que os usuários especifiquem um caminho, a profundidade da pasta e o limite mínimo de tamanho.
- O script é compatível com uma variedade de unidades de tamanho (KB, MB, GB, etc.) para definir o tamanho mínimo da pasta.
- Ideal para profissionais de TI e MSPs que precisam de uma visão geral rápida do uso do espaço em disco.
- Inclui recursos para lidar com problemas de permissão e fornecer resultados mais precisos.
- Emprega uma saída amigável, exibindo caminhos de pastas e seus tamanhos correspondentes.
- Útil em cenários como manutenção de servidores, otimização de armazenamento e limpeza de dados.
- Oferece uma alternativa mais personalizável e baseada em scripts às ferramentas tradicionais de análise de disco.
O gerenciamento eficiente de dados é a base das operações de TI, em que os insights sobre a distribuição e o armazenamento de dados desempenham um papel fundamental. O PowerShell, com seus versáteis recursos de script, é uma ferramenta poderosa para os profissionais de TI. Um script que pode listar e medir o tamanho das pastas não é apenas uma conveniência – é uma necessidade para manter o desempenho ideal e o gerenciamento de armazenamento em vários ambientes de TI.
Histórico
O script do PowerShell fornecido atende a uma necessidade essencial do setor de TI: entender e gerenciar o tamanho das pastas em um sistema. Para os profissionais de TI e para os provedores de serviços gerenciados (MSPs), isso é mais do que uma simples questão de manutenção. Em uma era em que os dados crescem exponencialmente, manter o controle sobre quais pastas estão consumindo mais espaço pode levar a decisões mais informadas sobre alocação de recursos, otimização do sistema e políticas de gerenciamento de dados. Esse script atende especificamente a essas necessidades, permitindo uma análise detalhada dos tamanhos das pastas.
O roteiro:
#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 {
}
Acesse mais de 300 scripts no NinjaOne Dojo
Detalhamento
O script funciona da seguinte forma:
- Inicialização de parâmetros: Ele começa definindo parâmetros como Path (caminho ), Depth (profundidade) e MinSize (tamanho mínimo). Esses parâmetros permitem que os usuários especifiquem o diretório de pesquisa, a profundidade da árvore de diretórios a ser analisada e o tamanho mínimo da pasta a ser relatada.
- Função de conversão de tamanho (Get-Size): Essa função converte diferentes unidades de tamanho (KB, MB, GB etc.) em bytes, garantindo uniformidade na medição do tamanho.
- Verificações de variáveis de ambiente: O script verifica e se adapta às variáveis ambientais, se definidas, permitindo configurações dinâmicas de caminho, profundidade e tamanho.
- Verificações de elevação e de conta do sistema: Ele examina se o script é executado com privilégios elevados ou com uma conta do sistema, o que é crucial para acessar determinados diretórios e garantir a precisão.
- Cálculo do tamanho da pasta (Get-SizeInfo): Essa função recursiva percorre a hierarquia de pastas, acumulando o tamanho dos arquivos e pastas até a profundidade especificada.
- Formatação de resultados (Write-Results): Os dados coletados são então formatados em uma estrutura legível, mostrando o caminho e o tamanho das pastas que excedem o tamanho mínimo especificado.
- Execução (Get-SubFolderSize): A função central que une todos os componentes, executando o cálculo do tamanho e a formatação do resultado.
- Saída: Por fim, o script gera os dados, concentrando-se em pastas maiores que o tamanho mínimo definido pelo usuário.
Casos de uso em potencial
Imagine que um administrador de TI de uma empresa perceba que o armazenamento do servidor está acabando. Usando esse script, eles podem identificar rapidamente pastas grandes, especialmente aquelas que cresceram inesperadamente. Essa análise pode revelar dados redundantes, arquivos de log com tamanho incomum ou áreas em que o arquivamento pode liberar espaço significativo.
Comparações
Métodos alternativos incluem o uso de ferramentas de terceiros ou verificações manuais. As ferramentas de terceiros podem ser mais fáceis de usar, mas talvez não ofereçam o mesmo nível de personalização. As verificações manuais, embora simples, são demoradas e impraticáveis para sistemas grandes.
Além do gerenciamento de armazenamento, o resultado do script pode ter implicações para a segurança de TI. Arquivos grandes e inesperados podem ser um sinal de violações de segurança, como despejos de dados. O monitoramento regular usando esses scripts pode fazer parte de uma estratégia de segurança proativa.
Recomendações
- Execute o script regularmente para obter um gerenciamento proativo do armazenamento.
- Combine a saída do script com outras ferramentas de monitoramento do sistema para obter insights abrangentes.
- Tenha cuidado com a carga do sistema ao executar esse script em servidores com diretórios extensos.
Considerações finais
No contexto de soluções orientadas por dados, como o NinjaOne, scripts do PowerShell como esses complementam estratégias mais amplas de gerenciamento de TI. Ao automatizar e simplificar tarefas complexas, como a análise do tamanho das pastas, os profissionais de TI podem se concentrar em iniciativas mais estratégicas, garantindo que os sistemas não sejam apenas operacionais, mas também otimizados e seguros. Com os recursos de integração do NinjaOne, scripts como esse podem fazer parte de um kit de ferramentas mais abrangente para o gerenciamento eficiente de TI.