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 Entreprise des Fuseaux Horaires sur macOS

Gérez les fuseaux horaires et les paramètres de date/heure dans votre Roundfleet avec automation de niveau entreprise, politiques de conformité géographique et capacités de surveillance complètes.

Comprendre la Gestion Entreprise des Fuseaux Horaires

La gestion des fuseaux horaires en entreprise nécessite plus qu'un simple réglage de l'heure, exigeant :

  • Conformité géographique automatisée avec politiques de fuseaux horaires régionales
  • Synchronisation temporelle centralisée avec serveurs NTP d'entreprise
  • Application de politiques pour les heures d'ouverture et conformité opérationnelle
  • Surveillance en temps réel de la dérive temporelle et du statut de synchronisation
  • Journalisation d'audit pour les exigences de conformité et sécurité
  • Capacités d'intégration avec l'infrastructure et services d'annuaire existants

Processus de Base de Gestion des Fuseaux Horaires

Commandes de Base

  1. Définir Fuseau Horaire - sudo systemsetup -settimezone <timezone>
  2. Lister Fuseaux Horaires - sudo systemsetup -listtimezones
  3. Activer Heure Réseau - /usr/sbin/systemsetup -setusingnetworktime on
  4. Définir Serveur Temps - /usr/sbin/systemsetup -setnetworktimeserver time.apple.com

Exemples de Configuration de Base

# Réglage de fuseau horaire de base
sudo systemsetup -settimezone Pacific/Ponape

# Activer la synchronisation automatique de l'heure
/usr/sbin/systemsetup -setusingnetworktime on -setnetworktimeserver time.apple.com

# Lister les fuseaux horaires disponibles
sudo systemsetup -listtimezones

Système de Gestion des Fuseaux Horaires Entreprise

#!/bin/bash

# Système de Gestion des Fuseaux Horaires Entreprise Roundfleet
# Gestion complète des fuseaux horaires et date/heure avec contrôles entreprise et surveillance

# Configuration
SCRIPT_NAME="Gestionnaire Fuseau Horaire Roundfleet"
VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_timezone.log"
AUDIT_LOG="/var/log/roundfleet_timezone_audit.log"
CONFIG_DIR="/etc/roundfleet/timezone"
POLICIES_DIR="/etc/roundfleet/timezone/policies"
BACKUP_DIR="/var/backups/timezone"
TEMP_DIR="/tmp/roundfleet_timezone"
TIME_DRIFT_THRESHOLD=30  # secondes
SYNC_CHECK_INTERVAL=300  # 5 minutes
ORGANIZATION_NAME="Roundfleet Entreprise"
DEPLOYMENT_MODE="enterprise"
ENABLE_COMPLIANCE_CHECKING=true
ENABLE_GEOGRAPHIC_POLICIES=true
AUTO_TIME_SYNC=true

# Serveurs de Temps Entreprise (par ordre de priorité)
declare -a ENTERPRISE_TIME_SERVERS=(
    "time.company.com"          # Serveur NTP entreprise principal
    "time2.company.com"         # Serveur NTP entreprise secondaire
    "time.apple.com"            # Serveur temps Apple (fallback)
    "pool.ntp.org"              # Pool NTP public (fallback)
    "time.nist.gov"             # Serveur temps NIST (fallback)
)

# Mapping Politique Géographique
declare -A GEOGRAPHIC_POLICIES=(
    ["US_EAST"]="America/New_York"
    ["US_CENTRAL"]="America/Chicago"
    ["US_MOUNTAIN"]="America/Denver"
    ["US_PACIFIC"]="America/Los_Angeles"
    ["US_ALASKA"]="America/Anchorage"
    ["US_HAWAII"]="Pacific/Honolulu"
    ["EU_LONDON"]="Europe/London"
    ["EU_PARIS"]="Europe/Paris"
    ["EU_BERLIN"]="Europe/Berlin"
    ["EU_ZURICH"]="Europe/Zurich"
    ["ASIA_TOKYO"]="Asia/Tokyo"
    ["ASIA_SINGAPORE"]="Asia/Singapore"
    ["ASIA_HONG_KONG"]="Asia/Hong_Kong"
    ["AUSTRALIA_SYDNEY"]="Australia/Sydney"
)

# Politiques Heures d'Ouverture
declare -A BUSINESS_HOURS_POLICIES=(
    ["standard"]="09:00-17:00"
    ["extended"]="08:00-18:00"
    ["24x7"]="00:00-23:59"
    ["custom"]="configurable"
)

# Exigences de Conformité
declare -A COMPLIANCE_STANDARDS=(
    ["SOX"]="audit_temps_strict"
    ["HIPAA"]="journalisation_synchronisee"
    ["PCI_DSS"]="sync_temps_securise"
    ["ISO27001"]="validation_source_temps"
)

