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

Supprimer les comptes mobiles sur les appareils macOS

Ce guide complet démontre comment supprimer les comptes mobiles sur les appareils macOS pour une gestion efficace des utilisateurs, la réaffectation d'appareils et les scénarios de nettoyage organisationnel.

Aperçu

Les comptes mobiles sur macOS sont des profils utilisateur conçus pour un accès transparent aux ressources sur différents appareils au sein des organisations. Contrairement aux comptes locaux, les comptes mobiles sont gérés de manière centralisée par des services d'annuaire comme Open Directory ou Active Directory.

Scénarios courants pour la suppression de comptes mobiles

  • Départs d'employés : Nettoyer les comptes lorsque les employés quittent l'organisation
  • Changements de rôle : Supprimer les anciens comptes mobiles lors de changements de poste
  • Réaffectation d'appareils : Préparer les appareils pour de nouveaux utilisateurs
  • Conformité de sécurité : Supprimer les comptes inactifs ou compromis
  • Optimisation du stockage : Libérer l'espace disque en supprimant les comptes non utilisés

Suppression de base des comptes mobiles

Script simple de suppression des comptes mobiles

#!/bin/bash

# Script de suppression basique des comptes mobiles
# Utilisation : ./supprimer_comptes_mobiles.sh

supprimer_comptes_mobiles() {
    echo "Démarrage du processus de suppression des comptes mobiles..."
    
    # Vérifier si le script est exécuté en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Erreur : Ce script doit être exécuté en tant que root"
        exit 1
    fi
    
    # Compteur pour les comptes supprimés
    local compteur_suppression=0
    
    # Parcourir tous les utilisateurs
    for nom_utilisateur in $(dscl . -list /Users | grep -v '^_'); do
        # Vérifier si l'utilisateur a une authentification de compte mobile
        autorite_auth=$(dscl . -read "/Users/$nom_utilisateur" AuthenticationAuthority 2>/dev/null | grep "LocalCachedUser")
        
        if [ -n "$autorite_auth" ]; then
            echo "Suppression du compte mobile : $nom_utilisateur"
            
            # Supprimer l'utilisateur des services d'annuaire
            dscl . -delete "/Users/$nom_utilisateur"
            
            # Supprimer le répertoire home de l'utilisateur
            rm -rf "/Users/$nom_utilisateur"
            
            ((compteur_suppression++))
        fi
    done
    
    echo "Suppression des comptes mobiles terminée. $compteur_suppression comptes supprimés."
    echo "Note : Veuillez redémarrer l'appareil pour que les changements prennent pleinement effet."
}

# Exécuter la suppression
supprimer_comptes_mobiles

Gestionnaire de comptes mobiles avancé

#!/bin/bash

# Gestionnaire avancé de comptes mobiles avec vérifications de sécurité
# Utilisation : ./gestionnaire_comptes_mobiles_avance.sh

gestionnaire_comptes_mobiles_avance() {
    local fichier_log="/var/log/roundfleet_comptes_mobiles.log"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local repertoire_sauvegarde="/var/backups/roundfleet/comptes_mobiles"
    
    # Vérifier si le script est exécuté en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Erreur : Ce script doit être exécuté en tant que root"
        exit 1
    fi
    
    # Créer le répertoire de log
    mkdir -p /var/log
    mkdir -p "$repertoire_sauvegarde"
    
    echo "[$timestamp] Gestionnaire avancé de comptes mobiles démarré" >> "$fichier_log"
    
    # Afficher les comptes mobiles actuels
    afficher_comptes_mobiles
    
    # Confirmer la suppression
    echo ""
    read -p "Voulez-vous procéder à la suppression des comptes mobiles ? (o/N) : " confirmer
    
    if [ "$confirmer" = "o" ] || [ "$confirmer" = "O" ]; then
        creer_sauvegarde_comptes
        supprimer_comptes_mobiles_avance
    else
        echo "Opération annulée."
        echo "[$timestamp] Suppression des comptes mobiles annulée par l'utilisateur" >> "$fichier_log"
    fi
}

