Gestion de Stockage d'Entreprise sur macOS

Surveillez et optimisez le stockage de vos appareils Roundfleet en utilisant l'analyse avancée d'utilisation du disque, les politiques de nettoyage automatisées et la gestion complète de stockage. Ce tutoriel fournit des outils de niveau entreprise pour implémenter les politiques de stockage organisationnelles et l'optimisation de stockage à l'échelle de la flotte.

Comprendre la Gestion de Stockage macOS

macOS fournit plusieurs outils en ligne de commande pour la gestion de stockage :

du - Analyse d'utilisation de répertoires et consommation d'espace
df - Espace disque libre et informations du système de fichiers
diskutil - Utilitaire de disque pour opérations avancées de disque
tmutil - Utilitaire Time Machine pour stockage de sauvegarde
Gestion de Stockage - Interface d'optimisation de stockage graphique

Opérations de Stockage de Base

Vérifier l'Utilisation de Stockage des Utilisateurs

#!/bin/bash

# Vérifier l'utilisation du disque pour tous les utilisateurs
echo "=== Utilisation de Stockage des Utilisateurs ==="
sudo du -hxd1 /Users

echo "Vérification d'utilisation de stockage terminée"

Vérifier l'Utilisation du Système de Fichiers

#!/bin/bash

# Vérifier l'utilisation globale du système de fichiers
echo "=== Utilisation du Système de Fichiers ==="
df -h

# Vérifier un système de fichiers spécifique
# df -h /dev/disk1s1

echo "Vérification d'utilisation du système de fichiers terminée"

Vérifier l'Utilisation du Répertoire Actuel

#!/bin/bash

# Vérifier l'utilisation du répertoire actuel
echo "=== Utilisation du Répertoire Actuel ==="
du -sh *

echo "Vérification d'utilisation du répertoire terminée"

Système de Gestion de Stockage d'Entreprise

#!/bin/bash

# Système de Gestion de Stockage d'Entreprise Roundfleet
# Surveillance complète de stockage, optimisation et gestion de politiques

# Configuration
ROUNDFLEET_DIR="/etc/roundfleet"
STORAGE_DIR="$ROUNDFLEET_DIR/storage_management"
REPORTS_DIR="$ROUNDFLEET_DIR/reports"
COMPLIANCE_DIR="$ROUNDFLEET_DIR/compliance"
AUDIT_DIR="$ROUNDFLEET_DIR/audit"
LOG_FILE="/var/log/roundfleet_storage_management.log"
POLICIES_DIR="$ROUNDFLEET_DIR/storage_policies"
CLEANUP_DIR="$ROUNDFLEET_DIR/cleanup_logs"

# Créer la structure de répertoires
create_directories() {
    local dirs=("$ROUNDFLEET_DIR" "$STORAGE_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR" "$POLICIES_DIR" "$CLEANUP_DIR")
    for dir in "${dirs[@]}"; do
        [[ ! -d "$dir" ]] && mkdir -p "$dir"
    done
}

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

# Catégories de Stockage pour la Gestion d'Entreprise
declare -A STORAGE_CATEGORIES=(
    ["system_critical"]="macOS,system_apps,kernel_extensions,system_logs"
    ["user_data"]="documents,downloads,desktop,pictures,movies"
    ["application_data"]="app_support,caches,preferences,saved_states"
    ["development"]="xcode,simulators,build_artifacts,source_code"
    ["media_content"]="photos,videos,music,podcasts"
    ["temporary_files"]="caches,logs,trash,temp_downloads"
    ["backup_data"]="time_machine,local_snapshots,manual_backups"
)

# Politiques de Stockage pour Différents Environnements
declare -A STORAGE_POLICIES=(
    ["aggressive_cleanup"]="clear_caches,remove_logs_7days,empty_trash,remove_downloads_30days"
    ["conservative_cleanup"]="clear_caches,remove_logs_30days,archive_old_files"
    ["development_optimized"]="preserve_builds,clear_simulator_data,optimize_xcode_cache"
    ["media_optimized"]="compress_videos,optimize_photos,remove_duplicates"
    ["security_focused"]="secure_delete,encrypt_backups,audit_sensitive_files"
    ["compliance_strict"]="retain_all,encrypt_storage,detailed_logging,no_auto_delete"
)

# Seuils d'Espace Disque pour Différents Niveaux d'Alerte
declare -A ALERT_THRESHOLDS=(
    ["critical"]=5     # Moins de 5GB libres
    ["warning"]=10     # Moins de 10GB libres
    ["low"]=20         # Moins de 20GB libres
    ["optimal"]=50     # Moins de 50GB libres
)

