Guide

Nouvelles mises à jour et améliorations de Roundfleet.
Suivez-nous sur X.com

Avis important

Les exemples de code et scripts fournis dans ces tutoriels sont uniquement à des fins éducatives. Roundfleet n'est pas responsable des problèmes, dommages ou vulnérabilités de sécurité qui pourraient survenir lors de l'utilisation, modification ou implémentation de ces exemples. Toujours vérifier et tester le code dans un environnement sécurisé avant de l'utiliser dans des systèmes de production.

← Tous les articles

Gestion d'Entreprise des Redémarrages Programmés sur macOS

Gérez et automatisez les redémarrages système de votre Roundfleet avec des capacités de planification de niveau entreprise. Ce tutoriel couvre la planification avancée des redémarrages, les fenêtres de maintenance, les notifications utilisateur et le déploiement à l'échelle de la flotte avec surveillance de conformité.

Comprendre la Gestion des Redémarrages macOS

Les redémarrages programmés sont essentiels pour :

  • 🔄 Maintenance système - Effacer la mémoire, appliquer les mises à jour, réinitialiser l'état système
  • 🛡️ Conformité sécuritaire - S'assurer que les correctifs de sécurité sont actifs après installation
  • ⚡ Optimisation performance - Réinitialiser l'utilisation des ressources et éliminer les fuites mémoire
  • 🏢 Planification d'entreprise - Coordonner la maintenance sur des flottes entières

Planification de Base des Redémarrages

Redémarrage Programmé par Heure

#!/bin/bash

# Programmer un redémarrage à une heure spécifique (format 24h)
# Remplacer 0300 par l'heure de redémarrage désirée (03:00 AM)
sudo shutdown -r 0300

echo "✅ Redémarrage programmé pour 03:00"

Redémarrage Immédiat avec Délai

#!/bin/bash

# Programmer un redémarrage dans X minutes
MINUTES=30
sudo shutdown -r +$MINUTES

echo "✅ Redémarrage programmé dans $MINUTES minutes"

Annuler un Redémarrage Programmé

#!/bin/bash

# Annuler tout redémarrage en attente
sudo shutdown -c

echo "✅ Redémarrage programmé annulé"

Options de Planification Avancées

Redémarrage Conditionnel avec Vérifications Système

#!/bin/bash

# Redémarrer seulement si le système remplit des conditions spécifiques
perform_system_checks() {
    echo "🔍 Exécution des vérifications système pré-redémarrage..."
    
    # Vérifier la charge système
    local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    local load_threshold=2.0
    
    if (( $(echo "$load_avg > $load_threshold" | bc -l) )); then
        echo "⚠️ Charge système trop élevée ($load_avg) - report du redémarrage"
        return 1
    fi
    
    # Vérifier les processus critiques
    local critical_processes=("backup" "sync" "deploy")
    for process in "${critical_processes[@]}"; do
        if pgrep -f "$process" > /dev/null; then
            echo "⚠️ Processus critique '$process' en cours - report du redémarrage"
            return 1
        fi
    done
    
    # Vérifier l'espace disque disponible
    local available_space=$(df / | tail -1 | awk '{print $4}')
    local min_space=1048576  # 1GB en KB
    
    if [[ $available_space -lt $min_space ]]; then
        echo "⚠️ Espace disque insuffisant - report du redémarrage"
        return 1
    fi
    
    echo "✅ Toutes les vérifications système réussies"
    return 0
}

# Programmer le redémarrage seulement si les conditions sont remplies
if perform_system_checks; then
    sudo shutdown -r +5
    echo "✅ Redémarrage programmé dans 5 minutes"
else
    echo "❌ Redémarrage reporté en raison des conditions système"
fi

Redémarrage Convivial avec Notifications

#!/bin/bash

# Redémarrage amélioré avec notifications utilisateur et période de grâce
graceful_restart() {
    local delay_minutes="${1:-15}"
    local restart_time="${2:-$(date -d "+$delay_minutes minutes" "+%H:%M")}"
    
    echo "🔔 Programmation d'un redémarrage gracieux dans $delay_minutes minutes"
    
    # Envoyer notification aux utilisateurs connectés
    local logged_users=$(who | awk '{print $1}' | sort -u)
    
    for user in $logged_users; do
        sudo -u "$user" osascript -e "display notification \"Redémarrage système programmé pour $restart_time. Veuillez sauvegarder votre travail.\" with title \"Maintenance Roundfleet\" sound name \"Glass\""
    done
    
    # Programmer le redémarrage
    sudo shutdown -r "+$delay_minutes"
    
    echo "✅ Redémarrage programmé pour $restart_time avec notifications utilisateur envoyées"
}