# Créer les répertoires nécessaires
mkdir -p "$CONFIG_DIR"
mkdir -p "$POLICIES_DIR"
mkdir -p "$BACKUP_DIR"
mkdir -p "$TEMP_DIR"
mkdir -p "$(dirname "$LOG_FILE")"
mkdir -p "$(dirname "$AUDIT_LOG")"

# Définir les permissions sécurisées
chmod 755 "$CONFIG_DIR"
chmod 750 "$POLICIES_DIR"
chmod 750 "$BACKUP_DIR"
chmod 700 "$TEMP_DIR"

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

log_security_event() {
    local event_type="$1"
    local details="$2"
    local severity="$3"
    local admin_user=$(whoami)
    
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local source_ip=$(who am i | awk '{print $5}' | tr -d '()')
    echo "SECURITY|$timestamp|$event_type|$severity|$admin_user|$source_ip|$details" >> "$AUDIT_LOG"
}

# Obtenir les informations actuelles du fuseau horaire
get_current_timezone() {
    local current_tz=$(systemsetup -gettimezone 2>/dev/null | awk -F': ' '{print $2}')
    local current_time=$(date '+%Y-%m-%d %H:%M:%S %Z')
    local utc_time=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
    local time_server=$(systemsetup -getnetworktimeserver 2>/dev/null | awk -F': ' '{print $2}')
    local network_time_status=$(systemsetup -getusingnetworktime 2>/dev/null | awk -F': ' '{print $2}')
    
    echo "=== Informations Fuseau Horaire Actuel ==="
    echo "Fuseau Horaire : $current_tz"
    echo "Heure Locale : $current_time"
    echo "Heure UTC : $utc_time"
    echo "Serveur Temps : $time_server"
    echo "Sync Heure Réseau : $network_time_status"
    echo ""
}

# Lister les fuseaux horaires disponibles avec groupement géographique
list_available_timezones() {
    local filter_region="${1:-all}"
    local format="${2:-grouped}"
    
    echo "=== Fuseaux Horaires Disponibles ==="
    echo "Filtre : $filter_region"
    echo "Format : $format"
    echo ""
    
    if [[ "$format" == "grouped" ]]; then
        # Grouper par région
        echo "Amériques :"
        systemsetup -listtimezones 2>/dev/null | grep "America/" | sort | head -20
        echo ""
        
        echo "Europe :"
        systemsetup -listtimezones 2>/dev/null | grep "Europe/" | sort | head -20
        echo ""
        
        echo "Asie :"
        systemsetup -listtimezones 2>/dev/null | grep "Asia/" | sort | head -20
        echo ""
        
        echo "Pacifique :"
        systemsetup -listtimezones 2>/dev/null | grep "Pacific/" | sort | head -20
        echo ""
        
        echo "Autres :"
        systemsetup -listtimezones 2>/dev/null | grep -v -E "America/|Europe/|Asia/|Pacific/" | sort | head -10
    else
        # Liste simple
        case "$filter_region" in
            "americas"|"america")
                systemsetup -listtimezones 2>/dev/null | grep "America/" | sort
                ;;
            "europe")
                systemsetup -listtimezones 2>/dev/null | grep "Europe/" | sort
                ;;
            "asia")
                systemsetup -listtimezones 2>/dev/null | grep "Asia/" | sort
                ;;
            "pacific")
                systemsetup -listtimezones 2>/dev/null | grep "Pacific/" | sort
                ;;
            *)
                systemsetup -listtimezones 2>/dev/null | sort
                ;;
        esac
    fi
}

# Valider le fuseau horaire
validate_timezone() {
    local timezone="$1"
    
    if [[ -z "$timezone" ]]; then
        echo "Erreur : Le fuseau horaire ne peut pas être vide"
        return 1
    fi
    
    # Vérifier si le fuseau horaire existe dans la liste système
    if systemsetup -listtimezones 2>/dev/null | grep -q "^$timezone$"; then
        echo "✅ Fuseau horaire '$timezone' est valide"
        return 0
    else
        echo "❌ Fuseau horaire '$timezone' n'est pas valide"
        echo "Utilisez la commande 'list-timezones' pour voir les options disponibles"
        return 1
    fi
}

