Guide

Collectez et analysez les informations système complètes de vos appareils Roundfleet en utilisant le profilage système avancé, la collecte automatisée de données et l'analytique de niveau entreprise. Ce tutoriel fournit des outils puissants pour implémenter l'inventaire organisationnel des appareils, la surveillance et les rapports de conformité.

Comprendre l'Information Système macOS

macOS fournit plusieurs outils pour la collecte d'informations système :

• system_profiler - Collecte complète d'informations système
• uname - Informations de base du système et du noyau
• sw_vers - Informations de version logicielle
• hwpref - Données de préférence matérielle
• ioreg - Informations matérielles du registre I/O
• Information Système.app - Interface graphique d'information système

Opérations d'Information Système de Base

Information Système Complète

#!/bin/bash

# Obtenir l'information système complète
echo "=== Information Système Complète ==="
system_profiler

echo "Collecte d'information système terminée"

Lister les Types de Données Disponibles

#!/bin/bash

# Lister tous les types de données system_profiler disponibles
echo "=== Types de Données Disponibles ==="
system_profiler --listDataTypes

echo "Listage des types de données terminé"

Information Système Spécifique

#!/bin/bash

# Obtenir une information système spécifique
DATA_TYPE="${1:-SPHardwareDataType}"

echo "=== Information $DATA_TYPE ==="
system_profiler "$DATA_TYPE"

echo "Information système spécifique récupérée"

Sauvegarder le Rapport Système dans un Fichier

#!/bin/bash

# Sauvegarder l'information système dans un fichier
REPORT_FILE="${1:-/tmp/system_report_$(date +%Y%m%d_%H%M%S).txt}"

echo "=== Sauvegarde du Rapport Système ==="
system_profiler > "$REPORT_FILE"

echo "Rapport système sauvegardé dans : $REPORT_FILE"

Système de Gestion d'Information Système d'Entreprise

#!/bin/bash

# Système de Gestion d'Information Système d'Entreprise Roundfleet
# Collecte complète de données système, analyse et surveillance

# Configuration
ROUNDFLEET_DIR="/etc/roundfleet"
SYSINFO_DIR="$ROUNDFLEET_DIR/system_information"
REPORTS_DIR="$ROUNDFLEET_DIR/reports"
COMPLIANCE_DIR="$ROUNDFLEET_DIR/compliance"
AUDIT_DIR="$ROUNDFLEET_DIR/audit"
LOG_FILE="/var/log/roundfleet_system_information.log"
POLICIES_DIR="$ROUNDFLEET_DIR/system_policies"
INVENTORY_DIR="$ROUNDFLEET_DIR/inventory"

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

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

# Catégories d'Information Système pour la Gestion d'Entreprise
declare -A SYSTEM_CATEGORIES=(
    ["hardware_overview"]="SPHardwareDataType,SPMemoryDataType,SPStorageDataType"
    ["software_inventory"]="SPSoftwareDataType,SPApplicationsDataType,SPExtensionsDataType"
    ["network_configuration"]="SPNetworkDataType,SPBluetoothDataType,SPWWANDataType"
    ["security_configuration"]="SPFirewallDataType,SPManagedClientDataType,SPConfigurationProfileDataType"
    ["peripherals"]="SPUSBDataType,SPThunderboltDataType,SPAudioDataType,SPDisplaysDataType"
    ["system_diagnostics"]="SPPowerDataType,SPLogsDataType,SPDiagnosticsDataType"
    ["enterprise_management"]="SPManagedClientDataType,SPConfigurationProfileDataType,SPCertificatesDataType"
)

# Politiques de Collecte de Données
declare -A COLLECTION_POLICIES=(
    ["comprehensive"]="all_data_types,full_detail,include_sensitive,export_json"
    ["security_focused"]="security_data,certificates,firewall_config,managed_profiles"
    ["hardware_inventory"]="hardware_overview,storage_details,memory_config,peripherals"
    ["software_audit"]="applications,extensions,system_software,preferences"
    ["network_assessment"]="network_interfaces,bluetooth_devices,wireless_config"
    ["compliance_report"]="security_config,certificates,managed_profiles,audit_data"
)