# Analyse complète de stockage
analyze_storage_comprehensive() {
    local analysis_level="$1"
    local output_file="$STORAGE_DIR/storage_analysis_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Démarrage de l'analyse complète de stockage : $analysis_level"
    
    # Obtenir les informations de base du système de fichiers
    local total_space=$(df -h / | awk 'NR==2 {print $2}')
    local used_space=$(df -h / | awk 'NR==2 {print $3}')
    local available_space=$(df -h / | awk 'NR==2 {print $4}')
    local usage_percentage=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
    
    # Convertir en octets pour les calculs
    local available_gb=$(df -g / | awk 'NR==2 {print $4}')
    
    # Déterminer le niveau d'alerte
    local alert_level="optimal"
    if [[ $available_gb -lt ${ALERT_THRESHOLDS["critical"]} ]]; then
        alert_level="critical"
    elif [[ $available_gb -lt ${ALERT_THRESHOLDS["warning"]} ]]; then
        alert_level="warning"
    elif [[ $available_gb -lt ${ALERT_THRESHOLDS["low"]} ]]; then
        alert_level="low"
    fi
    
    # Analyser les répertoires utilisateurs
    local user_data=""
    while IFS= read -r user_dir; do
        if [[ -d "$user_dir" && ! "$user_dir" =~ (Shared|.localized)$ ]]; then
            local user_name=$(basename "$user_dir")
            local user_size=$(du -sg "$user_dir" 2>/dev/null | awk '{print $1}' || echo "0")
            user_data="$user_data{\"user\":\"$user_name\",\"size_gb\":$user_size},"
        fi
    done <<< "$(find /Users -maxdepth 1 -type d)"
    
    # Supprimer la virgule finale
    user_data="${user_data%,}"
    
    # Analyser les grands répertoires
    local large_dirs=""
    if [[ "$analysis_level" == "detailed" || "$analysis_level" == "full" ]]; then
        while IFS= read -r dir_info; do
            local size=$(echo "$dir_info" | awk '{print $1}')
            local path=$(echo "$dir_info" | awk '{$1=""; print substr($0,2)}')
            [[ $size -gt 1 ]] && large_dirs="$large_dirs{\"path\":\"$path\",\"size_gb\":$size},"
        done <<< "$(sudo du -sg /Applications /Library /System /Users 2>/dev/null | sort -nr)"
        large_dirs="${large_dirs%,}"
    fi
    
    # Analyser les caches système et fichiers temporaires
    local temp_data=""
    local cache_size=$(du -sg ~/Library/Caches 2>/dev/null | awk '{print $1}' || echo "0")
    local log_size=$(du -sg /var/log 2>/dev/null | awk '{print $1}' || echo "0")
    local trash_size=$(du -sg ~/.Trash 2>/dev/null | awk '{print $1}' || echo "0")
    
    temp_data="{\"caches_gb\":$cache_size,\"logs_gb\":$log_size,\"trash_gb\":$trash_size}"
    
    # Créer un rapport complet
    cat > "$output_file" << EOF
{
  "storage_analysis": {
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "analysis_level": "$analysis_level",
    "alert_level": "$alert_level",
    "filesystem_info": {
      "total_space": "$total_space",
      "used_space": "$used_space",
      "available_space": "$available_space",
      "usage_percentage": $usage_percentage,
      "available_gb": $available_gb
    },
    "user_breakdown": [$user_data],
    "large_directories": [$large_dirs],
    "temporary_files": $temp_data
  },
  "recommendations": [
    $([ $alert_level == "critical" ] && echo "\"Nettoyage immédiat requis - niveau de stockage critique\",")
    $([ $alert_level == "warning" ] && echo "\"Nettoyage de stockage recommandé\",")
    $([ $cache_size -gt 5 ] && echo "\"Vider les caches d'application ($cache_size GB)\",")
    $([ $trash_size -gt 1 ] && echo "\"Vider la corbeille ($trash_size GB)\",")
    $([ $log_size -gt 2 ] && echo "\"Archiver les anciens fichiers de log ($log_size GB)\",")
    "\"Surveillance régulière du stockage recommandée\""
  ]
}
EOF
    
    log_action "Analyse de stockage terminée. Rapport : $output_file"
    
    # Alerte si critique
    if [[ "$alert_level" == "critical" ]]; then
        log_action "ALERTE CRITIQUE : Espace de stockage critique ($available_gb GB restants)"
        # Envoyer notification d'alerte
        osascript -e "display notification \"Espace de stockage critique : $available_gb GB restants\" with title \"Alerte Stockage Roundfleet\""
    fi
    
    echo "$output_file"
}

