Guide

Maîtrisez l'analyse de taille de fichiers et la gestion du stockage sur vos appareils Roundfleet en utilisant des outils puissants d'analyse d'utilisation du disque. Ce tutoriel couvre les requêtes de taille de base, l'analyse de stockage, la surveillance de l'utilisation du disque et les techniques d'optimisation de stockage avancées pour une gestion efficace du stockage de flotte.

Comprendre l'Analyse de Stockage macOS

macOS fournit plusieurs outils en ligne de commande pour l'analyse de stockage :

• du - Analyse de l'utilisation du disque pour les fichiers et répertoires
• df - Utilisation de l'espace disque du système de fichiers
• ls - Listage de fichiers avec informations de taille
• find - Recherche de fichiers par critères de taille
• stat - Informations détaillées sur les fichiers incluant la taille

Opérations de Base pour la Taille de Fichiers et Dossiers

Trouver la Taille d'un Fichier

#!/bin/bash

# Obtenir la taille d'un fichier spécifique
FILE_PATH="/Users/stefan/Desktop/Document.txt"

echo "Taille du fichier pour : $FILE_PATH"
du -h "$FILE_PATH"

echo "Analyse de taille de fichier terminée"

Trouver la Taille d'un Dossier

#!/bin/bash

# Obtenir la taille d'un dossier
FOLDER_PATH="/Users/stefan/Desktop/Wallpapers"

echo "Taille du dossier pour : $FOLDER_PATH"
du -h "$FOLDER_PATH"

echo "Analyse de taille de dossier terminée"

Informations de Taille Détaillées

#!/bin/bash

# Obtenir des informations de taille détaillées avec options
analyze_size() {
    local target_path="$1"
    
    if [[ ! -e "$target_path" ]]; then
        echo "Erreur : Chemin non trouvé : $target_path"
        return 1
    fi
    
    echo "=== Analyse de Taille pour : $target_path ==="
    
    # Taille de base
    echo "Taille totale :"
    du -h "$target_path"
    
    # Taille avec tous les fichiers listés
    echo -e "\nDétail complet :"
    du -ah "$target_path" | head -20
    
    # Total général avec résumé
    echo -e "\nRésumé avec total :"
    du -ch "$target_path"
}

# Utilisation
analyze_size "/Users/stefan/Desktop/Document.txt"

Analyse de Stockage Avancée

Répartition de Taille de Répertoires

#!/bin/bash

# Analyser les tailles de répertoires avec tri
directory_analysis() {
    local base_path="$1"
    local max_depth="${2:-1}"
    
    echo "=== Analyse de Taille de Répertoires : $base_path ==="
    
    # Tailles de répertoires de niveau supérieur, triées par taille
    echo "Plus gros répertoires :"
    du -h -d "$max_depth" "$base_path" 2>/dev/null | sort -hr | head -20
    
    # Nombre d'éléments
    echo -e "\nNombre d'éléments :"
    echo "Fichiers : $(find "$base_path" -type f 2>/dev/null | wc -l)"
    echo "Répertoires : $(find "$base_path" -type d 2>/dev/null | wc -l)"
    
    # Analyse des types de fichiers
    echo -e "\nDistribution des types de fichiers :"
    find "$base_path" -type f 2>/dev/null | grep '\.' | rev | cut -d. -f1 | rev | sort | uniq -c | sort -nr | head -10
}

# Utilisation
directory_analysis "/Users" 2

Détection de Gros Fichiers

#!/bin/bash

# Trouver les gros fichiers dans un répertoire
find_large_files() {
    local search_path="$1"
    local min_size="${2:-100M}"
    
    echo "=== Analyse de Gros Fichiers (>$min_size) dans : $search_path ==="
    
    # Trouver les gros fichiers
    echo "Gros fichiers trouvés :"
    find "$search_path" -type f -size +"$min_size" -exec ls -lh {} \; 2>/dev/null | sort -k5 -hr
    
    # Nombre et taille totale
    local large_files_count=$(find "$search_path" -type f -size +"$min_size" 2>/dev/null | wc -l)
    echo -e "\nTotal de gros fichiers : $large_files_count"
    
    if [[ $large_files_count -gt 0 ]]; then
        echo "Taille totale des gros fichiers :"
        find "$search_path" -type f -size +"$min_size" -exec du -ch {} + 2>/dev/null | tail -1
    fi
}