# Exécuter le redémarrage gracieux
graceful_restart 15

Fenêtres de Maintenance d'Entreprise

Planning de Maintenance Hebdomadaire

#!/bin/bash

# Programmer un redémarrage pendant la fenêtre de maintenance
schedule_maintenance_restart() {
    local day_of_week=$(date +%u)  # 1=Lundi, 7=Dimanche
    local current_hour=$(date +%H)
    local maintenance_day=7        # Dimanche
    local maintenance_hour=03      # 3h du matin
    
    # Calculer le temps jusqu'à la prochaine fenêtre de maintenance
    local days_until_maintenance=$(( (maintenance_day - day_of_week) % 7 ))
    if [[ $days_until_maintenance -eq 0 ]] && [[ $current_hour -ge $maintenance_hour ]]; then
        days_until_maintenance=7  # Semaine prochaine si on a dépassé la fenêtre d'aujourd'hui
    fi
    
    local restart_date=$(date -d "+$days_until_maintenance days $maintenance_hour:00" "+%Y-%m-%d %H:%M")
    local restart_timestamp=$(date -d "$restart_date" "+%m%d%H%M")
    
    echo "📅 Programmation du redémarrage pour la prochaine fenêtre de maintenance : $restart_date"
    
    # Utiliser la commande at pour une planification précise
    echo "sudo shutdown -r now" | at "$restart_timestamp" 2>/dev/null
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Redémarrage programmé pour la fenêtre de maintenance : $restart_date"
    else
        # Solution de repli si 'at' n'est pas disponible
        echo "⚠️ Commande 'at' non disponible, utilisation de la planification immédiate"
        sudo shutdown -r 0300  # 3h aujourd'hui/demain
    fi
}

schedule_maintenance_restart

Protection des Heures de Bureau

#!/bin/bash

# Empêcher les redémarrages pendant les heures de bureau
business_hours_restart() {
    local current_hour=$(date +%H)
    local current_day=$(date +%u)  # 1=Lundi, 7=Dimanche
    local business_start=9
    local business_end=17
    
    # Vérifier si c'est un jour de semaine pendant les heures de bureau
    if [[ $current_day -le 5 ]] && [[ $current_hour -ge $business_start ]] && [[ $current_hour -lt $business_end ]]; then
        echo "🏢 Heures de bureau détectées - programmation du redémarrage après les heures de bureau"
        
        if [[ $current_hour -lt 12 ]]; then
            # Matin - programmer pour le soir
            sudo shutdown -r 1800  # 18h
            echo "✅ Redémarrage programmé pour 18:00 (après les heures de bureau)"
        else
            # Après-midi - programmer pour le lendemain tôt le matin
            sudo shutdown -r 0600  # 6h le lendemain
            echo "✅ Redémarrage programmé pour 06:00 demain (avant les heures de bureau)"
        fi
    else
        echo "✅ En dehors des heures de bureau - redémarrage sûr"
        sudo shutdown -r +5
        echo "✅ Redémarrage programmé dans 5 minutes"
    fi
}

business_hours_restart

Script de Gestion d'Entreprise de Flotte

#!/bin/bash

# Système de Gestion des Redémarrages d'Entreprise Roundfleet
# Planification avancée, surveillance et déploiement de flotte

# Configuration
SCRIPT_NAME="Roundfleet Restart Manager"
VERSION="3.0.0"
LOG_FILE="/var/log/roundfleet_restart.log"
CONFIG_DIR="/etc/roundfleet/restart"
SCHEDULE_DIR="/etc/roundfleet/restart/schedules"
POLICY_DIR="/etc/roundfleet/restart/policies"
AUDIT_DIR="/etc/roundfleet/restart/audit"

# Créer les répertoires nécessaires
mkdir -p "$CONFIG_DIR" "$SCHEDULE_DIR" "$POLICY_DIR" "$AUDIT_DIR"

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