# Définir le fuseau horaire avec validation entreprise
set_enterprise_timezone() {
    local timezone="$1"
    local policy="${2:-standard}"
    local force="${3:-false}"
    local admin_user=$(whoami)
    
    log_security_event "TIMEZONE_CHANGE_ATTEMPT" "timezone=$timezone,policy=$policy" "INFO"
    
    echo "=== Configuration Fuseau Horaire Entreprise ==="
    echo "Fuseau Horaire Cible : $timezone"
    echo "Politique : $policy"
    echo "Administrateur : $admin_user"
    echo "Mode Force : $force"
    echo ""
    
    # Valider le fuseau horaire
    if ! validate_timezone "$timezone"; then
        log_operation "ERROR" "Fuseau horaire invalide spécifié : $timezone"
        return 1
    fi
    
    # Vérifier le fuseau horaire actuel
    local current_tz=$(systemsetup -gettimezone 2>/dev/null | awk -F': ' '{print $2}')
    
    if [[ "$current_tz" == "$timezone" && "$force" != "true" ]]; then
        echo "✅ Fuseau horaire déjà défini sur $timezone"
        log_operation "INFO" "Fuseau horaire inchangé : $timezone"
        return 0
    fi
    
    # Sauvegarder la configuration actuelle
    local backup_file="$BACKUP_DIR/timezone_$(date +%Y%m%d_%H%M%S).conf"
    {
        echo "# Sauvegarde Fuseau Horaire Roundfleet"
        echo "PREVIOUS_TIMEZONE=$current_tz"
        echo "PREVIOUS_TIME_SERVER=$(systemsetup -getnetworktimeserver 2>/dev/null | awk -F': ' '{print $2}')"
        echo "PREVIOUS_NETWORK_TIME=$(systemsetup -getusingnetworktime 2>/dev/null | awk -F': ' '{print $2}')"
        echo "BACKUP_TIMESTAMP=$(date)"
        echo "CHANGED_BY=$admin_user"
    } > "$backup_file"
    
    log_operation "INFO" "Configuration sauvegardée dans : $backup_file"
    
    # Appliquer le changement de fuseau horaire
    echo "Définition du fuseau horaire sur : $timezone"
    
    if sudo systemsetup -settimezone "$timezone" 2>/dev/null; then
        echo "✅ Fuseau horaire défini avec succès"
        log_operation "INFO" "Fuseau horaire changé de '$current_tz' vers '$timezone'"
        log_security_event "TIMEZONE_CHANGED" "from=$current_tz,to=$timezone,policy=$policy" "INFO"
        
        # Configurer la synchronisation de l'heure réseau
        configure_time_sync "$policy"
        
        # Vérifier le changement
        sleep 2
        local new_tz=$(systemsetup -gettimezone 2>/dev/null | awk -F': ' '{print $2}')
        
        if [[ "$new_tz" == "$timezone" ]]; then
            echo "✅ Vérification du fuseau horaire réussie"
            
            # Afficher les informations de temps mises à jour
            get_current_timezone
            
            return 0
        else
            echo "❌ Vérification du fuseau horaire échouée"
            log_operation "ERROR" "Vérification fuseau horaire échouée : attendu '$timezone', obtenu '$new_tz'"
            return 1
        fi
    else
        echo "❌ Échec de définition du fuseau horaire"
        log_operation "ERROR" "Échec de définition du fuseau horaire sur : $timezone"
        log_security_event "TIMEZONE_CHANGE_FAILED" "timezone=$timezone,error=systemsetup_failed" "ERROR"
        return 1
    fi
}

# Configurer la synchronisation de l'heure
configure_time_sync() {
    local policy="${1:-standard}"
    local admin_user=$(whoami)
    
    echo "=== Configuration Synchronisation Heure ==="
    echo "Politique : $policy"
    echo ""
    
    # Déterminer le serveur de temps basé sur la politique
    local time_server
    case "$policy" in
        "enterprise")
            time_server="${ENTERPRISE_TIME_SERVERS[0]}"
            ;;
        "secure")
            time_server="${ENTERPRISE_TIME_SERVERS[1]}"
            ;;
        "standard")
            time_server="time.apple.com"
            ;;
        "public")
            time_server="pool.ntp.org"
            ;;
        *)
            time_server="time.apple.com"
            ;;
    esac
    
    echo "Définition du serveur de temps sur : $time_server"
    
    # Activer l'heure réseau et définir le serveur
    if sudo systemsetup -setusingnetworktime on -setnetworktimeserver "$time_server" 2>/dev/null; then
        echo "✅ Synchronisation de l'heure configurée avec succès"
        log_operation "INFO" "Sync temps configuré : serveur=$time_server, politique=$policy"
        
        # Tester la connectivité du serveur de temps
        test_time_server_connectivity "$time_server"
        
        return 0
    else
        echo "❌ Échec de configuration de la synchronisation de l'heure"
        log_operation "ERROR" "Échec config sync temps : serveur=$time_server"
        
        # Essayer les serveurs de fallback
        echo "Tentative de serveurs de temps de fallback..."
        for fallback_server in "${ENTERPRISE_TIME_SERVERS[@]}"; do
            if [[ "$fallback_server" != "$time_server" ]]; then
                echo "Tentative serveur fallback : $fallback_server"
                
                if sudo systemsetup -setusingnetworktime on -setnetworktimeserver "$fallback_server" 2>/dev/null; then
                    echo "✅ Serveur de temps fallback configuré : $fallback_server"
                    log_operation "INFO" "Sync temps fallback configuré : $fallback_server"
                    return 0
                fi
            fi
        done
        
        echo "❌ Toutes les configurations de serveur de temps ont échoué"
        log_operation "ERROR" "Toutes les configurations de serveur de temps ont échoué"
        return 1
    fi
}

