Gestion Entreprise de Création Utilisateur sur macOS
Créez et provisionnez efficacement les comptes utilisateur dans votre déploiement MacFleet avec une gestion du cycle de vie utilisateur de niveau entreprise, des workflows automatisés et des contrôles de sécurité complets. Ce tutoriel transforme les commandes dscl et sysadminctl de base en solutions robustes de provisioning utilisateur.
Comprendre la Gestion de Création Utilisateur en Entreprise
La création utilisateur en entreprise nécessite plus qu'un simple provisioning de comptes, exigeant :
- Workflows de provisioning automatisés avec configuration basée sur des modèles
- Création de comptes axée sécurité avec attribution appropriée des privilèges
- Intégration standardisée d'utilisateurs avec structures d'annuaire cohérentes
- Capacités d'intégration avec les systèmes d'identité d'entreprise
- Journalisation d'audit pour la surveillance de conformité et sécurité
- Opérations utilisateur en masse pour une gestion de flotte efficace
Opérations de Création Utilisateur de Base
Commandes de Création Utilisateur Basiques
# Création utilisateur basée sur dscl
sudo dscl . -create /Users/Username
sudo dscl . -create /Users/Username RealName "John Doe"
sudo dscl . -passwd /Users/Username password_here
sudo dscl . -create /Users/Username UniqueID 1088
sudo dscl . -create /Users/Username PrimaryGroupID 20
sudo dscl . -create /Users/Username UserShell /bin/bash
sudo dscl . -create /Users/Username NFSHomeDirectory /Users/Username
# Création utilisateur basée sur sysadminctl
sysadminctl -addUser <username> -password <password>Celles-ci utilisent l'utilitaire en ligne de commande du service d'annuaire (dscl) et le contrôle administrateur système (sysadminctl) pour la gestion des comptes utilisateur.
Système de Gestion de Création Utilisateur Entreprise
#!/bin/bash
# Système de Gestion de Création Utilisateur Entreprise MacFleet
# Provisioning utilisateur complet avec contrôles entreprise et automatisation
# Configuration
SCRIPT_NAME="Gestionnaire de Création Utilisateur MacFleet"
VERSION="1.0.0"
LOG_FILE="/var/log/macfleet_user_creation.log"
AUDIT_LOG="/var/log/macfleet_user_audit.log"
TEMPLATES_DIR="/etc/macfleet/user_templates"
PROVISIONING_DIR="/var/lib/macfleet/provisioning"
TEMP_DIR="/tmp/macfleet_users"
MIN_UID=1000
MAX_UID=65000
DEFAULT_SHELL="/bin/zsh"
HOME_BASE_DIR="/Users"
COMPANY_DOMAIN="company.local"
REQUIRE_SECURE_PASSWORDS=true
ENFORCE_NAMING_CONVENTION=true
AUTO_FILEVAULT_ENABLE=true
STANDARD_GROUPS=("staff" "_appserverusr" "_appserveradm")
ADMIN_GROUPS=("admin" "staff" "_developer")
DEVELOPER_GROUPS=("staff" "_developer" "_appserverusr")
# Créer les répertoires nécessaires
mkdir -p "$TEMPLATES_DIR"
mkdir -p "$PROVISIONING_DIR"
mkdir -p "$TEMP_DIR"
mkdir -p "$(dirname "$LOG_FILE")"
mkdir -p "$(dirname "$AUDIT_LOG")"
# Définir les permissions sécurisées
chmod 700 "$TEMP_DIR"
chmod 750 "$PROVISIONING_DIR"
chmod 755 "$TEMPLATES_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_audit_action() {
local action_type="$1"
local target_user="$2"
local performed_by="$3"
local details="$4"
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
local source_ip=$(who am i | awk '{print $5}' | tr -d '()')
echo "ACTION|$timestamp|$action_type|$target_user|$performed_by|$source_ip|$details" >> "$AUDIT_LOG"
}
# Générer un mot de passe sécurisé aléatoire
generate_secure_password() {
local length="${1:-12}"
local complexity="${2:-high}"
case "$complexity" in
"high")
# Haute complexité : majuscules, minuscules, chiffres, symboles
openssl rand -base64 32 | tr -d "=+/" | cut -c1-${length}
;;
"medium")
# Complexité moyenne : majuscules, minuscules, chiffres
LC_ALL=C tr -dc 'A-Za-z0-9' </dev/urandom | head -c ${length}
;;
"basic")
# Complexité basique : minuscules et chiffres
LC_ALL=C tr -dc 'a-z0-9' </dev/urandom | head -c ${length}
;;
*)
echo "Erreur : Niveau de complexité inconnu"
return 1
;;
esac
}
# Valider la politique de mot de passe
validate_password() {
local password="$1"
local min_length=8
local errors=()
# Vérifier la longueur minimale
if [[ ${#password} -lt $min_length ]]; then
errors+=("Le mot de passe doit contenir au moins $min_length caractères")
fi
# Vérifier la lettre majuscule
if [[ ! "$password" =~ [A-Z] ]]; then
errors+=("Le mot de passe doit contenir au moins une lettre majuscule")
fi
# Vérifier la lettre minuscule
if [[ ! "$password" =~ [a-z] ]]; then
errors+=("Le mot de passe doit contenir au moins une lettre minuscule")
fi
# Vérifier le chiffre
if [[ ! "$password" =~ [0-9] ]]; then
errors+=("Le mot de passe doit contenir au moins un chiffre")
fi
# Vérifier le caractère spécial
if [[ ! "$password" =~ [^A-Za-z0-9] ]]; then
errors+=("Le mot de passe doit contenir au moins un caractère spécial")
fi
if [[ ${#errors[@]} -gt 0 ]]; then
echo "Validation du mot de passe échouée :"
printf ' - %s\n' "${errors[@]}"
return 1
fi
return 0
}
# Valider le nom d'utilisateur selon la convention de nommage entreprise
validate_username() {
local username="$1"
local errors=()
# Vérifier la longueur (3-20 caractères)
if [[ ${#username} -lt 3 || ${#username} -gt 20 ]]; then
errors+=("Le nom d'utilisateur doit contenir 3-20 caractères")
fi
# Vérifier les caractères valides (alphanumériques, points, tirets, underscores)
if [[ ! "$username" =~ ^[a-zA-Z0-9._-]+$ ]]; then
errors+=("Le nom d'utilisateur ne peut contenir que des lettres, chiffres, points, tirets et underscores")
fi
# Vérifier qu'il commence par une lettre
if [[ ! "$username" =~ ^[a-zA-Z] ]]; then
errors+=("Le nom d'utilisateur doit commencer par une lettre")
fi
# Vérifier les noms réservés
local reserved_names=("admin" "root" "daemon" "nobody" "wheel" "operator" "system")
for reserved in "${reserved_names[@]}"; do
if [[ "$username" == "$reserved" ]]; then
errors+=("Le nom d'utilisateur '$username' est réservé")
fi
done
# Vérifier si le nom d'utilisateur existe déjà
if dscl . -read "/Users/$username" &>/dev/null; then
errors+=("Le nom d'utilisateur '$username' existe déjà")
fi
if [[ ${#errors[@]} -gt 0 ]]; then
echo "Validation du nom d'utilisateur échouée :"
printf ' - %s\n' "${errors[@]}"
return 1
fi
return 0
}
# Trouver le prochain UID disponible
find_next_uid() {
local start_uid="${1:-$MIN_UID}"
local max_uid="${2:-$MAX_UID}"
# Obtenir tous les UIDs existants
local existing_uids=($(dscl . list /Users UniqueID | awk '{print $2}' | sort -n))
# Trouver le premier UID disponible
for ((uid=start_uid; uid<=max_uid; uid++)); do
local uid_exists=false
for existing_uid in "${existing_uids[@]}"; do
if [[ $uid -eq $existing_uid ]]; then
uid_exists=true
break
fi
done
if [[ "$uid_exists" == "false" ]]; then
echo "$uid"
return 0
fi
done
echo "Erreur : Aucun UID disponible trouvé dans la plage $start_uid-$max_uid"
return 1
}
# Créer un compte utilisateur avec paramètres entreprise
create_enterprise_user() {
local username="$1"
local real_name="$2"
local password="$3"
local user_type="${4:-standard}"
local department="${5:-General}"
local admin_user=$(whoami)
log_audit_action "USER_CREATION_START" "$username" "$admin_user" "type=$user_type,department=$department"
# Valider les entrées
if ! validate_username "$username"; then
log_operation "ERROR" "Validation du nom d'utilisateur échouée pour : $username"
return 1
fi
if [[ "$REQUIRE_SECURE_PASSWORDS" == "true" ]] && ! validate_password "$password"; then
log_operation "ERROR" "Validation du mot de passe échouée pour l'utilisateur : $username"
return 1
fi
# Trouver l'UID disponible
local uid
uid=$(find_next_uid)
if [[ $? -ne 0 ]]; then
log_operation "ERROR" "Échec de trouver un UID disponible pour : $username"
return 1
fi
echo "=== Création Utilisateur Entreprise : $username ==="
echo "Nom Réel : $real_name"
echo "Type Utilisateur : $user_type"
echo "Département : $department"
echo "UID Assigné : $uid"
echo "Administrateur : $admin_user"
echo ""
# Créer le compte utilisateur avec dscl
echo "Création du compte utilisateur..."
# Création utilisateur de base
if ! sudo dscl . -create "/Users/$username"; then
log_operation "ERROR" "Échec de créer l'utilisateur : $username"
return 1
fi
# Définir le nom réel
sudo dscl . -create "/Users/$username" RealName "$real_name"
# Définir le mot de passe
sudo dscl . -passwd "/Users/$username" "$password"
# Définir l'UID
sudo dscl . -create "/Users/$username" UniqueID "$uid"
# Déterminer l'ID du groupe principal selon le type d'utilisateur
local primary_gid
case "$user_type" in
"admin")
primary_gid=80 # groupe admin
;;
"developer")
primary_gid=20 # groupe staff
;;
"standard"|*)
primary_gid=20 # groupe staff
;;
esac
sudo dscl . -create "/Users/$username" PrimaryGroupID "$primary_gid"
# Définir le shell
sudo dscl . -create "/Users/$username" UserShell "$DEFAULT_SHELL"
# Créer le répertoire home
local home_dir="$HOME_BASE_DIR/$username"
sudo dscl . -create "/Users/$username" NFSHomeDirectory "$home_dir"
# Ajouter les attributs entreprise
sudo dscl . -create "/Users/$username" Department "$department"
sudo dscl . -create "/Users/$username" Company "$(hostname -s | cut -d. -f1)"
sudo dscl . -create "/Users/$username" CreationDate "$(date)"
sudo dscl . -create "/Users/$username" CreatedBy "$admin_user"
# Ajouter l'indice de mot de passe
sudo dscl . -create "/Users/$username" hint "Contactez le support IT pour l'assistance mot de passe"
# Configurer les appartenances aux groupes selon le type d'utilisateur
echo "Configuration des appartenances aux groupes..."
case "$user_type" in
"admin")
for group in "${ADMIN_GROUPS[@]}"; do
sudo dseditgroup -o edit -a "$username" -t user "$group" 2>/dev/null
done
;;
"developer")
for group in "${DEVELOPER_GROUPS[@]}"; do
sudo dseditgroup -o edit -a "$username" -t user "$group" 2>/dev/null
done
;;
"standard"|*)
for group in "${STANDARD_GROUPS[@]}"; do
sudo dseditgroup -o edit -a "$username" -t user "$group" 2>/dev/null
done
;;
esac
# Créer et configurer le répertoire home
echo "Configuration du répertoire home..."
if [[ ! -d "$home_dir" ]]; then
sudo mkdir -p "$home_dir"
sudo chown "$username:staff" "$home_dir"
sudo chmod 755 "$home_dir"
fi
# Copier le modèle utilisateur si disponible
local template_dir="$TEMPLATES_DIR/$user_type"
if [[ -d "$template_dir" ]]; then
echo "Application du modèle utilisateur : $user_type"
sudo cp -R "$template_dir/"* "$home_dir/" 2>/dev/null
sudo chown -R "$username:staff" "$home_dir"
fi
# Activer FileVault pour le nouvel utilisateur si requis
if [[ "$AUTO_FILEVAULT_ENABLE" == "true" ]]; then
echo "Activation de l'accès FileVault pour l'utilisateur..."
sudo fdesetup add -usertoadd "$username" 2>/dev/null || true
fi
# Générer le rapport de profil utilisateur
local profile_file="$PROVISIONING_DIR/${username}_profile.txt"
{
echo "Profil Utilisateur MacFleet"
echo "=========================="
echo "Nom d'utilisateur : $username"
echo "Nom Réel : $real_name"
echo "UID : $uid"
echo "GID : $primary_gid"
echo "Type Utilisateur : $user_type"
echo "Département : $department"
echo "Répertoire Home : $home_dir"
echo "Shell : $DEFAULT_SHELL"
echo "Créé : $(date)"
echo "Créé Par : $admin_user"
echo "Groupes : $(groups "$username" 2>/dev/null | cut -d: -f2)"
echo ""
echo "Paramètres de Sécurité :"
echo "- FileVault Activé : $AUTO_FILEVAULT_ENABLE"
echo "- Mot de Passe Sécurisé : $REQUIRE_SECURE_PASSWORDS"
echo "- Convention de Nommage : $ENFORCE_NAMING_CONVENTION"
} > "$profile_file"
echo "✅ Création utilisateur terminée avec succès"
echo "Profil sauvegardé : $profile_file"
log_operation "INFO" "Utilisateur créé avec succès : $username (UID : $uid, Type : $user_type)"
log_audit_action "USER_CREATION_SUCCESS" "$username" "$admin_user" "uid=$uid,type=$user_type,groups=$(groups "$username" 2>/dev/null | cut -d: -f2)"
return 0
}
# Création utilisateur en masse depuis fichier CSV
bulk_create_users() {
local csv_file="$1"
local admin_user=$(whoami)
if [[ ! -f "$csv_file" ]]; then
echo "Erreur : Fichier CSV non trouvé : $csv_file"
return 1
fi
log_audit_action "BULK_CREATION_START" "multiple" "$admin_user" "source=$csv_file"
echo "=== Création Utilisateur en Masse ==="
echo "Fichier CSV : $csv_file"
echo "Administrateur : $admin_user"
echo ""
local line_count=0
local success_count=0
local error_count=0
local results_file="$PROVISIONING_DIR/bulk_creation_$(date +%Y%m%d_%H%M%S).log"
# Lire le fichier CSV (format : nom_utilisateur,nom_reel,type_utilisateur,departement)
while IFS=',' read -r username real_name user_type department; do
line_count=$((line_count + 1))
# Ignorer la ligne d'en-tête
if [[ $line_count -eq 1 && "$username" == "username" ]]; then
continue
fi
# Ignorer les lignes vides
if [[ -z "$username" ]]; then
continue
fi
# Générer un mot de passe sécurisé
local password
password=$(generate_secure_password 12 "high")
echo "Traitement utilisateur $line_count : $username"
# Créer l'utilisateur
if create_enterprise_user "$username" "$real_name" "$password" "$user_type" "$department"; then
success_count=$((success_count + 1))
echo "SUCCÈS : $username,$real_name,$password,$user_type,$department" >> "$results_file"
else
error_count=$((error_count + 1))
echo "ERREUR : $username,$real_name,ÉCHEC,$user_type,$department" >> "$results_file"
fi
echo ""
done < "$csv_file"
echo "=== Résumé Création en Masse ==="
echo "Total Traité : $line_count"
echo "Réussis : $success_count"
echo "Erreurs : $error_count"
echo "Fichier Résultats : $results_file"
log_operation "INFO" "Création utilisateur en masse terminée : $success_count réussies, $error_count erreurs"
log_audit_action "BULK_CREATION_COMPLETE" "multiple" "$admin_user" "total=$line_count,success=$success_count,errors=$error_count"
}
# Créer des modèles utilisateur
create_user_template() {
local template_type="$1"
local template_dir="$TEMPLATES_DIR/$template_type"
echo "Création du modèle utilisateur : $template_type"
mkdir -p "$template_dir"
case "$template_type" in
"standard")
# Modèle utilisateur standard
mkdir -p "$template_dir/Desktop"
mkdir -p "$template_dir/Documents"
mkdir -p "$template_dir/Downloads"
# Créer le document de bienvenue
cat > "$template_dir/Desktop/Welcome.txt" << EOF
Bienvenue sur MacFleet !
Votre compte a été configuré avec des privilèges utilisateur standard.
Pour le support, veuillez contacter IT à support@company.com
Type de Compte : Utilisateur Standard
Date de Création : $(date)
EOF
;;
"admin")
# Modèle utilisateur admin
mkdir -p "$template_dir/Desktop"
mkdir -p "$template_dir/Documents/OutilsAdmin"
mkdir -p "$template_dir/Downloads"
cat > "$template_dir/Desktop/Admin_Welcome.txt" << EOF
Bienvenue sur MacFleet - Compte Administrateur
Votre compte a été configuré avec des privilèges administratifs.
Veuillez utiliser ces privilèges de manière responsable.
Type de Compte : Administrateur
Date de Création : $(date)
Important :
- Suivez les politiques de sécurité de l'entreprise
- Changements de mot de passe réguliers requis
- Toutes les actions administratives sont enregistrées
EOF
;;
"developer")
# Modèle utilisateur développeur
mkdir -p "$template_dir/Desktop"
mkdir -p "$template_dir/Documents/Projets"
mkdir -p "$template_dir/Downloads"
mkdir -p "$template_dir/Development"
cat > "$template_dir/Desktop/Developer_Setup.txt" << EOF
Configuration Compte Développeur
Votre compte inclut l'accès aux outils de développement.
Type de Compte : Développeur
Date de Création : $(date)
Étapes Suivantes :
1. Installer Xcode depuis l'App Store
2. Configurer les identifiants Git
3. Configurer l'environnement de développement
4. Consulter la documentation des standards de codage
EOF
;;
esac
# Définir les permissions du modèle
chmod -R 755 "$template_dir"
echo "Modèle créé : $template_dir"
log_operation "INFO" "Modèle utilisateur créé : $template_type"
}
# Générer un rapport de provisioning
generate_provisioning_report() {
local report_type="${1:-resume}"
local admin_user=$(whoami)
local report_file="$PROVISIONING_DIR/provisioning_report_$(date +%Y%m%d_%H%M%S).txt"
log_audit_action "PROVISIONING_REPORT" "system" "$admin_user" "type=$report_type"
{
echo "Rapport de Provisioning Utilisateur MacFleet"
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
"resume")
echo "== Résumé de Provisioning =="
local total_users=$(dscl . list /Users | grep -v '^_' | wc -l)
local recent_users=$(find "$PROVISIONING_DIR" -name "*_profile.txt" -mtime -7 | wc -l)
echo "Total Utilisateurs : $total_users"
echo "Utilisateurs Créés (7 derniers jours) : $recent_users"
echo ""
echo "Distribution Type Utilisateur :"
echo "Utilisateurs Standard : $(dscl . list /Users | xargs -I {} dscl . read /Users/{} PrimaryGroupID 2>/dev/null | grep -c '20')"
echo "Utilisateurs Admin : $(dscl . list /Users | xargs -I {} dscl . read /Users/{} PrimaryGroupID 2>/dev/null | grep -c '80')"
;;
"recent")
echo "== Créations Utilisateur Récentes =="
echo "Utilisateurs créés dans les 30 derniers jours :"
find "$PROVISIONING_DIR" -name "*_profile.txt" -mtime -30 -exec basename {} \; | sed 's/_profile.txt//'
;;
"audit")
echo "== Information d'Audit =="
if [[ -f "$AUDIT_LOG" ]]; then
echo "Activités de provisioning récentes :"
grep "USER_CREATION" "$AUDIT_LOG" | tail -10
else
echo "Aucun log d'audit disponible"
fi
;;
esac
echo ""
echo "== Configuration =="
echo "UID Min : $MIN_UID"
echo "UID Max : $MAX_UID"
echo "Shell Par Défaut : $DEFAULT_SHELL"
echo "FileVault Auto : $AUTO_FILEVAULT_ENABLE"
echo "Mots de Passe Sécurisés : $REQUIRE_SECURE_PASSWORDS"
echo "Convention Nommage : $ENFORCE_NAMING_CONVENTION"
} > "$report_file"
echo "Rapport de provisioning généré : $report_file"
log_operation "INFO" "Rapport de provisioning généré : $report_file"
}
# Fonction principale de gestion de création utilisateur
main() {
local action="${1:-help}"
case "$action" in
"create")
local username="$2"
local real_name="$3"
local password="$4"
local user_type="${5:-standard}"
local department="${6:-General}"
if [[ -z "$username" || -z "$real_name" ]]; then
echo "Usage : $0 create <nom_utilisateur> <nom_reel> [mot_de_passe] [type_utilisateur] [departement]"
echo "Types utilisateur : standard, admin, developer"
exit 1
fi
# Générer un mot de passe si non fourni
if [[ -z "$password" ]]; then
password=$(generate_secure_password 12 "high")
echo "Mot de passe sécurisé généré : $password"
fi
create_enterprise_user "$username" "$real_name" "$password" "$user_type" "$department"
;;
"bulk")
local csv_file="$2"
if [[ -z "$csv_file" ]]; then
echo "Usage : $0 bulk <fichier_csv>"
echo "Format CSV : nom_utilisateur,nom_reel,type_utilisateur,departement"
exit 1
fi
bulk_create_users "$csv_file"
;;
"template")
local template_type="$2"
if [[ -z "$template_type" ]]; then
echo "Usage : $0 template <type_modele>"
echo "Types de modèle : standard, admin, developer"
exit 1
fi
create_user_template "$template_type"
;;
"report")
local report_type="${2:-resume}"
generate_provisioning_report "$report_type"
;;
"password")
local length="${2:-12}"
local complexity="${3:-high}"
echo "Mot de passe généré : $(generate_secure_password "$length" "$complexity")"
;;
"help"|*)
echo "$SCRIPT_NAME v$VERSION"
echo "Gestion Entreprise de Création Utilisateur"
echo ""
echo "Usage : $0 <action> [options]"
echo ""
echo "Actions :"
echo " create <nom_utilisateur> <nom_reel> [mot_de_passe] [type] [dept] - Créer un utilisateur unique"
echo " bulk <fichier_csv> - Créer des utilisateurs depuis CSV"
echo " template <type> - Créer un modèle utilisateur"
echo " report [type] - Générer des rapports de provisioning"
echo " password [longueur] [complexite] - Générer un mot de passe sécurisé"
echo " help - Afficher ce message d'aide"
echo ""
echo "Types Utilisateur :"
echo " standard - Utilisateur standard avec privilèges de base"
echo " admin - Utilisateur administratif avec privilèges élevés"
echo " developer - Utilisateur développeur avec accès aux outils de développement"
echo ""
echo "Types de Rapport :"
echo " resume - Aperçu du provisioning utilisateur (défaut)"
echo " recent - Utilisateurs récemment créés"
echo " audit - Information de piste d'audit"
echo ""
echo "Complexité Mot de Passe :"
echo " basic - Minuscules et chiffres uniquement"
echo " medium - Lettres et chiffres"
echo " high - Lettres, chiffres et symboles (défaut)"
echo ""
echo "Fonctionnalités :"
echo " • Provisioning utilisateur automatisé avec modèles entreprise"
echo " • Création de comptes axée sécurité avec validation"
echo " • Création utilisateur en masse depuis fichiers CSV"
echo " • Journalisation d'audit complète et conformité"
echo " • Intégration avec FileVault et sécurité entreprise"
echo " • Intégration utilisateur basée sur modèles"
echo " • Génération et validation automatisées de mots de passe"
;;
esac
}
# Exécuter la fonction principale avec tous les arguments
main "$@"Commandes de Référence Rapide
Création Utilisateur Unique
# Créer un utilisateur standard
./user_creator.sh create jean.dupont "Jean Dupont"
# Créer un utilisateur admin avec mot de passe personnalisé
./user_creator.sh create admin.utilisateur "Utilisateur Admin" "MotDePasseSecurise123!" admin IT
# Créer un utilisateur développeur
./user_creator.sh create dev.utilisateur "Utilisateur Développeur" "" developer Ingenierie
# Créer un utilisateur avec tous les paramètres
./user_creator.sh create jane.smith "Jane Smith" "MotDePassePerso456!" standard MarketingOpérations Utilisateur en Masse
# Créer des utilisateurs depuis un fichier CSV
./user_creator.sh bulk utilisateurs.csv
# Exemple de format CSV :
# nom_utilisateur,nom_reel,type_utilisateur,departement
# jean.dupont,Jean Dupont,standard,Ventes
# jane.admin,Jane Admin,admin,IT
# dev.utilisateur,Utilisateur Dev,developer,IngenierieGestion de Modèles
# Créer un modèle utilisateur standard
./user_creator.sh template standard
# Créer un modèle utilisateur admin
./user_creator.sh template admin
# Créer un modèle utilisateur développeur
./user_creator.sh template developerGénération de Mot de Passe
# Générer un mot de passe haute complexité (défaut)
./user_creator.sh password
# Générer un mot de passe de 16 caractères
./user_creator.sh password 16
# Générer un mot de passe complexité moyenne
./user_creator.sh password 12 medium
# Générer un mot de passe basique
./user_creator.sh password 10 basicOpérations de Rapport
# Générer un rapport résumé
./user_creator.sh report
# Générer un rapport utilisateurs récents
./user_creator.sh report recent
# Générer un rapport d'audit
./user_creator.sh report auditExemples d'Intégration
Intégration JAMF Pro
#!/bin/bash
# Script JAMF Pro pour création utilisateur entreprise
# Paramètres : $4 = nom_utilisateur, $5 = nom_reel, $6 = type_utilisateur, $7 = departement
NOM_UTILISATEUR="$4"
NOM_REEL="$5"
TYPE_UTILISATEUR="$6"
DEPARTEMENT="$7"
# Télécharger le créateur utilisateur s'il n'est pas présent
if [[ ! -f "/usr/local/bin/macfleet_user_creator.sh" ]]; then
curl -o "/usr/local/bin/macfleet_user_creator.sh" \
"https://scripts.macfleet.com/user_creator.sh"
chmod +x "/usr/local/bin/macfleet_user_creator.sh"
fi
# Créer l'utilisateur avec paramètres entreprise
/usr/local/bin/macfleet_user_creator.sh create \
"$NOM_UTILISATEUR" "$NOM_REEL" "" "$TYPE_UTILISATEUR" "$DEPARTEMENT"
# Rapporter le statut à JAMF
if [[ $? -eq 0 ]]; then
echo "Utilisateur $NOM_UTILISATEUR créé avec succès"
exit 0
else
echo "Échec de création de l'utilisateur $NOM_UTILISATEUR"
exit 1
fiFonctionnalités de Sécurité et Conformité
Application de Politique de Mot de Passe
# Validation avancée de politique de mot de passe
enforce_enterprise_password_policy() {
local password="$1"
local username="$2"
# Vérifier contre les mots de passe communs
local common_passwords=("password" "123456" "admin" "welcome")
for common in "${common_passwords[@]}"; do
if [[ "${password,,}" == "${common,,}" ]]; then
echo "Erreur : Mot de passe trop commun"
return 1
fi
done
# Vérifier le nom d'utilisateur dans le mot de passe
if [[ "${password,,}" =~ ${username,,} ]]; then
echo "Erreur : Le mot de passe ne peut pas contenir le nom d'utilisateur"
return 1
fi
# Vérifier l'historique des mots de passe (si implémenté)
check_password_history "$username" "$password"
}Rapport d'Audit et Conformité
# Générer un rapport de conformité pour la création utilisateur
generate_compliance_report() {
local start_date="$1"
local end_date="$2"
local report_file="/var/reports/user_creation_compliance_$(date +%Y%m%d).json"
{
echo "{"
echo " \"report_type\": \"user_creation_compliance\","
echo " \"period\": \"$start_date à $end_date\","
echo " \"generated\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","
echo " \"total_users_created\": $(grep "USER_CREATION_SUCCESS" "$AUDIT_LOG" | wc -l),"
echo " \"policy_violations\": $(grep "POLICY_VIOLATION" "$AUDIT_LOG" | wc -l),"
echo " \"security_reviews\": $(grep "SECURITY_REVIEW" "$AUDIT_LOG" | wc -l)"
echo "}"
} > "$report_file"
echo "Rapport de conformité généré : $report_file"
}Meilleures Pratiques
- Utiliser des politiques de mots de passe forts avec exigences de complexité
- Implémenter des types d'utilisateur basés sur les rôles pour attribution appropriée des privilèges
- Activer la journalisation d'audit complète pour toutes les activités de création utilisateur
- Utiliser des modèles pour des expériences d'intégration utilisateur cohérentes
- Intégrer avec les services d'annuaire d'entreprise pour une gestion centralisée
- Automatiser l'inscription FileVault pour la conformité de sécurité
- Générer des rapports de conformité réguliers à des fins d'audit
- Valider les noms d'utilisateur selon les conventions de nommage d'entreprise
Ce système de gestion de création utilisateur entreprise fournit des capacités de provisioning utilisateur complètes avec contrôles de sécurité, conformité d'audit et workflows automatisés pour une gestion efficace du cycle de vie utilisateur MacFleet.