Guide

Rationalisez le déploiement logiciel et la gestion de paquets sur vos appareils Roundfleet en utilisant Homebrew. Ce tutoriel couvre l'installation de logiciels d'entreprise, la gestion de configuration, le suivi de conformité et les flux de déploiement automatisés pour une gestion complète de flotte.

Comprendre Homebrew pour l'Entreprise

Homebrew fournit une gestion de paquets puissante pour macOS :

• Paquets Formula - Outils en ligne de commande et bibliothèques
• Applications Cask - Applications GUI et gros binaires
• Dépôts Tap - Sources de paquets tiers
• Fichiers Bundle - Manifestes de paquets déclaratifs
• Services - Gestion de démons en arrière-plan

Installation Homebrew Basique

Installer Homebrew

#!/bin/bash

# Installer le gestionnaire de paquets Homebrew
install_homebrew() {
    echo "=== Installation du Gestionnaire de Paquets Homebrew ==="
    
    # Vérifier si Homebrew est déjà installé
    if command -v brew >/dev/null 2>&1; then
        echo "✅ Homebrew déjà installé : $(brew --version | head -1)"
        return 0
    fi
    
    echo "📦 Installation de Homebrew..."
    
    # Installer Homebrew
    if /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"; then
        echo "✅ Installation de Homebrew terminée"
        
        # Ajouter Homebrew au PATH pour la session actuelle
        if [[ -f "/opt/homebrew/bin/brew" ]]; then
            eval "$(/opt/homebrew/bin/brew shellenv)"
        elif [[ -f "/usr/local/bin/brew" ]]; then
            eval "$(/usr/local/bin/brew shellenv)"
        fi
        
        # Vérifier l'installation
        if command -v brew >/dev/null 2>&1; then
            echo "🔍 Version Homebrew : $(brew --version | head -1)"
            return 0
        else
            echo "❌ Échec de la vérification d'installation Homebrew"
            return 1
        fi
    else
        echo "❌ Échec de l'installation Homebrew"
        return 1
    fi
}

# Exécuter l'installation
install_homebrew

Script d'Installation de Paquets Amélioré

#!/bin/bash

# Installation de paquets améliorée basée sur GitHub Gist
# Référence : https://gist.github.com/CliffordAnderson/817777b5dc0e67769e4b

enhanced_package_installation() {
    echo "=== Installation de Paquets Améliorée ==="
    
    # S'assurer que Homebrew est installé
    if ! command -v brew >/dev/null 2>&1; then
        echo "❌ Homebrew non trouvé. Installation..."
        install_homebrew || return 1
    fi
    
    # Mettre à jour Homebrew
    echo "🔄 Mise à jour de Homebrew..."
    brew update
    
    # Langages de programmation
    echo "💻 Installation des langages de programmation..."
    brew install scala
    brew install --cask r
    brew install openjdk
    
    # Outils de développement
    echo "🛠️ Installation des outils de développement..."
    brew install docker
    brew install git
    brew install --cask github
    brew install --cask visual-studio-code
    brew install --cask hyper
    
    # Applications de communication
    echo "💬 Installation des applications de communication..."
    brew install --cask discord
    brew install --cask microsoft-teams
    brew install --cask slack
    brew install --cask zoom
    
    # Outils web
    echo "🌐 Installation des outils web..."
    brew install httpie
    brew install node
    brew install nvm
    brew install --cask firefox
    brew install --cask google-chrome
    brew install --cask postman
    
    # Stockage de fichiers
    echo "📁 Installation des outils de stockage de fichiers..."
    brew install --cask dropbox
    brew install --cask onedrive
    
    # Applications d'écriture
    echo "✍️ Installation des applications d'écriture..."
    brew install pandoc
    brew install --cask zotero
    brew install --cask microsoft-word
    
    # Autres applications
    echo "🎯 Installation d'applications supplémentaires..."
    brew install --cask anki
    
    echo "✅ Installation de paquets terminée"
}