# Utilisation
find_large_files "/Users" "50M"

Utilisation de Stockage par Type de Fichier

#!/bin/bash

# Analyser l'utilisation de stockage par extension de fichier
storage_by_type() {
    local search_path="$1"
    
    echo "=== Utilisation de Stockage par Type de Fichier : $search_path ==="
    
    # Créer un fichier temporaire pour l'analyse
    local temp_file="/tmp/file_analysis_$$"
    
    # Obtenir tous les fichiers avec extensions et leurs tailles
    find "$search_path" -type f -name "*.*" -exec sh -c '
        for file; do
            ext=$(echo "$file" | rev | cut -d. -f1 | rev | tr "[:upper:]" "[:lower:]")
            size=$(stat -f%z "$file" 2>/dev/null || echo 0)
            echo "$ext $size"
        done
    ' _ {} + > "$temp_file"
    
    # Résumer par extension
    echo "Principaux types de fichiers par taille totale :"
    awk '{
        ext_size[$1] += $2
        ext_count[$1]++
    } END {
        for (ext in ext_size) {
            printf "%-10s %15s %10d fichiers\n", ext, ext_size[ext], ext_count[ext]
        }
    }' "$temp_file" | sort -k2 -nr | head -15 | \
    while read ext size count; do
        # Convertir les octets en format lisible
        if [[ $size -gt 1073741824 ]]; then
            printf "%-10s %10.2f GB %10d fichiers\n" "$ext" $(echo "scale=2; $size/1073741824" | bc) "$count"
        elif [[ $size -gt 1048576 ]]; then
            printf "%-10s %10.2f MB %10d fichiers\n" "$ext" $(echo "scale=2; $size/1048576" | bc) "$count"
        else
            printf "%-10s %10.2f KB %10d fichiers\n" "$ext" $(echo "scale=2; $size/1024" | bc) "$count"
        fi
    done
    
    # Nettoyage
    rm -f "$temp_file"
}

# Utilisation
storage_by_type "/Users"

Surveillance de l'Espace Disque

Utilisation du Disque Système

#!/bin/bash

# Rapport complet d'utilisation du disque
system_disk_report() {
    echo "=== Rapport d'Utilisation du Disque Système ==="
    
    # Utilisation du système de fichiers
    echo "Utilisation du Système de Fichiers :"
    df -h
    
    echo -e "\nUtilisation du disque par point de montage :"
    df -h | awk 'NR>1 {print $5 " " $1}' | while read output; do
        usage=$(echo $output | awk '{print $1}' | cut -d'%' -f1)
        partition=$(echo $output | awk '{print $2}')
        if [[ $usage -ge 80 ]]; then
            echo "⚠️  $partition : ${usage}% (AVERTISSEMENT)"
        elif [[ $usage -ge 90 ]]; then
            echo "🚨 $partition : ${usage}% (CRITIQUE)"
        else
            echo "✅ $partition : ${usage}%"
        fi
    done
    
    # Principaux répertoires par taille
    echo -e "\nPrincipaux répertoires par taille :"
    du -h / 2>/dev/null | sort -hr | head -10
}

# Exécuter le rapport système
system_disk_report

Analyse des Tendances de Stockage

#!/bin/bash

