Gestion d'Utilitaire de Disque d'Entreprise sur macOS
Gérez le stockage et les opérations de disque sur vos appareils MacFleet en utilisant des commandes diskutil avancées et des outils de gestion de stockage d'entreprise. Ce tutoriel couvre la gestion de disque, la sécurité de stockage, la surveillance de conformité et la gestion du cycle de vie de stockage d'entreprise.
Comprendre la Gestion de Disque macOS
macOS fournit plusieurs outils en ligne de commande pour la gestion de disque et de stockage :
diskutil- Utilitaire de disque principal pour la gestion de volumes et partitionsdf- Afficher l'utilisation d'espace disque du système de fichiersdu- Afficher l'utilisation d'espace répertoirefsck- Utilitaire de vérification et réparation du système de fichiers- APFS - Système de fichiers Apple avec fonctionnalités avancées
Opérations de Disque de Base
Lister Tous les Disques
#!/bin/bash
# Liste de disques de base
diskutil list
echo "Inventaire de disques terminé avec succès"Informations de Disque Améliorées
#!/bin/bash
# Informations de disque améliorées avec analyse détaillée
get_comprehensive_disk_info() {
echo "=== Analyse Complète de Disque ==="
# Liste de disques de base
echo "Inventaire de Disques :"
diskutil list
echo -e "\nRésumé d'Utilisation de Disque :"
df -h
echo -e "\nInformations de Conteneur APFS :"
diskutil apfs list
echo -e "\nInformations de Disque Physique :"
system_profiler SPStorageDataType
echo -e "\nStatut SMART :"
for disk in $(diskutil list | grep "^/dev/disk[0-9]" | awk '{print $1}'); do
echo "Statut SMART pour $disk :"
smartctl -H "$disk" 2>/dev/null || echo " Données SMART non disponibles"
done
}
# Exécuter l'analyse complète
get_comprehensive_disk_infoCatégories de Gestion de Stockage
Classifications de Types de Stockage
#!/bin/bash
# Catégories de stockage d'entreprise pour gestion et application de politiques
declare -A STORAGE_CATEGORIES=(
["systeme_critique"]="Volumes système, partitions de démarrage, partitions de récupération"
["donnees_utilisateur"]="Répertoires home utilisateur, documents personnels, données d'application"
["stockage_application"]="Binaires d'application, frameworks, bibliothèques système"
["espace_developpement"]="Environnements de développement, code source, artefacts de build"
["contenu_media"]="Vidéos, images, fichiers audio, ressources créatives"
["archives_sauvegarde"]="Time Machine, sauvegardes système, stockage d'archives"
["cache_temporaire"]="Fichiers cache, données temporaires, journaux système"
["volumes_securite"]="Volumes chiffrés, conteneurs sécurisés, stockage de clés"
["stockage_reseau"]="Lecteurs réseau montés, stockage cloud, volumes distants"
["peripheriques_externes"]="Clés USB, disques durs externes, stockage amovible"
)
# Niveaux de risque de stockage
declare -A RISK_LEVELS=(
["systeme_critique"]="critique"
["donnees_utilisateur"]="eleve"
["stockage_application"]="moyen"
["espace_developpement"]="moyen"
["contenu_media"]="faible"
["archives_sauvegarde"]="eleve"
["cache_temporaire"]="faible"
["volumes_securite"]="critique"
["stockage_reseau"]="moyen"
["peripheriques_externes"]="eleve"
)
# Priorités de gestion
declare -A MANAGEMENT_PRIORITIES=(
["systeme_critique"]="protection_maximale"
["donnees_utilisateur"]="protection_elevee"
["stockage_application"]="protection_standard"
["espace_developpement"]="protection_standard"
["contenu_media"]="protection_basique"
["archives_sauvegarde"]="protection_maximale"
["cache_temporaire"]="priorite_nettoyage"
["volumes_securite"]="protection_maximale"
["stockage_reseau"]="priorite_surveillance"
["peripheriques_externes"]="verification_securite"
)
print_storage_categories() {
echo "=== Catégories de Gestion de Stockage ==="
for category in "${!STORAGE_CATEGORIES[@]}"; do
echo "Catégorie : $category"
echo " Description : ${STORAGE_CATEGORIES[$category]}"
echo " Niveau de Risque : ${RISK_LEVELS[$category]}"
echo " Priorité de Gestion : ${MANAGEMENT_PRIORITIES[$category]}"
echo ""
done
}
# Afficher les catégories disponibles
print_storage_categoriesPolitiques de Gestion de Disque
Moteur de Politique de Stockage
#!/bin/bash
# Politiques de gestion de stockage pour différentes exigences organisationnelles
declare -A STORAGE_POLICIES=(
["entreprise_standard"]="Stockage d'entreprise standard avec sauvegarde et surveillance"
["securite_elevee_financiere"]="Stockage haute sécurité pour données financières et sensibles"
["flux_creatif"]="Optimisé pour équipes créatives avec gros fichiers média"
["environnement_developpement"]="Axé développement avec contrôle de version et optimisation de build"
["conformite_stricte"]="Conformité stricte avec exigences de rétention et audit des données"
["optimise_performance"]="Axé performance avec optimisation SSD et mise en cache"
["efficace_cout"]="Stockage rentable avec hiérarchisation intelligente et nettoyage"
)
# Configurations de politique
get_storage_policy() {
local policy_type="$1"
case "$policy_type" in
"entreprise_standard")
cat << EOF
{
"chiffrement_requis": true,
"frequence_sauvegarde": "quotidienne",
"periode_retention": "90_jours",
"compression_activee": true,
"deduplication": true,
"niveau_surveillance": "standard",
"analyse_securite": true,
"nettoyage_automatique": false,
"optimisation_performance": "equilibree",
"cadres_conformite": ["iso27001"],
"surveillance_sante_disque": true,
"quotas_stockage": {
"donnees_utilisateur": "100GB",
"stockage_application": "50GB",
"cache_temporaire": "10GB"
}
}
EOF
;;
"securite_elevee_financiere")
cat << EOF
{
"chiffrement_requis": true,
"niveau_chiffrement": "aes256",
"frequence_sauvegarde": "continue",
"periode_retention": "2555_jours",
"compression_activee": false,
"deduplication": false,
"niveau_surveillance": "complet",
"analyse_securite": true,
"nettoyage_automatique": false,
"optimisation_performance": "securite_prioritaire",
"cadres_conformite": ["sox", "pci_dss", "nist"],
"surveillance_sante_disque": true,
"sauvegardes_immuables": true,
"journalisation_acces": "detaillee",
"verification_integrite": "continue",
"quotas_stockage": {
"donnees_utilisateur": "50GB",
"stockage_application": "25GB",
"cache_temporaire": "5GB",
"journaux_audit": "illimite"
}
}
EOF
;;
"flux_creatif")
cat << EOF
{
"chiffrement_requis": false,
"frequence_sauvegarde": "basee_projet",
"periode_retention": "365_jours",
"compression_activee": false,
"deduplication": false,
"niveau_surveillance": "performance",
"analyse_securite": false,
"nettoyage_automatique": true,
"optimisation_performance": "vitesse_prioritaire",
"cadres_conformite": ["confidentialite_client"],
"surveillance_sante_disque": true,
"optimisation_gros_fichiers": true,
"acceleration_cache": true,
"quotas_stockage": {
"donnees_utilisateur": "500GB",
"contenu_media": "2TB",
"archives_projet": "1TB",
"cache_temporaire": "100GB"
}
}
EOF
;;
*)
echo "Politique de stockage inconnue : $policy_type"
return 1
;;
esac
}
# Appliquer une politique de stockage
apply_storage_policy() {
local policy="$1"
local config_file="/tmp/politique_stockage.json"
echo "Application de la politique de stockage : $policy"
get_storage_policy "$policy" > "$config_file"
if [[ ! -f "$config_file" ]]; then
echo "❌ Échec de génération de la configuration de politique"
return 1
fi
echo "✅ Politique de stockage appliquée avec succès"
echo "Configuration : $config_file"
# Afficher les paramètres clés de la politique
echo "=== Résumé de Politique ==="
echo "Chiffrement Requis : $(jq -r '.chiffrement_requis' "$config_file")"
echo "Fréquence Sauvegarde : $(jq -r '.frequence_sauvegarde' "$config_file")"
echo "Période Rétention : $(jq -r '.periode_retention' "$config_file")"
echo "Niveau Surveillance : $(jq -r '.niveau_surveillance' "$config_file")"
echo "Optimisation Performance : $(jq -r '.optimisation_performance' "$config_file")"
return 0
}Opérations de Disque Avancées
Effacement Sécurisé de Disque
#!/bin/bash
# Effacement sécurisé de disque amélioré avec vérification
secure_erase_volume() {
local identifier="$1"
local security_level="$2"
local new_name="$3"
local filesystem_type="${4:-APFS}"
echo "=== Effacement Sécurisé de Volume ==="
echo "Cible : $identifier"
echo "Niveau de Sécurité : $security_level"
echo "Nouveau Nom : $new_name"
echo "Système de Fichiers : $filesystem_type"
# Vérifier que le disque existe
if ! diskutil info "$identifier" &>/dev/null; then
echo "❌ Erreur : Identifiant de disque '$identifier' non trouvé"
return 1
fi
# Obtenir les informations de disque avant effacement
local disk_info
disk_info=$(diskutil info "$identifier")
echo "Informations de Disque :"
echo "$disk_info"
# Invite de confirmation
echo ""
echo "⚠️ ATTENTION : Ceci effacera définitivement toutes les données sur $identifier"
echo "Volume actuel : $(echo "$disk_info" | grep "Volume Name:" | awk -F': ' '{print $2}')"
echo "Taille : $(echo "$disk_info" | grep "Disk Size:" | awk -F': ' '{print $2}')"
read -p "Tapez 'CONFIRMER' pour procéder à l'effacement : " confirmation
if [[ "$confirmation" != "CONFIRMER" ]]; then
echo "❌ Opération annulée par l'utilisateur"
return 1
fi
# Effectuer l'effacement sécurisé basé sur le niveau de sécurité
case "$security_level" in
"basique")
echo "Effacement basique en cours..."
diskutil eraseVolume "$filesystem_type" "$new_name" "$identifier"
;;
"securise")
echo "Effacement sécurisé en cours (DoD 5220.22-M)..."
diskutil secureErase freespace 3 "$identifier"
diskutil eraseVolume "$filesystem_type" "$new_name" "$identifier"
;;
"militaire")
echo "Effacement niveau militaire en cours (7 passes)..."
diskutil secureErase freespace 4 "$identifier"
diskutil eraseVolume "$filesystem_type" "$new_name" "$identifier"
;;
*)
echo "❌ Niveau de sécurité inconnu : $security_level"
return 1
;;
esac
# Vérifier la completion de l'effacement
if diskutil info "$identifier" | grep -q "Volume Name.*$new_name"; then
echo "✅ Effacement sécurisé terminé avec succès"
echo "Nouveau volume : $new_name"
echo "Système de fichiers : $filesystem_type"
# Journaliser l'opération
audit_log "Effacement sécurisé terminé : $identifier -> $new_name (Sécurité : $security_level)"
return 0
else
echo "❌ Échec de vérification d'effacement"
return 1
fi
}
# Exemple d'utilisation
# secure_erase_volume "disk2s1" "securise" "VolumeNettoyé" "APFS"Système de Gestion de Stockage d'Entreprise
#!/bin/bash
# Système de Gestion de Stockage d'Entreprise MacFleet
# Gestion complète de disque et stockage
# Configuration
CONFIG_DIR="/etc/macfleet/stockage"
LOG_FILE="/var/log/macfleet_gestion_stockage.log"
DATA_DIR="/var/data/macfleet/stockage"
REPORTS_DIR="/var/reports/macfleet/stockage"
AUDIT_LOG="/var/log/macfleet_audit_stockage.log"
BACKUP_DIR="/var/backups/macfleet/stockage"
# Créer les répertoires requis
create_directories() {
local directories=("$CONFIG_DIR" "$DATA_DIR" "$REPORTS_DIR" "$BACKUP_DIR")
for dir in "${directories[@]}"; do
if [[ ! -d "$dir" ]]; then
sudo mkdir -p "$dir"
sudo chmod 755 "$dir"
fi
done
}
# Fonctions de journalisation
log_action() {
echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] $1" | tee -a "$LOG_FILE"
}
log_error() {
echo "$(date '+%Y-%m-%d %H:%M:%S') [ERREUR] $1" | tee -a "$LOG_FILE" >&2
}
audit_log() {
echo "$(date '+%Y-%m-%d %H:%M:%S') [AUDIT] $1" | tee -a "$AUDIT_LOG"
}
# Gestion d'inventaire de stockage
initialize_storage_database() {
local db_file="$DATA_DIR/inventaire_stockage.json"
if [[ ! -f "$db_file" ]]; then
cat > "$db_file" << EOF
{
"version": "1.0",
"cree": "$(date -Iseconds)",
"peripheriques_stockage": {},
"configurations_volume": {},
"surveillance_sante": {},
"metriques_performance": {},
"evaluations_securite": {}
}
EOF
log_action "Base de données de stockage initialisée : $db_file"
fi
}
# Découverte complète de stockage
discover_storage_infrastructure() {
local discovery_file="$DATA_DIR/decouverte_stockage_$(date +%Y%m%d_%H%M%S).json"
log_action "Début de découverte complète d'infrastructure de stockage"
echo "=== Découverte d'Infrastructure de Stockage ==="
# Périphériques de stockage physiques
echo "Découverte des périphériques de stockage physiques..."
local physical_devices
physical_devices=$(system_profiler SPStorageDataType -json)
# Volumes et partitions logiques
echo "Analyse des volumes logiques..."
local logical_volumes
logical_volumes=$(diskutil list -plist | plutil -convert json -o -)
# Conteneurs et volumes APFS
echo "Examen des conteneurs APFS..."
local apfs_containers
apfs_containers=$(diskutil apfs list -plist | plutil -convert json -o -)
# Volumes montés réseau
echo "Vérification des volumes réseau..."
local network_volumes
network_volumes=$(mount | grep -E "(nfs|smb|afp)" | jq -R . | jq -s .)
# Périphériques externes
echo "Détection des périphériques externes..."
local external_devices
external_devices=$(diskutil list external -plist | plutil -convert json -o -)
# Statut de chiffrement
echo "Évaluation du statut de chiffrement..."
local encryption_status=()
while IFS= read -r volume; do
if [[ -n "$volume" ]]; then
local encrypted="false"
if diskutil info "$volume" | grep -q "FileVault.*Yes"; then
encrypted="true"
fi
encryption_status+=("{\"volume\": \"$volume\", \"chiffre\": $encrypted}")
fi
done <<< "$(diskutil list | grep -E "^\s+[0-9]+:" | awk '{print $NF}')"
# Générer rapport de découverte complet
cat > "$discovery_file" << EOF
{
"horodatage_decouverte": "$(date -Iseconds)",
"nom_hote": "$(hostname)",
"stockage_physique": $physical_devices,
"volumes_logiques": $logical_volumes,
"conteneurs_apfs": $apfs_containers,
"volumes_reseau": $network_volumes,
"peripheriques_externes": $external_devices,
"statut_chiffrement": [$(IFS=,; echo "${encryption_status[*]}")],
"info_systeme": {
"version_os": "$(sw_vers -productVersion)",
"stockage_total": "$(df -h / | tail -1 | awk '{print $2}')",
"stockage_disponible": "$(df -h / | tail -1 | awk '{print $4}')"
}
}
EOF
log_action "Découverte de stockage terminée : $discovery_file"
# Afficher le résumé
echo ""
echo "Résumé de Découverte :"
echo " Périphériques Physiques : $(echo "$physical_devices" | jq '.SPStorageDataType | length' 2>/dev/null || echo "0")"
echo " Volumes Logiques : $(echo "$logical_volumes" | jq '.AllDisks | length' 2>/dev/null || echo "0")"
echo " Conteneurs APFS : $(echo "$apfs_containers" | jq '.Containers | length' 2>/dev/null || echo "0")"
echo " Volumes Réseau : $(echo "$network_volumes" | jq '. | length' 2>/dev/null || echo "0")"
echo " Périphériques Externes : $(echo "$external_devices" | jq '.AllDisks | length' 2>/dev/null || echo "0")"
echo " Rapport de Découverte : $discovery_file"
return 0
}
# Surveillance de santé de volume
monitor_volume_health() {
local identifier="$1"
local health_report="/tmp/sante_volume_$(date +%Y%m%d_%H%M%S).json"
echo "=== Surveillance de Santé de Volume ==="
echo "Volume Cible : $identifier"
# Initialiser le rapport de santé
cat > "$health_report" << EOF
{
"identifiant_volume": "$identifier",
"horodatage_analyse": "$(date -Iseconds)",
"nom_hote": "$(hostname)",
"verifications_sante": {}
}
EOF
# Vérification de volume
echo "Exécution de vérification de volume..."
local verify_output
verify_output=$(diskutil verifyVolume "$identifier" 2>&1)
local verify_status=$?
# Analyser les résultats de vérification
local verification_passed=false
if [[ $verify_status -eq 0 ]] && echo "$verify_output" | grep -q "appears to be OK"; then
verification_passed=true
fi
# Vérification statut SMART (si supporté)
echo "Vérification du statut SMART..."
local smart_status="inconnu"
local physical_disk
physical_disk=$(diskutil info "$identifier" | grep "Part of Whole" | awk '{print $4}')
if [[ -n "$physical_disk" ]]; then
if smartctl -H "$physical_disk" 2>/dev/null | grep -q "PASSED"; then
smart_status="reussi"
elif smartctl -H "$physical_disk" 2>/dev/null | grep -q "FAILED"; then
smart_status="echec"
fi
fi
# Analyse d'utilisation de disque
echo "Analyse d'utilisation de disque..."
local disk_usage
disk_usage=$(df -h "$identifier" 2>/dev/null | tail -1)
local usage_percent
usage_percent=$(echo "$disk_usage" | awk '{print $5}' | tr -d '%')
# Test de performance
echo "Exécution de test de performance..."
local write_speed read_speed
local test_file="/Volumes/$(diskutil info "$identifier" | grep "Mount Point" | awk -F': ' '{print $2}' | xargs)/test_vitesse_$$"
if [[ -w "$(dirname "$test_file")" ]]; then
# Test d'écriture (10MB)
write_speed=$(dd if=/dev/zero of="$test_file" bs=1m count=10 2>&1 | grep "bytes/sec" | awk '{print $(NF-1)}')
# Test de lecture
read_speed=$(dd if="$test_file" of=/dev/null bs=1m 2>&1 | grep "bytes/sec" | awk '{print $(NF-1)}')
# Nettoyage
rm -f "$test_file"
else
write_speed="non_disponible"
read_speed="non_disponible"
fi
# Mettre à jour le rapport de santé
jq --argjson verification "$verification_passed" \
--arg smart_status "$smart_status" \
--argjson usage_percent "${usage_percent:-0}" \
--arg write_speed "$write_speed" \
--arg read_speed "$read_speed" \
'.verifications_sante = {
"verification_systeme_fichiers": $verification,
"statut_smart": $smart_status,
"pourcentage_utilisation_disque": $usage_percent,
"vitesse_ecriture_mbps": $write_speed,
"vitesse_lecture_mbps": $read_speed
}' "$health_report" > "${health_report}.tmp" && mv "${health_report}.tmp" "$health_report"
# Évaluation de santé
local health_score=100
local issues=()
if [[ "$verification_passed" != "true" ]]; then
((health_score -= 30))
issues+=("corruption_systeme_fichiers")
fi
if [[ "$smart_status" == "echec" ]]; then
((health_score -= 50))
issues+=("echec_smart")
fi
if [[ ${usage_percent:-0} -gt 90 ]]; then
((health_score -= 20))
issues+=("espace_disque_critique")
elif [[ ${usage_percent:-0} -gt 80 ]]; then
((health_score -= 10))
issues+=("alerte_espace_disque")
fi
# Ajouter score de santé et problèmes au rapport
jq --argjson health_score "$health_score" \
--argjson issues "$(printf '%s\n' "${issues[@]}" | jq -R . | jq -s .)" \
'.evaluation_sante = {
"score_global": $health_score,
"problemes_detectes": $issues,
"recommandations": []
}' "$health_report" > "${health_report}.tmp" && mv "${health_report}.tmp" "$health_report"
# Afficher les résultats
echo ""
echo "Résultats d'Évaluation de Santé :"
echo " Score de Santé Global : $health_score/100"
echo " Vérification Système de Fichiers : $([ "$verification_passed" = "true" ] && echo "✅ RÉUSSI" || echo "❌ ÉCHEC")"
echo " Statut SMART : $smart_status"
echo " Utilisation Disque : ${usage_percent:-0}%"
echo " Vitesse Écriture : $write_speed"
echo " Vitesse Lecture : $read_speed"
if [[ ${#issues[@]} -gt 0 ]]; then
echo " Problèmes Détectés :"
for issue in "${issues[@]}"; do
echo " - $issue"
done
else
echo " ✅ Aucun problème détecté"
fi
echo " Rapport de Santé : $health_report"
# Journaliser la vérification de santé
audit_log "Vérification santé volume terminée : $identifier (Score : $health_score/100)"
return 0
}
# Fonction principale avec routage de commandes
main() {
local command="$1"
shift
# Initialiser
create_directories
initialize_storage_database
case "$command" in
"lister")
# Liste de disques améliorée
get_comprehensive_disk_info
;;
"verification_sante")
monitor_volume_health "$@"
;;
"effacement_securise")
secure_erase_volume "$@"
;;
"decouvrir")
discover_storage_infrastructure
;;
"appliquer_politique")
apply_storage_policy "$@"
;;
"afficher_categories")
print_storage_categories
;;
"afficher_politiques")
for policy in entreprise_standard securite_elevee_financiere flux_creatif environnement_developpement conformite_stricte optimise_performance efficace_cout; do
echo "Politique : $policy"
get_storage_policy "$policy" | jq .
echo ""
done
;;
*)
echo "Système de Gestion de Stockage d'Entreprise MacFleet"
echo "Utilisation : $0 <commande> [options]"
echo ""
echo "Commandes :"
echo " lister - Liste et analyse de disques améliorées"
echo " verification_sante <identifiant> - Surveillance complète de santé de volume"
echo " effacement_securise <id> <niveau> <nom> - Effacement sécurisé de volume"
echo " decouvrir - Découverte d'infrastructure de stockage"
echo " appliquer_politique <politique> - Appliquer politique de gestion de stockage"
echo " afficher_categories - Afficher catégories de stockage"
echo " afficher_politiques - Afficher politiques de stockage"
echo ""
echo "Exemples :"
echo " $0 lister"
echo " $0 verification_sante disk1s1"
echo " $0 effacement_securise disk2s1 securise DisqueNettoye"
echo " $0 decouvrir"
echo " $0 appliquer_politique entreprise_standard"
;;
esac
}
# Exécuter la fonction principale avec tous les arguments
main "$@"Configuration de Déploiement en Flotte
Exemple de Configuration de Flotte
{
"nom_flotte": "Stockage d'Entreprise MacFleet",
"date_deploiement": "2025-07-07",
"hotes": [
"mac-poste-01.entreprise.com",
"mac-serveur-01.entreprise.com",
"mac-dev-01.entreprise.com"
],
"politiques_stockage": {
"defaut": "entreprise_standard",
"hotes_securises": "securite_elevee_financiere",
"hotes_creatifs": "flux_creatif"
},
"planning_surveillance": {
"verifications_sante": "quotidiennes",
"surveillance_performance": "hebdomadaire",
"audits_securite": "mensuels"
}
}Exemple de Liste de Volumes pour Opérations en Masse
# Liste de Volumes pour Opérations en Masse
# Format : identifiant|nom|systeme_fichiers
disk1s1|Macintosh HD|APFS
disk2s1|Volume Données|APFS
disk3s1|Disque Sauvegarde|APFS
disk4s1|Stockage Externe|ExFATConsidérations de Sécurité
Sécurité de Stockage
- Application de Chiffrement - S'assurer que tous les volumes sensibles sont chiffrés avec FileVault
- Effacement Sécurisé - Plusieurs niveaux de sécurité pour destruction appropriée des données
- Contrôles d'Accès - Surveiller et contrôler l'accès aux ressources de stockage
- Surveillance d'Intégrité - Vérification continue de l'intégrité du stockage
- Détection de Menaces - Analyser l'accès non autorisé et activités suspectes
Cadre de Conformité
- Rétention de Données - Application automatisée des politiques de rétention de données
- Pistes d'Audit - Journalisation complète de toutes les opérations de stockage
- Standards de Chiffrement - Conformité avec AES-256 et autres exigences de chiffrement
- Vérification de Sauvegarde - Vérification automatisée de l'intégrité des sauvegardes
- Récupération après Sinistre - Procédures de récupération après sinistre axées stockage
Optimisation de Performance
Performance de Stockage
- Optimisation SSD - Activation TRIM et optimisation d'usure
- Optimisation APFS - Défragmentation de conteneur et gestion d'instantanés
- Gestion de Cache - Mise en cache intelligente et optimisation mémoire
- Surveillance I/O - Surveillance en temps réel de la performance I/O de stockage
- Détection de Goulots d'Étranglement - Détection et résolution automatisées des problèmes de performance
Guide de Dépannage
Problèmes Courants
Échecs de Vérification de Disque
- Exécuter First Aid depuis Utilitaire de Disque
- Démarrer depuis Mode Récupération pour réparations de volume système
- Vérifier problèmes matériels avec Diagnostics Apple
Dégradation de Performance
- Surveiller statut SMART pour santé du lecteur
- Vérifier fragmentation sur anciens systèmes de fichiers
- Vérifier espace libre adéquat (maintenir 10-15% libre)
Problèmes de Montage/Démontage
- Vérifier processus utilisant le volume :
lsof /Volumes/NomVolume - Forcer le démontage si nécessaire :
diskutil unmount force /dev/diskXsY - Vérifier intégrité système de fichiers avant remontage
Commandes de Diagnostic
# Vérifier santé de disque
diskutil verifyVolume disk1s1
# Surveiller I/O de disque
iostat -d 1
# Vérifier utilisation système de fichiers
df -h
# Voir statut SMART
smartctl -a /dev/disk0Notes Importantes
- Sécurité des Données - Toujours sauvegarder les données critiques avant d'effectuer des opérations de disque
- Privilèges Administratifs - La plupart des opérations de disque nécessitent un accès sudo/administrateur
- Tests - Tester tous les scripts sur systèmes non-production avant déploiement en flotte
- Planification de Récupération - Maintenir des lecteurs de récupération amorçables et stratégies de sauvegarde
- Surveillance - Implémenter surveillance continue pour détection précoce de problèmes
- Documentation - Conserver des enregistrements détaillés de toutes les configurations et changements de stockage