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

Gestion d'Entreprise des Polices sur macOS

Gérez et déployez des polices sur vos appareils Roundfleet en utilisant des outils de ligne de commande avancés et des méthodes de distribution centralisées. Ce tutoriel couvre l'installation de polices, la standardisation typographique, la conformité des licences et la gestion de polices de niveau entreprise avec des capacités complètes de surveillance et de rapport.

Comprendre la Gestion des Polices macOS

macOS fournit plusieurs emplacements et méthodes pour la gestion des polices :

  • ~/Library/Fonts/ - Polices spécifiques à l'utilisateur (utilisateur actuel uniquement)
  • /Library/Fonts/ - Polices système (tous les utilisateurs)
  • /Library/User Template/Non_localized/Library/Fonts/ - Modèle pour nouveaux utilisateurs
  • Font Book - Application native macOS de gestion des polices
  • Formats de polices : TTF (TrueType), OTF (OpenType), WOFF, et formats hérités

La gestion d'entreprise des polices nécessite une attention particulière aux licences, à la standardisation et aux stratégies de déploiement.

Commandes d'Installation de Base des Polices

Installer une Police pour l'Utilisateur Actuel

#!/bin/bash

# Installer une police pour l'utilisateur actuel uniquement
install_user_font() {
    local font_path="$1"
    local font_name="$2"
    
    if [[ -z "$font_path" || -z "$font_name" ]]; then
        echo "Usage: install_user_font <chemin_source> <nom_police>"
        return 1
    fi
    
    # Copier la police vers le répertoire de polices de l'utilisateur
    cp -R "$font_path/$font_name" ~/Library/Fonts/
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Police '$font_name' installée pour l'utilisateur actuel"
        return 0
    else
        echo "❌ Échec de l'installation de la police '$font_name'"
        return 1
    fi
}

# Exemple d'utilisation
# install_user_font "/Users/user1/Downloads" "CROCHETPATTERN.ttf"

Installer une Police pour Tout le Système

#!/bin/bash

# Installer une police pour tous les utilisateurs (nécessite des privilèges admin)
install_system_font() {
    local font_path="$1"
    local font_name="$2"
    
    if [[ -z "$font_path" || -z "$font_name" ]]; then
        echo "Usage: install_system_font <chemin_source> <nom_police>"
        return 1
    fi
    
    # Vérifier les privilèges administrateur
    if [[ $EUID -ne 0 ]]; then
        echo "❌ Privilèges administrateur requis pour l'installation système"
        return 1
    fi
    
    # Copier la police vers le répertoire de polices système
    cp -R "$font_path/$font_name" /Library/Fonts/
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Police '$font_name' installée sur tout le système"
        
        # Vider le cache des polices pour assurer la disponibilité immédiate
        atsutil databases -remove
        atsutil server -shutdown
        atsutil server -ping
        
        return 0
    else
        echo "❌ Échec de l'installation système de la police '$font_name'"
        return 1
    fi
}

# Exemple d'utilisation (exécuter avec sudo)
# install_system_font "/Users/user1/Downloads" "CROCHETPATTERN.ttf"

Installer une Police pour le Modèle Nouvel Utilisateur

#!/bin/bash

# Installer une police dans le modèle utilisateur (affecte uniquement les nouveaux utilisateurs)
install_template_font() {
    local font_path="$1"
    local font_name="$2"
    
    if [[ -z "$font_path" || -z "$font_name" ]]; then
        echo "Usage: install_template_font <chemin_source> <nom_police>"
        return 1
    fi
    
    # Vérifier les privilèges administrateur
    if [[ $EUID -ne 0 ]]; then
        echo "❌ Privilèges administrateur requis pour modifier le modèle utilisateur"
        return 1
    fi
    
    # Créer le répertoire de polices du modèle s'il n'existe pas
    mkdir -p "/Library/User Template/Non_localized/Library/Fonts"
    
    # Copier la police vers le modèle utilisateur
    cp -R "$font_path/$font_name" "/Library/User Template/Non_localized/Library/Fonts/"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Police '$font_name' ajoutée au modèle utilisateur"
        return 0
    else
        echo "❌ Échec de l'ajout de la police '$font_name' au modèle utilisateur"
        return 1
    fi
}

# Exemple d'utilisation (exécuter avec sudo)
# install_template_font "/Users/user1/Downloads" "CROCHETPATTERN.ttf"

Gestion Avancée des Polices

Validation et Informations des Polices

#!/bin/bash