# Seuils de Surveillance de Santé Système
declare -A HEALTH_THRESHOLDS=(
    ["cpu_temperature_warning"]=80
    ["memory_pressure_warning"]=80
    ["storage_usage_warning"]=85
    ["battery_cycle_warning"]=800
    ["uptime_excessive_hours"]=168  # 1 semaine
)

# Collecte complète d'information système
collect_system_information() {
    local collection_policy="$1"
    local output_format="${2:-json}"
    local include_sensitive="${3:-false}"
    local collection_id="sysinfo_$(date +%Y%m%d_%H%M%S)"
    local output_file="$SYSINFO_DIR/${collection_id}.${output_format}"
    
    log_action "Démarrage de la collecte d'information système : $collection_policy"
    
    # Initialiser les métadonnées de collecte
    local hostname=$(hostname)
    local serial_number=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')
    local model_identifier=$(system_profiler SPHardwareDataType | grep "Model Identifier" | awk '{print $3}')
    local os_version=$(sw_vers -productVersion)
    local build_version=$(sw_vers -buildVersion)
    local uptime=$(uptime | awk '{print $3,$4}' | sed 's/,//')
    
    # Collecter les données selon la politique
    local collected_data=""
    local data_types=""
    
    case "$collection_policy" in
        "comprehensive")
            data_types=$(system_profiler --listDataTypes | tr '\n' ' ')
            ;;
        "security_focused")
            data_types="SPFirewallDataType SPManagedClientDataType SPConfigurationProfileDataType SPCertificatesDataType"
            ;;
        "hardware_inventory")
            data_types="SPHardwareDataType SPMemoryDataType SPStorageDataType SPUSBDataType SPDisplaysDataType SPAudioDataType"
            ;;
        "software_audit")
            data_types="SPSoftwareDataType SPApplicationsDataType SPExtensionsDataType SPPrefPaneDataType"
            ;;
        "network_assessment")
            data_types="SPNetworkDataType SPBluetoothDataType SPWWANDataType SPAirPortDataType"
            ;;
        "compliance_report")
            data_types="SPManagedClientDataType SPConfigurationProfileDataType SPCertificatesDataType SPFirewallDataType"
            ;;
    esac
    
    # Collecter les données pour chaque type spécifié
    for data_type in $data_types; do
        [[ -z "$data_type" ]] && continue
        
        log_action "Collecte du type de données : $data_type"
        
        if [[ "$output_format" == "json" ]]; then
            local type_data=$(system_profiler -json "$data_type" 2>/dev/null)
            if [[ -n "$type_data" && "$type_data" != "null" ]]; then
                collected_data="$collected_data\"$data_type\":$type_data,"
            fi
        else
            local type_data=$(system_profiler "$data_type" 2>/dev/null)
            if [[ -n "$type_data" ]]; then
                collected_data="$collected_data\n=== $data_type ===\n$type_data\n"
            fi
        fi
    done
    
    # Métriques système supplémentaires
    local additional_metrics=""
    if [[ "$include_sensitive" == "true" || "$collection_policy" == "comprehensive" ]]; then
        local cpu_info=$(sysctl -n machdep.cpu.brand_string)
        local memory_total=$(system_profiler SPHardwareDataType | grep "Memory:" | awk '{print $2,$3}')
        local storage_info=$(df -h / | awk 'NR==2 {print $2,$3,$4,$5}')
        local network_interfaces=$(ifconfig | grep "^[a-z]" | awk '{print $1}' | sed 's/:$//' | tr '\n' ' ')
        local running_processes=$(ps aux | wc -l)
        local logged_in_users=$(who | wc -l)
        
        additional_metrics="{\"cpu_info\":\"$cpu_info\",\"memory_total\":\"$memory_total\",\"storage_info\":\"$storage_info\",\"network_interfaces\":\"$network_interfaces\",\"running_processes\":$running_processes,\"logged_in_users\":$logged_in_users}"
    fi
    
    # Créer une sortie structurée
    if [[ "$output_format" == "json" ]]; then
        # Supprimer la virgule finale des données collectées
        collected_data="${collected_data%,}"
        
        cat > "$output_file" << EOF
{
  "collection_metadata": {
    "collection_id": "$collection_id",
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "policy": "$collection_policy",
    "hostname": "$hostname",
    "serial_number": "$serial_number",
    "model_identifier": "$model_identifier",
    "os_version": "$os_version",
    "build_version": "$build_version",
    "uptime": "$uptime"
  },
  "system_data": {$collected_data},
  "additional_metrics": $additional_metrics,
  "collection_summary": {
    "data_types_collected": $(echo "$data_types" | wc -w),
    "include_sensitive": "$include_sensitive",
    "collection_size_bytes": $(wc -c < "$output_file" 2>/dev/null || echo "0")
  }
}
EOF
    else
        cat > "$output_file" << EOF