# Exécuter l'installation améliorée
enhanced_package_installation

Système de Gestion Homebrew d'Entreprise

#!/bin/bash

# Système de Gestion Homebrew d'Entreprise Roundfleet
# Déploiement de paquets complet, suivi de conformité et gestion de flotte

# Configuration
LOG_FILE="/var/log/roundfleet_homebrew.log"
CONFIG_DIR="/etc/roundfleet/packages"
PROFILES_DIR="$CONFIG_DIR/profiles"
CACHE_DIR="/var/cache/roundfleet/homebrew"
REPORTS_DIR="$CONFIG_DIR/reports"
COMPLIANCE_DIR="$CONFIG_DIR/compliance"

# Profils de paquets pour différents rôles
declare -A PACKAGE_PROFILES=(
    ["developpeur"]="git,node,python,docker,visual-studio-code,github,postman,hyper"
    ["designer"]="adobe-creative-cloud,figma,sketch,canva,affinity-designer,imageoptim"
    ["manager"]="microsoft-office,slack,zoom,teams,dropbox,onedrive,notion"
    ["analyste"]="r,python,tableau,microsoft-excel,jupyter-notebook,pandas"
    ["securite"]="wireshark,nmap,burp-suite,malwarebytes,1password,gpg-suite"
    ["education"]="zoom,microsoft-office,rstudio,zotero,anki,mendeley"
    ["minimal"]="google-chrome,firefox,zoom,slack"
    ["entreprise"]="microsoft-office,teams,onedrive,1password,chrome-enterprise"
)

# Cadres de conformité
declare -A COMPLIANCE_PACKAGES=(
    ["hipaa"]="1password,malwarebytes,gpg-suite,microsoft-office"
    ["sox"]="microsoft-office,1password,box-drive,tableau"
    ["rgpd"]="1password,gpg-suite,notion,signal"
    ["iso27001"]="1password,malwarebytes,gpg-suite,microsoft-defender"
)

# Suivi des licences
declare -A LICENSE_REQUIRED=(
    ["microsoft-office"]="commercial"
    ["adobe-creative-cloud"]="commercial"
    ["tableau"]="commercial"
    ["sketch"]="commercial"
    ["1password"]="commercial"
    ["zoom"]="freemium"
    ["slack"]="freemium"
    ["notion"]="freemium"
)

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

# Configurer les répertoires
setup_directories() {
    for dir in "$CONFIG_DIR" "$PROFILES_DIR" "$CACHE_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR"; do
        if [[ ! -d "$dir" ]]; then
            mkdir -p "$dir"
            log_action "Répertoire créé : $dir"
        fi
    done
}

# S'assurer que Homebrew est installé et configuré
ensure_homebrew() {
    log_action "S'assurer que Homebrew est correctement configuré"
    
    # Vérifier si Homebrew est installé
    if ! command -v brew >/dev/null 2>&1; then
        log_action "Installation de Homebrew..."
        if ! /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"; then
            log_action "❌ Échec de l'installation Homebrew"
            return 1
        fi
        
        # Configurer PATH
        if [[ -f "/opt/homebrew/bin/brew" ]]; then
            eval "$(/opt/homebrew/bin/brew shellenv)"
        elif [[ -f "/usr/local/bin/brew" ]]; then
            eval "$(/usr/local/bin/brew shellenv)"
        fi
    fi
    
    # Mettre à jour Homebrew
    log_action "Mise à jour de Homebrew..."
    brew update 2>/dev/null || log_action "⚠️ Échec de la mise à jour Homebrew"
    
    # Vérifier la santé de Homebrew
    if brew doctor >/dev/null 2>&1; then
        log_action "✅ Vérification de santé Homebrew réussie"
    else
        log_action "⚠️ Problèmes détectés lors de la vérification de santé Homebrew"
    fi
    
    return 0
}