# Journalisation d'audit pour la conformité
log_restart_action() {
    local action="$1"
    local schedule_type="$2"
    local restart_time="$3"
    local user=$(whoami)
    local hostname=$(hostname)
    
    local audit_entry="{
        \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",
        \"hostname\": \"$hostname\",
        \"user\": \"$user\",
        \"action\": \"$action\",
        \"schedule_type\": \"$schedule_type\",
        \"restart_time\": \"$restart_time\",
        \"script_version\": \"$VERSION\"
    }"
    
    echo "$audit_entry" >> "$AUDIT_DIR/restart_audit.json"
    log_action "Action de redémarrage : $action - $schedule_type à $restart_time"
}

# Évaluation de la santé système
assess_system_health() {
    echo "🏥 Évaluation de la santé système pour la préparation au redémarrage..."
    
    local health_score=100
    local issues=()
    
    # Vérifier la charge système
    local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    if (( $(echo "$load_avg > 3.0" | bc -l) )); then
        health_score=$((health_score - 20))
        issues+=("Charge système élevée : $load_avg")
    fi
    
    # Vérifier l'utilisation mémoire
    local memory_pressure=$(memory_pressure | grep "System-wide memory free percentage" | awk '{print $5}' | sed 's/%//')
    if [[ $memory_pressure -lt 10 ]]; then
        health_score=$((health_score - 15))
        issues+=("Mémoire faible : ${memory_pressure}% libre")
    fi
    
    # Vérifier l'espace disque
    local disk_usage=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')
    if [[ $disk_usage -gt 90 ]]; then
        health_score=$((health_score - 10))
        issues+=("Utilisation disque élevée : ${disk_usage}%")
    fi
    
    # Vérifier les processus critiques
    local critical_procs=$(pgrep -f "(backup|sync|deploy|update)" | wc -l)
    if [[ $critical_procs -gt 0 ]]; then
        health_score=$((health_score - 25))
        issues+=("Processus critiques en cours : $critical_procs")
    fi
    
    # Vérifier la connectivité réseau
    if ! ping -c 1 -W 5 8.8.8.8 >/dev/null 2>&1; then
        health_score=$((health_score - 5))
        issues+=("Problème de connectivité réseau")
    fi
    
    # Générer le rapport de santé
    local health_report="{
        \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",
        \"hostname\": \"$(hostname)\",
        \"health_score\": $health_score,
        \"issues\": [$(printf '\"%s\",' "${issues[@]}" | sed 's/,$//')]
    }"
    
    echo "$health_report" > "$AUDIT_DIR/health_assessment_$(date +%Y%m%d_%H%M%S).json"
    
    echo "📊 Score de santé système : $health_score/100"
    if [[ ${#issues[@]} -gt 0 ]]; then
        echo "⚠️ Problèmes détectés :"
        printf '   - %s\n' "${issues[@]}"
    fi
    
    # Retourner le score de santé (0 = échec, 1 = succès)
    [[ $health_score -ge 70 ]]
}

# Système de notification avancé
send_restart_notifications() {
    local restart_time="$1"
    local minutes_until="$2"
    local notification_type="${3:-standard}"
    
    echo "🔔 Envoi des notifications de redémarrage..."
    
    # Obtenir les utilisateurs connectés
    local logged_users=$(who | awk '{print $1}' | sort -u)
    
    # Messages de notification basés sur le type
    case "$notification_type" in
        "emergency")
            local title="URGENCE : Redémarrage Système Requis"
            local message="Mise à jour de sécurité critique nécessite un redémarrage immédiat à $restart_time"
            local sound="Basso"
            ;;
        "maintenance")
            local title="Maintenance Programmée"
            local message="Redémarrage système programmé pour $restart_time dans le cadre de la maintenance de routine"
            local sound="Glass"
            ;;
        *)
            local title="Notification de Redémarrage Système"
            local message="Redémarrage système programmé pour $restart_time. Veuillez sauvegarder votre travail."
            local sound="Blow"
            ;;
    esac
    
    # Envoyer notifications à chaque utilisateur
    for user in $logged_users; do
        if [[ -n "$user" ]]; then
            sudo -u "$user" osascript -e "display notification \"$message\" with title \"$title\" sound name \"$sound\"" 2>/dev/null
            
            # Envoyer aussi un message terminal si l'utilisateur a un terminal ouvert
            sudo -u "$user" wall "Avis Roundfleet : $message" 2>/dev/null
        fi
    done
    
    log_action "Notifications envoyées aux utilisateurs : $(echo $logged_users | tr '\n' ' ')"
}