# Surveiller les tendances de stockage dans le temps
storage_trend_monitor() {
    local target_path="$1"
    local log_file="/var/log/roundfleet_storage_trends.log"
    
    echo "=== Surveillance des Tendances de Stockage : $target_path ==="
    
    # Horodatage et taille actuels
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local current_size=$(du -sk "$target_path" 2>/dev/null | cut -f1)
    
    # Enregistrer la mesure actuelle
    echo "$timestamp,$target_path,$current_size" >> "$log_file"
    
    # Afficher les tendances récentes si le log existe
    if [[ -f "$log_file" ]]; then
        echo "Tendances de stockage récentes (10 dernières mesures) :"
        echo "Horodatage              | Chemin            | Taille (KB)  | Changement"
        echo "------------------------|-------------------|--------------|------------"
        
        tail -10 "$log_file" | while IFS=',' read -r time path size; do
            # Calculer le changement par rapport à la mesure précédente
            printf "%-23s | %-17s | %12s | \n" "$time" "$(basename "$path")" "$size"
        done
        
        # Calculer le taux de croissance
        local first_size=$(head -1 "$log_file" | cut -d',' -f3)
        local growth=$((current_size - first_size))
        local growth_percent=$(echo "scale=2; ($growth * 100) / $first_size" | bc 2>/dev/null || echo "0")
        
        echo -e "\nCroissance depuis la première mesure : ${growth} KB (${growth_percent}%)"
    fi
}

# Utilisation
storage_trend_monitor "/Users"

Système de Gestion de Stockage d'Entreprise

#!/bin/bash

# Outil de Gestion de Stockage Roundfleet
# Analyse et optimisation complète du stockage pour les appareils de flotte

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_storage.log"
REPORT_DIR="/etc/roundfleet/reports/storage"
CONFIG_DIR="/etc/roundfleet/storage"
ALERT_DIR="$CONFIG_DIR/alerts"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$ALERT_DIR"

# Catégories de stockage pour l'analyse
declare -A STORAGE_CATEGORIES=(
    ["system_critical"]="/System,/Library,/usr,/bin,/sbin"
    ["user_data"]="/Users,/home"
    ["applications"]="/Applications"
    ["caches"]="/Library/Caches,/Users/*/Library/Caches"
    ["logs"]="/var/log,/Library/Logs,/Users/*/Library/Logs"
    ["downloads"]="/Users/*/Downloads"
    ["documents"]="/Users/*/Documents,/Users/*/Desktop"
    ["media"]="/Users/*/Movies,/Users/*/Music,/Users/*/Pictures"
    ["temporary"]="/tmp,/var/tmp,/Users/*/Library/Application Support/*/Cache"
    ["development"]="/usr/local,/opt,/Users/*/Development"
)

# Seuils et politiques de stockage
declare -A STORAGE_POLICIES=(
    ["space_warning"]="80,85,90,95"
    ["large_file_threshold"]="100M,500M,1G,5G"
    ["old_file_threshold"]="30,90,180,365"
    ["cache_cleanup_age"]="7,14,30,60"
    ["temp_cleanup_age"]="1,3,7,14"
    ["log_retention_days"]="30,60,90,180"
)

# Fonction de journalisation
log_action() {
    local message="$1"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] $message" | tee -a "$LOG_FILE"
}