# Tester la connectivité du serveur de temps
test_time_server_connectivity() {
    local time_server="$1"
    local timeout=10
    
    echo "Test de connectivité vers le serveur de temps : $time_server"
    
    # Tester la connectivité de base
    if timeout "$timeout" ping -c 3 "$time_server" &>/dev/null; then
        echo "✅ Serveur de temps accessible"
        
        # Tester la connectivité NTP spécifique (si ntpdate est disponible)
        if command -v ntpdate &>/dev/null; then
            if timeout "$timeout" ntpdate -q "$time_server" &>/dev/null; then
                echo "✅ Service NTP répond"
                return 0
            else
                echo "⚠️  Serveur de temps accessible mais NTP peut ne pas répondre"
                return 1
            fi
        else
            echo "✅ Connectivité de base confirmée (ntpdate non disponible pour test NTP)"
            return 0
        fi
    else
        echo "❌ Serveur de temps non accessible"
        log_operation "WARNING" "Connectivité serveur de temps échouée : $time_server"
        return 1
    fi
}

# Surveiller la dérive temporelle et la synchronisation
monitor_time_sync() {
    local check_type="${1:-basic}"
    local admin_user=$(whoami)
    
    echo "=== Surveillance Synchronisation Heure ==="
    echo "Type de Vérification : $check_type"
    echo "Surveillant : $admin_user"
    echo ""
    
    local sync_status="HEALTHY"
    local issues=()
    
    # Vérifier si l'heure réseau est activée
    local network_time_status=$(systemsetup -getusingnetworktime 2>/dev/null | awk -F': ' '{print $2}')
    
    if [[ "$network_time_status" == "On" ]]; then
        echo "✅ Synchronisation heure réseau activée"
    else
        echo "❌ Synchronisation heure réseau désactivée"
        sync_status="CRITICAL"
        issues+=("Sync heure réseau désactivée")
    fi
    
    # Vérifier la configuration du serveur de temps
    local time_server=$(systemsetup -getnetworktimeserver 2>/dev/null | awk -F': ' '{print $2}')
    echo "Serveur de Temps : $time_server"
    
    # Tester la connectivité du serveur de temps
    if ! test_time_server_connectivity "$time_server"; then
        sync_status="WARNING"
        issues+=("Problèmes de connectivité serveur de temps")
    fi
    
    # Vérifier la dérive temporelle (si ntpdate est disponible)
    if command -v ntpdate &>/dev/null; then
        echo ""
        echo "Vérification de la dérive temporelle..."
        
        local drift_output=$(ntpdate -q "$time_server" 2>/dev/null | tail -1)
        
        if [[ -n "$drift_output" ]]; then
            # Extraire la valeur de dérive (analyse simplifiée)
            local drift_seconds=$(echo "$drift_output" | grep -o "offset [+-][0-9.]*" | awk '{print $2}' | tr -d '+')
            
            if [[ -n "$drift_seconds" ]]; then
                local drift_abs=$(echo "$drift_seconds" | tr -d '-')
                
                echo "Dérive temporelle : ${drift_seconds}s"
                
                if (( $(echo "$drift_abs > $TIME_DRIFT_THRESHOLD" | bc -l) )); then
                    echo "⚠️  Dérive temporelle dépasse le seuil (${TIME_DRIFT_THRESHOLD}s)"
                    sync_status="WARNING"
                    issues+=("Dérive temporelle : ${drift_seconds}s")
                else
                    echo "✅ Dérive temporelle dans la plage acceptable"
                fi
            fi
        fi
    else
        echo "ntpdate non disponible pour vérification de dérive"
    fi
    
    # Vérifications avancées
    if [[ "$check_type" == "comprehensive" ]]; then
        echo ""
        echo "Exécution surveillance temps complète..."
        
        # Vérifier horloge système vs horloge matérielle
        if command -v hwclock &>/dev/null; then
            local sys_time=$(date +%s)
            local hw_time=$(sudo hwclock --show | date -f - +%s 2>/dev/null || echo "0")
            
            if [[ "$hw_time" != "0" ]]; then
                local clock_diff=$((sys_time - hw_time))
                local clock_diff_abs=${clock_diff#-}
                
                echo "Différence horloge système/matérielle : ${clock_diff}s"
                
                if [[ $clock_diff_abs -gt 30 ]]; then
                    sync_status="WARNING"
                    issues+=("Dérive horloge système/matérielle : ${clock_diff}s")
                fi
            fi
        fi
        
        # Vérifier les processus chronyd ou ntpd
        if pgrep -x "chronyd" &>/dev/null || pgrep -x "ntpd" &>/dev/null; then
            echo "✅ Démon de temps en cours d'exécution"
        else
            echo "⚠️  Aucun démon de temps détecté"
        fi
    fi
    
    # Générer le rapport de surveillance
    echo ""
    echo "=== Rapport État Sync Temps ==="
    echo "État Global : $sync_status"
    echo "Horodatage : $(date)"
    
    if [[ ${#issues[@]} -gt 0 ]]; then
        echo "Problèmes Trouvés :"
        printf '  - %s\n' "${issues[@]}"
    else
        echo "✅ Tous les systèmes de synchronisation temporelle opérationnels"
    fi
    
    # Enregistrer les résultats de surveillance
    log_operation "INFO" "Surveillance sync temps terminée : $sync_status (${#issues[@]} problèmes)"
    log_security_event "TIME_SYNC_CHECK" "status=$sync_status,issues=${#issues[@]}" "INFO"
    
    # Retourner le code de sortie approprié
    case "$sync_status" in
        "HEALTHY") return 0 ;;
        "WARNING") return 1 ;;
        "CRITICAL") return 2 ;;
        *) return 3 ;;
    esac
}