# Planification intelligente de redémarrage
intelligent_restart() {
    local schedule_type="$1"
    local target_time="$2"
    local force="${3:-false}"
    
    echo "🧠 Initiation de la planification intelligente de redémarrage..."
    
    # Évaluer la santé système sauf si forcé
    if [[ "$force" != "true" ]]; then
        if ! assess_system_health; then
            echo "❌ Vérification de santé système échouée - redémarrage reporté"
            log_restart_action "postponed" "$schedule_type" "$target_time"
            return 1
        fi
    fi
    
    case "$schedule_type" in
        "immediate")
            echo "⚡ Programmation d'un redémarrage immédiat..."
            send_restart_notifications "dans 2 minutes" "2" "emergency"
            sudo shutdown -r +2
            ;;
        "maintenance")
            echo "🔧 Programmation d'un redémarrage de maintenance..."
            local delay_minutes=15
            local restart_time=$(date -d "+$delay_minutes minutes" "+%H:%M")
            send_restart_notifications "$restart_time" "$delay_minutes" "maintenance"
            sudo shutdown -r "+$delay_minutes"
            ;;
        "business_safe")
            schedule_business_safe_restart
            ;;
        "weekly")
            schedule_weekly_maintenance
            ;;
        "custom")
            if [[ -n "$target_time" ]]; then
                echo "🎯 Programmation d'un redémarrage personnalisé pour $target_time..."
                send_restart_notifications "$target_time" "personnalisé" "standard"
                sudo shutdown -r "$target_time"
            else
                echo "❌ Le redémarrage personnalisé nécessite une heure cible"
                return 1
            fi
            ;;
        *)
            echo "❌ Type de planification invalide : $schedule_type"
            echo "Types disponibles : immediate, maintenance, business_safe, weekly, custom"
            return 1
            ;;
    esac
    
    log_restart_action "scheduled" "$schedule_type" "${target_time:-auto}"
    echo "✅ Redémarrage programmé avec succès"
}

# Planification de redémarrage sûre pour les affaires
schedule_business_safe_restart() {
    local current_hour=$(date +%H)
    local current_day=$(date +%u)
    
    if [[ $current_day -le 5 ]] && [[ $current_hour -ge 9 ]] && [[ $current_hour -lt 17 ]]; then
        echo "🏢 Heures de bureau détectées - programmation après les heures de bureau"
        if [[ $current_hour -lt 12 ]]; then
            sudo shutdown -r 1800  # 18h
            send_restart_notifications "18:00" "après les heures de bureau" "maintenance"
        else
            sudo shutdown -r 0600  # 6h le lendemain
            send_restart_notifications "06:00 demain" "tôt le matin" "maintenance"
        fi
    else
        echo "✅ En dehors des heures de bureau - redémarrage sûr"
        send_restart_notifications "dans 10 minutes" "10" "maintenance"
        sudo shutdown -r +10
    fi
}

# Planification de maintenance hebdomadaire
schedule_weekly_maintenance() {
    local day_of_week=$(date +%u)
    local maintenance_day=7  # Dimanche
    local maintenance_hour=03
    
    local days_until=$(( (maintenance_day - day_of_week) % 7 ))
    if [[ $days_until -eq 0 ]] && [[ $(date +%H) -ge $maintenance_hour ]]; then
        days_until=7
    fi
    
    local restart_date=$(date -d "+$days_until days $maintenance_hour:00" "+%Y-%m-%d %H:%M")
    
    echo "📅 Programmation pour la prochaine fenêtre de maintenance : $restart_date"
    
    # Utiliser launchd pour une planification précise (plus fiable que 'at')
    create_maintenance_schedule "$restart_date"
}