# Installer des paquets depuis un profil
install_package_profile() {
    local profile_name="$1"
    local dry_run="${2:-false}"
    
    log_action "Installation du profil de paquets : $profile_name (dry_run: $dry_run)"
    
    # Obtenir les paquets du profil
    local profile_packages="${PACKAGE_PROFILES[$profile_name]}"
    if [[ -z "$profile_packages" ]]; then
        log_action "❌ Profil inconnu : $profile_name"
        return 1
    fi
    
    # S'assurer que Homebrew est prêt
    ensure_homebrew || return 1
    
    # Analyser les paquets
    IFS=',' read -ra PACKAGES <<< "$profile_packages"
    
    local success_count=0
    local failure_count=0
    local already_installed=0
    
    for package in "${PACKAGES[@]}"; do
        # Nettoyer le nom du paquet
        package=$(echo "$package" | sed 's/^[ \t]*//;s/[ \t]*$//')
        
        log_action "Traitement du paquet : $package"
        
        if [[ "$dry_run" == "true" ]]; then
            echo "Installerait : $package"
            continue
        fi
        
        # Vérifier si déjà installé
        if is_package_installed "$package"; then
            log_action "✅ Paquet déjà installé : $package"
            already_installed=$((already_installed + 1))
            continue
        fi
        
        # Installer le paquet
        if install_single_package "$package"; then
            log_action "✅ Installation réussie : $package"
            success_count=$((success_count + 1))
        else
            log_action "❌ Échec de l'installation : $package"
            failure_count=$((failure_count + 1))
        fi
    done
    
    # Résumé
    log_action "Résumé d'installation - Succès : $success_count, Échecs : $failure_count, Déjà installés : $already_installed"
    
    # Générer un rapport d'installation
    generate_installation_report "$profile_name" "$success_count" "$failure_count" "$already_installed"
    
    return 0
}

# Vérifier si un paquet est installé
is_package_installed() {
    local package="$1"
    
    # Vérifier si c'est un cask
    if brew list --cask "$package" >/dev/null 2>&1; then
        return 0
    fi
    
    # Vérifier si c'est une formula
    if brew list "$package" >/dev/null 2>&1; then
        return 0
    fi
    
    return 1
}

# Installer un seul paquet
install_single_package() {
    local package="$1"
    
    # Essayer d'abord comme cask (pour les applications GUI)
    if brew install --cask "$package" 2>/dev/null; then
        return 0
    fi
    
    # Essayer comme formula (pour les outils CLI)
    if brew install "$package" 2>/dev/null; then
        return 0
    fi
    
    return 1
}

# Générer un inventaire logiciel complet
generate_software_inventory() {
    log_action "Génération de l'inventaire logiciel complet"
    
    local inventory_file="$REPORTS_DIR/software_inventory_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$inventory_file" << EOF
{
    "inventory_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "os_version": "$(sw_vers -productVersion)",
        "homebrew_version": "$(brew --version | head -1)",
        "generator": "Roundfleet Homebrew Manager"
    },
    "installed_packages": {
        "formulae": $(brew list --formula --json),
        "casks": $(brew list --cask --json)
    },
    "package_summary": {
        "total_formulae": $(brew list --formula | wc -l | tr -d ' '),
        "total_casks": $(brew list --cask | wc -l | tr -d ' '),
        "outdated_packages": $(brew outdated --json)
    },
    "system_info": {
        "homebrew_prefix": "$(brew --prefix)",
        "homebrew_cellar": "$(brew --cellar)",
        "homebrew_cache": "$(brew --cache)"
    }
}
EOF

    log_action "✅ Inventaire logiciel généré : $inventory_file"
    echo "$inventory_file"
}

