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

Récupérer les versions des applications installées sur macOS

La gestion d'une flotte Mac nécessite de suivre les versions d'applications sur tous les appareils. Ce tutoriel vous montre comment créer et déployer des scripts pour récupérer les versions d'applications sur les appareils macOS à distance.

Pourquoi le suivi des versions d'applications est important

Le suivi des versions d'applications est crucial pour :

  • Conformité de sécurité : S'assurer que tous les appareils exécutent des versions logicielles supportées
  • Gestion des licences : Suivre les déploiements logiciels et la conformité
  • Planification des mises à jour : Identifier les appareils qui nécessitent des mises à jour d'applications
  • Efficacité du support : Identifier rapidement les versions logicielles lors du dépannage
  • Gestion d'inventaire : Maintenir des enregistrements précis des ressources logicielles

Récupération basique des versions d'applications

Utilisation de la commande mdls

La commande mdls lit les attributs de métadonnées des fichiers, y compris les informations de version d'application stockées dans l'attribut kMDItemVersion.

#!/bin/bash

# Script basique pour récupérer les versions d'applications
applications=("Safari" "Mail" "Calendar" "Notes" "Contacts")
heading_printed=false

for app in "${applications[@]}"; do
    version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
    
    if [ -z "$version" ]; then
        echo "Impossible de récupérer la version pour ${app}"
    else
        if [ "$heading_printed" = false ]; then
            echo "Versions des applications :"
            heading_printed=true
        fi
        echo "${app}: ${version}"
    fi
done

Script de version amélioré avec contexte utilisateur

Pour les applications installées dans des emplacements spécifiques à l'utilisateur, vous devrez peut-être exécuter le script avec le contexte utilisateur :

#!/bin/bash

# Script amélioré avec support du contexte utilisateur
applications=("Safari" "Mail" "Calendar" "Notes" "Contacts" "Xcode" "Final Cut Pro")
current_user=$(whoami)
heading_printed=false

echo "Vérification des versions d'applications pour l'utilisateur : $current_user"
echo "Date : $(date)"
echo "----------------------------------------"