# Valider et extraire les informations des polices
validate_font() {
    local font_file="$1"
    
    if [[ ! -f "$font_file" ]]; then
        echo "❌ Fichier de police non trouvé : $font_file"
        return 1
    fi
    
    echo "=== Rapport de Validation de Police ==="
    echo "Fichier Police : $font_file"
    echo "Taille Fichier : $(ls -lh "$font_file" | awk '{print $5}')"
    echo "Type Fichier : $(file "$font_file")"
    echo ""
    
    # Vérifier s'il s'agit d'un fichier de police valide
    local file_type
    file_type=$(file -b "$font_file")
    
    if echo "$file_type" | grep -qi "font\|truetype\|opentype"; then
        echo "✅ Fichier de police valide détecté"
        
        # Extraire les informations de police en utilisant fc-query si disponible
        if command -v fc-query >/dev/null 2>&1; then
            echo ""
            echo "Détails de la Police :"
            fc-query "$font_file" | grep -E "(family|style|weight|slant)" | head -10
        fi
        
        # Vérifier les problèmes potentiels
        local file_size
        file_size=$(stat -f%z "$font_file" 2>/dev/null || stat -c%s "$font_file" 2>/dev/null)
        
        if [[ "$file_size" -gt 10485760 ]]; then  # 10MB
            echo "⚠️  Avertissement : Fichier de police volumineux (>10MB) - peut impacter les performances système"
        fi
        
        if [[ "$file_size" -lt 1024 ]]; then  # 1KB
            echo "⚠️  Avertissement : Fichier de police très petit (<1KB) - peut être corrompu"
        fi
        
        return 0
    else
        echo "❌ Format de fichier de police invalide"
        return 1
    fi
}

# Exemple d'utilisation
# validate_font "/Users/user1/Downloads/CROCHETPATTERN.ttf"

Découverte et Inventaire des Polices

#!/bin/bash