# Appliquer une politique géographique
apply_geographic_policy() {
    local policy_name="$1"
    local admin_user=$(whoami)
    
    log_security_event "GEOGRAPHIC_POLICY_APPLY" "policy=$policy_name" "INFO"
    
    echo "=== Application Politique Géographique ==="
    echo "Politique : $policy_name"
    echo "Administrateur : $admin_user"
    echo ""
    
    # Vérifier si la politique existe
    if [[ -z "${GEOGRAPHIC_POLICIES[$policy_name]}" ]]; then
        echo "❌ Politique géographique inconnue : $policy_name"
        echo ""
        echo "Politiques disponibles :"
        for policy in "${!GEOGRAPHIC_POLICIES[@]}"; do
            echo "  $policy -> ${GEOGRAPHIC_POLICIES[$policy]}"
        done
        return 1
    fi
    
    local target_timezone="${GEOGRAPHIC_POLICIES[$policy_name]}"
    
    echo "Fuseau horaire cible : $target_timezone"
    echo "Mapping politique : $policy_name -> $target_timezone"
    echo ""
    
    # Appliquer le changement de fuseau horaire
    set_enterprise_timezone "$target_timezone" "geographic_policy"
}

# Générer un rapport de conformité des fuseaux horaires
generate_timezone_report() {
    local report_type="${1:-summary}"
    local admin_user=$(whoami)
    local report_file="/var/reports/timezone_report_$(date +%Y%m%d_%H%M%S).txt"
    
    mkdir -p "$(dirname "$report_file")"
    
    log_security_event "REPORT_GENERATION" "type=$report_type" "INFO"
    
    {
        echo "Rapport Gestion Fuseau Horaire Roundfleet"
        echo "======================================"
        echo "Type de Rapport : $report_type"
        echo "Généré : $(date)"
        echo "Généré Par : $admin_user"
        echo "Nom d'hôte : $(hostname)"
        echo ""
        
        case "$report_type" in
            "summary")
                echo "== Résumé Fuseau Horaire =="
                get_current_timezone
                
                echo "Politiques Géographiques Disponibles :"
                for policy in "${!GEOGRAPHIC_POLICIES[@]}"; do
                    echo "  $policy: ${GEOGRAPHIC_POLICIES[$policy]}"
                done
                ;;
            "compliance")
                echo "== Évaluation Conformité =="
                
                # Vérifier les exigences de conformité
                local current_tz=$(systemsetup -gettimezone 2>/dev/null | awk -F': ' '{print $2}')
                local network_time=$(systemsetup -getusingnetworktime 2>/dev/null | awk -F': ' '{print $2}')
                local time_server=$(systemsetup -getnetworktimeserver 2>/dev/null | awk -F': ' '{print $2}')
                
                echo "Configuration Actuelle :"
                echo "  Fuseau Horaire : $current_tz"
                echo "  Sync Heure Réseau : $network_time"
                echo "  Serveur Temps : $time_server"
                echo ""
                
                echo "Standards de Conformité :"
                for standard in "${!COMPLIANCE_STANDARDS[@]}"; do
                    echo "  $standard: ${COMPLIANCE_STANDARDS[$standard]}"
                done
                ;;
            "audit")
                echo "== Information d'Audit =="
                if [[ -f "$AUDIT_LOG" ]]; then
                    echo "Événements fuseau horaire récents (20 derniers) :"
                    tail -20 "$AUDIT_LOG"
                else
                    echo "Aucun log d'audit disponible"
                fi
                ;;
        esac
        
        echo ""
        echo "== Informations Temps Système =="
        echo "Heure Locale : $(date)"
        echo "Heure UTC : $(date -u)"
        echo "Uptime : $(uptime)"
        
    } > "$report_file"
    
    echo "Rapport fuseau horaire généré : $report_file"
    log_operation "INFO" "Rapport fuseau horaire généré : $report_file"
}

