איתור נפח תיקיות כבדות בשרת

ניהול נכון של משאבי השרת הוא קריטי לשמירה על ביצועים גבוהים ויציבות המערכת. איתור תיקיות היא מהבעיות הנפוצות שמנהלי מערכות נתקלים בה. בעיקר עקב מחסור בשטח אחסון, הנגרם לעיתים קרובות מתיקיות כבדות התופסות נפח משמעותי ללא צורך.

במדריך זה נסקור כיצד ניתן לזהות תיקיות כבדות בשרת, לנתח את נפחן, ולהבין אילו נתונים משפיעים על ניצול שטח האחסון. בנוסף, נדון בכלים ושיטות יעילות לניהול ואופטימיזציה של שטח הדיסק, שיסייעו לכם לשמור על שרת תקין ומסודר לאורך זמן.

לעיתים רחוקות המחשב או השרת שלנו מתמלא עד שלא נשאר בו מקום, כך שצריך לאתר תיקיות כבדות ומיותרות במהירות, להעתיק אותן למקום אחר או למחוק אותן. הנה כיצד לבצע אנליזה לתיקיות:

מתחילים

יש מספר פתרונות היום שיכולות לסייע לנו באיתור התיקיות הכבדות:

• תוכנת Treesize– תוכנה פשוטה וקלה למציאת תיקיות כבדות בדיסק הקשיח
• תוכנת Foldersizes– תוכנה מתקדמת המאפשרת לנו לייצא את הנתונים לאקסל
• תוכנת WizTree – תוכנה דוגמת Treesize שמסייעת לאיתור תיקיות בצורה נוחה
• באמצעות הרצת קוד PowerShell ופייתון עליהם נפרט בשורות הבאות

איתור קבצים כבדים דרך PowerShell

איתור הקבצים מתבצע דרך שימוש בפקודת PS פשוטה למציאת קבצים כבדים (הדוגמה לפנינו מציגה תוצאות קבצים מעל 2GB):

PS C:\> gci -r|sort -descending -property length | select -first 10 name, @{Name="Gigabytes";Expression={[Math]::round($_.length / 1GB, 2)}}

התוצאה נראית כך:

PS C:\> gci -r|sort -descending -property length | select -first 10 name, @{Name="Gigabytes";Expression={[Math]::round($_.length / 1GB, 2)}}


Name                                         Gigabytes
----                                         ---------
Backup.zip                                       97.17
Centos.zip                                       11.69
00000500000A8.tgz                                 4.24

הרצת הסקריפט מתוך קובץ PS1

לחלופין ניתן להשתמש בסקריפט הבא (יש לשנות את סיומת הקובץ אל ps1 ולפתוח כמנהל). אם לא מצליחים, נסו להריץ את הסקריפט הבא באמצעות השיטה הבאה:

powershell.exe -ExecutionPolicy Bypass -File "c:\path\to\file.ps1"

הרצת סקריפט זה תציג בצורה נוחה את התוצאות לכדלהלן:

Total capacity of C: - 80 GB
Total space free on C: - 36 GB / 36,536 MB
 
Below are the 2 largest files on C:\ from largest to smallest:
 
Name          : CentOS-7-x86_64-DVD-1511.iso
Size In MB    : 4,129
Path          : C:\Users\Administrator\Downloads
LastWriteTime : 9/9/2020 3:03:48 PM
 
Name          : Fedora-Live-Workstation-x86_64-23-10.iso
Size In MB    : 1,401
Path          : C:\Users\Administrator\Downloads
LastWriteTime : 8/9/2020 5:28:00 PM

 
Estimated subfolder sizes for C:\ :
 
Name                   Value   
----                   -----      
C:\Program Files       3,110MB 
C:\Program Files (x86) 3,098MB 
C:\Users               22,475MB  
C:\Windows             17,589MB
 
Estimated folder sizes for c:\windows :
 
Name                                Value  
----                                -----    
c:\windows\apppatch                 11MB      
c:\windows\assembly                 1,793MB   
c:\windows\Fonts                    504MB    
c:\windows\System32                 3,096MB  
c:\windows\SysWOW64                 1,119MB  
c:\windows\WinSxS                   7,907MB

איתור קבצים כבדים דרך שימוש בפקודה בלינוקס

להלן פקודה שתוכל להשתמש בה ב-Command Line של שרת מבוסס לינוקס כדי לאתר תיקיות כבדות ולהציג את הנפח שלהן בצורה ברורה ומאורגנת לפי אחוזים:

du -s /path/to/directory/* | sort -rn | awk '{percent=$1/total*100; printf "%s (%.2f%%)\n", $2, percent}' total=$(du -s /path/to/directory | awk '{print $1}')

הסבר על הפקודה:

1. du -ah /path/to/directory:
   • du (Disk Usage) מחשב את נפח התיקיות והקבצים.
   • -a מציג גם קבצים בודדים.
   • -h מציג את הגדלים בצורה קריאה לאדם (כמו KB, MB, GB).
   • /path/to/directory הוא הנתיב של התיקיה הראשית שברצונך לנתח.
2. sort -rh:
   • sort ממיין את התוצאות.
   • -r ממיין בסדר יורד (מהגדול לקטן).
   • -h מבטיח שהמיון יתבצע בצורה חכמה לפי גודל (התחשבות ב-MB, GB וכו').
3. head -n 20: מציג את 20 השורות הראשונות בלבד, כך שהתוצאה תהיה ממוקדת וברורה.
4. du -s: סוכם את הנפח הכולל של כל תיקיה בתיקיית הבסיס.
5. awk: מחשב את האחוז היחסי של כל תיקיה לעומת הנפח הכולל ומציג את התוצאה בצורה ברורה.

סקריפט Python לבדיקת נפח תיקיות והצגת האחוזים

להלן סקריפט Python פשוט שעובד ב-Windows מסייע באיתור, ומחשב את נפח התיקיות בתיקיית יעד, כולל אחוזים מכלל השטח. זהו פתרון נוח וגמיש להצגת נפח תיקיות עם אחוזים ב-Windows:

import os

def get_folder_sizes(base_path):
    folder_sizes = {}
    total_size = 0

    # מחשב את גודל כל תיקיה בתיקיית הבסיס
    for folder_name in os.listdir(base_path):
        folder_path = os.path.join(base_path, folder_name)
        if os.path.isdir(folder_path):
            folder_size = sum(
                os.path.getsize(os.path.join(dirpath, file))
                for dirpath, _, filenames in os.walk(folder_path)
                for file in filenames
            )
            folder_sizes[folder_name] = folder_size
            total_size += folder_size

    return folder_sizes, total_size

def display_folder_sizes(base_path):
    folder_sizes, total_size = get_folder_sizes(base_path)
    
    print(f"Folder sizes in '{base_path}':\n")
    for folder_name, size in sorted(folder_sizes.items(), key=lambda x: x[1], reverse=True):
        percent = (size / total_size) * 100 if total_size > 0 else 0
        print(f"{folder_name}: {size / (1024 * 1024):.2f} MB ({percent:.2f}%)")

if __name__ == "__main__":
    base_path = r"C:\path\to\your\directory"  # שנה לנתיב התיקיה הרצוי
    display_folder_sizes(base_path)

איך להפעיל את הסקריפט פייתון

• שמור את הקוד כקובץ check_folder_sizes.py.
• ערוך את המשתנה base_path ושנה אותו לנתיב הרצוי (לדוגמה: C:\intel).
• הרץ את הסקריפט עם שורת קוד Python הבאה:

python check_folder_sizes.py

מה התוצאה?

הפלט שיתקבל יראה כך:

Folder sizes in 'C:\path\to\your\directory':

Folder1: 123.45 MB (45.67%)
Folder2: 67.89 MB (25.19%)
Folder3: 45.67 MB (18.91%)
Folder4: 33.21 MB (10.23%)

חיפוש מעמיק ואיתור באמצעות פייתון

בשורות הבאות נראה כיצד לבצע באמצעות קוד פייתון:

• איתור בעיות שטח אחסון: מציאת קבצים גדולים או כפולים.
• ניהול תחזוקה שוטפת: מחיקת קבצים זמניים או ישנים.
• תיעוד ודיווח: דוחות CSV או סטטיסטיקות שימוש בדיסק.

איתור קבצים הגדולים מגודל מסוים

להלן קוד Python שמוצא קבצים שגודלם עולה על גודל נתון בתיקיה מסוימת:

import os

def find_large_files(base_path, size_limit_mb):
    size_limit_bytes = size_limit_mb * 1024 * 1024
    large_files = []

    for dirpath, _, filenames in os.walk(base_path):
        for file in filenames:
            file_path = os.path.join(dirpath, file)
            try:
                file_size = os.path.getsize(file_path)
                if file_size > size_limit_bytes:
                    large_files.append((file_path, file_size / (1024 * 1024)))
            except FileNotFoundError:
                pass  # אם יש בעיות גישה לקבצים מסוימים, נמשיך

    return large_files

if __name__ == "__main__":
    base_path = r"C:\path\to\your\directory"  # שנה לנתיב התיקיה
    size_limit_mb = 100  # גודל מינימלי ב-MB
    files = find_large_files(base_path, size_limit_mb)
    
    print(f"Files larger than {size_limit_mb} MB in '{base_path}':")
    for file_path, size in files:
        print(f"{file_path}: {size:.2f} MB")

זיהוי קבצים כפולים בתיקיה

להלן סקריפט Python שמשווה קבצים לפי תוכן ומאתר קבצים כפולים:

import os
import hashlib

def hash_file(file_path, block_size=65536):
    hasher = hashlib.md5()
    with open(file_path, 'rb') as f:
        while chunk := f.read(block_size):
            hasher.update(chunk)
    return hasher.hexdigest()

def find_duplicates(base_path):
    hashes = {}
    duplicates = []

    for dirpath, _, filenames in os.walk(base_path):
        for file in filenames:
            file_path = os.path.join(dirpath, file)
            try:
                file_hash = hash_file(file_path)
                if file_hash in hashes:
                    duplicates.append((file_path, hashes[file_hash]))
                else:
                    hashes[file_hash] = file_path
            except FileNotFoundError:
                pass  # מתעלמים מקבצים שלא ניתן לקרוא

    return duplicates

if __name__ == "__main__":
    base_path = r"C:\path\to\your\directory"  # שנה לנתיב התיקיה
    duplicates = find_duplicates(base_path)
    
    if duplicates:
        print("Duplicate files found:")
        for dup, orig in duplicates:
            print(f"Duplicate: {dup}\nOriginal: {orig}\n")
    else:
        print("No duplicates found.")

מחיקת קבצים זמניים או ישנים

להלן קוד שמאתר ומוחק קבצים ישנים בתיקיה על סמך גילם (בימים):

import os
import time

def delete_old_files(base_path, days):
    now = time.time()
    cutoff = now - (days * 86400)  # ממיר ימים לשניות

    for dirpath, _, filenames in os.walk(base_path):
        for file in filenames:
            file_path = os.path.join(dirpath, file)
            try:
                file_mtime = os.path.getmtime(file_path)
                if file_mtime < cutoff:
                    os.remove(file_path)
                    print(f"Deleted: {file_path}")
            except FileNotFoundError:
                pass  # אם הקובץ נמחק כבר, מתעלמים

if __name__ == "__main__":
    base_path = r"C:\path\to\your\directory"  # שנה לנתיב התיקיה
    days = 30  # קבצים שלא שונו ב-30 הימים האחרונים
    delete_old_files(base_path, days)

בדיקת אחוזי שימוש בדיסק (Windows בלבד)

שימוש ב-Python להפקת סטטיסטיקות שימוש בדיסק:

import shutil

def disk_usage_report(drive):
    total, used, free = shutil.disk_usage(drive)
    print(f"Drive: {drive}")
    print(f"Total: {total / (1024**3):.2f} GB")
    print(f"Used: {used / (1024**3):.2f} GB")
    print(f"Free: {free / (1024**3):.2f} GB")
    print(f"Usage: {(used / total) * 100:.2f}%")

if __name__ == "__main__":
    drive = "C:\\"  # שנה לנתיב הכונן הרצוי
    disk_usage_report(drive)

שמירת דוח נפח תיקיות לקובץ CSV

כמיטב המסורת, להלן סקריפט Python להצגת דוח נפח תיקיות לקובץ CSV לקריאה נוחה:

import os
import csv

def generate_folder_size_csv(base_path, output_file):
    folder_sizes = {}

    for folder_name in os.listdir(base_path):
        folder_path = os.path.join(base_path, folder_name)
        if os.path.isdir(folder_path):
            folder_size = sum(
                os.path.getsize(os.path.join(dirpath, file))
                for dirpath, _, filenames in os.walk(folder_path)
                for file in filenames
            )
            folder_sizes[folder_name] = folder_size / (1024 * 1024)  # ממירים ל-MB

    with open(output_file, "w", newline="") as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(["Folder", "Size (MB)"])
        for folder, size in sorted(folder_sizes.items(), key=lambda x: x[1], reverse=True):
            writer.writerow([folder, f"{size:.2f}"])

if __name__ == "__main__":
    base_path = r"C:\path\to\your\directory"  # שנה לנתיב התיקיה
    output_file = "folder_sizes.csv"
    generate_folder_size_csv(base_path, output_file)
    print(f"Folder size report saved to {output_file}")

סיכום

ניהול שטח אחסון בשרתים הוא משימה קריטית לשמירה על ביצועי המערכת והימנעות מתקלות. במאמר זה סקרנו כיצד לבצע איתור תיקיות כבדות בשרת ולנתח את נפחן ביחס לניצול השטח הכולל.

כאן הצגנו פקודות שימושיות לסביבות Windows ולינוקס המסייעות לאיתור תיקיות כבדות, וכן פתרונות גמישים באמצעות Python, המאפשרות איתור וחישוב אחוזי הנפח שכל תיקיה תופסת לפי פרמטרים. שימוש בכלים ושיטות אלו יסייע לכם לזהות בעיות עומס אחסון במהירות ולייעל את השימוש במשאבי השרת, כך שתוכלו לשמור על מערכת יציבה ומסודרת לאורך זמן.