# Découvrir et inventorier les polices installées
discover_fonts() {
    echo "=== Rapport d'Inventaire des Polices ==="
    echo "Généré : $(date)"
    echo "Nom d'hôte : $(hostname)"
    echo "========================================="
    echo ""
    
    # Polices système
    echo "1. POLICES SYSTÈME (/Library/Fonts/) :"
    echo "--------------------------------------"
    if [[ -d "/Library/Fonts" ]]; then
        local sys_count
        sys_count=$(ls -1 /Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        echo "Total polices système : $sys_count"
        echo ""
        ls -la /Library/Fonts/ | head -10
        if [[ "$sys_count" -gt 10 ]]; then
            echo "... et $((sys_count - 10)) polices supplémentaires"
        fi
    else
        echo "Répertoire des polices système non trouvé"
    fi
    echo ""
    
    # Polices utilisateur (utilisateur actuel)
    echo "2. POLICES UTILISATEUR (~/Library/Fonts/) :"
    echo "-------------------------------------------"
    if [[ -d "$HOME/Library/Fonts" ]]; then
        local user_count
        user_count=$(ls -1 ~/Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        echo "Total polices utilisateur : $user_count"
        echo ""
        if [[ "$user_count" -gt 0 ]]; then
            ls -la ~/Library/Fonts/ | head -10
            if [[ "$user_count" -gt 10 ]]; then
                echo "... et $((user_count - 10)) polices supplémentaires"
            fi
        else
            echo "Aucune police spécifique à l'utilisateur installée"
        fi
    else
        echo "Répertoire des polices utilisateur non trouvé"
    fi
    echo ""
    
    # Analyse des formats de polices
    echo "3. ANALYSE DES FORMATS DE POLICES :"
    echo "-----------------------------------"
    local ttf_count otf_count other_count
    ttf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.ttf" 2>/dev/null | wc -l | tr -d ' ')
    otf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.otf" 2>/dev/null | wc -l | tr -d ' ')
    other_count=$(find /Library/Fonts ~/Library/Fonts -type f ! -name "*.ttf" ! -name "*.otf" 2>/dev/null | wc -l | tr -d ' ')
    
    echo "Polices TrueType (.ttf) : $ttf_count"
    echo "Polices OpenType (.otf) : $otf_count"
    echo "Autres formats : $other_count"
}

# Exécuter la découverte des polices
discover_fonts

Système de Gestion d'Entreprise des Polices

#!/bin/bash

# Système de Gestion d'Entreprise des Polices Roundfleet
# Déploiement, gestion et surveillance de conformité complets des polices

# Configuration
LOG_FILE="/var/log/roundfleet_font_management.log"
FONT_REPO_DIR="/var/lib/roundfleet/fonts"
CONFIG_FILE="/etc/roundfleet/font_config.conf"
BACKUP_DIR="/var/backups/roundfleet/fonts"
STAGING_DIR="/tmp/roundfleet_fonts"

# Créer la structure de répertoires
setup_directories() {
    mkdir -p "$(dirname "$LOG_FILE")" "$FONT_REPO_DIR" "$BACKUP_DIR" "$STAGING_DIR" "$(dirname "$CONFIG_FILE")"
    touch "$LOG_FILE"
    
    # Définir les permissions appropriées
    chmod 755 "$FONT_REPO_DIR" "$BACKUP_DIR" "$STAGING_DIR"
}

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

# Télécharger et valider une police depuis une URL
download_font() {
    local font_url="$1"
    local font_name="$2"
    local license_info="$3"
    
    if [[ -z "$font_url" || -z "$font_name" ]]; then
        log_action "ERREUR : URL et nom de police requis"
        return 1
    fi
    
    log_action "Téléchargement de la police : $font_name depuis $font_url"
    
    # Télécharger vers le répertoire de préparation
    local download_path="$STAGING_DIR/$font_name"
    
    if command -v curl >/dev/null 2>&1; then
        curl -L -o "$download_path" "$font_url"
    elif command -v wget >/dev/null 2>&1; then
        wget -O "$download_path" "$font_url"
    else
        log_action "ERREUR : Aucun outil de téléchargement disponible (curl ou wget requis)"
        return 1
    fi
    
    if [[ ! -f "$download_path" ]]; then
        log_action "ERREUR : Échec du téléchargement pour $font_name"
        return 1
    fi
    
    # Valider la police téléchargée
    if validate_font "$download_path" >/dev/null; then
        # Déplacer vers le dépôt de polices
        mv "$download_path" "$FONT_REPO_DIR/"
        
        # Créer un fichier de métadonnées
        cat > "$FONT_REPO_DIR/${font_name}.meta" <<EOF
{
    "font_name": "$font_name",
    "download_url": "$font_url",
    "download_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "license_info": "$license_info",
    "file_size": $(stat -f%z "$FONT_REPO_DIR/$font_name" 2>/dev/null || stat -c%s "$FONT_REPO_DIR/$font_name"),
    "checksum": "$(md5 -q "$FONT_REPO_DIR/$font_name" 2>/dev/null || md5sum "$FONT_REPO_DIR/$font_name" | cut -d' ' -f1)"
}
EOF
        
        log_action "✅ Police téléchargée et validée : $font_name"
        return 0
    else
        log_action "❌ Échec de validation de la police : $font_name"
        rm -f "$download_path"
        return 1
    fi
}

# Déployer une police sur la flotte avec options
deploy_font() {
    local font_name="$1"
    local deployment_scope="${2:-system}"  # user, system, template
    local force_install="${3:-false}"
    
    if [[ ! -f "$FONT_REPO_DIR/$font_name" ]]; then
        log_action "ERREUR : Police non trouvée dans le dépôt : $font_name"
        return 1
    fi
    
    log_action "Déploiement de la police : $font_name (portée : $deployment_scope)"
    
    # Créer une sauvegarde des polices existantes
    backup_fonts
    
    case "$deployment_scope" in
        "user")
            # Installer pour l'utilisateur actuel
            mkdir -p ~/Library/Fonts
            cp -R "$FONT_REPO_DIR/$font_name" ~/Library/Fonts/
            local result=$?
            ;;
        "system")
            # Installer sur tout le système (nécessite admin)
            if [[ $EUID -ne 0 ]]; then
                log_action "ERREUR : Privilèges administrateur requis pour le déploiement système"
                return 1
            fi
            cp -R "$FONT_REPO_DIR/$font_name" /Library/Fonts/
            local result=$?
            ;;
        "template")
            # Installer dans le modèle utilisateur
            if [[ $EUID -ne 0 ]]; then
                log_action "ERREUR : Privilèges administrateur requis pour le déploiement modèle"
                return 1
            fi
            mkdir -p "/Library/User Template/Non_localized/Library/Fonts"
            cp -R "$FONT_REPO_DIR/$font_name" "/Library/User Template/Non_localized/Library/Fonts/"
            local result=$?
            ;;
        *)
            log_action "ERREUR : Portée de déploiement invalide : $deployment_scope"
            return 1
            ;;
    esac
    
    if [[ $result -eq 0 ]]; then
        # Vider le cache des polices
        refresh_font_cache
        
        # Vérifier l'installation
        verify_font_installation "$font_name" "$deployment_scope"
        
        log_action "✅ Police déployée avec succès : $font_name"
        return 0
    else
        log_action "❌ Échec du déploiement de la police : $font_name"
        return 1
    fi
}

# Actualiser le cache des polices
refresh_font_cache() {
    log_action "Actualisation du cache des polices système..."
    
    # Vider le cache des polices macOS
    atsutil databases -remove 2>/dev/null
    atsutil server -shutdown 2>/dev/null
    sleep 2
    atsutil server -ping 2>/dev/null
    
    # Vider le cache des polices utilisateur si fontconfig est disponible
    if command -v fc-cache >/dev/null 2>&1; then
        fc-cache -f -v 2>/dev/null
    fi
    
    log_action "Cache des polices actualisé"
}