# Vérification de conformité des licences
check_license_compliance() {
    log_action "Vérification de conformité des licences pour les paquets installés"
    
    local compliance_report="$COMPLIANCE_DIR/license_compliance_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$compliance_report" << EOF
{
    "compliance_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "check_type": "license_compliance"
    },
    "license_analysis": [
EOF

    local first=true
    local compliance_issues=0
    
    # Vérifier les casks installés pour les exigences de licence
    while IFS= read -r package; do
        local license_type="${LICENSE_REQUIRED[$package]}"
        
        if [[ -n "$license_type" ]]; then
            if [[ "$first" == true ]]; then
                first=false
            else
                echo "," >> "$compliance_report"
            fi
            
            local compliance_status="unknown"
            local needs_attention=false
            
            case "$license_type" in
                "commercial")
                    compliance_status="requires_license"
                    needs_attention=true
                    compliance_issues=$((compliance_issues + 1))
                    ;;
                "freemium")
                    compliance_status="freemium_check_usage"
                    ;;
            esac
            
            cat >> "$compliance_report" << EOF
        {
            "package": "$package",
            "license_type": "$license_type",
            "compliance_status": "$compliance_status",
            "needs_attention": $needs_attention,
            "installed_date": "$(brew list --cask --versions "$package" 2>/dev/null | awk '{print $2}' || echo 'unknown')"
        }
EOF
        fi
    done < <(brew list --cask)
    
    cat >> "$compliance_report" << EOF
    ],
    "summary": {
        "total_packages_checked": $(brew list --cask | wc -l | tr -d ' '),
        "license_issues_found": $compliance_issues,
        "compliance_status": "$([ $compliance_issues -eq 0 ] && echo 'compliant' || echo 'requires_attention')"
    }
}
EOF

    log_action "✅ Vérification de conformité des licences terminée : $compliance_report"
    echo "$compliance_report"
}

# Mettre à jour tous les paquets
update_all_packages() {
    local update_mode="${1:-safe}"  # safe, aggressive, ou security-only
    
    log_action "Démarrage des mises à jour de paquets (mode : $update_mode)"
    
    # S'assurer que Homebrew est prêt
    ensure_homebrew || return 1
    
    # Mettre à jour Homebrew lui-même
    log_action "Mise à jour de Homebrew..."
    if brew update; then
        log_action "✅ Homebrew mis à jour avec succès"
    else
        log_action "❌ Échec de la mise à jour Homebrew"
        return 1
    fi
    
    # Obtenir les paquets obsolètes
    local outdated_formulae outdated_casks
    outdated_formulae=$(brew outdated --formula --quiet)
    outdated_casks=$(brew outdated --cask --quiet)
    
    case "$update_mode" in
        "safe")
            # Mettre à jour uniquement les formulae (les outils CLI sont généralement plus sûrs à mettre à jour)
            if [[ -n "$outdated_formulae" ]]; then
                log_action "Mise à jour des formulae obsolètes : $outdated_formulae"
                brew upgrade
            fi
            ;;
        "aggressive")
            # Tout mettre à jour
            if [[ -n "$outdated_formulae" ]]; then
                log_action "Mise à jour de toutes les formulae obsolètes"
                brew upgrade
            fi
            if [[ -n "$outdated_casks" ]]; then
                log_action "Mise à jour de tous les casks obsolètes"
                brew upgrade --cask
            fi
            ;;
        "security-only")
            # Mettre à jour uniquement les paquets avec des problèmes de sécurité connus
            # Cela nécessiterait une intégration avec des bases de données de vulnérabilités
            log_action "Mises à jour de sécurité uniquement pas encore implémentées"
            ;;
    esac
    
    # Nettoyage
    log_action "Nettoyage des anciennes versions..."
    brew cleanup
    
    log_action "✅ Mises à jour de paquets terminées"
    
    # Générer un inventaire post-mise à jour
    generate_software_inventory
}