# Définir une politique d'heures d'ouverture
set_business_hours_policy() {
    local policy_name="$1"
    local custom_hours="$2"
    
    echo "=== Configuration Politique Heures d'Ouverture ==="
    echo "Politique : $policy_name"
    
    if [[ "$policy_name" == "custom" && -n "$custom_hours" ]]; then
        echo "Heures Personnalisées : $custom_hours"
        BUSINESS_HOURS_POLICIES["custom"]="$custom_hours"
    fi
    
    local hours="${BUSINESS_HOURS_POLICIES[$policy_name]}"
    
    if [[ -z "$hours" ]]; then
        echo "❌ Politique heures d'ouverture inconnue : $policy_name"
        echo ""
        echo "Politiques disponibles :"
        for policy in "${!BUSINESS_HOURS_POLICIES[@]}"; do
            echo "  $policy: ${BUSINESS_HOURS_POLICIES[$policy]}"
        done
        return 1
    fi
    
    echo "Heures d'Ouverture : $hours"
    
    # Sauvegarder la politique dans le fichier de configuration
    local policy_file="$POLICIES_DIR/business_hours.conf"
    {
        echo "# Politique Heures d'Ouverture Roundfleet"
        echo "POLICY_NAME=$policy_name"
        echo "BUSINESS_HOURS=$hours"
        echo "CONFIGURED_BY=$(whoami)"
        echo "CONFIGURED_DATE=$(date)"
    } > "$policy_file"
    
    echo "✅ Politique heures d'ouverture configurée"
    log_operation "INFO" "Politique heures d'ouverture définie : $policy_name ($hours)"
}