# Moteur d'analyse de stockage avancé
analyze_storage_comprehensive() {
    local target_path="$1"
    local analysis_level="${2:-standard}"
    local category="${3:-general}"
    
    log_action "Début de l'analyse complète de stockage : $target_path (Niveau : $analysis_level)"
    
    if [[ ! -e "$target_path" ]]; then
        log_action "ERREUR : Le chemin cible n'existe pas : $target_path"
        return 1
    fi
    
    local report_file="$REPORT_DIR/storage_analysis_$(echo "$target_path" | tr '/' '_')_$(date +%Y%m%d_%H%M%S).json"
    
    # Initialiser le rapport
    cat > "$report_file" << EOF
{
    "analysis_info": {
        "target_path": "$target_path",
        "analysis_level": "$analysis_level",
        "category": "$category",
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "script_version": "$SCRIPT_VERSION"
    },
    "storage_metrics": {},
    "file_analysis": {},
    "recommendations": [],
    "alerts": []
}
EOF
    
    # Métriques de stockage de base
    local total_size_kb=$(du -sk "$target_path" 2>/dev/null | cut -f1)
    local total_files=$(find "$target_path" -type f 2>/dev/null | wc -l)
    local total_dirs=$(find "$target_path" -type d 2>/dev/null | wc -l)
    local largest_file_size=$(find "$target_path" -type f -exec stat -f%z {} \; 2>/dev/null | sort -nr | head -1)
    
    # Mettre à jour le rapport avec les métriques de base
    jq --argjson total_size_kb "$total_size_kb" \
       --argjson total_files "$total_files" \
       --argjson total_dirs "$((total_dirs - 1))" \
       --argjson largest_file "$largest_file_size" \
       '.storage_metrics = {
           "total_size_kb": $total_size_kb,
           "total_size_mb": ($total_size_kb / 1024),
           "total_size_gb": ($total_size_kb / 1048576),
           "total_files": $total_files,
           "total_directories": $total_dirs,
           "largest_file_bytes": $largest_file,
           "average_file_size": (if $total_files > 0 then ($total_size_kb * 1024 / $total_files) else 0 end)
       }' "$report_file" > "${report_file}.tmp" && mv "${report_file}.tmp" "$report_file"
    
    # Effectuer l'analyse selon le niveau
    case "$analysis_level" in
        "quick")
            perform_quick_storage_analysis "$target_path" "$report_file"
            ;;
        "standard")
            perform_standard_storage_analysis "$target_path" "$report_file"
            ;;
        "comprehensive")
            perform_comprehensive_storage_analysis "$target_path" "$report_file"
            ;;
        "optimization")
            perform_optimization_analysis "$target_path" "$report_file"
            ;;
        "security")
            perform_security_storage_analysis "$target_path" "$report_file"
            ;;
    esac
    
    log_action "Analyse de stockage terminée : $report_file"
    echo "$report_file"
}

# Fonction d'exécution principale
main() {
    local action="${1:-analyze}"
    local target="${2:-/Users}"
    local level="${3:-standard}"
    local options="${4:-}"
    
    log_action "=== Gestion de Stockage Roundfleet Démarrée ==="
    log_action "Action : $action, Cible : $target, Niveau : $level"
    
    case "$action" in
        "analyze")
            analyze_storage_comprehensive "$target" "$level"
            ;;
        "size")
            echo "Taille de fichier/dossier :"
            du -h "$target"
            ;;
        "fleet")
            manage_fleet_storage "$level" "$target" "$options"
            ;;
        "report")
            generate_fleet_storage_report
            ;;
        "help")
            echo "Usage : $0 [action] [cible] [niveau] [options]"
            echo "Actions :"
            echo "  analyze <chemin> [niveau] - Analyse complète de stockage"
            echo "  size <chemin> - Vérification simple de taille"
            echo "  fleet <action> [motif] [seuil] - Gestion de flotte"
            echo "  report - Générer un rapport de stockage de flotte"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Niveaux d'analyse : quick, standard, comprehensive, optimization, security"
            echo "Actions de flotte : audit, cleanup, monitor, report"
            ;;
        *)
            log_action "ERREUR : Action inconnue : $action"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion de stockage terminée ==="
}

# Exécuter la fonction principale
main "$@"

Tâches Courantes d'Analyse de Stockage

Comparaison de Répertoires

#!/bin/bash

# Comparer les tailles de plusieurs répertoires
compare_directories() {
    local directories=("$@")
    
    echo "=== Comparaison de Taille de Répertoires ==="
    printf "%-40s %15s %15s\n" "Répertoire" "Taille" "Fichiers"
    echo "--------------------------------------------------------------------------------"
    
    for dir in "${directories[@]}"; do
        if [[ -d "$dir" ]]; then
            local size=$(du -sh "$dir" 2>/dev/null | cut -f1)
            local files=$(find "$dir" -type f 2>/dev/null | wc -l)
            printf "%-40s %15s %15d\n" "$dir" "$size" "$files"
        else
            printf "%-40s %15s %15s\n" "$dir" "N/A" "N/A"
        fi
    done
}