# Créer un job launchd pour la planification de maintenance
create_maintenance_schedule() {
    local restart_datetime="$1"
    local plist_name="com.roundfleet.maintenance.restart"
    local plist_path="/Library/LaunchDaemons/${plist_name}.plist"
    
    # Calculer l'intervalle de démarrage depuis l'époque
    local start_time=$(date -j -f "%Y-%m-%d %H:%M" "$restart_datetime" "+%s" 2>/dev/null)
    
    if [[ -n "$start_time" ]]; then
        cat > "$plist_path" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>$plist_name</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/sbin/shutdown</string>
        <string>-r</string>
        <string>now</string>
    </array>
    <key>StartCalendarInterval</key>
    <dict>
        <key>Hour</key>
        <integer>3</integer>
        <key>Minute</key>
        <integer>0</integer>
        <key>Weekday</key>
        <integer>0</integer>
    </dict>
    <key>RunAtLoad</key>
    <false/>
</dict>
</plist>
EOF
        
        # Charger le job
        launchctl load "$plist_path"
        echo "✅ Planning de maintenance créé et chargé"
    else
        echo "❌ Échec de l'analyse de la date/heure de redémarrage : $restart_datetime"
        return 1
    fi
}

# Déploiement de flotte
deploy_restart_schedule() {
    local schedule_type="$1"
    local target_time="$2"
    local fleet_file="$CONFIG_DIR/fleet_hosts.txt"
    
    if [[ ! -f "$fleet_file" ]]; then
        echo "❌ Fichier des hôtes de flotte non trouvé : $fleet_file"
        return 1
    fi
    
    echo "🚀 Déploiement du planning de redémarrage sur la flotte..."
    echo "Type de Planning : $schedule_type"
    echo "Heure Cible : ${target_time:-auto}"
    
    local success_count=0
    local total_count=0
    
    while IFS= read -r host; do
        [[ "$host" =~ ^#.*$ ]] && continue
        [[ -z "$host" ]] && continue
        
        ((total_count++))
        echo "Déploiement vers : $host"
        
        # Déployer et exécuter
        if scp "$0" "$host:/tmp/roundfleet_restart.sh" >/dev/null 2>&1 && \
           ssh "$host" "chmod +x /tmp/roundfleet_restart.sh && sudo /tmp/roundfleet_restart.sh --schedule '$schedule_type' ${target_time:+--time '$target_time'}" >/dev/null 2>&1; then
            echo "✅ Déployé avec succès vers $host"
            ((success_count++))
        else
            echo "❌ Échec du déploiement vers $host"
        fi
        
    done < "$fleet_file"
    
    echo "📊 Déploiement de flotte terminé : $success_count/$total_count réussi"
    log_action "Déploiement de flotte : $success_count/$total_count hôtes réussis"
}

# Générer un rapport de conformité de redémarrage
generate_restart_report() {
    local report_file="$AUDIT_DIR/restart_compliance_$(date +%Y%m%d_%H%M%S).json"
    
    echo "📊 Génération du rapport de conformité de redémarrage..."
    
    # Rassembler les informations système
    local uptime_days=$(uptime | awk '{print $3}' | sed 's/,//')
    local last_restart=$(last reboot | head -1 | awk '{print $3, $4, $5, $6}')
    local pending_restart=$(sudo shutdown -q 2>&1 | grep -o "shutdown.*" || echo "aucun")
    
    # Vérifier les mises à jour en attente
    local pending_updates=$(softwareupdate -l 2>/dev/null | grep -c "recommended" || echo "0")
    
    # Générer le rapport
    local report="{
        \"report_metadata\": {
            \"generated_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",
            \"hostname\": \"$(hostname)\",
            \"script_version\": \"$VERSION\",
            \"compliance_frameworks\": [\"NIST\", \"ISO 27001\", \"SOX\", \"HIPAA\"]
        },
        \"system_status\": {
            \"uptime_days\": \"$uptime_days\",
            \"last_restart\": \"$last_restart\",
            \"pending_restart\": \"$pending_restart\",
            \"pending_updates\": $pending_updates
        },
        \"restart_history\": $(tail -10 "$LOG_FILE" 2>/dev/null | jq -R . | jq -s . || echo "[]"),
        \"compliance_score\": $(calculate_restart_compliance_score "$uptime_days" "$pending_updates")
    }"
    
    echo "$report" > "$report_file"
    echo "📋 Rapport de conformité sauvegardé : $report_file"
    log_action "Rapport de conformité généré : $report_file"
}