# Nettoyage avancé de stockage avec politiques
perform_storage_cleanup() {
    local cleanup_policy="$1"
    local dry_run="${2:-false}"
    local cleanup_report="$CLEANUP_DIR/cleanup_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Démarrage du nettoyage de stockage avec politique : $cleanup_policy (dry_run: $dry_run)"
    
    local total_freed=0
    local operations=""
    
    case "$cleanup_policy" in
        "aggressive_cleanup")
            # Vider les caches d'application
            if [[ "$dry_run" == "false" ]]; then
                local cache_size_before=$(du -sg ~/Library/Caches 2>/dev/null | awk '{print $1}' || echo "0")
                find ~/Library/Caches -type f -mtime +1 -delete 2>/dev/null
                local cache_size_after=$(du -sg ~/Library/Caches 2>/dev/null | awk '{print $1}' || echo "0")
                local cache_freed=$((cache_size_before - cache_size_after))
                total_freed=$((total_freed + cache_freed))
                operations="$operations{\"operation\":\"clear_caches\",\"freed_gb\":$cache_freed},"
            fi
            
            # Supprimer les anciens logs (7 jours)
            if [[ "$dry_run" == "false" ]]; then
                local log_size_before=$(du -sg ~/Library/Logs 2>/dev/null | awk '{print $1}' || echo "0")
                find ~/Library/Logs -type f -mtime +7 -delete 2>/dev/null
                local log_size_after=$(du -sg ~/Library/Logs 2>/dev/null | awk '{print $1}' || echo "0")
                local log_freed=$((log_size_before - log_size_after))
                total_freed=$((total_freed + log_freed))
                operations="$operations{\"operation\":\"remove_old_logs\",\"freed_gb\":$log_freed},"
            fi
            
            # Vider la corbeille
            if [[ "$dry_run" == "false" ]]; then
                local trash_size=$(du -sg ~/.Trash 2>/dev/null | awk '{print $1}' || echo "0")
                rm -rf ~/.Trash/*
                total_freed=$((total_freed + trash_size))
                operations="$operations{\"operation\":\"empty_trash\",\"freed_gb\":$trash_size},"
            fi
            ;;
            
        "development_optimized")
            # Vider les données dérivées Xcode
            if [[ -d ~/Library/Developer/Xcode/DerivedData && "$dry_run" == "false" ]]; then
                local derived_size=$(du -sg ~/Library/Developer/Xcode/DerivedData 2>/dev/null | awk '{print $1}' || echo "0")
                rm -rf ~/Library/Developer/Xcode/DerivedData/*
                total_freed=$((total_freed + derived_size))
                operations="$operations{\"operation\":\"clear_xcode_derived_data\",\"freed_gb\":$derived_size},"
            fi
            
            # Vider les données du simulateur iOS
            if [[ -d ~/Library/Developer/CoreSimulator && "$dry_run" == "false" ]]; then
                local sim_size_before=$(du -sg ~/Library/Developer/CoreSimulator 2>/dev/null | awk '{print $1}' || echo "0")
                xcrun simctl delete unavailable
                local sim_size_after=$(du -sg ~/Library/Developer/CoreSimulator 2>/dev/null | awk '{print $1}' || echo "0")
                local sim_freed=$((sim_size_before - sim_size_after))
                total_freed=$((total_freed + sim_freed))
                operations="$operations{\"operation\":\"cleanup_simulator_data\",\"freed_gb\":$sim_freed},"
            fi
            ;;
    esac
    
    # Supprimer la virgule finale
    operations="${operations%,}"
    
    # Créer un rapport de nettoyage
    cat > "$cleanup_report" << EOF
{
  "cleanup_report": {
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "policy": "$cleanup_policy",
    "dry_run": "$dry_run",
    "total_freed_gb": $total_freed,
    "operations": [$operations]
  },
  "storage_after_cleanup": {
    "available_space": "$(df -h / | awk 'NR==2 {print $4}')",
    "usage_percentage": "$(df -h / | awk 'NR==2 {print $5}')"
  }
}
EOF
    
    if [[ "$dry_run" == "false" ]]; then
        log_action "Nettoyage terminé. Espace total libéré : ${total_freed}GB"
    else
        log_action "Test à blanc terminé. Libérerait approximativement : ${total_freed}GB"
    fi
    
    echo "$cleanup_report"
}

# Surveillance et alerte de stockage
monitor_storage_continuously() {
    local monitoring_interval="${1:-300}"  # 5 minutes par défaut
    local alert_threshold="${2:-10}"       # 10GB par défaut
    
    log_action "Démarrage de la surveillance continue de stockage (intervalle : ${monitoring_interval}s, seuil : ${alert_threshold}GB)"
    
    while true; do
        local available_gb=$(df -g / | awk 'NR==2 {print $4}')
        local usage_percent=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
        
        if [[ $available_gb -lt $alert_threshold ]]; then
            log_action "ALERTE STOCKAGE : Seulement ${available_gb}GB restants (${usage_percent}% utilisés)"
            
            # Envoyer notification système
            osascript -e "display notification \"Stockage faible : ${available_gb}GB restants\" with title \"Moniteur Stockage Roundfleet\""
            
            # Optionnellement déclencher le nettoyage automatique
            if [[ $available_gb -lt 5 ]]; then
                log_action "Déclenchement du nettoyage d'urgence..."
                perform_storage_cleanup "aggressive_cleanup" "false"
            fi
        fi
        
        # Enregistrer le statut actuel
        log_action "Statut stockage : ${available_gb}GB disponible (${usage_percent}% utilisé)"
        
        sleep "$monitoring_interval"
    done
}

# Fonction d'exécution principale
main() {
    create_directories
    
    case "${1:-}" in
        "analyze")
            analyze_storage_comprehensive "${2:-standard}"
            ;;
        "cleanup")
            perform_storage_cleanup "${2:-conservative_cleanup}" "${3:-false}"
            ;;
        "monitor")
            monitor_storage_continuously "${2:-300}" "${3:-10}"
            ;;
        "help"|*)
            echo "Système de Gestion de Stockage d'Entreprise Roundfleet"
            echo ""
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  analyze [niveau]                     - Analyser le stockage (basic|standard|detailed|full)"
            echo "  cleanup <politique> [dry_run]       - Effectuer nettoyage (aggressive_cleanup|conservative_cleanup|development_optimized|media_optimized) [true|false]"
            echo "  monitor [intervalle] [seuil]         - Surveillance continue (intervalle en secondes, seuil en GB)"
            echo ""
            echo "Exemples :"
            echo "  $0 analyze detailed"
            echo "  $0 cleanup aggressive_cleanup false"
            echo "  $0 monitor 600 15"
            ;;
    esac
}

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

## Analyse et Surveillance de Stockage

Le système d'entreprise fournit une analyse complète de stockage :

| **Niveau d'Analyse** | **Portée** | **Détails** | **Cas d'Usage** |
|---|---|---|---|
| **Basic** | Utilisation globale du disque | Vérification rapide d'espace | Surveillance quotidienne |
| **Standard** | Répartition utilisateur et système | Modèles d'utilisation détaillés | Révisions hebdomadaires |
| **Detailed** | Analyse des grands répertoires | Inventaire complet | Audits mensuels |
| **Full** | Analyse complète du système | Rapports d'entreprise | Évaluations trimestrielles |

## Politiques de Nettoyage de Stockage

### Politique de Nettoyage Agressive

```bash
# Effectuer nettoyage agressif pour récupérer un maximum d'espace
./storage_manager.sh cleanup aggressive_cleanup false

# Test à blanc pour voir ce qui serait nettoyé
./storage_manager.sh cleanup aggressive_cleanup true

Nettoyage Optimisé pour le Développement

# Nettoyer les caches et données de build spécifiques au développement
./storage_manager.sh cleanup development_optimized false

Surveillance de Stockage d'Entreprise

Surveillance Continue

# Surveiller le stockage toutes les 5 minutes avec seuil de 10GB
./storage_manager.sh monitor 300 10

# Surveiller le stockage chaque heure avec seuil de 20GB
./storage_manager.sh monitor 3600 20

Alertes Automatisées

Le système fournit des alertes intelligentes :

Alerte Critique - Moins de 5GB restants
Alerte d'Avertissement - Moins de 10GB restants
Stockage Faible - Moins de 20GB restants
Optimal - Plus de 50GB restants

Considérations Importantes de Stockage

Chiffrement FileVault doit être activé pour la sécurité d'entreprise
Sauvegardes Time Machine nécessitent un stockage externe adéquat
Instantanés APFS consomment du stockage et doivent être surveillés
Caches d'application peuvent grossir et nécessitent un nettoyage régulier
Éducation des utilisateurs aide à maintenir une utilisation optimale du stockage

Conformité et Gouvernance

Le système d'entreprise supporte diverses frameworks de conformité :

Conformité GDPR - Rétention de données et suppression sécurisée
Exigences HIPAA - Sécurité de stockage de données de santé
Conformité SOX - Contrôles de stockage de données financières
ISO 27001 - Gestion de sécurité de stockage d'information

Ce système complet transforme les commandes de base d'utilisation du disque en une plateforme de gestion de stockage de niveau entreprise avec surveillance avancée, optimisation automatisée et capacités de gestion de flotte.

Guide

Avis important