# Générer un Brewfile pour l'installation actuelle
generate_brewfile() {
    local brewfile_path="${1:-$CONFIG_DIR/Brewfile}"
    
    log_action "Génération du Brewfile : $brewfile_path"
    
    # Créer l'en-tête du Brewfile
    cat > "$brewfile_path" << EOF
# Roundfleet Brewfile
# Généré le $(date)
# Nom d'hôte : $(hostname)

# Taps
EOF

    # Ajouter les taps
    brew tap | while read -r tap; do
        echo "tap \"$tap\"" >> "$brewfile_path"
    done
    
    echo "" >> "$brewfile_path"
    echo "# Formulae" >> "$brewfile_path"
    
    # Ajouter les formulae
    brew list --formula | while read -r formula; do
        echo "brew \"$formula\"" >> "$brewfile_path"
    done
    
    echo "" >> "$brewfile_path"
    echo "# Casks" >> "$brewfile_path"
    
    # Ajouter les casks
    brew list --cask | while read -r cask; do
        echo "cask \"$cask\"" >> "$brewfile_path"
    done
    
    log_action "✅ Brewfile généré : $brewfile_path"
    echo "$brewfile_path"
}

# Installer depuis un Brewfile
install_from_brewfile() {
    local brewfile_path="$1"
    local dry_run="${2:-false}"
    
    if [[ ! -f "$brewfile_path" ]]; then
        log_action "❌ Brewfile non trouvé : $brewfile_path"
        return 1
    fi
    
    log_action "Installation depuis le Brewfile : $brewfile_path (dry_run: $dry_run)"
    
    # S'assurer que Homebrew est prêt
    ensure_homebrew || return 1
    
    if [[ "$dry_run" == "true" ]]; then
        log_action "Exécution à sec - installerait les paquets depuis : $brewfile_path"
        brew bundle --file="$brewfile_path" --verbose --no-install
    else
        # Installer les paquets depuis le Brewfile
        if brew bundle --file="$brewfile_path"; then
            log_action "✅ Installation Brewfile terminée"
            return 0
        else
            log_action "❌ Échec de l'installation Brewfile"
            return 1
        fi
    fi
}

# Audit de sécurité des paquets installés
security_audit() {
    log_action "Exécution de l'audit de sécurité des paquets installés"
    
    local audit_report="$REPORTS_DIR/security_audit_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$audit_report" << EOF
{
    "audit_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "audit_type": "security"
    },
    "security_findings": [
EOF

    local first=true
    local security_issues=0
    
    # Vérifier les paquets vulnérables connus (vérification simplifiée)
    # En production, cela s'intégrerait avec des bases de données CVE
    local vulnerable_packages=("[email protected]" "node@14" "[email protected]")
    
    for vuln_package in "${vulnerable_packages[@]}"; do
        if is_package_installed "$vuln_package"; then
            if [[ "$first" == true ]]; then
                first=false
            else
                echo "," >> "$audit_report"
            fi
            
            cat >> "$audit_report" << EOF
        {
            "package": "$vuln_package",
            "severity": "medium",
            "issue": "potentially_outdated_version",
            "recommendation": "update_to_latest_version",
            "installed_version": "$(brew list --versions "$vuln_package" | awk '{print $2}')"
        }
EOF
            security_issues=$((security_issues + 1))
        fi
    done
    
    cat >> "$audit_report" << EOF
    ],
    "summary": {
        "total_packages_audited": $(( $(brew list --formula | wc -l) + $(brew list --cask | wc -l) )),
        "security_issues_found": $security_issues,
        "security_status": "$([ $security_issues -eq 0 ] && echo 'secure' || echo 'requires_attention')"
    }
}
EOF

    log_action "✅ Audit de sécurité terminé : $audit_report"
    echo "$audit_report"
}

# Générer un rapport d'installation
generate_installation_report() {
    local profile_name="$1"
    local success_count="$2"
    local failure_count="$3"
    local already_installed="$4"
    
    local report_file="$REPORTS_DIR/installation_report_${profile_name}_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$report_file" << EOF
{
    "installation_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)",
        "profile": "$profile_name",
        "generator": "Roundfleet Homebrew Manager"
    },
    "installation_results": {
        "successful_installations": $success_count,
        "failed_installations": $failure_count,
        "already_installed": $already_installed,
        "total_processed": $(( success_count + failure_count + already_installed ))
    },
    "post_installation_inventory": $(generate_software_inventory | tail -n +2 | head -n -1)
}
EOF

    log_action "✅ Rapport d'installation généré : $report_file"
    echo "$report_file"
}