# Calculer le score de conformité de redémarrage
calculate_restart_compliance_score() {
    local uptime_days="$1"
    local pending_updates="$2"
    local score=100
    
    # Déduire des points pour un temps de fonctionnement prolongé
    if [[ "$uptime_days" =~ ^[0-9]+$ ]]; then
        if [[ $uptime_days -gt 30 ]]; then
            score=$((score - 30))
        elif [[ $uptime_days -gt 14 ]]; then
            score=$((score - 15))
        elif [[ $uptime_days -gt 7 ]]; then
            score=$((score - 5))
        fi
    fi
    
    # Déduire des points pour les mises à jour en attente
    if [[ "$pending_updates" =~ ^[0-9]+$ ]] && [[ $pending_updates -gt 0 ]]; then
        score=$((score - (pending_updates * 10)))
    fi
    
    # S'assurer que le score est entre 0 et 100
    [[ $score -lt 0 ]] && score=0
    [[ $score -gt 100 ]] && score=100
    
    echo "$score"
}

# Capacité de redémarrage d'urgence
emergency_restart() {
    echo "🚨 REDÉMARRAGE D'URGENCE INITIÉ"
    
    # Envoyer des notifications immédiates
    send_restart_notifications "dans 60 secondes" "1" "emergency"
    
    # Créer une entrée de journal d'urgence
    log_restart_action "emergency" "immediate" "60 secondes"
    
    # Forcer le redémarrage avec un délai minimal
    sudo shutdown -r +1
    
    echo "⚠️ REDÉMARRAGE D'URGENCE DANS 60 SECONDES"
}

# Vérification de statut
check_restart_status() {
    echo "=== Statut de Redémarrage Roundfleet ==="
    
    # Temps de fonctionnement système
    echo "🕐 Temps de Fonctionnement Système : $(uptime | awk '{print $3, $4}' | sed 's/,//')"
    
    # Dernier redémarrage
    echo "📅 Dernier Redémarrage : $(last reboot | head -1 | awk '{print $3, $4, $5, $6}')"
    
    # Redémarrage en attente
    local pending=$(sudo shutdown -q 2>&1 | grep -o "shutdown.*" || echo "aucun")
    echo "⏰ Redémarrage en Attente : $pending"
    
    # Santé système
    if assess_system_health >/dev/null 2>&1; then
        echo "🟢 Santé Système : Bonne"
    else
        echo "🔴 Santé Système : Problèmes détectés"
    fi
    
    # Mises à jour en attente
    local updates=$(softwareupdate -l 2>/dev/null | grep -c "recommended" || echo "0")
    echo "📦 Mises à Jour en Attente : $updates"
}

# Afficher l'utilisation
show_usage() {
    cat << EOF
$SCRIPT_NAME v$VERSION

Utilisation : $0 [OPTION]

PLANIFICATION DE REDÉMARRAGE :
    --schedule TYPE [TIME]      Programmer un redémarrage (immediate|maintenance|business_safe|weekly|custom)
    --emergency                 Redémarrage d'urgence (avertissement 60 secondes)
    --cancel                    Annuler le redémarrage en attente
    --status                    Afficher le statut de redémarrage actuel

GESTION DE FLOTTE :
    --deploy-fleet TYPE [TIME]  Déployer le planning de redémarrage sur toute la flotte
    --generate-report           Générer un rapport de conformité

EXEMPLES :
    $0 --schedule immediate
    $0 --schedule maintenance
    $0 --schedule custom 0300
    $0 --deploy-fleet weekly
    $0 --emergency
    $0 --status

Configuration :
    $CONFIG_DIR/fleet_hosts.txt  - Hôtes de déploiement de flotte
    
Journaux :
    $LOG_FILE                    - Fichier de journal principal
    $AUDIT_DIR/                  - Journaux d'audit et de conformité
EOF
}

# Fonction principale
main() {
    case "$1" in
        --schedule)
            [[ -z "$2" ]] && { echo "❌ Type de planification requis"; exit 1; }
            intelligent_restart "$2" "$3"
            ;;
        --emergency)
            emergency_restart
            ;;
        --cancel)
            sudo shutdown -c 2>/dev/null && echo "✅ Redémarrage annulé" || echo "❌ Aucun redémarrage à annuler"
            ;;
        --status)
            check_restart_status
            ;;
        --deploy-fleet)
            [[ -z "$2" ]] && { echo "❌ Type de planification requis pour le déploiement de flotte"; exit 1; }
            deploy_restart_schedule "$2" "$3"
            ;;
        --generate-report)
            generate_restart_report
            ;;
        --help|"")
            show_usage
            ;;
        *)
            echo "❌ Option invalide : $1"
            show_usage
            exit 1
            ;;
    esac
}

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