afficher_comptes_mobiles() {
    echo "======================================="
    echo "Comptes mobiles actuels sur l'appareil"
    echo "======================================="
    
    local comptes_mobiles_trouves=false
    
    for nom_utilisateur in $(dscl . -list /Users | grep -v '^_'); do
        autorite_auth=$(dscl . -read "/Users/$nom_utilisateur" AuthenticationAuthority 2>/dev/null | grep "LocalCachedUser")
        
        if [ -n "$autorite_auth" ]; then
            comptes_mobiles_trouves=true
            
            # Obtenir des informations supplémentaires sur l'utilisateur
            local nom_reel=$(dscl . -read "/Users/$nom_utilisateur" RealName 2>/dev/null | cut -d: -f2 | xargs)
            local uid=$(dscl . -read "/Users/$nom_utilisateur" UniqueID 2>/dev/null | cut -d: -f2 | xargs)
            local repertoire_home=$(dscl . -read "/Users/$nom_utilisateur" NFSHomeDirectory 2>/dev/null | cut -d: -f2 | xargs)
            local derniere_connexion=$(last -1 "$nom_utilisateur" 2>/dev/null | head -1 | awk '{print $3, $4, $5, $6}')
            
            echo "Nom d'utilisateur : $nom_utilisateur"
            echo "  Nom réel : $nom_reel"
            echo "  UID : $uid"
            echo "  Répertoire home : $repertoire_home"
            echo "  Dernière connexion : $derniere_connexion"
            
            # Vérifier la taille du répertoire home
            if [ -d "$repertoire_home" ]; then
                local taille_repertoire=$(du -sh "$repertoire_home" 2>/dev/null | cut -f1)
                echo "  Taille du répertoire home : $taille_repertoire"
            fi
            
            echo ""
        fi
    done
    
    if [ "$comptes_mobiles_trouves" = false ]; then
        echo "Aucun compte mobile trouvé sur cet appareil."
        echo "[$timestamp] Aucun compte mobile trouvé sur l'appareil" >> "$fichier_log"
        exit 0
    fi
}

creer_sauvegarde_comptes() {
    echo "Création d'une sauvegarde des informations des comptes mobiles..."
    
    local fichier_sauvegarde="$repertoire_sauvegarde/sauvegarde_comptes_mobiles_$(date +%Y%m%d_%H%M%S).txt"
    
    cat > "$fichier_sauvegarde" << EOF
Sauvegarde des comptes mobiles Roundfleet
Généré : $(date)
Appareil : $(scutil --get ComputerName)
Version macOS : $(sw_vers -productVersion)

Comptes mobiles trouvés :
EOF
    
    for nom_utilisateur in $(dscl . -list /Users | grep -v '^_'); do
        autorite_auth=$(dscl . -read "/Users/$nom_utilisateur" AuthenticationAuthority 2>/dev/null | grep "LocalCachedUser")
        
        if [ -n "$autorite_auth" ]; then
            echo "Nom d'utilisateur : $nom_utilisateur" >> "$fichier_sauvegarde"
            dscl . -read "/Users/$nom_utilisateur" >> "$fichier_sauvegarde"
            echo "---" >> "$fichier_sauvegarde"
        fi
    done
    
    echo "Sauvegarde créée : $fichier_sauvegarde"
    echo "[$timestamp] Sauvegarde des comptes mobiles créée : $fichier_sauvegarde" >> "$fichier_log"
}