# Fonction d'exécution principale
main() {
    local action="${1:-inventory}"
    local parameter="$2"
    local additional_param="$3"
    
    log_action "=== Démarrage de la Gestion Homebrew Roundfleet ==="
    log_action "Action : $action"
    log_action "Paramètre : ${parameter:-N/A}"
    
    setup_directories
    
    case "$action" in
        "install-profile")
            if [[ -z "$parameter" ]]; then
                echo "Profils de paquets disponibles :"
                for profile in "${!PACKAGE_PROFILES[@]}"; do
                    echo "  - $profile : ${PACKAGE_PROFILES[$profile]}"
                done
                echo ""
                echo "Usage : $0 install-profile <nom_profil> [dry_run]"
                exit 1
            fi
            install_package_profile "$parameter" "$additional_param"
            ;;
        "inventory")
            generate_software_inventory
            ;;
        "update")
            update_all_packages "$parameter"
            ;;
        "compliance")
            check_license_compliance
            ;;
        "security")
            security_audit
            ;;
        "brewfile-generate")
            generate_brewfile "$parameter"
            ;;
        "brewfile-install")
            if [[ -z "$parameter" ]]; then
                echo "Usage : $0 brewfile-install <chemin_brewfile> [dry_run]"
                exit 1
            fi
            install_from_brewfile "$parameter" "$additional_param"
            ;;
        "ensure")
            ensure_homebrew
            ;;
        *)
            echo "Usage : $0 {install-profile|inventory|update|compliance|security|brewfile-generate|brewfile-install|ensure}"
            echo "  install-profile    - Installer les paquets depuis un profil prédéfini"
            echo "  inventory         - Générer un rapport d'inventaire logiciel"
            echo "  update           - Mettre à jour tous les paquets (safe|aggressive|security-only)"
            echo "  compliance       - Vérifier la conformité des licences"
            echo "  security         - Effectuer un audit de sécurité"
            echo "  brewfile-generate - Générer un Brewfile depuis l'installation actuelle"
            echo "  brewfile-install  - Installer les paquets depuis un Brewfile"
            echo "  ensure           - S'assurer que Homebrew est installé et configuré"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion Homebrew terminée ==="
}

# Exécuter la fonction principale
main "$@"

Fonctionnalités Avancées de Gestion de Paquets

Création de Profil de Paquet Personnalisé

#!/bin/bash