Politiques de Planification de Redémarrage

Politique d'Environnement de Production

#!/bin/bash

# Politique de redémarrage de production haute disponibilité
production_restart_policy() {
    echo "🏭 Application de la politique de redémarrage de production..."
    
    # Autoriser les redémarrages seulement pendant les fenêtres de maintenance désignées
    local current_hour=$(date +%H)
    local current_day=$(date +%u)
    
    # Fenêtres de maintenance : Dimanches 2-4h, Jours de semaine 2-3h
    local maintenance_allowed=false
    
    if [[ $current_day -eq 7 ]] && [[ $current_hour -ge 2 ]] && [[ $current_hour -lt 4 ]]; then
        maintenance_allowed=true
    elif [[ $current_day -le 5 ]] && [[ $current_hour -ge 2 ]] && [[ $current_hour -lt 3 ]]; then
        maintenance_allowed=true
    fi
    
    if [[ "$maintenance_allowed" == "true" ]]; then
        echo "✅ Dans la fenêtre de maintenance - redémarrage autorisé"
        return 0
    else
        echo "⛔ En dehors de la fenêtre de maintenance - redémarrage bloqué"
        return 1
    fi
}

Politique d'Environnement de Développement

#!/bin/bash

# Politique de redémarrage de développement flexible
development_restart_policy() {
    echo "💻 Application de la politique de redémarrage de développement..."
    
    # Planification plus flexible pour le développement
    local current_hour=$(date +%H)
    
    # Bloquer les redémarrages seulement pendant les heures de développement de pointe (9h-18h)
    if [[ $current_hour -ge 9 ]] && [[ $current_hour -lt 18 ]]; then
        echo "⚠️ Heures de développement de pointe - demande de confirmation"
        
        # Dans une implémentation réelle, ceci pourrait déclencher un workflow d'approbation
        echo "Le redémarrage sera programmé après les heures de pointe (18h)"
        sudo shutdown -r 1800
        return 0
    else
        echo "✅ En dehors des heures de pointe - redémarrage autorisé"
        return 0
    fi
}

Exemples d'Utilisation

Programmer un Redémarrage de Maintenance Immédiat

# Redémarrage d'urgence avec notifications utilisateur
sudo ./roundfleet_restart.sh --schedule immediate

# Redémarrage de maintenance avec période de grâce de 15 minutes
sudo ./roundfleet_restart.sh --schedule maintenance

Planification Sûre pour les Affaires

# Éviter automatiquement les heures de bureau
sudo ./roundfleet_restart.sh --schedule business_safe

# Fenêtre de maintenance hebdomadaire
sudo ./roundfleet_restart.sh --schedule weekly

Déploiement de Flotte

# Déployer un redémarrage immédiat sur toute la flotte
sudo ./roundfleet_restart.sh --deploy-fleet immediate

# Déployer un planning de maintenance hebdomadaire
sudo ./roundfleet_restart.sh --deploy-fleet weekly

Planification Personnalisée

# Programmer un redémarrage pour 3h du matin
sudo ./roundfleet_restart.sh --schedule custom 0300

# Programmer un redémarrage pour 18h
sudo ./roundfleet_restart.sh --schedule custom 1800

Conformité et Surveillance

Cadres de Conformité de Redémarrage

Cadre de Cybersécurité NIST

  • 🛡️ Identifier : Suivre le temps de fonctionnement système et les exigences de redémarrage
  • 🔒 Protéger : S'assurer que les mises à jour de sécurité sont appliquées via les redémarrages
  • 🔍 Détecter : Surveiller les fenêtres de maintenance manquées
  • 🚨 Réagir : Planification et application automatisées de redémarrage
  • ♻️ Récupérer : Capacités de redémarrage d'urgence pour la réponse aux incidents

Conformité SOX

  • 📋 Pistes d'audit pour toutes les activités de redémarrage
  • 🔐 Contrôles d'accès pour la planification de redémarrage
  • 📊 Rapports de conformité avec suivi du temps de fonctionnement système

Protections Techniques HIPAA

  • 🏥 Maintenance système s'assurant que les correctifs de sécurité sont actifs
  • 📝 Contrôles d'audit avec journalisation complète des redémarrages