supprimer_comptes_mobiles_avance() {
    echo "======================================="
    echo "Suppression des comptes mobiles"
    echo "======================================="
    
    local compteur_suppression=0
    local compteur_echec=0
    
    for nom_utilisateur in $(dscl . -list /Users | grep -v '^_'); do
        autorite_auth=$(dscl . -read "/Users/$nom_utilisateur" AuthenticationAuthority 2>/dev/null | grep "LocalCachedUser")
        
        if [ -n "$autorite_auth" ]; then
            echo "Traitement du compte mobile : $nom_utilisateur"
            
            # Vérifier si l'utilisateur est actuellement connecté
            if who | grep -q "^$nom_utilisateur "; then
                echo "  Attention : L'utilisateur $nom_utilisateur est actuellement connecté. Ignoré..."
                echo "[$timestamp] Suppression ignorée pour $nom_utilisateur - utilisateur connecté" >> "$fichier_log"
                ((compteur_echec++))
                continue
            fi
            
            # Supprimer l'utilisateur des services d'annuaire
            if dscl . -delete "/Users/$nom_utilisateur" 2>/dev/null; then
                echo "  Enregistrement utilisateur supprimé des services d'annuaire"
            else
                echo "  Attention : Échec de la suppression de l'enregistrement utilisateur"
                echo "[$timestamp] Échec de la suppression de l'enregistrement utilisateur pour $nom_utilisateur" >> "$fichier_log"
                ((compteur_echec++))
                continue
            fi
            
            # Supprimer le répertoire home de l'utilisateur
            local repertoire_home=$(dscl . -read "/Users/$nom_utilisateur" NFSHomeDirectory 2>/dev/null | cut -d: -f2 | xargs)
            if [ -d "$repertoire_home" ]; then
                if rm -rf "$repertoire_home" 2>/dev/null; then
                    echo "  Répertoire home supprimé : $repertoire_home"
                else
                    echo "  Attention : Échec de la suppression du répertoire home : $repertoire_home"
                    echo "[$timestamp] Échec de la suppression du répertoire home pour $nom_utilisateur : $repertoire_home" >> "$fichier_log"
                fi
            fi
            
            echo "  Compte mobile supprimé avec succès : $nom_utilisateur"
            echo "[$timestamp] Compte mobile supprimé avec succès : $nom_utilisateur" >> "$fichier_log"
            ((compteur_suppression++))
        fi
    done
    
    echo ""
    echo "======================================="
    echo "Résumé de la suppression des comptes mobiles"
    echo "======================================="
    echo "Supprimés avec succès : $compteur_suppression comptes"
    echo "Échec de suppression : $compteur_echec comptes"
    echo "Total traité : $((compteur_suppression + compteur_echec)) comptes"
    echo ""
    echo "Note : Veuillez redémarrer l'appareil pour que les changements prennent pleinement effet."
    
    echo "[$timestamp] Suppression des comptes mobiles terminée - Succès : $compteur_suppression, Échec : $compteur_echec" >> "$fichier_log"
}

# Exécuter la gestion avancée
gestionnaire_comptes_mobiles_avance

Gestion sélective des comptes mobiles

Suppression d'un compte mobile spécifique

#!/bin/bash

# Suppression sélective d'un compte mobile spécifique
# Utilisation : ./supprimer_compte_mobile_specifique.sh