# Fonction principale de gestion des fuseaux horaires
main() {
    local action="${1:-help}"
    
    case "$action" in
        "status"|"current")
            get_current_timezone
            ;;
        "list-timezones")
            local filter_region="$2"
            local format="${3:-grouped}"
            
            list_available_timezones "$filter_region" "$format"
            ;;
        "set")
            local timezone="$2"
            local policy="${3:-standard}"
            local force="$4"
            
            if [[ -z "$timezone" ]]; then
                echo "Usage : $0 set <timezone> [policy] [force]"
                echo "Exemple : $0 set America/New_York enterprise"
                return 1
            fi
            
            set_enterprise_timezone "$timezone" "$policy" "$force"
            ;;
        "validate")
            local timezone="$2"
            
            if [[ -z "$timezone" ]]; then
                echo "Usage : $0 validate <timezone>"
                return 1
            fi
            
            validate_timezone "$timezone"
            ;;
        "sync")
            local policy="${2:-standard}"
            
            configure_time_sync "$policy"
            ;;
        "monitor")
            local check_type="${2:-basic}"
            
            monitor_time_sync "$check_type"
            ;;
        "apply-policy")
            local policy_name="$2"
            
            if [[ -z "$policy_name" ]]; then
                echo "Usage : $0 apply-policy <policy_name>"
                echo ""
                echo "Politiques géographiques disponibles :"
                for policy in "${!GEOGRAPHIC_POLICIES[@]}"; do
                    echo "  $policy"
                done
                return 1
            fi
            
            apply_geographic_policy "$policy_name"
            ;;
        "business-hours")
            local policy_name="$2"
            local custom_hours="$3"
            
            if [[ -z "$policy_name" ]]; then
                echo "Usage : $0 business-hours <policy> [custom_hours]"
                echo ""
                echo "Politiques disponibles :"
                for policy in "${!BUSINESS_HOURS_POLICIES[@]}"; do
                    echo "  $policy"
                done
                return 1
            fi
            
            set_business_hours_policy "$policy_name" "$custom_hours"
            ;;
        "report")
            local report_type="${2:-summary}"
            
            generate_timezone_report "$report_type"
            ;;
        "help"|*)
            echo "$SCRIPT_NAME v$VERSION"
            echo "Gestion Entreprise des Fuseaux Horaires et Date/Heure"
            echo ""
            echo "Usage : $0 <action> [options]"
            echo ""
            echo "Actions :"
            echo "  status                                  - Afficher les informations fuseau horaire actuel"
            echo "  list-timezones [region] [format]        - Lister les fuseaux horaires disponibles"
            echo "  set <timezone> [policy] [force]         - Définir fuseau horaire avec politique"
            echo "  validate <timezone>                     - Valider le format du fuseau horaire"
            echo "  sync [policy]                           - Configurer la synchronisation de l'heure"
            echo "  monitor [type]                          - Surveiller la synchronisation de l'heure"
            echo "  apply-policy <policy>                   - Appliquer une politique géographique"
            echo "  business-hours <policy> [custom]        - Configurer les heures d'ouverture"
            echo "  report [type]                           - Générer des rapports de fuseau horaire"
            echo "  help                                    - Afficher ce message d'aide"
            echo ""
            echo "Politiques Géographiques :"
            for policy in "${!GEOGRAPHIC_POLICIES[@]}"; do
                echo "  $policy"
            done
            echo ""
            echo "Politiques Sync Temps :"
            echo "  enterprise  - Utiliser serveur NTP entreprise principal"
            echo "  secure      - Utiliser serveur NTP entreprise secondaire"
            echo "  standard    - Utiliser serveur temps Apple (défaut)"
            echo "  public      - Utiliser pool NTP public"
            echo ""
            echo "Politiques Heures d'Ouverture :"
            for policy in "${!BUSINESS_HOURS_POLICIES[@]}"; do
                echo "  $policy: ${BUSINESS_HOURS_POLICIES[$policy]}"
            done
            echo ""
            echo "Types de Surveillance :"
            echo "  basic       - Vérification statut sync temps de base"
            echo "  comprehensive - Surveillance étendue et diagnostics"
            echo ""
            echo "Types de Rapport :"
            echo "  summary     - Aperçu fuseau horaire (défaut)"
            echo "  compliance  - Évaluation conformité"
            echo "  audit       - Piste d'audit et événements"
            echo ""
            echo "Exemples :"
            echo "  $0 set America/New_York enterprise      - Définir heure Est avec politique entreprise"
            echo "  $0 apply-policy US_PACIFIC              - Appliquer politique Pacifique US"
            echo "  $0 monitor comprehensive                - Vérification surveillance complète"
            echo "  $0 business-hours extended              - Définir heures ouverture étendues"
            echo ""
            echo "Fonctionnalités :"
            echo "  • Gestion fuseaux horaires niveau entreprise"
            echo "  • Automation politique géographique"
            echo "  • Synchronisation temps avancée avec serveurs fallback"
            echo "  • Surveillance temps réel et détection dérive"
            echo "  • Journalisation audit complète et conformité"
            echo "  • Application politiques heures d'ouverture"
            echo "  • Intégration avec infrastructure Roundfleet"
            ;;
    esac
}

# Exécuter la fonction principale avec tous les arguments
main "$@"

Commandes de Référence Rapide

Opérations Fuseaux Horaires de Base

# Vérifier le statut du fuseau horaire actuel
./timezone_manager.sh status

# Lister les fuseaux horaires disponibles
./timezone_manager.sh list-timezones

# Définir fuseau horaire avec politique entreprise
./timezone_manager.sh set America/New_York enterprise

# Valider fuseau horaire avant définition
./timezone_manager.sh validate Europe/London

Gestion Politique Géographique

# Appliquer les politiques géographiques prédéfinies
./timezone_manager.sh apply-policy US_EAST
./timezone_manager.sh apply-policy EU_LONDON
./timezone_manager.sh apply-policy ASIA_TOKYO

# Lister toutes les politiques géographiques disponibles
./timezone_manager.sh apply-policy

Synchronisation Heure

# Configurer synchronisation heure avec différentes politiques
./timezone_manager.sh sync enterprise    # Utiliser serveurs NTP entreprise
./timezone_manager.sh sync standard      # Utiliser serveur temps Apple
./timezone_manager.sh sync public        # Utiliser pool NTP public

# Surveiller santé synchronisation heure
./timezone_manager.sh monitor basic
./timezone_manager.sh monitor comprehensive

Heures d'Ouverture et Conformité