# Utilisation
compare_directories "/Users/stefan/Documents" "/Users/stefan/Downloads" "/Users/stefan/Desktop"

Suivi de Croissance de Stockage

#!/bin/bash

# Suivre la croissance de stockage dans le temps
track_storage_growth() {
    local target_path="$1"
    local log_file="/var/log/storage_growth.csv"
    
    # Créer l'en-tête si le fichier n'existe pas
    if [[ ! -f "$log_file" ]]; then
        echo "timestamp,path,size_kb,files,directories" > "$log_file"
    fi
    
    # Obtenir les métriques actuelles
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local size_kb=$(du -sk "$target_path" 2>/dev/null | cut -f1)
    local files=$(find "$target_path" -type f 2>/dev/null | wc -l)
    local dirs=$(find "$target_path" -type d 2>/dev/null | wc -l)
    
    # Enregistrer la mesure actuelle
    echo "$timestamp,$target_path,$size_kb,$files,$dirs" >> "$log_file"
    
    echo "Croissance de stockage enregistrée pour : $target_path"
    echo "Taille actuelle : $(echo "scale=2; $size_kb/1024" | bc) MB"
    echo "Fichiers : $files, Répertoires : $dirs"
}

# Utilisation
track_storage_growth "/Users/stefan"

Recommandations de Nettoyage

#!/bin/bash

# Générer des recommandations de nettoyage
generate_cleanup_recommendations() {
    local target_path="$1"
    
    echo "=== Recommandations de Nettoyage pour : $target_path ==="
    
    # Anciens téléchargements
    local old_downloads=$(find "$target_path" -path "*/Downloads/*" -type f -mtime +30 2>/dev/null | wc -l)
    if [[ $old_downloads -gt 0 ]]; then
        echo "📁 Trouvé $old_downloads fichiers dans Téléchargements de plus de 30 jours"
    fi
    
    # Gros fichiers de cache
    local cache_size=$(find "$target_path" -path "*/Cache*" -type f -size +10M 2>/dev/null | wc -l)
    if [[ $cache_size -gt 0 ]]; then
        echo "🗂️  Trouvé $cache_size gros fichiers de cache (>10MB)"
    fi
    
    # Fichiers dupliqués
    local duplicates=$(find "$target_path" -type f -exec md5 {} \; 2>/dev/null | sort | uniq -d -w 32 | wc -l)
    if [[ $duplicates -gt 0 ]]; then
        echo "📄 Trouvé approximativement $duplicates fichiers dupliqués"
    fi
    
    # Répertoires vides
    local empty_dirs=$(find "$target_path" -type d -empty 2>/dev/null | wc -l)
    if [[ $empty_dirs -gt 0 ]]; then
        echo "📂 Trouvé $empty_dirs répertoires vides"
    fi
    
    # Fichiers de log
    local large_logs=$(find "$target_path" -name "*.log" -size +50M 2>/dev/null | wc -l)
    if [[ $large_logs -gt 0 ]]; then
        echo "📋 Trouvé $large_logs gros fichiers de log (>50MB)"
    fi
    
    echo -e "\n💡 Considérez exécuter des opérations de nettoyage pour ces éléments"
}

# Utilisation
generate_cleanup_recommendations "/Users"

Notes Importantes

• Chemins de fichiers avec espaces - Utilisez des guillemets ou échappez les caractères : du -h "/chemin/avec espaces"
• Exigences de permissions - Certains répertoires nécessitent un accès administrateur
• Impact sur les performances - Les analyses de gros répertoires peuvent être gourmandes en ressources
• Surveillance régulière - Configurez une surveillance automatisée du stockage pour la gestion de flotte
• Sauvegarde avant nettoyage - Sauvegardez toujours les données importantes avant les opérations de nettoyage
• Testez les scripts sur des répertoires d'exemple avant le déploiement à l'échelle de la flotte