supprimer_compte_mobile_specifique() {
    local nom_utilisateur="$1"
    local fichier_log="/var/log/roundfleet_comptes_mobiles.log"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Vérifier si le script est exécuté en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Erreur : Ce script doit être exécuté en tant que root"
        exit 1
    fi
    
    # Vérifier si le nom d'utilisateur est fourni
    if [ -z "$nom_utilisateur" ]; then
        echo "Utilisation : $0 <nom_utilisateur>"
        echo "Exemple : $0 john.doe"
        exit 1
    fi
    
    # Vérifier si l'utilisateur existe et est un compte mobile
    local autorite_auth=$(dscl . -read "/Users/$nom_utilisateur" AuthenticationAuthority 2>/dev/null | grep "LocalCachedUser")
    
    if [ -z "$autorite_auth" ]; then
        echo "Erreur : L'utilisateur '$nom_utilisateur' n'existe pas ou n'est pas un compte mobile."
        exit 1
    fi
    
    echo "======================================="
    echo "Suppression du compte mobile : $nom_utilisateur"
    echo "======================================="
    
    # Afficher les détails du compte
    local nom_reel=$(dscl . -read "/Users/$nom_utilisateur" RealName 2>/dev/null | cut -d: -f2 | xargs)
    local repertoire_home=$(dscl . -read "/Users/$nom_utilisateur" NFSHomeDirectory 2>/dev/null | cut -d: -f2 | xargs)
    
    echo "Nom d'utilisateur : $nom_utilisateur"
    echo "Nom réel : $nom_reel"
    echo "Répertoire home : $repertoire_home"
    
    # Vérifier si l'utilisateur est connecté
    if who | grep -q "^$nom_utilisateur "; then
        echo "Attention : L'utilisateur est actuellement connecté !"
        read -p "Voulez-vous continuer quand même ? (o/N) : " forcer_suppression
        if [ "$forcer_suppression" != "o" ] && [ "$forcer_suppression" != "O" ]; then
            echo "Suppression annulée."
            return
        fi
    fi
    
    echo ""
    read -p "Êtes-vous sûr de vouloir supprimer ce compte ? (o/N) : " confirmer
    
    if [ "$confirmer" = "o" ] || [ "$confirmer" = "O" ]; then
        # Créer une sauvegarde des données utilisateur
        local repertoire_sauvegarde="/var/backups/roundfleet/comptes_mobiles"
        mkdir -p "$repertoire_sauvegarde"
        
        local fichier_sauvegarde="$repertoire_sauvegarde/${nom_utilisateur}_sauvegarde_$(date +%Y%m%d_%H%M%S).txt"
        
        echo "Création d'une sauvegarde des données utilisateur..."
        dscl . -read "/Users/$nom_utilisateur" > "$fichier_sauvegarde"
        
        # Supprimer l'utilisateur des services d'annuaire
        if dscl . -delete "/Users/$nom_utilisateur" 2>/dev/null; then
            echo "Enregistrement utilisateur supprimé des services d'annuaire"
        else
            echo "Échec de la suppression de l'enregistrement utilisateur"
            return 1
        fi
        
        # Supprimer le répertoire home de l'utilisateur
        if [ -d "$repertoire_home" ]; then
            read -p "Voulez-vous supprimer le répertoire home ? (o/N) : " supprimer_home
            if [ "$supprimer_home" = "o" ] || [ "$supprimer_home" = "O" ]; then
                if rm -rf "$repertoire_home"; then
                    echo "Répertoire home supprimé : $repertoire_home"
                else
                    echo "Échec de la suppression du répertoire home : $repertoire_home"
                fi
            else
                echo "Répertoire home préservé : $repertoire_home"
            fi
        fi
        
        echo "Compte mobile supprimé avec succès : $nom_utilisateur"
        echo "Sauvegarde créée : $fichier_sauvegarde"
        echo "[$timestamp] Compte mobile supprimé avec succès : $nom_utilisateur" >> "$fichier_log"
    else
        echo "Suppression annulée."
    fi
}