for app in "${applications[@]}"; do
    # Essayer d'abord le dossier Applications système
    version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
    
    # Si non trouvé, essayer le dossier Applications utilisateur
    if [ -z "$version" ]; then
        version=$(mdls -name kMDItemVersion "/Users/$current_user/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
    fi
    
    if [ -z "$version" ]; then
        echo "❌ Impossible de récupérer la version pour ${app}"
    else
        if [ "$heading_printed" = false ]; then
            echo "Versions des applications :"
            heading_printed=true
        fi
        echo "✅ ${app}: ${version}"
    fi
done

Scripts d'inventaire avancés

Scanner d'applications complet

#!/bin/bash

# Scanner complet des versions d'applications
OUTPUT_FILE="/tmp/app_versions_$(date +%Y%m%d_%H%M%S).txt"
DEVICE_NAME=$(scutil --get ComputerName)
DEVICE_USER=$(whoami)

echo "Rapport des versions d'applications Roundfleet" > "$OUTPUT_FILE"
echo "===========================================" >> "$OUTPUT_FILE"
echo "Appareil : $DEVICE_NAME" >> "$OUTPUT_FILE"
echo "Utilisateur : $DEVICE_USER" >> "$OUTPUT_FILE"
echo "Date : $(date)" >> "$OUTPUT_FILE"
echo "Version macOS : $(sw_vers -productVersion)" >> "$OUTPUT_FILE"
echo "" >> "$OUTPUT_FILE"

# Fonction pour récupérer les informations de l'application
get_app_info() {
    local app_path="$1"
    local app_name=$(basename "$app_path" .app)
    
    if [ -d "$app_path" ]; then
        local version=$(mdls -name kMDItemVersion "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        local bundle_id=$(mdls -name kMDItemCFBundleIdentifier "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        local size=$(du -sh "$app_path" 2>/dev/null | cut -f1)
        local modified=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path" 2>/dev/null)
        
        if [ -n "$version" ]; then
            echo "Application : $app_name" >> "$OUTPUT_FILE"
            echo "  Version : $version" >> "$OUTPUT_FILE"
            echo "  Bundle ID : $bundle_id" >> "$OUTPUT_FILE"
            echo "  Taille : $size" >> "$OUTPUT_FILE"
            echo "  Modifié : $modified" >> "$OUTPUT_FILE"
            echo "  Chemin : $app_path" >> "$OUTPUT_FILE"
            echo "" >> "$OUTPUT_FILE"
        fi
    fi
}

# Scanner le dossier Applications système
echo "Applications système :" >> "$OUTPUT_FILE"
echo "--------------------" >> "$OUTPUT_FILE"
if [ -d "/Applications" ]; then
    for app in /Applications/*.app; do
        get_app_info "$app"
    done
fi

# Scanner le dossier Applications utilisateur
echo "Applications utilisateur :" >> "$OUTPUT_FILE"
echo "------------------------" >> "$OUTPUT_FILE"
if [ -d "/Users/$DEVICE_USER/Applications" ]; then
    for app in "/Users/$DEVICE_USER/Applications"/*.app; do
        get_app_info "$app"
    done
fi

# Scanner le dossier Utilitaires
echo "Utilitaires :" >> "$OUTPUT_FILE"
echo "------------" >> "$OUTPUT_FILE"
if [ -d "/Applications/Utilities" ]; then
    for app in "/Applications/Utilities"/*.app; do
        get_app_info "$app"
    done
fi

echo "Rapport généré : $OUTPUT_FILE"
echo "Total d'applications trouvées : $(grep -c "Application :" "$OUTPUT_FILE")"

# Optionnel : Afficher le rapport
cat "$OUTPUT_FILE"

Vérificateur de versions d'applications spécifiques

#!/bin/bash

# Vérifier les applications spécifiques couramment utilisées en entreprise
declare -A enterprise_apps=(
    ["Microsoft Word"]="/Applications/Microsoft Word.app"
    ["Microsoft Excel"]="/Applications/Microsoft Excel.app"
    ["Microsoft PowerPoint"]="/Applications/Microsoft PowerPoint.app"
    ["Microsoft Outlook"]="/Applications/Microsoft Outlook.app"
    ["Adobe Photoshop 2024"]="/Applications/Adobe Photoshop 2024/Adobe Photoshop 2024.app"
    ["Adobe Illustrator 2024"]="/Applications/Adobe Illustrator 2024/Adobe Illustrator 2024.app"
    ["Slack"]="/Applications/Slack.app"
    ["Zoom"]="/Applications/zoom.us.app"
    ["Google Chrome"]="/Applications/Google Chrome.app"
    ["Firefox"]="/Applications/Firefox.app"
    ["Visual Studio Code"]="/Applications/Visual Studio Code.app"
    ["Docker Desktop"]="/Applications/Docker.app"
    ["Xcode"]="/Applications/Xcode.app"
)

echo "Vérification des versions d'applications d'entreprise"
echo "===================================================="
echo "Appareil : $(scutil --get ComputerName)"
echo "Date : $(date)"
echo ""

for app_name in "${!enterprise_apps[@]}"; do
    app_path="${enterprise_apps[$app_name]}"
    
    if [ -d "$app_path" ]; then
        version=$(mdls -name kMDItemVersion "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        bundle_id=$(mdls -name kMDItemCFBundleIdentifier "$app_path" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        
        if [ -n "$version" ]; then
            echo "✅ $app_name : $version"
            echo "   Bundle ID : $bundle_id"
        else
            echo "⚠️  $app_name : Installé mais version non disponible"
        fi
    else
        echo "❌ $app_name : Non installé"
    fi
done

# Vérifier les applications de sécurité critiques
echo ""
echo "Applications de sécurité :"
echo "------------------------"
security_apps=("Antivirus One" "Malwarebytes" "CleanMyMac" "Little Snitch")

for app in "${security_apps[@]}"; do
    if [ -d "/Applications/${app}.app" ]; then
        version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        echo "✅ $app : ${version:-Version non disponible}"
    else
        echo "❌ $app : Non installé"
    fi
done

Scripts de déploiement à distance

Collecte de versions multi-appareils

#!/bin/bash

# Script pour collecter les versions d'applications de plusieurs appareils Mac
# Ce script doit être déployé sur chaque appareil et les résultats collectés centralement

CENTRAL_SERVER="your-roundfleet-server.com"
DEVICE_ID=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')
REPORT_FILE="/tmp/device_app_report_${DEVICE_ID}.json"

# Créer un rapport JSON
create_json_report() {
    local device_name=$(scutil --get ComputerName)
    local device_user=$(whoami)
    local os_version=$(sw_vers -productVersion)
    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    
    cat > "$REPORT_FILE" << EOF
{
  "device_info": {
    "device_id": "$DEVICE_ID",
    "device_name": "$device_name",
    "user": "$device_user",
    "os_version": "$os_version",
    "timestamp": "$timestamp"
  },
  "applications": [
EOF

    local first_app=true
    for app in /Applications/*.app; do
        if [ -d "$app" ]; then
            local app_name=$(basename "$app" .app)
            local version=$(mdls -name kMDItemVersion "$app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
            local bundle_id=$(mdls -name kMDItemCFBundleIdentifier "$app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
            
            if [ -n "$version" ]; then
                if [ "$first_app" = false ]; then
                    echo "," >> "$REPORT_FILE"
                fi
                
                cat >> "$REPORT_FILE" << EOF
    {
      "name": "$app_name",
      "version": "$version",
      "bundle_id": "$bundle_id",
      "path": "$app"
    }EOF
                first_app=false
            fi
        fi
    done
    
    echo "" >> "$REPORT_FILE"
    echo "  ]" >> "$REPORT_FILE"
    echo "}" >> "$REPORT_FILE"
}

# Créer le rapport
create_json_report

# Afficher les résultats locaux
echo "Rapport des versions d'applications créé : $REPORT_FILE"
echo "ID de l'appareil : $DEVICE_ID"
echo "Total d'applications : $(grep -c '"name":' "$REPORT_FILE")"

# Optionnel : Envoyer au serveur central (décommentez si nécessaire)
# curl -X POST -H "Content-Type: application/json" -d @"$REPORT_FILE" "https://$CENTRAL_SERVER/api/device-reports"

Surveillance automatisée des versions

#!/bin/bash

# Surveillance automatisée des versions d'applications avec alertes
ALERT_THRESHOLD_DAYS=30
LOG_FILE="/var/log/roundfleet_app_monitor.log"
ALERT_FILE="/tmp/app_version_alerts.txt"

# Fonction pour enregistrer les messages
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Fonction pour vérifier si l'application nécessite une mise à jour
check_app_age() {
    local app_path="$1"
    local app_name=$(basename "$app_path" .app)
    local modified_date=$(stat -f "%Sm" -t "%Y-%m-%d" "$app_path" 2>/dev/null)
    
    if [ -n "$modified_date" ]; then
        local days_old=$(( ($(date +%s) - $(date -j -f "%Y-%m-%d" "$modified_date" +%s)) / 86400 ))
        
        if [ $days_old -gt $ALERT_THRESHOLD_DAYS ]; then
            echo "⚠️  $app_name : Dernière modification il y a $days_old jours ($modified_date)" >> "$ALERT_FILE"
            log_message "ALERTE : $app_name a $days_old jours"
        fi
    fi
}

# Initialiser le fichier d'alertes
echo "Alertes d'âge des applications Roundfleet" > "$ALERT_FILE"
echo "=======================================" >> "$ALERT_FILE"
echo "Généré : $(date)" >> "$ALERT_FILE"
echo "Seuil : $ALERT_THRESHOLD_DAYS jours" >> "$ALERT_FILE"
echo "" >> "$ALERT_FILE"

log_message "Début de la surveillance des versions d'applications"

# Vérifier les applications critiques
critical_apps=("Safari" "Mail" "Calendar" "Microsoft Word" "Microsoft Excel" "Google Chrome" "Slack" "Zoom")

for app in "${critical_apps[@]}"; do
    if [ -d "/Applications/${app}.app" ]; then
        check_app_age "/Applications/${app}.app"
        
        version=$(mdls -name kMDItemVersion "/Applications/${app}.app" 2>/dev/null | grep -o '".*"' | sed 's/"//g')
        log_message "Vérifié $app : Version $version"
    else
        log_message "AVERTISSEMENT : $app non trouvé"
    fi
done

# Afficher les alertes s'il y en a
if [ -s "$ALERT_FILE" ] && [ $(wc -l < "$ALERT_FILE") -gt 4 ]; then
    echo "⚠️  Alertes d'âge des applications trouvées :"
    cat "$ALERT_FILE"
    
    # Optionnel : Envoyer les alertes par email ou service de notification
    # mail -s "Alertes de versions d'applications Roundfleet - $(hostname)" [email protected] < "$ALERT_FILE"
fi

log_message "Surveillance des versions d'applications terminée"

Meilleures pratiques pour la gestion de flotte Mac

1. Surveillance régulière

  • Planifier les vérifications de versions hebdomadaires ou bihebdomadaires
  • Surveiller les applications métier critiques plus fréquemment
  • Suivre les applications installées système et utilisateur

2. Standardisation des versions

  • Maintenir des listes de versions d'applications approuvées
  • Créer des politiques pour les mises à jour automatiques
  • Documenter les exigences de compatibilité des versions

3. Considérations de sécurité

  • Prioriser les mises à jour de sécurité pour toutes les applications
  • Surveiller les applications avec des vulnérabilités connues
  • Implémenter des flux d'approbation pour les mises à jour majeures

4. Reporting et analytique

  • Générer des rapports de conformité réguliers
  • Suivre les taux de succès de déploiement des mises à jour
  • Surveiller les modèles d'utilisation des applications

5. Intégration d'automatisation

  • Intégrer avec les outils de gestion de configuration
  • Automatiser les vérifications de versions de routine
  • Configurer des alertes pour les divergences de versions

Résolution des problèmes courants

Problème : Commande mdls introuvable

# Vérifier la disponibilité de la commande
which mdls
# Si non trouvé, vérifier l'intégrité du système
sudo /usr/bin/mdutil -i on /

Problème : Permission refusée

# Exécuter avec les permissions appropriées
sudo -u [nomutilisateur] mdls -name kMDItemVersion "/Applications/NomApp.app"

Problème : Informations de version non disponibles

# Essayer des méthodes alternatives
defaults read "/Applications/NomApp.app/Contents/Info.plist" CFBundleShortVersionString
plutil -p "/Applications/NomApp.app/Contents/Info.plist" | grep -i version

Problème : Applications dans des emplacements non standard

# Rechercher les applications dans tout le système
find /Applications /Users/*/Applications -name "*.app" -type d 2>/dev/null

Conclusion

Le suivi des versions d'applications est essentiel pour maintenir une flotte Mac sécurisée et conforme. Ces scripts fournissent une base pour :

  • La découverte automatisée des versions et le reporting
  • La surveillance de la conformité et les alertes
  • L'évaluation des vulnérabilités de sécurité
  • La gestion des ressources logicielles

L'implémentation régulière de ces pratiques de surveillance aidera à s'assurer que votre flotte Mac reste sécurisée, conforme et correctement gérée.

Pour des capacités de gestion de flotte Mac plus avancées, envisagez d'intégrer ces scripts avec vos outils existants de gestion de configuration et de surveillance.

Related Tutorials

Gestion Navigateur Safari sur macOS

Apprenez à configurer la page d'accueil Safari, paramètres navigateur, politiques sécurité et déployer la gestion navigateur entreprise sur vos appareils Roundfleet avec gestion utilisateur complète et fonctionnalités conformité.

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

Gestion de Paquets d'Entreprise avec Homebrew sur macOS

Déployez, gérez et maintenez les paquets logiciels sur les appareils macOS en utilisant Homebrew avec une gestion de configuration d'entreprise, un suivi de conformité et des flux de déploiement automatisés.

7 juil. 2025

Gérer les extensions de noyau sur macOS

Apprenez à afficher, charger, décharger et surveiller les extensions de noyau (kexts) sur les appareils macOS via des scripts en ligne de commande pour une gestion système et sécurité améliorées.

7 juil. 2025

Installer des Packages Non Signés sur macOS

Déployez et installez des packages PKG non signés sur Mac à l'aide de scripts pour les outils de développement spécialisés et logiciels open-source.

7 juil. 2025

Installer la dernière version de Firefox sur les appareils macOS

Apprenez à installer et gérer la dernière version de Firefox sur les appareils macOS pour le déploiement d'entreprise, les mises à jour et la gestion de configuration.

7 juil. 2025

Gestion de Réseau Wi-Fi sur macOS

Gérez les réseaux Wi-Fi, configurez les paramètres proxy, serveurs DNS et implémentez les politiques de réseau d'entreprise sur les appareils macOS en utilisant les commandes networksetup avancées et la gestion de flotte centralisée.

7 juil. 2025

Contrôle Wi-Fi d'Entreprise sur macOS

Guide complet pour contrôler les paramètres Wi-Fi sur les appareils macOS en utilisant les commandes networksetup pour la gestion sans fil d'entreprise, les politiques de sécurité et l'optimisation énergétique dans les déploiements de flotte.

7 juil. 2025
View all tutorials →