Analyse de Taille de Fichiers et Gestion de Stockage sur macOS
Maîtrisez l'analyse de taille de fichiers et la gestion du stockage sur vos appareils MacFleet 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épertoiresdf- Utilisation de l'espace disque du système de fichiersls- Listage de fichiers avec informations de taillefind- Recherche de fichiers par critères de taillestat- 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" 2Dé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_reportAnalyse 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/macfleet_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 MacFleet
# Analyse et optimisation complète du stockage pour les appareils de flotte
# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/macfleet_storage.log"
REPORT_DIR="/etc/macfleet/reports/storage"
CONFIG_DIR="/etc/macfleet/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 MacFleet 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