Afficher l'heure de dernière ouverture des applications et fichiers sur macOS
Ce guide complet démontre comment suivre quand les applications et fichiers ont été accédés pour la dernière fois sur les appareils macOS, fournissant des informations essentielles pour la gestion du parc Mac et la surveillance d'utilisation.
Aperçu
La surveillance des modèles d'accès aux applications et fichiers est cruciale pour :
- Optimisation des performances : Identifier les applications gourmandes en ressources
- Gestion des licences : Suivre l'utilisation des logiciels pour la conformité
- Audit de sécurité : Surveiller l'accès aux fichiers pour la conformité sécuritaire
- Optimisation du stockage : Trouver les applications et fichiers inutilisés
- Analyse comportementale : Comprendre les habitudes de travail et la productivité
Script de base pour l'heure de dernière ouverture
Vérification simple d'application/fichier
Créez un script de base pour vérifier quand une application ou un fichier a été ouvert pour la dernière fois :
#!/bin/bash
# Script de base pour obtenir l'heure de dernière ouverture d'une app ou fichier
# Usage: ./last_opened.sh "/chemin/vers/app/ou/fichier"
if [ $# -eq 0 ]; then
echo "Usage: $0 <chemin_fichier>"
echo "Exemple: $0 '/Applications/Safari.app'"
exit 1
fi
file_path="$1"
# Vérifier si le fichier existe
if [ ! -e "$file_path" ]; then
echo "Erreur: Fichier ou application non trouvé: $file_path"
exit 1
fi
# Obtenir l'heure de dernière ouverture avec mdls
datetime=$(mdls "$file_path" -name kMDItemLastUsedDate | awk '{print $3,$4}')
if [ "$datetime" = "(null)" ]; then
echo "'$file_path' n'a jamais été ouvert ou l'heure de dernière ouverture n'est pas disponible"
exit 0
fi
echo "'$file_path' a été ouvert pour la dernière fois le (UTC):"
echo "$datetime"
echo "'$file_path' a été ouvert pour la dernière fois le (Heure locale):"
echo "$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S")"Script amélioré avec gestion d'erreurs
#!/bin/bash
# Script amélioré avec gestion d'erreurs complète et formatage
# Usage: ./enhanced_last_opened.sh "/chemin/vers/app/ou/fichier"
check_last_opened() {
local file_path="$1"
local file_name=$(basename "$file_path")
# Valider l'entrée
if [ -z "$file_path" ]; then
echo "Erreur: Aucun chemin de fichier fourni"
return 1
fi
# Vérifier si le fichier existe
if [ ! -e "$file_path" ]; then
echo "Erreur: Fichier non trouvé: $file_path"
return 1
fi
# Obtenir les métadonnées
local datetime=$(mdls "$file_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
local creation_date=$(mdls "$file_path" -name kMDItemContentCreationDate 2>/dev/null | awk '{print $3,$4}')
local modification_date=$(mdls "$file_path" -name kMDItemContentModificationDate 2>/dev/null | awk '{print $3,$4}')
echo "=== Informations du fichier ==="
echo "Fichier: $file_name"
echo "Chemin: $file_path"
echo ""
# Heure de dernière ouverture
if [ "$datetime" = "(null)" ] || [ -z "$datetime" ]; then
echo "Dernière ouverture: Jamais ouvert ou information non disponible"
else
echo "Dernière ouverture (UTC): $datetime"
local local_time=$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S" 2>/dev/null)
if [ $? -eq 0 ]; then
echo "Dernière ouverture (Locale): $local_time"
else
echo "Dernière ouverture (Locale): Impossible de convertir l'heure"
fi
fi
# Date de création
if [ "$creation_date" != "(null)" ] && [ -n "$creation_date" ]; then
echo "Créé (UTC): $creation_date"
fi
# Date de modification
if [ "$modification_date" != "(null)" ] && [ -n "$modification_date" ]; then
echo "Modifié (UTC): $modification_date"
fi
echo "=============================="
echo ""
}
# Exécution principale
if [ $# -eq 0 ]; then
echo "Usage: $0 <chemin_fichier>"
echo "Exemple: $0 '/Applications/Safari.app'"
exit 1
fi
check_last_opened "$1"Surveillance avancée des applications
Scanner d'applications en lot
#!/bin/bash
# Scanner d'applications en lot avec rapport détaillé
# Usage: ./bulk_app_scanner.sh
scan_applications() {
local output_file="rapport_usage_apps_$(date +%Y%m%d_%H%M%S).txt"
echo "Rapport d'utilisation des applications MacFleet" > "$output_file"
echo "Généré: $(date)" >> "$output_file"
echo "Appareil: $(scutil --get ComputerName)" >> "$output_file"
echo "Utilisateur: $(whoami)" >> "$output_file"
echo "=======================================" >> "$output_file"
echo "" >> "$output_file"
# Scanner le dossier Applications
echo "Scan de /Applications..."
find /Applications -maxdepth 2 -name "*.app" -type d | while read app_path; do
app_name=$(basename "$app_path" .app)
# Obtenir l'heure de dernière ouverture
datetime=$(mdls "$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
if [ "$datetime" = "(null)" ] || [ -z "$datetime" ]; then
last_opened="Jamais ouvert"
else
last_opened=$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S" 2>/dev/null)
if [ $? -ne 0 ]; then
last_opened="$datetime (UTC)"
fi
fi
# Obtenir la version de l'app
app_version=$(mdls "$app_path" -name kMDItemVersion 2>/dev/null | awk -F'"' '{print $2}')
if [ "$app_version" = "(null)" ] || [ -z "$app_version" ]; then
app_version="Inconnue"
fi
# Obtenir la taille de l'app
app_size=$(du -sh "$app_path" 2>/dev/null | cut -f1)
if [ -z "$app_size" ]; then
app_size="Inconnue"
fi
echo "App: $app_name" >> "$output_file"
echo " Version: $app_version" >> "$output_file"
echo " Taille: $app_size" >> "$output_file"
echo " Dernière ouverture: $last_opened" >> "$output_file"
echo " Chemin: $app_path" >> "$output_file"
echo "" >> "$output_file"
# Indicateur de progression
echo "Traité: $app_name"
done
echo "Rapport sauvegardé dans: $output_file"
}
# Exécuter le scan
scan_applicationsFiltre des applications récemment utilisées
#!/bin/bash
# Filtrer les applications par utilisation récente
# Usage: ./recent_apps.sh [jours]
filter_recent_apps() {
local days_threshold=${1:-7} # Par défaut 7 jours
local cutoff_date=$(date -v -${days_threshold}d +%Y-%m-%d)
echo "Applications utilisées dans les $days_threshold derniers jours:"
echo "Date limite: $cutoff_date"
echo "=================================="
find /Applications -maxdepth 2 -name "*.app" -type d | while read app_path; do
app_name=$(basename "$app_path" .app)
# Obtenir l'heure de dernière ouverture
datetime=$(mdls "$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
if [ "$datetime" != "(null)" ] && [ -n "$datetime" ]; then
# Convertir en format comparable
app_date=$(echo "$datetime" | cut -d' ' -f1)
# Comparer les dates
if [[ "$app_date" > "$cutoff_date" ]]; then
local_time=$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S" 2>/dev/null)
if [ $? -eq 0 ]; then
echo "$app_name - Dernière utilisation: $local_time"
else
echo "$app_name - Dernière utilisation: $datetime (UTC)"
fi
fi
fi
done | sort
}
# Exécution principale
if [ $# -gt 1 ]; then
echo "Usage: $0 [jours]"
echo "Exemple: $0 30 # Afficher les apps utilisées dans les 30 derniers jours"
exit 1
fi
filter_recent_apps "$1"Surveillance des fichiers d'entreprise
Suivi d'accès aux documents
#!/bin/bash
# Suivre les modèles d'accès aux documents pour les types de fichiers courants
# Usage: ./document_tracker.sh "/chemin/vers/documents"
track_document_access() {
local base_path=${1:-"$HOME/Documents"}
local output_file="acces_documents_$(date +%Y%m%d_%H%M%S).json"
echo "Suivi de l'accès aux documents dans: $base_path"
# Créer le rapport JSON
cat > "$output_file" << EOF
{
"info_rapport": {
"genere": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"appareil": "$(scutil --get ComputerName)",
"utilisateur": "$(whoami)",
"chemin_scan": "$base_path",
"version_macfleet": "1.0"
},
"documents": [
EOF
local first_entry=true
# Types de documents courants
local file_types=("*.pdf" "*.doc" "*.docx" "*.xls" "*.xlsx" "*.ppt" "*.pptx" "*.txt" "*.rtf" "*.pages" "*.numbers" "*.keynote")
for pattern in "${file_types[@]}"; do
find "$base_path" -name "$pattern" -type f 2>/dev/null | while read file_path; do
# Obtenir les métadonnées du fichier
local filename=$(basename "$file_path")
local extension="${filename##*.}"
local size=$(stat -f%z "$file_path" 2>/dev/null || echo "0")
# Obtenir les horodatages
local last_used=$(mdls "$file_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
local created=$(mdls "$file_path" -name kMDItemContentCreationDate 2>/dev/null | awk '{print $3,$4}')
local modified=$(mdls "$file_path" -name kMDItemContentModificationDate 2>/dev/null | awk '{print $3,$4}')
# Formater pour JSON
if [ "$last_used" = "(null)" ] || [ -z "$last_used" ]; then
last_used="null"
else
last_used="\"$last_used\""
fi
if [ "$created" = "(null)" ] || [ -z "$created" ]; then
created="null"
else
created="\"$created\""
fi
if [ "$modified" = "(null)" ] || [ -z "$modified" ]; then
modified="null"
else
modified="\"$modified\""
fi
# Ajouter une virgule si ce n'est pas la première entrée
if [ "$first_entry" = false ]; then
echo "," >> "$output_file"
fi
first_entry=false
# Ajouter l'entrée du document
cat >> "$output_file" << EOF
{
"nom_fichier": "$filename",
"extension": "$extension",
"taille_octets": $size,
"chemin": "$file_path",
"derniere_utilisation": $last_used,
"cree": $created,
"modifie": $modified
}EOF
done
done
# Fermer le JSON
cat >> "$output_file" << EOF
]
}
EOF
echo "Rapport d'accès aux documents sauvegardé dans: $output_file"
}
# Exécuter le suivi
track_document_access "$1"Moniteur d'accès aux fichiers multi-utilisateurs
#!/bin/bash
# Surveiller l'accès aux fichiers sur plusieurs comptes utilisateurs
# Usage: ./multi_user_monitor.sh
monitor_multi_user_access() {
local report_file="acces_multi_utilisateurs_$(date +%Y%m%d_%H%M%S).txt"
echo "Rapport d'accès aux fichiers multi-utilisateurs MacFleet" > "$report_file"
echo "Généré: $(date)" >> "$report_file"
echo "Appareil: $(scutil --get ComputerName)" >> "$report_file"
echo "=========================================" >> "$report_file"
echo "" >> "$report_file"
# Obtenir tous les répertoires home des utilisateurs
local users=($(dscl . -list /Users | grep -v "^_" | grep -v "daemon" | grep -v "nobody" | grep -v "root"))
for user in "${users[@]}"; do
local user_home=$(dscl . -read /Users/$user NFSHomeDirectory | awk '{print $2}')
if [ -d "$user_home" ]; then
echo "Utilisateur: $user ($user_home)" >> "$report_file"
echo "--------------------------------" >> "$report_file"
# Vérifier le dossier Documents
if [ -d "$user_home/Documents" ]; then
echo "Documents récemment accédés:" >> "$report_file"
find "$user_home/Documents" -type f -name "*.pdf" -o -name "*.doc*" -o -name "*.xls*" -o -name "*.ppt*" 2>/dev/null | head -10 | while read file_path; do
local filename=$(basename "$file_path")
local last_used=$(mdls "$file_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
if [ "$last_used" != "(null)" ] && [ -n "$last_used" ]; then
echo " - $filename (Dernière utilisation: $last_used)" >> "$report_file"
fi
done
fi
# Vérifier le dossier Téléchargements
if [ -d "$user_home/Downloads" ]; then
echo "Téléchargements récents:" >> "$report_file"
find "$user_home/Downloads" -type f -mtime -7 2>/dev/null | head -5 | while read file_path; do
local filename=$(basename "$file_path")
local mod_time=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$file_path" 2>/dev/null)
echo " - $filename (Téléchargé: $mod_time)" >> "$report_file"
done
fi
echo "" >> "$report_file"
fi
done
echo "Rapport d'accès multi-utilisateurs sauvegardé dans: $report_file"
}
# Exécuter la surveillance
monitor_multi_user_accessGestion distante du parc
Collecteur d'utilisation centralisé
#!/bin/bash
# Collecter les données d'utilisation pour la gestion distante du parc
# Usage: ./fleet_collector.sh
collect_fleet_data() {
local device_id=$(system_profiler SPHardwareDataType | grep "Hardware UUID" | awk '{print $3}')
local computer_name=$(scutil --get ComputerName)
local timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
# Créer un rapport complet
local report_file="utilisation_parc_${computer_name}_$(date +%Y%m%d_%H%M%S).json"
cat > "$report_file" << EOF
{
"info_appareil": {
"id_appareil": "$device_id",
"nom_ordinateur": "$computer_name",
"horodatage": "$timestamp",
"version_os": "$(sw_vers -productVersion)",
"duree_fonctionnement": "$(uptime | awk '{print $3,$4}' | sed 's/,//')"
},
"utilisation_applications": [
EOF
# Collecter les principales applications
local first_app=true
find /Applications -maxdepth 2 -name "*.app" -type d | head -20 | while read app_path; do
local app_name=$(basename "$app_path" .app)
local last_used=$(mdls "$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
local version=$(mdls "$app_path" -name kMDItemVersion 2>/dev/null | awk -F'"' '{print $2}')
if [ "$first_app" = false ]; then
echo "," >> "$report_file"
fi
first_app=false
# Formater les valeurs pour JSON
if [ "$last_used" = "(null)" ] || [ -z "$last_used" ]; then
last_used="null"
else
last_used="\"$last_used\""
fi
if [ "$version" = "(null)" ] || [ -z "$version" ]; then
version="null"
else
version="\"$version\""
fi
cat >> "$report_file" << EOF
{
"nom": "$app_name",
"version": $version,
"derniere_utilisation": $last_used,
"chemin": "$app_path"
}EOF
done
cat >> "$report_file" << EOF
],
"stats_systeme": {
"total_applications": $(find /Applications -maxdepth 2 -name "*.app" -type d | wc -l | tr -d ' '),
"utilisation_disque": "$(df -h / | tail -1 | awk '{print $5}')",
"utilisation_memoire": "$(vm_stat | grep "Pages active" | awk '{print $3}' | sed 's/\.//')"
}
}
EOF
echo "Données du parc collectées dans: $report_file"
# Optionnel: Envoyer au serveur central
# curl -X POST -H "Content-Type: application/json" -d @"$report_file" "https://votre-serveur-parc.com/api/utilisation"
}
# Exécuter la collecte
collect_fleet_dataSurveillance automatisée de l'utilisation
#!/bin/bash
# Surveillance automatisée de l'utilisation avec alertes
# Usage: ./usage_monitor.sh
setup_monitoring() {
local log_file="/var/log/macfleet_usage.log"
local config_file="/etc/macfleet/usage_config.conf"
# Créer la configuration si elle n'existe pas
if [ ! -f "$config_file" ]; then
sudo mkdir -p /etc/macfleet
sudo cat > "$config_file" << EOF
# Configuration de surveillance d'utilisation MacFleet
MONITOR_INTERVAL=3600 # Vérifier toutes les heures
ALERT_THRESHOLD=30 # Alerter si app inutilisée pendant 30 jours
REPORT_INTERVAL=86400 # Générer rapport quotidien
CLEANUP_THRESHOLD=90 # Marquer les apps inutilisées pendant 90 jours
EOF
fi
# Charger la configuration
source "$config_file"
# Créer le script de surveillance
cat > "/tmp/macfleet_monitor.sh" << EOF
#!/bin/bash
# Moniteur d'utilisation MacFleet
log_usage() {
local timestamp=\$(date -u +%Y-%m-%dT%H:%M:%SZ)
local computer_name=\$(scutil --get ComputerName)
echo "[\$timestamp] Début de vérification d'utilisation sur \$computer_name" >> "$log_file"
# Vérifier les applications inutilisées
find /Applications -maxdepth 2 -name "*.app" -type d | while read app_path; do
local app_name=\$(basename "\$app_path" .app)
local last_used=\$(mdls "\$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print \$3,\$4}')
if [ "\$last_used" != "(null)" ] && [ -n "\$last_used" ]; then
local days_since=\$(( (\$(date +%s) - \$(date -jf "%Y-%m-%d %H:%M:%S %z" "\$last_used +0000" +%s)) / 86400 ))
if [ \$days_since -gt $ALERT_THRESHOLD ]; then
echo "[\$timestamp] ALERTE: \$app_name inutilisée pendant \$days_since jours" >> "$log_file"
fi
if [ \$days_since -gt $CLEANUP_THRESHOLD ]; then
echo "[\$timestamp] NETTOYAGE: \$app_name marquée pour suppression (\$days_since jours)" >> "$log_file"
fi
fi
done
echo "[\$timestamp] Vérification d'utilisation terminée" >> "$log_file"
}
# Exécuter la surveillance
log_usage
EOF
chmod +x "/tmp/macfleet_monitor.sh"
# Configurer launchd pour la surveillance automatisée
cat > "/tmp/com.macfleet.usage.monitor.plist" << 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>com.macfleet.usage.monitor</string>
<key>ProgramArguments</key>
<array>
<string>/tmp/macfleet_monitor.sh</string>
</array>
<key>StartInterval</key>
<integer>$MONITOR_INTERVAL</integer>
<key>RunAtLoad</key>
<true/>
</dict>
</plist>
EOF
echo "Configuration de surveillance terminée. Utilisez 'sudo launchctl load /tmp/com.macfleet.usage.monitor.plist' pour démarrer."
}
# Exécuter la configuration
setup_monitoringMeilleures pratiques pour la gestion du parc Mac
1. Optimisation des performances
- Surveiller les applications gourmandes en ressources
- Suivre les applications qui n'ont pas été utilisées récemment
- Identifier les opportunités de nettoyage d'applications
- Optimiser les performances système grâce aux informations d'utilisation
2. Sécurité et conformité
- Suivre l'accès aux fichiers pour les audits de sécurité
- Surveiller la conformité de gestion des documents
- Identifier les modèles d'accès non autorisés aux fichiers
- Maintenir les journaux d'accès pour les exigences de conformité
3. Gestion des licences
- Surveiller l'utilisation des logiciels pour l'optimisation des licences
- Suivre l'efficacité du déploiement d'applications
- Identifier les licences inutilisées pour des économies de coût
- Assurer la conformité aux accords de licence logicielle
4. Expérience utilisateur
- Comprendre les modèles de comportement des utilisateurs
- Optimiser les stratégies de déploiement d'applications
- Améliorer la productivité des utilisateurs grâce aux informations d'utilisation
- Personnaliser les configurations d'appareils basées sur l'utilisation
5. Maintenance et nettoyage
- Identifier les applications inutilisées pour la suppression
- Nettoyer les fichiers temporaires et les caches
- Optimiser l'utilisation du stockage
- Programmer la maintenance régulière basée sur les modèles d'utilisation
Dépannage des problèmes courants
1. Erreurs de permissions
# Corriger les problèmes de permissions
sudo chown -R $(whoami) /Users/$(whoami)/Documents
sudo chmod -R 755 /Users/$(whoami)/Documents2. Métadonnées non disponibles
# Vérifier si l'indexation Spotlight est activée
mdutil -s /
# Re-indexer si nécessaire
sudo mdutil -i on /
sudo mdutil -E /3. Problèmes d'exécution de script
# Rendre le script exécutable
chmod +x nom_script.sh
# Vérifier la version bash
bash --version
# Utiliser le chemin complet pour les commandes
/usr/bin/mdls au lieu de mdls4. Problèmes de format de date
# Gérer différents formats de date
date -jf "%Y-%m-%d %H:%M:%S %z" "2024-01-01 12:00:00 +0000" +"%Y-%m-%d %H:%M:%S"Conclusion
La surveillance de l'utilisation des applications et fichiers est essentielle pour une gestion efficace du parc Mac. Ces scripts fournissent des informations complètes sur le comportement des utilisateurs, les performances du système et la conformité sécuritaire. Une surveillance régulière aide à optimiser les ressources, améliorer l'expérience utilisateur et maintenir les normes de sécurité à travers votre parc Mac.
N'oubliez pas de tester les scripts dans un environnement contrôlé avant de les déployer sur votre parc, et toujours suivre les politiques de sécurité et de confidentialité de votre organisation lors de la surveillance de l'activité des utilisateurs.