=== Rapport d'Information Système Roundfleet ===
ID de Collecte : $collection_id
Horodatage : $(date)
Politique : $collection_policy
Nom d'hôte : $hostname
Numéro de Série : $serial_number
Modèle : $model_identifier
Version OS : $os_version ($build_version)
Temps de fonctionnement : $uptime

$collected_data
EOF
    fi
    
    log_action "Collecte d'information système terminée : $output_file"
    echo "$output_file"
}

# Analyse de santé système
analyze_system_health() {
    local analysis_type="$1"
    local health_report="$REPORTS_DIR/system_health_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Démarrage de l'analyse de santé système : $analysis_type"
    
    # Collecter les métriques de santé de base
    local cpu_temp=$(sudo powermetrics -n 1 -s cpu_power | grep "CPU die temperature" | awk '{print $4}' 2>/dev/null || echo "0")
    local memory_pressure=$(vm_stat | grep "Pages compressed" | awk '{print $3}' | sed 's/\.//' | head -1)
    local storage_usage=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
    local uptime_seconds=$(sysctl -n kern.boottime | awk '{print $4}' | sed 's/,//')
    local current_time=$(date +%s)
    local uptime_hours=$(( (current_time - uptime_seconds) / 3600 ))
    
    # Analyse de charge système
    local load_average=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    local cpu_cores=$(sysctl -n hw.ncpu)
    local load_per_core=$(echo "scale=2; $load_average / $cpu_cores" | bc -l 2>/dev/null || echo "0")
    
    # Informations de batterie (si disponible)
    local battery_cycle_count=0
    local battery_condition="Inconnu"
    if system_profiler SPPowerDataType | grep -q "Cycle Count"; then
        battery_cycle_count=$(system_profiler SPPowerDataType | grep "Cycle Count" | awk '{print $3}')
        battery_condition=$(system_profiler SPPowerDataType | grep "Condition" | awk '{print $2}')
    fi
    
    # Déterminer l'état de santé
    local health_status="healthy"
    local health_alerts=""
    
    if [[ $(echo "$cpu_temp > ${HEALTH_THRESHOLDS[cpu_temperature_warning]}" | bc -l 2>/dev/null) -eq 1 ]]; then
        health_status="warning"
        health_alerts="$health_alerts\"Température CPU élevée : ${cpu_temp}°C\","
    fi
    
    if [[ $storage_usage -gt ${HEALTH_THRESHOLDS[storage_usage_warning]} ]]; then
        health_status="warning"
        health_alerts="$health_alerts\"Utilisation stockage élevée : ${storage_usage}%\","
    fi
    
    if [[ $battery_cycle_count -gt ${HEALTH_THRESHOLDS[battery_cycle_warning]} ]]; then
        health_status="warning"
        health_alerts="$health_alerts\"Nombre de cycles batterie élevé : $battery_cycle_count\","
    fi
    
    if [[ $uptime_hours -gt ${HEALTH_THRESHOLDS[uptime_excessive_hours]} ]]; then
        health_status="attention"
        health_alerts="$health_alerts\"Temps de fonctionnement excessif : ${uptime_hours} heures\","
    fi
    
    # Supprimer la virgule finale
    health_alerts="${health_alerts%,}"
    
    # Créer le rapport de santé
    cat > "$health_report" << EOF
{
  "system_health_analysis": {
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "analysis_type": "$analysis_type",
    "health_status": "$health_status",
    "device_info": {
      "hostname": "$(hostname)",
      "serial_number": "$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')",
      "model": "$(system_profiler SPHardwareDataType | grep "Model Identifier" | awk '{print $3}')",
      "os_version": "$(sw_vers -productVersion)"
    }
  },
  "health_metrics": {
    "cpu_temperature_celsius": "$cpu_temp",
    "memory_pressure_pages": "$memory_pressure",
    "storage_usage_percent": $storage_usage,
    "uptime_hours": $uptime_hours,
    "load_average": "$load_average",
    "load_per_core": "$load_per_core",
    "cpu_cores": $cpu_cores,
    "battery_cycle_count": $battery_cycle_count,
    "battery_condition": "$battery_condition"
  },
  "health_alerts": [$health_alerts],
  "recommendations": [
    $([ "$health_status" != "healthy" ] && echo "\"Traiter les alertes de santé pour performance optimale\",")
    $([ $uptime_hours -gt 72 ] && echo "\"Considérer redémarrage système pour performance optimale\",")
    $([ $storage_usage -gt 80 ] && echo "\"Réviser utilisation stockage et nettoyer si nécessaire\",")
    "\"Surveillance régulière de santé recommandée\""
  ]
}
EOF
    
    if [[ "$health_status" != "healthy" ]]; then
        log_action "AVERTISSEMENT SANTÉ : Problèmes de santé système détectés - $health_status"
    fi
    
    log_action "Analyse de santé système terminée : $health_report"
    echo "$health_report"
}