# Vérifier l'installation de la police
verify_font_installation() {
    local font_name="$1"
    local scope="$2"
    
    local installed=false
    
    case "$scope" in
        "user")
            if [[ -f "$HOME/Library/Fonts/$font_name" ]]; then
                installed=true
            fi
            ;;
        "system")
            if [[ -f "/Library/Fonts/$font_name" ]]; then
                installed=true
            fi
            ;;
        "template")
            if [[ -f "/Library/User Template/Non_localized/Library/Fonts/$font_name" ]]; then
                installed=true
            fi
            ;;
    esac
    
    if [[ "$installed" == "true" ]]; then
        log_action "✅ Installation de police vérifiée : $font_name ($scope)"
        return 0
    else
        log_action "❌ Échec de vérification d'installation de police : $font_name ($scope)"
        return 1
    fi
}

# Sauvegarder les polices existantes
backup_fonts() {
    local backup_timestamp="$(date +%Y%m%d_%H%M%S)"
    local backup_path="$BACKUP_DIR/fonts_backup_$backup_timestamp"
    
    log_action "Création de sauvegarde des polices : $backup_path"
    
    mkdir -p "$backup_path"
    
    # Sauvegarder les polices système
    if [[ -d "/Library/Fonts" ]]; then
        cp -R /Library/Fonts "$backup_path/system_fonts" 2>/dev/null
    fi
    
    # Sauvegarder les polices utilisateur
    if [[ -d "$HOME/Library/Fonts" ]]; then
        cp -R "$HOME/Library/Fonts" "$backup_path/user_fonts" 2>/dev/null
    fi
    
    # Créer un manifeste de sauvegarde
    {
        echo "Manifeste de Sauvegarde des Polices"
        echo "==================================="
        echo "Date de Sauvegarde : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Utilisateur : $(whoami)"
        echo ""
        echo "Polices Système :"
        ls -la "$backup_path/system_fonts/" 2>/dev/null || echo "Aucune"
        echo ""
        echo "Polices Utilisateur :"
        ls -la "$backup_path/user_fonts/" 2>/dev/null || echo "Aucune"
    } > "$backup_path/manifest.txt"
    
    log_action "Sauvegarde des polices terminée : $backup_path"
}