# Exécuter la suppression si un nom d'utilisateur est fourni
if [ $# -eq 1 ]; then
    supprimer_compte_mobile_specifique "$1"
else
    echo "Utilisation : $0 <nom_utilisateur>"
    echo "Exemple : $0 john.doe"
    exit 1
fi

Nettoyage automatisé des comptes mobiles

Script de nettoyage automatisé pour l'entreprise

#!/bin/bash

# Nettoyage automatisé des comptes mobiles pour les environnements d'entreprise
# Utilisation : ./nettoyage_comptes_mobiles_automatise.sh

nettoyage_comptes_mobiles_automatise() {
    local fichier_config="/etc/roundfleet/config_nettoyage_mobile.conf"
    local fichier_log="/var/log/roundfleet_nettoyage_automatise.log"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Vérifier si le script est exécuté en tant que root
    if [ "$EUID" -ne 0 ]; then
        echo "Erreur : Ce script doit être exécuté en tant que root"
        exit 1
    fi
    
    # Créer la configuration si elle n'existe pas
    if [ ! -f "$fichier_config" ]; then
        creer_config_nettoyage
    fi
    
    source "$fichier_config"
    
    echo "[$timestamp] Nettoyage automatisé des comptes mobiles démarré" >> "$fichier_log"
    
    # Exécuter le nettoyage basé sur la configuration
    executer_nettoyage_automatise
}

creer_config_nettoyage() {
    mkdir -p /etc/roundfleet
    
    cat > "/etc/roundfleet/config_nettoyage_mobile.conf" << 'EOF'
# Configuration du nettoyage automatisé des comptes mobiles Roundfleet

# Paramètres de l'organisation
NOM_ORGANISATION="Organisation Roundfleet"
CONTACT_IT="[email protected]"

# Critères de nettoyage
JOURS_INACTIVITE_NETTOYAGE="30"
NETTOYAGE_ACTIVE="true"
PRESERVER_COMPTES_ADMIN="true"

# Paramètres de sécurité
NECESSITER_CONFIRMATION="true"
CREER_SAUVEGARDE="true"
PRESERVER_DONNEES_HOME="false"
IGNORER_UTILISATEURS_CONNECTES="true"

# Paramètres de notification
ENVOYER_NOTIFICATIONS="true"
EMAIL_NOTIFICATION="[email protected]"

# Planification
ACTIVER_NETTOYAGE_PLANIFIE="false"
PLANIFICATION_NETTOYAGE="hebdomadaire"
HEURE_NETTOYAGE="02:00"

# Journalisation
ACTIVER_JOURNALISATION_DETAILLEE="true"
RETENTION_LOGS_JOURS="90"
EOF
    
    echo "Configuration de nettoyage créée à /etc/roundfleet/config_nettoyage_mobile.conf"
}

executer_nettoyage_automatise() {
    echo "[$timestamp] Exécution du nettoyage automatisé des comptes mobiles" >> "$fichier_log"
    
    # Vérifier si le nettoyage est activé
    if [ "$NETTOYAGE_ACTIVE" != "true" ]; then
        echo "[$timestamp] Le nettoyage automatisé est désactivé" >> "$fichier_log"
        echo "Le nettoyage automatisé est désactivé dans la configuration."
        return
    fi
    
    # Afficher la configuration de nettoyage
    echo "======================================="
    echo "Nettoyage automatisé des comptes mobiles Roundfleet"
    echo "======================================="
    echo "Organisation : $NOM_ORGANISATION"
    echo "Nettoyer les comptes inactifs depuis : $JOURS_INACTIVITE_NETTOYAGE jours"
    echo "Préserver les comptes admin : $PRESERVER_COMPTES_ADMIN"
    echo "Créer une sauvegarde : $CREER_SAUVEGARDE"
    echo "Ignorer les utilisateurs connectés : $IGNORER_UTILISATEURS_CONNECTES"
    echo ""
    
    # Nécessiter une confirmation si activé
    if [ "$NECESSITER_CONFIRMATION" = "true" ]; then
        read -p "Voulez-vous procéder au nettoyage automatisé ? (o/N) : " confirmer
        if [ "$confirmer" != "o" ] && [ "$confirmer" != "O" ]; then
            echo "[$timestamp] Nettoyage automatisé annulé par l'utilisateur" >> "$fichier_log"
            echo "Nettoyage automatisé annulé."
            return
        fi
    fi
    
    # Trouver les comptes à nettoyer
    local comptes_a_nettoyer=()
    local timestamp_actuel=$(date +%s)
    local timestamp_limite=$((timestamp_actuel - (JOURS_INACTIVITE_NETTOYAGE * 24 * 60 * 60)))
    
    echo "Recherche des comptes mobiles à nettoyer..."
    
    for nom_utilisateur in $(dscl . -list /Users | grep -v '^_'); do
        autorite_auth=$(dscl . -read "/Users/$nom_utilisateur" AuthenticationAuthority 2>/dev/null | grep "LocalCachedUser")
        
        if [ -n "$autorite_auth" ]; then
            local doit_nettoyer=true
            
            # Vérifier si l'utilisateur est admin (si la préservation est activée)
            if [ "$PRESERVER_COMPTES_ADMIN" = "true" ]; then
                if dscl . -read "/Groups/admin" GroupMembership 2>/dev/null | grep -q "$nom_utilisateur"; then
                    echo "Ignorer le compte admin : $nom_utilisateur"
                    echo "[$timestamp] Compte admin ignoré : $nom_utilisateur" >> "$fichier_log"
                    doit_nettoyer=false
                fi
            fi
            
            # Vérifier si l'utilisateur est connecté (si l'option d'ignorer est activée)
            if [ "$IGNORER_UTILISATEURS_CONNECTES" = "true" ] && who | grep -q "^$nom_utilisateur "; then
                echo "Ignorer l'utilisateur connecté : $nom_utilisateur"
                echo "[$timestamp] Utilisateur connecté ignoré : $nom_utilisateur" >> "$fichier_log"
                doit_nettoyer=false
            fi
            
            # Vérifier la date de dernière connexion
            if [ "$doit_nettoyer" = true ]; then
                local derniere_connexion=$(last -1 "$nom_utilisateur" 2>/dev/null | head -1 | awk '{print $3, $4, $5, $6}')
                
                if [ -n "$derniere_connexion" ]; then
                    local timestamp_derniere_connexion=$(date -j -f "%a %b %d %H:%M:%S %Y" "$derniere_connexion" +%s 2>/dev/null)
                    
                    if [ -n "$timestamp_derniere_connexion" ] && [ "$timestamp_derniere_connexion" -lt "$timestamp_limite" ]; then
                        comptes_a_nettoyer+=("$nom_utilisateur")
                        echo "Compte marqué pour nettoyage : $nom_utilisateur (dernière connexion : $derniere_connexion)"
                    fi
                else
                    # Aucun enregistrement de connexion - considérer pour nettoyage
                    comptes_a_nettoyer+=("$nom_utilisateur")
                    echo "Compte marqué pour nettoyage : $nom_utilisateur (aucun enregistrement de connexion)"
                fi
            fi
        fi
    done
    
    if [ ${#comptes_a_nettoyer[@]} -eq 0 ]; then
        echo "Aucun compte mobile trouvé répondant aux critères de nettoyage."
        echo "[$timestamp] Aucun compte mobile trouvé pour le nettoyage" >> "$fichier_log"
        return
    fi
    
    echo ""
    echo "Trouvé ${#comptes_a_nettoyer[@]} comptes mobiles pour le nettoyage :"
    for compte in "${comptes_a_nettoyer[@]}"; do
        echo "  - $compte"
    done
    
    # Créer une sauvegarde si activé
    if [ "$CREER_SAUVEGARDE" = "true" ]; then
        creer_sauvegarde_automatisee "${comptes_a_nettoyer[@]}"
    fi
    
    # Nettoyer les comptes
    local compteur_succes=0
    local compteur_echec=0
    
    echo ""
    echo "Démarrage du nettoyage automatisé..."
    
    for nom_utilisateur in "${comptes_a_nettoyer[@]}"; do
        echo "Traitement : $nom_utilisateur"
        
        # Supprimer l'utilisateur des services d'annuaire
        if dscl . -delete "/Users/$nom_utilisateur" 2>/dev/null; then
            echo "  Enregistrement utilisateur supprimé des services d'annuaire"
            
            # Gérer le répertoire home basé sur la configuration
            local repertoire_home="/Users/$nom_utilisateur"
            
            if [ -d "$repertoire_home" ]; then
                if [ "$PRESERVER_DONNEES_HOME" = "true" ]; then
                    echo "  Répertoire home préservé : $repertoire_home"
                else
                    if rm -rf "$repertoire_home" 2>/dev/null; then
                        echo "  Répertoire home supprimé : $repertoire_home"
                    else
                        echo "  Attention : Échec de la suppression du répertoire home : $repertoire_home"
                    fi
                fi
            fi
            
            echo "  Compte nettoyé avec succès : $nom_utilisateur"
            echo "[$timestamp] Compte nettoyé avec succès : $nom_utilisateur" >> "$fichier_log"
            ((compteur_succes++))
        else
            echo "  Échec du nettoyage du compte : $nom_utilisateur"
            echo "[$timestamp] Échec du nettoyage du compte : $nom_utilisateur" >> "$fichier_log"
            ((compteur_echec++))
        fi
    done
    
    # Générer le résumé du nettoyage
    echo ""
    echo "======================================="
    echo "Résumé du nettoyage automatisé"
    echo "======================================="
    echo "Total des comptes traités : ${#comptes_a_nettoyer[@]}"
    echo "Nettoyés avec succès : $compteur_succes"
    echo "Échec de nettoyage : $compteur_echec"
    echo "Nettoyage terminé à : $(date)"
    
    echo "[$timestamp] Nettoyage automatisé terminé - Succès : $compteur_succes, Échec : $compteur_echec" >> "$fichier_log"
    
    # Envoyer une notification si activé
    if [ "$ENVOYER_NOTIFICATIONS" = "true" ]; then
        envoyer_notification_nettoyage "$compteur_succes" "$compteur_echec"
    fi
    
    echo ""
    echo "Note : Veuillez redémarrer l'appareil pour que les changements prennent pleinement effet."
}

creer_sauvegarde_automatisee() {
    local comptes=("$@")
    local repertoire_sauvegarde="/var/backups/roundfleet/nettoyage_automatise"
    local fichier_sauvegarde="$repertoire_sauvegarde/sauvegarde_nettoyage_$(date +%Y%m%d_%H%M%S).txt"
    
    mkdir -p "$repertoire_sauvegarde"
    
    echo "Création d'une sauvegarde des comptes à nettoyer..."
    
    cat > "$fichier_sauvegarde" << EOF
Sauvegarde de nettoyage automatisé Roundfleet
Généré : $(date)
Appareil : $(scutil --get ComputerName)
Organisation : $NOM_ORGANISATION
Critères de nettoyage : Inactif depuis $JOURS_INACTIVITE_NETTOYAGE jours

Comptes à nettoyer :
EOF
    
    for nom_utilisateur in "${comptes[@]}"; do
        echo "" >> "$fichier_sauvegarde"
        echo "Nom d'utilisateur : $nom_utilisateur" >> "$fichier_sauvegarde"
        dscl . -read "/Users/$nom_utilisateur" >> "$fichier_sauvegarde" 2>/dev/null
        echo "---" >> "$fichier_sauvegarde"
    done
    
    echo "Sauvegarde créée : $fichier_sauvegarde"
    echo "[$timestamp] Sauvegarde de nettoyage automatisé créée : $fichier_sauvegarde" >> "$fichier_log"
}

envoyer_notification_nettoyage() {
    local compteur_succes=$1
    local compteur_echec=$2
    
    # Utiliser osascript pour afficher une notification (pour les notifications locales)
    osascript -e "display notification \"Nettoyage terminé : $compteur_succes succès, $compteur_echec échec\" with title \"Nettoyage des comptes mobiles Roundfleet\""
    
    echo "[$timestamp] Notification de nettoyage envoyée" >> "$fichier_log"
}

# Exécuter le nettoyage automatisé
nettoyage_comptes_mobiles_automatise

Dépannage et bonnes pratiques

Problèmes courants et solutions

  1. Erreurs de permissions : Toujours exécuter les scripts en tant que root avec sudo
  2. Utilisateurs connectés : Vérifier les sessions actives avant suppression
  3. Services d'annuaire : Vérifier l'identification des comptes mobiles avec l'attribut LocalCachedUser
  4. Protection des répertoires home : Créer des sauvegardes avant de supprimer les répertoires home
  5. Comptes réseau : S'assurer de la connectivité réseau pour les opérations de services d'annuaire

Bonnes pratiques

  • Tester d'abord : Toujours tester les scripts dans des environnements contrôlés
  • Créer des sauvegardes : Maintenir des sauvegardes des données utilisateur avant suppression
  • Journaliser les opérations : Garder des logs détaillés de toutes les opérations de comptes
  • Communication utilisateur : Notifier les utilisateurs avant le nettoyage des comptes
  • Planifier la maintenance : Effectuer le nettoyage pendant les fenêtres de maintenance

Conclusion

La gestion des comptes mobiles est cruciale pour maintenir des environnements macOS propres et sécurisés. Ces scripts fournissent des solutions complètes pour supprimer les comptes mobiles, du nettoyage simple à l'automatisation de niveau entreprise. Assurez-vous toujours de procédures de test et de sauvegarde appropriées avant l'implémentation en environnement de production.

Related Tutorials

Gestion Entreprise de la Suppression de Fichiers et Dossiers pour macOS

Gérez la suppression de fichiers et dossiers macOS sur les appareils Roundfleet avec la suppression sécurisée de données, les pistes d'audit, la protection par sauvegarde, la gestion de conformité et les opérations de nettoyage automatisées pour la gouvernance des données d'entreprise.

7 juil. 2025

Gestion Entreprise de Création de Fichiers et Dossiers sur macOS

Guide complet pour les opérations de création de fichiers et dossiers en entreprise sur les appareils Roundfleet avec gestion de modèles, contrôle des permissions et capacités de provisionnement automatisé.

7 juil. 2025

Gestion des Privilèges Utilisateur et Conformité Sécurité sur macOS

Gestion complète des privilèges utilisateur, contrôle d'accès administrateur, surveillance de conformité sécuritaire et détection automatisée d'escalade de privilèges pour les appareils macOS en environnements d'entreprise.

7 juil. 2025

Gestion Entreprise des Détails Utilisateur sur macOS

Guide complet pour la récupération et gestion d'informations utilisateur en entreprise sur les appareils Roundfleet avec profilage utilisateur détaillé, capacités d'audit et contrôles de sécurité.

7 juil. 2025

Gestion Entreprise de Création Utilisateur sur macOS

Guide complet pour le provisioning utilisateur et gestion du cycle de vie en entreprise sur les appareils Roundfleet avec workflows automatisés, contrôles de sécurité et processus standardisés de création utilisateur.

7 juil. 2025

Gestion des Comptes Utilisateurs sur macOS

Apprenez à créer, gérer et configurer les comptes utilisateurs sur les appareils macOS en utilisant les outils en ligne de commande. Guide complet pour la création d'utilisateurs administrateurs et standards, politiques de mots de passe et gestion d'utilisateurs en entreprise.

7 juil. 2025

Analyse de Taille de Fichiers et Gestion de Stockage sur macOS

Apprenez à analyser les tailles de fichiers et dossiers, surveiller l'utilisation du disque, identifier les gros consommateurs de stockage et implémenter une gestion complète du stockage sur les appareils macOS avec des outils en ligne de commande pour une optimisation efficace du stockage.

7 juil. 2025

Protection de Fichiers d'Entreprise sur macOS

Implémentez une protection complète des fichiers et applications sur les appareils macOS en utilisant les drapeaux immuables, les contrôles d'accès et les politiques de sécurité d'entreprise pour la protection des données organisationnelles.

7 juil. 2025
View all tutorials →