Métriques de Surveillance

# Métriques clés suivies automatiquement :
# - Durée du temps de fonctionnement système
# - Horodatage du dernier redémarrage
# - Mises à jour logicielles en attente
# - Score de conformité de redémarrage
# - Tentatives de redémarrage échouées
# - Adhérence aux fenêtres de maintenance

Notes de Sécurité Importantes

  • 🔐 Nécessite des privilèges administratifs pour la planification de redémarrage
  • 📝 Toutes les activités de redémarrage sont auditées et journalisées pour la conformité
  • 🔔 Les notifications utilisateur fournissent des périodes de grâce pour la sauvegarde du travail
  • 🏥 Les vérifications de santé système empêchent les redémarrages pendant les opérations critiques
  • ⏰ Protection des heures de bureau empêche la perturbation de la productivité
  • 🚨 Override d'urgence disponible pour les incidents de sécurité critiques

Dépannage

Problèmes Courants

# Vérifier si un redémarrage est déjà programmé
sudo shutdown -q

# Annuler un redémarrage en attente
sudo shutdown -c

# Vérifier les journaux système pour les problèmes de redémarrage
log show --predicate 'eventMessage contains "shutdown"' --last 1d

# Vérifier les jobs launchd
launchctl list | grep roundfleet

Échecs de Redémarrage

# Vérifier les processus empêchant le redémarrage
lsof +c 15 | grep COMMAND

# Forcer le redémarrage si le système ne répond pas
sudo shutdown -r now

# Vérifier la santé système avant une nouvelle tentative
./roundfleet_restart.sh --status

Related Tutorials

Gestion Entreprise du Sommeil et de l'Alimentation pour macOS

Gérez les paramètres de sommeil et d'alimentation macOS sur les appareils Roundfleet avec des politiques d'alimentation automatisées, l'optimisation énergétique, la surveillance de conformité et la gestion complète de la flotte pour l'efficacité et la sécurité d'entreprise.

7 juil. 2025

Gestion Entreprise de l'Arrêt et du Redémarrage pour macOS

Gérez les opérations d'arrêt et de redémarrage macOS sur les appareils Roundfleet avec la planification automatisée de maintenance, les procédures d'arrêt en douceur, la validation de sécurité et la gestion complète de l'alimentation de la flotte pour les opérations d'entreprise.

7 juil. 2025

Gestion de Batterie d'Entreprise sur macOS

Apprenez à surveiller l'état, la santé et les performances de la batterie sur les appareils macOS en utilisant des outils de gestion de batterie avancés avec surveillance de niveau entreprise, optimisation, conformité et capacités d'analyse de batterie à l'échelle de la flotte.

7 juil. 2025

Gestion des Limites de Charge de Batterie sur macOS

Apprenez à gérer et configurer les limites de charge de batterie sur les appareils macOS en utilisant bclm (Battery Charge Limit Max) pour l'optimisation de la santé de la batterie d'entreprise et les politiques de gestion d'énergie.

7 juil. 2025

Exécuter l'Assistant de configuration sur les appareils macOS au prochain redémarrage

Apprenez à déclencher l'Assistant de configuration macOS au prochain redémarrage pour la reconfiguration des appareils, l'intégration des utilisateurs et les scénarios de déploiement d'entreprise.

7 juil. 2025

Gérer les processus en cours d'exécution sur macOS

Apprenez à surveiller l'utilisation du CPU, l'état de la mémoire, afficher les processus en cours et terminer des processus sur les appareils macOS en utilisant des scripts en ligne de commande pour la gestion système.

7 juil. 2025

Gestion Rosetta 2 et Compatibilité Apple Silicon sur macOS

Apprenez à installer, gérer et surveiller la couche traduction Rosetta 2 sur Mac Apple Silicon avec gestion compatibilité niveau entreprise, surveillance applications et capacités déploiement flotte.

7 juil. 2025

Sonnerie à Distance et Gestion de Localisation d'Appareils sur macOS

Apprenez à implémenter la fonctionnalité de sonnerie à distance, gérer les services de localisation d'appareils, créer des alertes audio et déployer des solutions de suivi d'appareils d'entreprise sur les appareils macOS pour la gestion de flotte.

7 juil. 2025
View all tutorials →