# Audit de conformité et licences des polices
audit_font_compliance() {
    local audit_file="$BACKUP_DIR/font_compliance_audit_$(date +%Y%m%d_%H%M%S).txt"
    
    log_action "Exécution d'audit de conformité des polices : $audit_file"
    
    {
        echo "Audit de Conformité des Polices Roundfleet"
        echo "========================================"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Auditeur : $(whoami)"
        echo ""
        
        echo "INVENTAIRE DU DÉPÔT DE POLICES :"
        echo "--------------------------------"
        if [[ -d "$FONT_REPO_DIR" ]]; then
            ls -la "$FONT_REPO_DIR" | grep -v "\.meta$"
            echo ""
            
            echo "RÉVISION DES MÉTADONNÉES DES POLICES :"
            echo "--------------------------------------"
            for meta_file in "$FONT_REPO_DIR"/*.meta; do
                if [[ -f "$meta_file" ]]; then
                    echo "Police : $(basename "$meta_file" .meta)"
                    cat "$meta_file" | grep -E "(license_info|download_url)" || echo "Aucune information de licence disponible"
                    echo ""
                fi
            done
        else
            echo "Dépôt de polices non trouvé"
        fi
        
        echo "ANALYSE DES POLICES INSTALLÉES :"
        echo "-------------------------------"
        echo "Emplacement Polices Système : /Library/Fonts/"
        ls -la /Library/Fonts/ | wc -l | awk '{print "Total polices système : " $1-1}'
        echo ""
        
        echo "Emplacement Polices Utilisateur : ~/Library/Fonts/"
        ls -la ~/Library/Fonts/ 2>/dev/null | wc -l | awk '{print "Total polices utilisateur : " $1-1}' || echo "Aucun répertoire de polices utilisateur"
        echo ""
        
        echo "RECOMMANDATIONS DE CONFORMITÉ :"
        echo "-------------------------------"
        echo "• Vérifier que toutes les polices ont une documentation de licence appropriée"
        echo "• Supprimer toute police sans termes de licence clairs"
        echo "• Documenter l'utilisation des polices pour la conformité d'entreprise"
        echo "• Implémenter des audits réguliers des polices"
        echo "• Maintenir des journaux de déploiement des polices pour le suivi"
        
    } > "$audit_file"
    
    log_action "Audit de conformité des polices terminé : $audit_file"
    echo "$audit_file"
}

# Supprimer une police
remove_font() {
    local font_name="$1"
    local scope="${2:-all}"  # user, system, template, all
    
    log_action "Suppression de la police : $font_name (portée : $scope)"
    
    local removed=false
    
    case "$scope" in
        "user"|"all")
            if [[ -f "$HOME/Library/Fonts/$font_name" ]]; then
                rm -f "$HOME/Library/Fonts/$font_name"
                log_action "Police utilisateur supprimée : $font_name"
                removed=true
            fi
            ;;& # Continuer vers le cas suivant
        "system"|"all")
            if [[ -f "/Library/Fonts/$font_name" ]]; then
                if [[ $EUID -eq 0 ]]; then
                    rm -f "/Library/Fonts/$font_name"
                    log_action "Police système supprimée : $font_name"
                    removed=true
                else
                    log_action "AVERTISSEMENT : Privilèges administrateur requis pour supprimer la police système"
                fi
            fi
            ;;& # Continuer vers le cas suivant
        "template"|"all")
            if [[ -f "/Library/User Template/Non_localized/Library/Fonts/$font_name" ]]; then
                if [[ $EUID -eq 0 ]]; then
                    rm -f "/Library/User Template/Non_localized/Library/Fonts/$font_name"
                    log_action "Police modèle supprimée : $font_name"
                    removed=true
                else
                    log_action "AVERTISSEMENT : Privilèges administrateur requis pour supprimer la police modèle"
                fi
            fi
            ;;
    esac
    
    if [[ "$removed" == "true" ]]; then
        refresh_font_cache
        log_action "✅ Suppression de police terminée : $font_name"
        return 0
    else
        log_action "❌ Police non trouvée ou échec de suppression : $font_name"
        return 1
    fi
}

# Générer un rapport de déploiement des polices
generate_font_report() {
    local report_file="$BACKUP_DIR/font_deployment_report_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Génération du rapport de déploiement des polices : $report_file"
    
    {
        echo "{"
        echo "  \"report_type\": \"font_deployment\","
        echo "  \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","
        echo "  \"hostname\": \"$(hostname)\","
        echo "  \"system_info\": {"
        echo "    \"macos_version\": \"$(sw_vers -productVersion)\","
        echo "    \"user\": \"$(whoami)\""
        echo "  },"
        echo "  \"font_statistics\": {"
        
        # Compter les polices
        local sys_fonts user_fonts repo_fonts
        sys_fonts=$(ls -1 /Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        user_fonts=$(ls -1 ~/Library/Fonts/ 2>/dev/null | wc -l | tr -d ' ')
        repo_fonts=$(ls -1 "$FONT_REPO_DIR"/*.ttf "$FONT_REPO_DIR"/*.otf 2>/dev/null | wc -l | tr -d ' ')
        
        echo "    \"system_fonts\": $sys_fonts,"
        echo "    \"user_fonts\": $user_fonts,"
        echo "    \"repository_fonts\": $repo_fonts"
        echo "  },"
        
        echo "  \"repository_fonts\": ["
        local first_font=true
        for font_file in "$FONT_REPO_DIR"/*.ttf "$FONT_REPO_DIR"/*.otf; do
            if [[ -f "$font_file" ]]; then
                if [[ "$first_font" == "false" ]]; then
                    echo ","
                fi
                first_font=false
                
                local font_name
                font_name=$(basename "$font_file")
                local file_size
                file_size=$(stat -f%z "$font_file" 2>/dev/null || stat -c%s "$font_file")
                
                echo "    {"
                echo "      \"name\": \"$font_name\","
                echo "      \"size\": $file_size,"
                echo "      \"path\": \"$font_file\""
                echo -n "    }"
            fi
        done
        echo ""
        echo "  ]"
        echo "}"
    } > "$report_file"
    
    log_action "Rapport de déploiement des polices généré : $report_file"
    echo "$report_file"
}

# Fonction de gestion principale
main() {
    local action="${1:-status}"
    local parameter1="$2"
    local parameter2="$3"
    local parameter3="$4"
    
    setup_directories
    log_action "Gestion des polices Roundfleet démarrée avec l'action : $action"
    
    case "$action" in
        "download")
            download_font "$parameter1" "$parameter2" "$parameter3"
            ;;
        "deploy")
            deploy_font "$parameter1" "$parameter2" "$parameter3"
            ;;
        "remove")
            remove_font "$parameter1" "$parameter2"
            ;;
        "validate")
            validate_font "$parameter1"
            ;;
        "discover")
            discover_fonts
            ;;
        "audit")
            audit_font_compliance
            ;;
        "backup")
            backup_fonts
            ;;
        "cache")
            refresh_font_cache
            ;;
        "report")
            generate_font_report
            ;;
        "status"|*)
            discover_fonts
            ;;
    esac
    
    log_action "Gestion des polices Roundfleet terminée avec l'action : $action"
}

# Exécuter la fonction principale avec tous les arguments
main "$@"

Modèles de Gestion des Polices

Configuration de Package de Polices d'Entreprise

# /etc/roundfleet/font_config.conf
# Configuration de Gestion des Polices Roundfleet

# Packages de polices d'entreprise
CORPORATE_FONTS=(
    "Arial-Bold.ttf"
    "Helvetica-Light.otf"
    "TimesNewRoman.ttf"
    "Calibri-Regular.ttf"
    "CompanyLogo-Font.otf"
)

# Paramètres du dépôt de polices
FONT_REPO_URL="https://fonts.company.com/repository"
AUTO_UPDATE_FONTS="true"
UPDATE_INTERVAL_HOURS="24"

# Paramètres de déploiement
DEFAULT_DEPLOYMENT_SCOPE="system"
REQUIRE_LICENSE_VALIDATION="true"
BACKUP_BEFORE_DEPLOYMENT="true"

# Paramètres de conformité
FONT_AUDIT_ENABLED="true"
LICENSE_TRACKING="mandatory"
USAGE_ANALYTICS="enabled"

Script de Déploiement de Polices

#!/bin/bash

# Déploiement automatisé des polices pour les standards d'entreprise
deploy_corporate_fonts() {
    local font_package_url="$1"
    local deployment_scope="${2:-system}"
    
    echo "🎨 Déploiement du Package de Polices d'Entreprise"
    echo "================================================="
    
    # Télécharger le package de polices
    local package_file="/tmp/corporate_fonts.zip"
    echo "Téléchargement du package de polices..."
    
    if curl -L -o "$package_file" "$font_package_url"; then
        echo "✅ Package téléchargé avec succès"
    else
        echo "❌ Échec du téléchargement du package"
        return 1
    fi
    
    # Extraire et valider les polices
    local extract_dir="/tmp/corporate_fonts"
    mkdir -p "$extract_dir"
    
    if command -v unzip >/dev/null 2>&1; then
        unzip -q "$package_file" -d "$extract_dir"
    else
        echo "❌ Commande unzip non disponible"
        return 1
    fi
    
    # Installer chaque police
    local installed_count=0
    local failed_count=0
    
    for font_file in "$extract_dir"/*.ttf "$extract_dir"/*.otf; do
        if [[ -f "$font_file" ]]; then
            local font_name
            font_name=$(basename "$font_file")
            
            echo "Installation : $font_name"
            
            if validate_font "$font_file" >/dev/null 2>&1; then
                case "$deployment_scope" in
                    "system")
                        sudo cp "$font_file" /Library/Fonts/
                        ;;
                    "user")
                        cp "$font_file" ~/Library/Fonts/
                        ;;
                    "template")
                        sudo cp "$font_file" "/Library/User Template/Non_localized/Library/Fonts/"
                        ;;
                esac
                
                if [[ $? -eq 0 ]]; then
                    echo "  ✅ $font_name installée"
                    ((installed_count++))
                else
                    echo "  ❌ Échec d'installation $font_name"
                    ((failed_count++))
                fi
            else
                echo "  ⚠️  Échec de validation $font_name - ignorée"
                ((failed_count++))
            fi
        fi
    done
    
    # Nettoyage
    rm -rf "$extract_dir" "$package_file"
    
    # Actualiser le cache des polices
    echo "Actualisation du cache des polices..."
    refresh_font_cache
    
    echo ""
    echo "📊 Résumé du Déploiement :"
    echo "  Installées avec succès : $installed_count polices"
    echo "  Échecs d'installation : $failed_count polices"
    echo "  Portée de déploiement : $deployment_scope"
    
    if [[ $failed_count -eq 0 ]]; then
        return 0
    else
        return 1
    fi
}

# Exemple d'utilisation
# deploy_corporate_fonts "https://fonts.company.com/corporate-package.zip" "system"

Fonctions de Sécurité et Conformité

Validation des Licences de Polices

#!/bin/bash

# Valider les licences de polices et la conformité
validate_font_licenses() {
    echo "🔍 Validation des Licences de Polices"
    echo "====================================="
    echo ""
    
    local compliance_issues=()
    
    # Vérifier les polices du dépôt
    if [[ -d "$FONT_REPO_DIR" ]]; then
        echo "Statut des Licences de Polices du Dépôt :"
        echo "------------------------------------------"
        
        for font_file in "$FONT_REPO_DIR"/*.ttf "$FONT_REPO_DIR"/*.otf; do
            if [[ -f "$font_file" ]]; then
                local font_name
                font_name=$(basename "$font_file")
                local meta_file="$FONT_REPO_DIR/${font_name}.meta"
                
                if [[ -f "$meta_file" ]]; then
                    local license_info
                    license_info=$(grep "license_info" "$meta_file" | cut -d'"' -f4)
                    
                    if [[ -n "$license_info" && "$license_info" != "null" ]]; then
                        echo "  ✅ $font_name : $license_info"
                    else
                        echo "  ⚠️  $font_name : Aucune information de licence"
                        compliance_issues+=("$font_name : Information de licence manquante")
                    fi
                else
                    echo "  ❌ $font_name : Aucun fichier de métadonnées"
                    compliance_issues+=("$font_name : Métadonnées manquantes")
                fi
            fi
        done
    fi
    
    echo ""
    
    # Vérifier les polices potentiellement problématiques
    echo "Détection de Polices Problématiques :"
    echo "------------------------------------"
    
    local problematic_fonts=(
        "Arial.ttf"
        "TimesNewRoman.ttf"
        "Helvetica.otf"
        "Calibri.ttf"
    )
    
    for problem_font in "${problematic_fonts[@]}"; do
        if [[ -f "/Library/Fonts/$problem_font" ]] || [[ -f "~/Library/Fonts/$problem_font" ]]; then
            echo "  ⚠️  Police potentiellement sous licence trouvée : $problem_font"
            compliance_issues+=("$problem_font : Nécessite vérification de licence")
        fi
    done
    
    echo ""
    
    # Générer le rapport de conformité
    if [[ ${#compliance_issues[@]} -eq 0 ]]; then
        echo "✅ Vérification de conformité des licences de polices réussie"
        return 0
    else
        echo "❌ Problèmes de conformité des licences de polices trouvés :"
        for issue in "${compliance_issues[@]}"; do
            echo "  - $issue"
        done
        return 1
    fi
}

validate_font_licenses

Analytiques d'Utilisation des Polices

#!/bin/bash

# Générer des analytiques d'utilisation des polices
analyze_font_usage() {
    echo "📊 Analytiques d'Utilisation des Polices"
    echo "========================================"
    echo ""
    
    # Nombre de polices par format
    echo "Distribution des Formats de Polices :"
    echo "------------------------------------"
    local ttf_count otf_count woff_count other_count
    
    ttf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.ttf" 2>/dev/null | wc -l | tr -d ' ')
    otf_count=$(find /Library/Fonts ~/Library/Fonts -name "*.otf" 2>/dev/null | wc -l | tr -d ' ')
    woff_count=$(find /Library/Fonts ~/Library/Fonts -name "*.woff*" 2>/dev/null | wc -l | tr -d ' ')
    other_count=$(find /Library/Fonts ~/Library/Fonts -type f ! -name "*.ttf" ! -name "*.otf" ! -name "*.woff*" 2>/dev/null | wc -l | tr -d ' ')
    
    echo "  TrueType (.ttf) : $ttf_count"
    echo "  OpenType (.otf) : $otf_count" 
    echo "  Polices Web (.woff) : $woff_count"
    echo "  Autres formats : $other_count"
    echo ""
    
    # Analyse de la taille des polices
    echo "Analyse de la Taille des Polices :"
    echo "----------------------------------"
    local total_size large_fonts
    total_size=0
    large_fonts=0
    
    while IFS= read -r font_file; do
        if [[ -f "$font_file" ]]; then
            local size
            size=$(stat -f%z "$font_file" 2>/dev/null || stat -c%s "$font_file" 2>/dev/null || echo "0")
            total_size=$((total_size + size))
            
            if [[ "$size" -gt 1048576 ]]; then  # 1MB
                ((large_fonts++))
            fi
        fi
    done < <(find /Library/Fonts ~/Library/Fonts -type f 2>/dev/null)
    
    echo "  Stockage total des polices : $(( total_size / 1024 / 1024 )) MB"
    echo "  Polices volumineuses (>1MB) : $large_fonts"
    echo ""
    
    # Évaluation de l'impact système
    echo "Évaluation de l'Impact Système :"
    echo "-------------------------------"
    local total_fonts
    total_fonts=$(find /Library/Fonts ~/Library/Fonts -type f 2>/dev/null | wc -l | tr -d ' ')
    
    if [[ "$total_fonts" -gt 200 ]]; then
        echo "  ⚠️  Nombre élevé de polices ($total_fonts) - peut impacter les performances système"
    elif [[ "$total_fonts" -gt 100 ]]; then
        echo "  ⚠️  Nombre modéré de polices ($total_fonts) - surveiller les performances"
    else
        echo "  ✅ Nombre raisonnable de polices ($total_fonts)"
    fi
    
    if [[ "$total_size" -gt 104857600 ]]; then  # 100MB
        echo "  ⚠️  Utilisation élevée du stockage de polices - considérer un nettoyage"
    else
        echo "  ✅ Utilisation raisonnable du stockage de polices"
    fi
}

analyze_font_usage

Notes Techniques Importantes

Emplacements d'Installation des Polices

  • /Library/Fonts/ : Polices système (tous utilisateurs, nécessite admin)
  • ~/Library/Fonts/ : Polices spécifiques utilisateur (utilisateur actuel uniquement)
  • /Library/User Template/Non_localized/Library/Fonts/ : Modèle nouvel utilisateur

Formats de Polices Supportés

  • TTF (TrueType) : Format standard, bonne compatibilité
  • OTF (OpenType) : Format avancé avec meilleures fonctionnalités typographiques
  • WOFF/WOFF2 : Polices web (support desktop limité)
  • Formats hérités : Type 1, polices bitmap (dépréciés)

Considérations de Sécurité

  1. Accès Disque Complet : Requis pour l'installation de polices système
  2. Validation des Polices : Toujours valider les polices avant installation
  3. Conformité des Licences : Assurer le licenciement approprié pour les polices commerciales
  4. Vérification des Sources : Installer uniquement des polices de sources fiables

Meilleures Pratiques

  1. Standardisation : Maintenir des bibliothèques de polices cohérentes sur la flotte
  2. Gestion des Licences : Suivre et valider toutes les licences de polices
  3. Impact Performance : Surveiller les performances système avec de grandes bibliothèques de polices
  4. Contrôle de Version : Maintenir les versions de polices et les procédures de mise à jour
  5. Stratégie de Sauvegarde : Sauvegardes régulières avant les changements de polices
  6. Formation Utilisateur : Éduquer les utilisateurs sur l'utilisation appropriée des polices
  7. Audit de Conformité : Audits réguliers des licences et de l'utilisation
  8. Déploiement Flotte : Tester les déploiements de polices sur de petits groupes d'abord

N'oubliez pas de valider tous les scripts sur des appareils de test avant de les déployer sur votre environnement Roundfleet, et d'assurer la conformité avec les accords de licence de polices lors de l'implémentation de systèmes de gestion de polices d'entreprise.

Related Tutorials

Gestion d'Imprimantes d'Entreprise sur macOS

Déployez, configurez et gérez les imprimantes sur les appareils macOS avec la gestion avancée d'imprimantes, les politiques de sécurité et l'automatisation d'entreprise pour l'infrastructure d'impression organisationnelle.

7 juil. 2025

Récupérer les Journaux d'Appareils sur macOS

Apprenez à collecter les journaux système, journaux d'applications et informations de diagnostic depuis des appareils macOS en utilisant le système de journalisation unifié pour le dépannage et la surveillance.

7 juil. 2025

Gestion de l'indexation Spotlight sur les appareils macOS

Apprenez à contrôler l'indexation Spotlight sur les appareils macOS en utilisant des scripts shell pour optimiser les performances et gérer efficacement les ressources système.

7 juil. 2025

Gestion des Mises à Jour macOS

Gérez les mises à jour macOS sur les appareils Roundfleet avec un déploiement automatisé de correctifs, une surveillance de conformité, des déploiements échelonnés et des politiques de mise à jour d'entreprise pour une maintenance sécurisée et contrôlée du système.

7 juil. 2025

Sonnerie à Distance et Gestion de Localisation d'Appareils sur macOS

Apprenez à implémenter la fonctionnalité de sonnerie à distance, gérer les services de localisation d'appareils, créer des alertes audio et déployer des solutions de suivi d'appareils d'entreprise sur les appareils macOS pour la gestion de flotte.

7 juil. 2025

Gestion d'Identité et Nomenclature d'Appareils Entreprise sur macOS

Gérez les noms d'appareils, noms d'hôtes et identités réseau sur les appareils Roundfleet avec des conventions de nomenclature standardisées, un provisioning automatisé et des fonctionnalités de conformité d'entreprise.

7 juil. 2025

Suppression de Comptes Utilisateur et Gestion du Cycle de Vie sur macOS

Apprenez à supprimer en toute sécurité les comptes utilisateur, gérer la rétention des données, implémenter des procédures de départ sécurisées et traiter la gestion du cycle de vie des utilisateurs d'entreprise sur les appareils macOS.

7 juil. 2025

Gestion Entreprise des Fuseaux Horaires sur macOS

Guide complet pour la gestion des fuseaux horaires et des paramètres de date/heure en entreprise sur les appareils Roundfleet avec synchronisation automatisée, conformité géographique, application de politiques et contrôle centralisé.

7 juil. 2025
View all tutorials →