Gestion des Mises à Jour macOS
Implémentez une gestion de mises à jour macOS de niveau entreprise sur votre déploiement Roundfleet avec un déploiement automatisé de correctifs, une surveillance de conformité, des déploiements échelonnés et des politiques de mise à jour complètes. Ce tutoriel fournit des solutions pour maintenir les correctifs de sécurité et la currency du système d'exploitation tout en minimisant les perturbations des opérations commerciales.
Comprendre la Gestion des Mises à Jour macOS
macOS fournit plusieurs méthodes pour gérer les mises à jour du système d'exploitation de manière programmatique :
- Utilitaire Software Update - Outil en ligne de commande pour vérifier et installer les mises à jour
- startosinstall - Installation directe du système depuis les applications d'installation
- Commandes de Mise à Jour MDM - Intégration avec la gestion des appareils mobiles
- Profils de Configuration - Contrôle des mises à jour basé sur les politiques
- Service de Recherche de Logiciels Apple - Vérification de disponibilité des mises à jour
Opérations de Mise à Jour de Base
Lister les Mises à Jour Disponibles
#!/bin/bash
# Lister toutes les versions de système disponibles pour installation
softwareupdate --list-full-installers | grep 'macOS' | awk '{print ++count " " $0}'Télécharger l'Installeur du Système
#!/bin/bash
# Récupérer l'installeur d'une version spécifique du système
softwareupdate --fetch-full-installer --full-installer-version 12.1
echo "Installeur du système téléchargé avec succès"Installer la Mise à Jour du Système
#!/bin/bash
# Installation basique de mise à jour système
osVersion="$1"
majorVersion=$(echo $osVersion | cut -d "." -f 1)
minorVersion=$(echo $osVersion | cut -d "." -f 2)
if [ $majorVersion == "12" ]; then
installerPath="Install macOS Monterey.app"
elif [ $majorVersion == "11" ]; then
installerPath="Install macOS Big Sur.app"
elif [ $minorVersion == "15"* ]; then
installerPath="Install macOS Catalina.app"
fi
fullPath="/Applications/$installerPath/Contents/Resources/startosinstall"
softwareupdate --fetch-full-installer --full-installer-version $osVersion
echo <Password> | "$fullPath" --agreetolicense --forcequitapps --nointeraction --user <Username> --stdinpassSystème de Gestion des Mises à Jour Entreprise
Outil de Gestion des Mises à Jour Complet
#!/bin/bash
# Outil de Gestion des Mises à Jour macOS Entreprise Roundfleet
# Déploiement automatisé de correctifs et surveillance de conformité
# Configuration
CONFIG_FILE="/etc/roundfleet/update_policy.conf"
LOG_FILE="/var/log/roundfleet_updates.log"
CACHE_DIR="/Library/Roundfleet/Updates"
REPORT_DIR="/var/log/roundfleet_reports"
# Créer les répertoires
mkdir -p "$(dirname "$CONFIG_FILE")" "$(dirname "$LOG_FILE")" "$CACHE_DIR" "$REPORT_DIR"
# Politique de mise à jour par défaut
cat > "$CONFIG_FILE" 2>/dev/null << 'EOF' || true
# Politique de Gestion des Mises à Jour macOS Roundfleet
# Version : 2.0
# Application des Mises à Jour
ENFORCE_SECURITY_UPDATES=true
ALLOW_MAJOR_OS_UPDATES=false
AUTO_INSTALL_SECURITY_PATCHES=true
DEFER_MAJOR_UPDATES_DAYS=30
# Configuration de Planification
UPDATE_CHECK_INTERVAL=86400 # 24 heures
MAINTENANCE_WINDOW_START="02:00"
MAINTENANCE_WINDOW_END="06:00"
WEEKEND_UPDATES_ALLOWED=true
BUSINESS_HOURS_UPDATES=false
# Stratégie de Déploiement
STAGED_ROLLOUT=true
PILOT_GROUP_PERCENTAGE=10
PRODUCTION_DELAY_DAYS=7
EMERGENCY_PATCH_IMMEDIATE=true
# Exigences Système
MIN_BATTERY_PERCENTAGE=50
MIN_FREE_SPACE_GB=20
REQUIRE_AC_POWER=true
MAX_REBOOT_ATTEMPTS=3
# Paramètres de Notification
NOTIFY_USERS_BEFORE_UPDATE=true
NOTIFICATION_LEAD_TIME_HOURS=24
FORCE_UPDATE_AFTER_DEFERRALS=5
SEND_COMPLETION_REPORTS=true
# Paramètres de Compatibilité
EXCLUDE_BETA_UPDATES=true
VALIDATE_APP_COMPATIBILITY=true
BACKUP_BEFORE_MAJOR_UPDATE=true
EOF
# Charger la configuration
source "$CONFIG_FILE" 2>/dev/null || true
# Fonction de journalisation
log_action() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}
# Obtenir la version macOS actuelle
get_current_version() {
sw_vers -productVersion
}
# Obtenir les mises à jour disponibles
get_available_updates() {
echo "=== Mises à Jour Disponibles ==="
# Vérifier les mises à jour logicielles
local updates
updates=$(softwareupdate --list 2>/dev/null)
if echo "$updates" | grep -q "No new software available"; then
echo "✅ Le système est à jour"
return 0
else
echo "Mises à jour disponibles :"
echo "$updates"
return 1
fi
}
# Obtenir les installeurs de système disponibles
get_available_installers() {
echo "=== Installeurs de Système Disponibles ==="
# Lister les installeurs complets
local installers
installers=$(softwareupdate --list-full-installers 2>/dev/null)
if [[ -n "$installers" ]]; then
echo "$installers" | grep 'macOS' | awk '{print ++count " " $0}'
else
echo "Aucun installeur de système disponible"
fi
}
# Vérifier la préparation du système pour les mises à jour
check_update_readiness() {
echo "=== Vérification de Préparation aux Mises à Jour ==="
local issues=0
local warnings=0
# Vérifier le niveau de batterie
local battery_level
if command -v pmset >/dev/null; then
battery_level=$(pmset -g batt | grep -Eo "\d+%" | tr -d '%' | head -1)
if [[ -n "$battery_level" && $battery_level -lt $MIN_BATTERY_PERCENTAGE ]]; then
echo "❌ Niveau de batterie trop faible : ${battery_level}% (min : ${MIN_BATTERY_PERCENTAGE}%)"
((issues++))
else
echo "✅ Niveau de batterie adéquat : ${battery_level:-Alimentation CA}%"
fi
fi
# Vérifier l'alimentation CA si requise
if [[ "$REQUIRE_AC_POWER" == "true" ]]; then
local ac_power
ac_power=$(pmset -g ps | grep "AC Power" || echo "")
if [[ -z "$ac_power" ]]; then
echo "❌ Alimentation CA requise mais non connectée"
((issues++))
else
echo "✅ Alimentation CA connectée"
fi
fi
# Vérifier l'espace disque libre
local free_space_gb
free_space_gb=$(df / | awk 'NR==2 {print int($4/1024/1024)}')
if [[ $free_space_gb -lt $MIN_FREE_SPACE_GB ]]; then
echo "❌ Espace disque insuffisant : ${free_space_gb}GB (min : ${MIN_FREE_SPACE_GB}GB)"
((issues++))
else
echo "✅ Espace disque suffisant : ${free_space_gb}GB"
fi
# Vérifier si le système est dans la fenêtre de maintenance
local current_time
current_time=$(date '+%H:%M')
if [[ "$current_time" > "$MAINTENANCE_WINDOW_START" && "$current_time" < "$MAINTENANCE_WINDOW_END" ]]; then
echo "✅ Dans la fenêtre de maintenance"
else
echo "⚠️ Hors de la fenêtre de maintenance (actuel : $current_time)"
((warnings++))
fi
# Vérifier si les mises à jour de week-end sont autorisées
local day_of_week
day_of_week=$(date '+%u') # 1=Lundi, 7=Dimanche
if [[ $day_of_week -gt 5 ]] && [[ "$WEEKEND_UPDATES_ALLOWED" != "true" ]]; then
echo "❌ Mises à jour de week-end non autorisées"
((issues++))
fi
echo "Résumé de préparation : $issues problèmes, $warnings avertissements"
return $issues
}
# Installer les mises à jour de sécurité
install_security_updates() {
echo "=== Installation des Mises à Jour de Sécurité ==="
if [[ "$AUTO_INSTALL_SECURITY_PATCHES" != "true" ]]; then
echo "Installation automatique des mises à jour de sécurité désactivée"
return 0
fi
# Vérifier la préparation
if ! check_update_readiness >/dev/null; then
echo "❌ Système non prêt pour les mises à jour"
return 1
fi
# Installer les mises à jour recommandées
echo "Installation des mises à jour de sécurité et recommandées..."
log_action "Démarrage de l'installation des mises à jour de sécurité"
# Utiliser softwareupdate pour installer les mises à jour recommandées
if softwareupdate --install --recommended --verbose; then
echo "✅ Mises à jour de sécurité installées avec succès"
log_action "Mises à jour de sécurité installées avec succès"
# Vérifier si un redémarrage est requis
if softwareupdate --list | grep -q "restart"; then
echo "⚠️ Redémarrage système requis"
log_action "Redémarrage système requis après mises à jour de sécurité"
fi
return 0
else
echo "❌ Échec de l'installation des mises à jour de sécurité"
log_action "ÉCHEC : Installation des mises à jour de sécurité"
return 1
fi
}
# Télécharger l'installeur du système
download_os_installer() {
local target_version="$1"
echo "=== Téléchargement de l'Installeur du Système ==="
echo "Version cible : $target_version"
# Valider le format de version
if [[ ! "$target_version" =~ ^[0-9]+\.[0-9]+(\.[0-9]+)?$ ]]; then
echo "❌ Format de version invalide : $target_version"
return 1
fi
# Télécharger l'installeur
echo "Téléchargement de l'installeur macOS $target_version..."
log_action "Téléchargement de l'installeur macOS : $target_version"
if softwareupdate --fetch-full-installer --full-installer-version "$target_version"; then
echo "✅ Installeur macOS téléchargé avec succès"
log_action "Installeur macOS téléchargé : $target_version"
# Vérifier que l'installeur existe
local installer_path
installer_path=$(find /Applications -name "Install macOS*.app" -path "*$target_version*" 2>/dev/null | head -1)
if [[ -n "$installer_path" && -d "$installer_path" ]]; then
echo "Emplacement de l'installeur : $installer_path"
return 0
else
# Vérifier l'installeur par version majeure
local major_version
major_version=$(echo "$target_version" | cut -d'.' -f1)
case "$major_version" in
"15")
installer_path="/Applications/Install macOS Sequoia.app"
;;
"14")
installer_path="/Applications/Install macOS Sonoma.app"
;;
"13")
installer_path="/Applications/Install macOS Ventura.app"
;;
"12")
installer_path="/Applications/Install macOS Monterey.app"
;;
"11")
installer_path="/Applications/Install macOS Big Sur.app"
;;
*)
echo "❌ Version macOS inconnue : $target_version"
return 1
;;
esac
if [[ -d "$installer_path" ]]; then
echo "Installeur trouvé : $installer_path"
return 0
else
echo "❌ Installeur non trouvé après téléchargement"
return 1
fi
fi
else
echo "❌ Échec du téléchargement de l'installeur macOS"
log_action "ÉCHEC : Téléchargement de l'installeur macOS pour $target_version"
return 1
fi
}
# Installer une mise à jour majeure du système
install_major_update() {
local target_version="$1"
local admin_user="$2"
local admin_password="$3"
echo "=== Installation de Mise à Jour Majeure du Système ==="
echo "Version cible : $target_version"
echo "Utilisateur admin : $admin_user"
if [[ "$ALLOW_MAJOR_OS_UPDATES" != "true" ]]; then
echo "❌ Mises à jour majeures du système non autorisées par la politique"
return 1
fi
# Vérifier la préparation
if ! check_update_readiness; then
echo "❌ Système non prêt pour une mise à jour majeure"
return 1
fi
# Trouver l'installeur
local installer_path
local major_version
major_version=$(echo "$target_version" | cut -d'.' -f1)
case "$major_version" in
"15")
installer_path="/Applications/Install macOS Sequoia.app"
;;
"14")
installer_path="/Applications/Install macOS Sonoma.app"
;;
"13")
installer_path="/Applications/Install macOS Ventura.app"
;;
"12")
installer_path="/Applications/Install macOS Monterey.app"
;;
"11")
installer_path="/Applications/Install macOS Big Sur.app"
;;
*)
echo "❌ Version macOS non supportée : $target_version"
return 1
;;
esac
if [[ ! -d "$installer_path" ]]; then
echo "Installeur non trouvé, téléchargement..."
if ! download_os_installer "$target_version"; then
return 1
fi
fi
# Préparer la commande d'installation
local install_cmd="$installer_path/Contents/Resources/startosinstall"
local install_args="--agreetolicense --forcequitapps --nointeraction"
# Vérifier si c'est un Mac Apple Silicon (nécessite des identifiants)
if system_profiler SPHardwareDataType | grep -q "Apple M"; then
if [[ -z "$admin_user" || -z "$admin_password" ]]; then
echo "❌ Mac Apple Silicon nécessite des identifiants administrateur"
return 1
fi
install_args="$install_args --user $admin_user --stdinpass"
fi
echo "Démarrage de l'installation macOS..."
log_action "Démarrage de la mise à jour majeure vers $target_version"
# Exécuter l'installation
if [[ -n "$admin_password" ]]; then
echo "$admin_password" | "$install_cmd" $install_args
else
"$install_cmd" $install_args
fi
local result=$?
if [[ $result -eq 0 ]]; then
echo "✅ Mise à jour macOS initiée avec succès"
log_action "Mise à jour macOS initiée avec succès vers $target_version"
echo "⚠️ Le système redémarrera pour terminer l'installation"
else
echo "❌ Échec de l'initiation de la mise à jour macOS (code de sortie : $result)"
log_action "ÉCHEC : Initiation de la mise à jour macOS vers $target_version (code de sortie : $result)"
fi
return $result
}
# Générer un rapport de conformité des mises à jour
generate_update_report() {
local report_file="$REPORT_DIR/update_compliance_$(date +%Y%m%d_%H%M%S).json"
echo "=== Génération du Rapport de Conformité des Mises à Jour ==="
# Obtenir les informations système actuelles
local current_version
current_version=$(sw_vers -productVersion)
local build_version
build_version=$(sw_vers -buildVersion)
local hardware_model
hardware_model=$(system_profiler SPHardwareDataType | grep "Model Identifier" | awk -F: '{print $2}' | xargs)
# Vérifier les mises à jour disponibles
local updates_available="false"
local security_updates_available="false"
if ! softwareupdate --list 2>/dev/null | grep -q "No new software available"; then
updates_available="true"
if softwareupdate --list 2>/dev/null | grep -i "security\|recommended"; then
security_updates_available="true"
fi
fi
# Calculer les jours depuis la dernière mise à jour
local last_update_date
last_update_date=$(system_profiler SPInstallHistoryDataType | grep "Install Date" | head -1 | awk -F: '{print $2}' | xargs)
local days_since_update="inconnu"
if [[ -n "$last_update_date" ]]; then
local last_update_epoch
last_update_epoch=$(date -j -f "%m/%d/%y" "$last_update_date" "+%s" 2>/dev/null || echo "0")
local current_epoch
current_epoch=$(date "+%s")
days_since_update=$(( (current_epoch - last_update_epoch) / 86400 ))
fi
# Créer le rapport JSON
cat > "$report_file" << EOF
{
"type_rapport": "conformite_mise_a_jour",
"horodatage": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"infos_appareil": {
"nom_hote": "$(hostname)",
"numero_serie": "$(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F: '{print $2}' | xargs)",
"modele_materiel": "$hardware_model",
"version_os_actuelle": "$current_version",
"version_build": "$build_version"
},
"statut_mise_a_jour": {
"mises_a_jour_disponibles": $updates_available,
"mises_a_jour_securite_disponibles": $security_updates_available,
"jours_depuis_derniere_mise_a_jour": $days_since_update,
"date_derniere_mise_a_jour": "$last_update_date",
"mise_a_jour_auto_activee": $(defaults read /Library/Preferences/com.apple.SoftwareUpdate AutomaticCheckEnabled 2>/dev/null || echo false)
},
"conformite_politique": {
"mises_a_jour_securite_appliquees": $ENFORCE_SECURITY_UPDATES,
"mises_a_jour_majeures_autorisees": $ALLOW_MAJOR_OS_UPDATES,
"installation_auto_activee": $AUTO_INSTALL_SECURITY_PATCHES,
"deploiement_echelonne_active": $STAGED_ROLLOUT
},
"preparation_systeme": {
"batterie_suffisante": true,
"alimentation_ca_connectee": $(pmset -g ps | grep -q "AC Power" && echo true || echo false),
"espace_disque_suffisant": true,
"dans_fenetre_maintenance": false
}
}
EOF
echo "Rapport de conformité des mises à jour sauvegardé dans : $report_file"
log_action "Rapport de conformité des mises à jour généré : $report_file"
}
# Fonction principale avec gestion d'arguments
main() {
log_action "=== Outil de Gestion des Mises à Jour Roundfleet Démarré ==="
case "${1:-status}" in
"check")
get_available_updates
;;
"security")
install_security_updates
;;
"download")
download_os_installer "$2"
;;
"install")
install_major_update "$2" "$3" "$4"
;;
"readiness")
check_update_readiness
;;
"installers")
get_available_installers
;;
"report")
generate_update_report
;;
"status"|*)
echo "Version macOS actuelle : $(get_current_version)"
get_available_updates
;;
esac
log_action "=== Opération de gestion des mises à jour terminée ==="
}
# Exécuter la fonction principale
main "$@"Gestion Avancée des Mises à Jour
Gestion du Déploiement Échelonné
#!/bin/bash
# Gestion du déploiement échelonné pour les déploiements d'entreprise
manage_staged_rollout() {
local update_version="$1"
local deployment_stage="${2:-pilot}"
echo "=== Gestion du Déploiement Échelonné ==="
echo "Version de mise à jour : $update_version"
echo "Étape de déploiement : $deployment_stage"
# Définir les groupes d'appareils
local device_serial
device_serial=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F: '{print $2}' | xargs)
# Calculer le hash pour l'affectation cohérente de groupe
local hash_value
hash_value=$(echo "$device_serial" | md5 | cut -c1-2)
local numeric_hash
numeric_hash=$(printf "%d" "0x$hash_value")
local group_percentage
group_percentage=$((numeric_hash % 100))
case "$deployment_stage" in
"pilot")
if [[ $group_percentage -lt $PILOT_GROUP_PERCENTAGE ]]; then
echo "✅ Appareil sélectionné pour le déploiement pilote"
log_action "Appareil inclus dans le groupe pilote pour $update_version"
return 0
else
echo "⏳ Appareil non dans le groupe pilote, en attente du déploiement production"
return 1
fi
;;
"production")
echo "✅ Appareil éligible pour le déploiement production"
log_action "Appareil inclus dans le déploiement production pour $update_version"
return 0
;;
"emergency")
echo "🚨 Déploiement d'urgence - contournement des étapes"
log_action "Déploiement d'urgence initié pour $update_version"
return 0
;;
*)
echo "❌ Étape de déploiement inconnue : $deployment_stage"
return 1
;;
esac
}
# Exemple d'utilisation :
# manage_staged_rollout "14.2.1" "pilot"Vérification de Compatibilité des Applications
#!/bin/bash
# Vérifier la compatibilité des applications avant les mises à jour majeures
check_app_compatibility() {
local target_version="$1"
echo "=== Vérification de Compatibilité des Applications ==="
if [[ "$VALIDATE_APP_COMPATIBILITY" != "true" ]]; then
echo "Vérification de compatibilité des applications désactivée"
return 0
fi
local incompatible_apps=()
# Vérifier les applications 32 bits (non supportées dans macOS 10.15+)
local target_major
target_major=$(echo "$target_version" | cut -d'.' -f1)
if [[ $target_major -ge 10 ]]; then
echo "Vérification des applications 32 bits..."
# Utiliser system_profiler pour trouver les applications 32 bits
local bit32_apps
bit32_apps=$(system_profiler SPApplicationsDataType | grep -B1 -A1 "64-Bit (Intel): No" | grep "Location:" | awk -F: '{print $2}' | xargs)
if [[ -n "$bit32_apps" ]]; then
echo "⚠️ Applications 32 bits trouvées :"
echo "$bit32_apps"
incompatible_apps+=("applications 32 bits")
fi
fi
# Vérifier les applications incompatibles connues
local known_incompatible=(
"/Applications/Adobe CS6"
"/Applications/Microsoft Office 2011"
"/Applications/Final Cut Pro 7"
)
for app_path in "${known_incompatible[@]}"; do
if [[ -d "$app_path" ]]; then
echo "⚠️ Application incompatible connue trouvée : $app_path"
incompatible_apps+=("$(basename "$app_path")")
fi
done
# Générer le rapport de compatibilité
if [[ ${#incompatible_apps[@]} -eq 0 ]]; then
echo "✅ Aucun problème de compatibilité détecté"
return 0
else
echo "❌ Problèmes de compatibilité trouvés :"
printf ' - %s\n' "${incompatible_apps[@]}"
# Journaliser les problèmes de compatibilité
log_action "Problèmes de compatibilité d'applications trouvés pour $target_version : ${incompatible_apps[*]}"
return 1
fi
}
check_app_compatibility "14.0"Sauvegarde Automatisée Avant Mises à Jour
#!/bin/bash
# Créer une sauvegarde système avant les mises à jour majeures
create_pre_update_backup() {
local backup_destination="${1:-/Volumes/Backup}"
echo "=== Sauvegarde Pré-Mise à Jour ==="
if [[ "$BACKUP_BEFORE_MAJOR_UPDATE" != "true" ]]; then
echo "Sauvegarde pré-mise à jour désactivée"
return 0
fi
# Vérifier la destination de sauvegarde
if [[ ! -d "$backup_destination" ]]; then
echo "❌ Destination de sauvegarde non disponible : $backup_destination"
return 1
fi
# Créer une sauvegarde Time Machine
echo "Création de la sauvegarde Time Machine..."
if tmutil startbackup --auto --block; then
echo "✅ Sauvegarde Time Machine terminée"
log_action "Sauvegarde Time Machine pré-mise à jour terminée"
else
echo "⚠️ Sauvegarde Time Machine échouée, poursuite de la mise à jour"
log_action "AVERTISSEMENT : Sauvegarde Time Machine pré-mise à jour échouée"
fi
# Créer une sauvegarde de configuration système
local config_backup="$backup_destination/roundfleet_config_$(date +%Y%m%d_%H%M%S).tar.gz"
echo "Création de la sauvegarde de configuration..."
if tar -czf "$config_backup" \
/etc/roundfleet \
/Library/Preferences \
/System/Library/LaunchDaemons/com.roundfleet.* \
2>/dev/null; then
echo "✅ Sauvegarde de configuration créée : $config_backup"
log_action "Sauvegarde de configuration créée : $config_backup"
else
echo "⚠️ Sauvegarde de configuration échouée"
log_action "AVERTISSEMENT : Sauvegarde de configuration échouée"
fi
return 0
}
create_pre_update_backupSurveillance et Conformité
Surveillance de Conformité des Mises à Jour
#!/bin/bash
# Surveiller la conformité des mises à jour dans la flotte
monitor_update_compliance() {
echo "=== Surveillance de Conformité des Mises à Jour ==="
local current_version
current_version=$(sw_vers -productVersion)
# Vérifier contre les lignes de base de sécurité
local security_baseline="14.2.1" # Exemple de ligne de base
if [[ "$(printf '%s\n' "$security_baseline" "$current_version" | sort -V | head -1)" != "$security_baseline" ]]; then
echo "❌ En dessous de la ligne de base de sécurité (actuel : $current_version, requis : $security_baseline)"
log_action "VIOLATION DE CONFORMITÉ : En dessous de la ligne de base de sécurité $security_baseline"
# Déclencher la remédiation si activée
if [[ "$ENFORCE_SECURITY_UPDATES" == "true" ]]; then
echo "Initiation de la remédiation automatique..."
install_security_updates
fi
else
echo "✅ Répond aux exigences de ligne de base de sécurité"
fi
# Vérifier les mises à jour en retard
local last_check
last_check=$(defaults read /Library/Preferences/com.apple.SoftwareUpdate LastSuccessfulDate 2>/dev/null || echo "")
if [[ -n "$last_check" ]]; then
local days_since_check
days_since_check=$(( ($(date +%s) - $(date -j -f "%Y-%m-%d %H:%M:%S %z" "$last_check" +%s 2>/dev/null || echo 0)) / 86400 ))
if [[ $days_since_check -gt 7 ]]; then
echo "⚠️ Mises à jour non vérifiées depuis $days_since_check jours"
log_action "AVERTISSEMENT : Mises à jour non vérifiées depuis $days_since_check jours"
fi
fi
}
monitor_update_complianceDéploiement de Correctifs d'Urgence
#!/bin/bash
# Déploiement de correctifs d'urgence pour les mises à jour de sécurité critiques
deploy_emergency_patch() {
local patch_version="$1"
local override_policies="${2:-false}"
echo "=== Déploiement de Correctifs d'Urgence ==="
echo "Version du correctif : $patch_version"
echo "Contournement des politiques : $override_policies"
log_action "URGENCE : Déploiement du correctif critique $patch_version"
# Contourner les restrictions normales pour les correctifs d'urgence
if [[ "$override_policies" == "true" ]]; then
# Modifier temporairement la configuration
local original_config
original_config=$(cat "$CONFIG_FILE")
# Configuration d'urgence
cat > "$CONFIG_FILE" << 'EOF'
ENFORCE_SECURITY_UPDATES=true
AUTO_INSTALL_SECURITY_PATCHES=true
EMERGENCY_PATCH_IMMEDIATE=true
REQUIRE_AC_POWER=false
MIN_BATTERY_PERCENTAGE=20
BUSINESS_HOURS_UPDATES=true
EOF
# Installer le correctif d'urgence
if install_security_updates; then
echo "✅ Correctif d'urgence déployé avec succès"
log_action "Correctif d'urgence $patch_version déployé avec succès"
else
echo "❌ Déploiement du correctif d'urgence échoué"
log_action "CRITIQUE : Déploiement du correctif d'urgence $patch_version ÉCHOUÉ"
fi
# Restaurer la configuration originale
echo "$original_config" > "$CONFIG_FILE"
else
# Déploiement d'urgence standard
install_security_updates
fi
}
# Exemple d'utilisation :
# deploy_emergency_patch "14.2.1" "true"Notes de Configuration Importantes
Outils de Mise à Jour macOS
- softwareupdate - Utilitaire de mise à jour logicielle en ligne de commande
- startosinstall - Outil d'installation directe du système
- system_profiler - Informations système et historique des mises à jour
- tmutil - Utilitaire de sauvegarde Time Machine
- pmset - Paramètres de gestion d'énergie
Considérations Apple Silicon
- Identifiants administrateur requis - Les mises à jour nécessitent une authentification utilisateur
- Politiques de démarrage sécurisé - Peuvent affecter l'installation des mises à jour
- Options de mode de récupération - Différentes des Mac Intel
- Extensions de noyau réduites - Modèle d'extension système
Bonnes Pratiques pour l'Entreprise
-
Stratégie de Déploiement Échelonné
- Tester les mises à jour sur un groupe pilote d'abord
- Surveiller les problèmes avant le déploiement complet
- Maintenir des capacités de retour en arrière
-
Gestion de Conformité
- Définir des lignes de base de sécurité
- Surveiller régulièrement le statut des mises à jour
- Automatiser les rapports de conformité
-
Atténuation des Risques
- Sauvegarder avant les mises à jour majeures
- Tester la compatibilité des applications
- Planifier pour les correctifs d'urgence
-
Communication Utilisateur
- Notifier les utilisateurs des mises à jour planifiées
- Fournir des fenêtres de maintenance claires
- Offrir des options de report dans les limites des politiques
Dépannage des Problèmes Courants
- Espace disque insuffisant - Nettoyer avant les mises à jour ou augmenter le stockage
- Exigences d'alimentation - Assurer l'alimentation CA pour les mises à jour majeures
- Connectivité réseau - Vérifier l'accès aux serveurs de mise à jour d'Apple
- Échecs d'authentification - Vérifier les identifiants administrateur sur Apple Silicon
- Échecs d'installation - Examiner les journaux système et la compatibilité
N'oubliez pas de tester minutieusement les procédures de mise à jour dans un environnement non-production avant de les déployer sur l'ensemble de votre Roundfleet.