# Fonction d'exécution principale
main() {
    create_directories
    
    case "${1:-}" in
        "collect")
            collect_system_information "${2:-comprehensive}" "${3:-json}" "${4:-false}"
            ;;
        "analyze_health")
            analyze_system_health "${2:-standard}"
            ;;
        "help"|*)
            echo "Système de Gestion d'Information Système d'Entreprise Roundfleet"
            echo ""
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  collect [politique] [format] [sensible]  - Collecter information système (comprehensive|security_focused|hardware_inventory|software_audit|network_assessment|compliance_report) [json|text] [true|false]"
            echo "  analyze_health [type]                    - Analyser santé système (standard|detailed|continuous)"
            echo ""
            echo "Exemples :"
            echo "  $0 collect comprehensive json false"
            echo "  $0 analyze_health detailed"
            ;;
    esac
}

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

Types de Données d'Information Système

Le système d'entreprise supporte la collecte complète de types de données :

Politiques de Collecte d'Entreprise

Collecte Complète

# Collecter toutes les informations système disponibles
./sysinfo_manager.sh collect comprehensive json false

# Inclure les informations sensibles pour analyse détaillée
./sysinfo_manager.sh collect comprehensive json true

Collecte Axée Sécurité

# Collecter uniquement les informations pertinentes à la sécurité
./sysinfo_manager.sh collect security_focused json false

Inventaire Matériel

# Collecter les données d'inventaire matériel
./sysinfo_manager.sh collect hardware_inventory json false

Surveillance de Santé Système

Analyse de Santé

# Effectuer analyse de santé standard
./sysinfo_manager.sh analyze_health standard

# Analyse de santé détaillée avec métriques complètes
./sysinfo_manager.sh analyze_health detailed

Considérations Importantes de Sécurité

• Sensibilité des données nécessite manipulation et chiffrement appropriés
• Contrôles d'accès doivent être implémentés pour informations système sensibles
• Journalisation d'audit doit suivre tous les accès et collectes d'information système
• Sécurité réseau doit protéger transmission de données entre appareils
• Exigences de conformité varient selon l'industrie et la localisation géographique

Performance et Évolutivité

Le système d'entreprise est conçu pour :

• Déploiement à grande échelle sur des milliers d'appareils
• Collecte efficace de données avec impact système minimal
• Stockage évolutif pour données historiques et analyse de tendances
• Haute disponibilité avec redondance et capacités de basculement
• Optimisation de performance pour diverses configurations matérielles

Ce système complet transforme la récupération d'information système de base en une plateforme de gestion et surveillance d'appareils de niveau entreprise avec analytique avancée, rapports de conformité et capacités de gestion de flotte.