# Créer un profil de paquet personnalisé
create_custom_profile() {
    local profile_name="$1"
    local packages="$2"
    
    echo "=== Création d'un Profil de Paquet Personnalisé ==="
    echo "Profil : $profile_name"
    echo "Paquets : $packages"
    
    # Valider que les paquets existent
    IFS=',' read -ra PACKAGE_LIST <<< "$packages"
    local valid_packages=()
    
    for package in "${PACKAGE_LIST[@]}"; do
        package=$(echo "$package" | sed 's/^[ \t]*//;s/[ \t]*$//')
        
        # Vérifier si le paquet existe dans Homebrew
        if brew search --formula --cask "$package" | grep -q "^$package$"; then
            valid_packages+=("$package")
            echo "✅ Paquet valide : $package"
        else
            echo "⚠️  Paquet non trouvé : $package"
        fi
    done
    
    if [[ ${#valid_packages[@]} -eq 0 ]]; then
        echo "❌ Aucun paquet valide trouvé"
        return 1
    fi
    
    # Créer le profil
    local profile_packages
    printf -v profile_packages '%s,' "${valid_packages[@]}"
    profile_packages=${profile_packages%,}  # Supprimer la virgule finale
    
    PACKAGE_PROFILES["$profile_name"]="$profile_packages"
    
    echo "✅ Profil personnalisé créé : $profile_name"
    echo "Paquets : $profile_packages"
}

Gestion Automatisée des Licences

#!/bin/bash

# Gestion et suivi automatisés des licences
manage_software_licenses() {
    echo "=== Gestion des Licences Logicielles ==="
    
    local license_db="$COMPLIANCE_DIR/license_database.json"
    
    # Créer la base de données de licences si elle n'existe pas
    if [[ ! -f "$license_db" ]]; then
        cat > "$license_db" << EOF
{
    "license_metadata": {
        "created": "$(date -Iseconds)",
        "last_updated": "$(date -Iseconds)"
    },
    "licenses": {},
    "compliance_rules": {}
}
EOF
    fi
    
    # Scanner les logiciels commerciaux
    local commercial_software=()
    while IFS= read -r package; do
        if [[ -n "${LICENSE_REQUIRED[$package]}" ]]; then
            commercial_software+=("$package")
        fi
    done < <(brew list --cask)
    
    echo "Trouvé ${#commercial_software[@]} paquets nécessitant une gestion de licence :"
    printf '%s\n' "${commercial_software[@]}"
    
    # Générer un rapport de licences
    local license_report="$REPORTS_DIR/license_report_$(date '+%Y%m%d_%H%M%S').json"
    
    cat > "$license_report" << EOF
{
    "license_report_metadata": {
        "timestamp": "$(date -Iseconds)",
        "hostname": "$(hostname)"
    },
    "commercial_software": [
EOF

    local first=true
    for package in "${commercial_software[@]}"; do
        if [[ "$first" == true ]]; then
            first=false
        else
            echo "," >> "$license_report"
        fi
        
        cat >> "$license_report" << EOF
        {
            "package": "$package",
            "license_type": "${LICENSE_REQUIRED[$package]}",
            "installed_version": "$(brew list --cask --versions "$package" 2>/dev/null | awk '{print $2}' || echo 'unknown')",
            "license_status": "requires_verification"
        }
EOF
    done
    
    cat >> "$license_report" << EOF
    ]
}
EOF

    echo "📋 Rapport de licences généré : $license_report"
}

Meilleures Pratiques

🚀 Déploiement d'Entreprise

• Installations basées sur les profils pour différents rôles utilisateur et départements
• Gestion centralisée des paquets avec déploiement Brewfile sur les flottes
• Suivi automatisé de l'inventaire logiciel et rapports
• Surveillance de conformité des licences avec audit automatisé

🔐 Gestion de Sécurité

• Audits de sécurité réguliers des paquets installés et dépendances
• Intégration de scan de vulnérabilités avec bases de données CVE
• Vérification de signature de paquets et validation de sources fiables
• Déploiement contrôlé des mises à jour avec phases de test

📋 Conformité et Gouvernance

• Suivi des licences pour la conformité des logiciels commerciaux
• Application de politiques basée sur les exigences organisationnelles
• Pistes d'audit pour toutes les installations et mises à jour de paquets
• Gestion des coûts grâce à l'optimisation des licences

🔧 Maintenance et Optimisation

• Mises à jour automatisées avec capacités de retour en arrière
• Nettoyage et optimisation pour gérer l'espace disque
• Surveillance des performances des opérations de gestion de paquets
• Création de profils personnalisés pour des cas d'usage spécialisés

Notes Importantes

• Tester les déploiements en environnements de staging avant le déploiement en production
• Sauvegarder les configurations avant les mises à jour majeures de paquets
• Surveiller la conformité des licences pour éviter les risques légaux et financiers
• Audits d'inventaire réguliers pour maintenir un suivi logiciel précis
• Considérations de bande passante réseau pour les déploiements à grande échelle
• Communication utilisateur pour les changements et mises à jour logiciels

Intégration avec les Systèmes d'Entreprise

Le système de gestion Homebrew peut être intégré avec :

• Solutions MDM pour l'application de politiques
• Systèmes de gestion d'actifs pour le suivi d'inventaire
• Plateformes de gestion de licences pour l'automatisation de conformité
• Outils de sécurité pour l'évaluation de vulnérabilités
• Systèmes de surveillance pour le suivi de déploiement