# Définir politiques heures d'ouverture
./timezone_manager.sh business-hours standard     # 09:00-17:00
./timezone_manager.sh business-hours extended     # 08:00-18:00
./timezone_manager.sh business-hours 24x7         # Opérations 24/7
./timezone_manager.sh business-hours custom "06:00-22:00"

# Générer rapports de conformité
./timezone_manager.sh report compliance
./timezone_manager.sh report audit

Exemples d'Intégration

Intégration JAMF Pro

#!/bin/bash

# Script JAMF Pro pour gestion fuseau horaire
# Paramètres : $4 = politique_géographique, $5 = politique_sync, $6 = heures_ouverture

POLITIQUE_GEOGRAPHIQUE="$4"
POLITIQUE_SYNC="$5"
HEURES_OUVERTURE="$6"

# Télécharger gestionnaire fuseau horaire s'il n'est pas présent
if [[ ! -f "/usr/local/bin/roundfleet_timezone_manager.sh" ]]; then
    curl -o "/usr/local/bin/roundfleet_timezone_manager.sh" \
         "https://scripts.roundfleet.com/timezone_manager.sh"
    chmod +x "/usr/local/bin/roundfleet_timezone_manager.sh"
fi

# Appliquer politique géographique
if [[ -n "$POLITIQUE_GEOGRAPHIQUE" ]]; then
    /usr/local/bin/roundfleet_timezone_manager.sh apply-policy "$POLITIQUE_GEOGRAPHIQUE"
fi

# Configurer synchronisation heure
if [[ -n "$POLITIQUE_SYNC" ]]; then
    /usr/local/bin/roundfleet_timezone_manager.sh sync "$POLITIQUE_SYNC"
fi

# Définir heures d'ouverture
if [[ -n "$HEURES_OUVERTURE" ]]; then
    /usr/local/bin/roundfleet_timezone_manager.sh business-hours "$HEURES_OUVERTURE"
fi

# Rapporter statut à JAMF
echo "Configuration fuseau horaire terminée avec succès"

Meilleures Pratiques

  1. Utiliser serveurs NTP entreprise pour synchronisation temporelle cohérente
  2. Implémenter politiques géographiques pour organisations multi-sites
  3. Surveiller dérive temporelle en continu avec alertes automatisées
  4. Maintenir pistes d'audit pour exigences de conformité
  5. Tester connectivité serveur temps avant déploiement
  6. Utiliser serveurs temps de sauvegarde pour redondance
  7. Coordonner avec équipes réseau pour accès serveurs NTP
  8. Documenter politiques fuseaux horaires pour opérations métier

Ce système de gestion des fuseaux horaires entreprise fournit un contrôle complet du temps et de la date avec conformité géographique automatisée, application de politiques et capacités de surveillance de niveau entreprise pour une gestion temporelle Roundfleet efficace.

Related Tutorials

Gestion des Préférences Système sur macOS

Apprenez à masquer, désactiver et gérer les panneaux des Préférences Système sur les appareils macOS en utilisant des scripts en ligne de commande pour la configuration d'entreprise et le contrôle des restrictions utilisateur.

7 juil. 2025

Gestion de la Luminosité d'Écran et Optimisation Énergétique sur macOS

Apprenez à contrôler la luminosité de l'écran, implémenter des politiques d'éclairage adaptatif, gérer la consommation d'énergie et optimiser les paramètres d'affichage sur les appareils macOS pour la gestion de flotte d'entreprise.

7 juil. 2025

Gestion d'Identité et Nomenclature d'Appareils Entreprise sur macOS

Gérez les noms d'appareils, noms d'hôtes et identités réseau sur les appareils Roundfleet avec des conventions de nomenclature standardisées, un provisioning automatisé et des fonctionnalités de conformité d'entreprise.

7 juil. 2025

Gestion Entreprise de la Date et Heure sur macOS

Guide complet pour la gestion de la date et heure en entreprise sur les appareils Roundfleet avec planification automatisée, validation, suivi de conformité et contrôle centralisé.

7 juil. 2025

Gestion d'Information Système d'Entreprise sur macOS

Collectez, analysez et gérez les informations système sur les appareils macOS avec le profilage système avancé, la collecte automatisée de données et l'analytique d'entreprise pour l'inventaire et la surveillance complète des appareils.

7 juil. 2025

Configurer Stage Manager sur les appareils macOS

Apprenez à activer, désactiver et personnaliser les paramètres de Stage Manager sur les appareils macOS à l'aide de scripts shell pour la gestion de flotte Mac.

7 juil. 2025

Gestion de l'indexation Spotlight sur les appareils macOS

Apprenez à contrôler l'indexation Spotlight sur les appareils macOS en utilisant des scripts shell pour optimiser les performances et gérer efficacement les ressources système.

7 juil. 2025

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
View all tutorials →