Guide de script : effacer le cache sur macOS avec un script Bash 

La gestion efficace du cache du navigateur est essentielle pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) qui s’efforcent d’optimiser les performances du système et de garantir une expérience utilisateur fluide. Pour les systèmes macOS, la gestion du cache du navigateur pour plusieurs utilisateurs et navigateurs peut s’avérer fastidieuse. Le script Bash présenté ici est conçu pour permettre aux administrateurs informatiques d’effacer le cache sur macOS de manière simplifiée et automatisée.

Comprendre le contexte du script

Le cache du navigateur stocke des données temporaires pour accélérer la navigation, mais il peut entraîner des problèmes tels que l’affichage de contenus obsolètes ou des inefficacités de stockage s’il n’est pas géré correctement. Pour les professionnels de l’informatique qui gèrent plusieurs systèmes, l’effacement des caches devient une tâche de maintenance essentielle.

Ce script est un outil puissant pour :

1. Automatiser la gestion du cache : réduit les interventions manuelles.
2. Rationaliser les opérations multi-navigateurs : prend en charge Chrome, Firefox, Safari et Edge.
3. Une compatibilité multi-utilisateurs : efface le cache pour un ou plusieurs comptes d’utilisateurs sur les appareils macOS.
4. Exécution forcée : s’assure que les navigateurs sont fermés avant l’effacement du cache pour éviter les conflits.

Les professionnels de l’informatique dans les environnements MSP peuvent tout particulièrement bénéficier de l’intégration de ce script dans les flux de travail de maintenance de routine, ce qui leur permet de gagner du temps et d’économiser des efforts.

Le script permettant d’effacer le cache sur macOS :

#!/usr/bin/env bash

# Description: Clears the browser cache for users on a Mac.
#   By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
#   Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
#   Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
#   Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
#   Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
#   Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
#   Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
#   EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#
# Parameter UserName: --UserName "User1,User2"
#   The names of the users to clear the cache for. If not specified, clears the current user's cache.
#
# Parameter Browser: --Browser "Chrome"
#   Clears the cache for the specified browser. If not specified, No browser will be cleared.
#   Valid options are "Chrome", "Firefox", "Edge", "Safari" or multiple browsers separated by a comma. For example, "Chrome,Firefox".
#
# Parameter Force: --Force
#   Will force close the selected browser before clearing the cache.

# These are all our preset parameter defaults. You can set these = to something if you would prefer the script defaults to a certain parameter value.
_arg_userNames=
_arg_browser=
_arg_force=

# Help text function for when invalid input is encountered
print_help() {
    printf '\n\n%s\n\n' 'Usage: [--UserName|-u <arg>] [--Browser|-b <arg>] [--Force|-f] [--help|-h]'
    printf '%s\n' 'Preset Parameter: --UserName "User1,User2"'
    printf '\t%s\n' "The names of the users to clear the cache for. If not specified, clears the current user's cache."
    printf '%s\n' 'Preset Parameter: --Browser "Chrome"'
    printf '\t%s\n' "Clears the cache for the specified browser. Separate multiple browsers with a comma. If not specified, No browser will be cleared."
    printf '\t%s\n' "Valid options are 'Chrome', 'Firefox', 'Edge', 'Safari'."
    printf '%s\n' 'Preset Parameter: --Force'
    printf '\t%s\n' "Will force close the selected browser before clearing the cache."
    printf '\n%s\n' 'Preset Parameter: --help'
    printf '\t%s\n' "Displays this help menu."
}

# Determines whether or not help text is necessary and routes the output to stderr
die() {
    local _ret="${2:-1}"
    echo "$1" >&2
    test "${_PRINT_HELP:-no}" = yes && print_help >&2
    exit "${_ret}"
}

# Grabbing the parameters and parsing through them.
parse_commandline() {
    while test $# -gt 0; do
        _key="$1"
        case "$_key" in
        -u | --UserName | --Username)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_userNames=$2
            shift
            ;;
        --UserName=*)
            _arg_userNames="${_key##--UserNames=}"
            ;;
        -b | -Browser | --Browser)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_browser=$2
            shift
            ;;
        --Browser=*)
            _arg_browser="${_key##--Browser=}"
            ;;
        -f | --Force)
            _arg_force="true"
            ;;
        --help | -h)
            _PRINT_HELP=yes die 0
            ;;
        *)
            _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
            ;;
        esac
        shift
    done
}

checkAppExists() {
    _Application=$1
    _UserName=$2
    if [[ -z "${_Application}" ]]; then
        echo "[Error] No application was specified."
        exit 1
    fi

    if [ -f "/Applications/${_Application}" ] || [ -f "/Users/${_UserName}/Applications/${_Application}" ]; then
        return 1
    else
        return 0
    fi
}

closeApp() {
    _UserName=$1
    _Application=$2
    # Force close the app by the user name
    if [[ "${_arg_force}" == "true" ]] && [[ "${_runningAsRoot}" == "true" ]]; then
        if ! su "${_UserName}" -c "osascript -e 'tell application \"${_Application}\" to quit'" 2>/dev/null; then
            echo "[Warn] Failed to force close ${_Application} for user ${_UserName}."
        else
            echo "[Info] Successfully force closed ${_Application} for user ${_UserName}."
        fi
    elif [[ "${_arg_force}" == "true" ]] && [[ "${_runningAsRoot}" == "false" ]]; then
        if ! osascript -e "tell application \"${_Application}\" to quit" 2>/dev/null; then
            echo "[Warn] Failed to force close ${_Application} for user ${_UserName}."
        else
            echo "[Info] Successfully force closed ${_Application} for user ${_UserName}."
        fi
    fi
}

clearCache() {
    _UserName=$1

    if [[ -z "${_UserName}" ]]; then
        echo "[Warn] ${_UserName} is not a valid user name. Skipping."
        return
    fi

    # Check that the path /Users/"$_UserName"/ exists
    if [[ ! -d "/Users/$_UserName/Library" ]]; then
        echo "[Warn] User $_UserName does not exist. Skipping."
        return
    fi

    _browserFound="false"
    # Safari
    #   /Users/$_user/Library/Caches/com.apple.Safari/WebKitCache
    if [[ "${_arg_browser}" == *"Safari"* ]] || [[ "${_arg_browser}" == *"safari"* ]]; then
        _browserFound="true"
        # Check if the app exists
        if checkAppExists "Safari.app" "${_UserName}"; then
            # Check if the user is logged in
            # Force close Safari by the user name
            closeApp "$_UserName" "Safari"
            # Check if the cache directory exists
            if ls /Users/"$_UserName"/Library/Caches/com.apple.Safari/WebKitCache 2>/dev/null | head -n 1 | grep -q .; then
                # Clear the cache for Safari
                rm -rf /Users/"$_UserName"/Library/Caches/com.apple.Safari/WebKitCache 2>/dev/null
                echo "[Info] Cleared Safari cache for user $_UserName"
            else
                echo "[Warn] Safari cache directory does not exist. Skipping."
            fi
        else
            echo "[Warn] Safari.app is not installed. Skipping."
        fi
    fi

    # Chrome
    #   /Users/$_user/Library/Caches/Google/Chrome/*/Cache
    if [[ "${_arg_browser}" == *"Chrome"* ]] || [[ "${_arg_browser}" == *"chrome"* ]]; then
        _browserFound="true"
        # Check if the app exists
        if checkAppExists "Google Chrome.app" "${_UserName}"; then
            # Force close Chrome by the user name
            closeApp "$_UserName" "Google Chrome"
            # Check if the cache directories exists
            if ls /Users/"$_UserName"/Library/Caches/Google/Chrome/*/Cache 2>/dev/null | head -n 1 | grep -q .; then
                # Clear the cache for Chrome
                rm -rf /Users/"$_UserName"/Library/Caches/Google/Chrome/*/Cache 2>/dev/null
                echo "[Info] Cleared Chrome cache for user $_UserName"
            else
                echo "[Warn] Chrome cache directory does not exist. Skipping."
            fi
        else
            echo "[Warn] Google Chrome.app is not installed. Skipping."
        fi
    fi

    # Firefox
    #   /Users/$_user/Library/Caches/Firefox/Profiles/????????.*/cache2/*
    if [[ "${_arg_browser}" == *"Firefox"* ]] || [[ "${_arg_browser}" == *"firefox"* ]]; then
        _browserFound="true"
        # Check if the app exists
        if checkAppExists "Firefox.app" "${_UserName}"; then
            # Force close Firefox by the user name
            closeApp "$_UserName" "Firefox"
            # Check if the cache directories exists
            if ls /Users/"$_UserName"/Library/Caches/Firefox/Profiles/????????.*/cache2/* 2>/dev/null | head -n 1 | grep -q .; then
                # Clear the cache for Firefox
                rm -rf /Users/"$_UserName"/Library/Caches/Firefox/Profiles/????????.*/cache2/* 2>/dev/null
                echo "[Info] Cleared Firefox cache for user $_UserName"
            else
                echo "[Warn] Firefox cache directory does not exist. Skipping."
            fi
        else
            echo "[Warn] Firefox.app is not installed. Skipping."
        fi
    fi

    # Edge
    #   /Users/$_user/Library/Caches/Microsoft Edge/*/Cache
    if [[ "${_arg_browser}" == *"Edge"* ]] || [[ "${_arg_browser}" == *"edge"* ]]; then
        _browserFound="true"
        # Check if the app exists
        if checkAppExists "Microsoft Edge.app" "${_UserName}"; then
            # Force close Edge by the user name
            closeApp "$_UserName" "Microsoft Edge"
            # Check if the cache directories exists
            if ls /Users/"$_UserName"/Library/Caches/Microsoft\ Edge/*/Cache 2>/dev/null | head -n 1 | grep -q .; then
                # Clear the cache for Edge
                rm -rf /Users/"$_UserName"/Library/Caches/Microsoft\ Edge/*/Cache 2>/dev/null
                echo "[Info] Cleared Edge cache for user $_UserName"
            else
                echo "[Warn] Edge cache directory does not exist. Skipping."
            fi
        else
            echo "[Warn] Microsoft Edge.app is not installed. Skipping."
        fi
    fi

    if [[ "$_browserFound" == "false" ]]; then
        echo "[Error] At least one browser must be specified. Please specify one of the following: Chrome, Firefox, Edge, Safari."
        exit 1
    fi
}

parse_commandline "$@"

# If script variable is used override commandline arguments
if [[ -n $userNames ]]; then
    # Split userNames into an array
    _arg_userNames=$userNames
fi

if [[ -z $chrome ]] && [[ -z $firefox ]] && [[ -z $edge ]] && [[ -z $safari ]] && [[ -z $_arg_browser ]]; then
    echo "[Error] At least one browser must be specified. Please specify one of the following: Chrome, Firefox, Edge, Safari."
    exit 1
fi

# Append browser names to _arg_browser as we check if the name exists in _arg_browser later on
if [[ -n $chrome ]] && [[ "${chrome}" == "true" ]]; then
    _arg_browser="$_arg_browser,chrome"
fi
if [[ -n $firefox ]] && [[ "${firefox}" == "true" ]]; then
    _arg_browser="$_arg_browser,firefox"
fi
if [[ -n $edge ]] && [[ "${edge}" == "true" ]]; then
    _arg_browser="$_arg_browser,edge"
fi
if [[ -n $safari ]] && [[ "${safari}" == "true" ]]; then
    _arg_browser="$_arg_browser,safari"
fi

if [[ -n $force ]]; then
    if [[ "${force}" == "true" ]]; then
        _arg_force="true"
    else
        _arg_force="false"
    fi
fi

# Check if the user is running this script as root
_runningAsRoot="false"
if [[ $EUID -eq 0 ]]; then
    _runningAsRoot="true"
fi

_Users=()
if [[ -z "${_arg_userNames}" ]] && [[ $_runningAsRoot == "true" ]]; then
    # Get a list of all user names that can login
    _userNames=$(dscl . -list /Users UniqueID | awk '$2 > 499 {print $1}')
    # Loop through each user name
    for _userName in $_userNames; do
        # Trim whitespace from the user name
        _userName="${_userName##*( )}" # Remove leading whitespace
        _userName="${_userName%%*( )}" # Remove trailing whitespace
        _Users+=("$_userName")
    done
else
    IFS=',' read -r -a _userNames <<<"$_arg_userNames"
    for _userName in "${_userNames[@]}"; do
        # Trim whitespace from the user name
        _userName="${_userName##*( )}" # Remove leading whitespace
        _userName="${_userName%%*( )}" # Remove trailing whitespace
        _Users+=("$_userName")
    done
fi

if [[ $_runningAsRoot == "true" ]]; then
    # Check if the user is in the list of users to clear cache for
    for _userName in "${_Users[@]}"; do
        _user=$(echo "$_userName" | awk '{$1=$1};1')
        if dscl . read "/Users/$_user" 1>/dev/null 2>&1; then
            clearCache "$_user"
            echo ""
        else
            echo "[Warn] ${_user} is not a valid user name. Skipping."
        fi
    done
else
    if [[ "$(whoami)" == "${_arg_userNames}" ]] || [[ -z "${_arg_userNames}" ]]; then
        clearCache "$(whoami)"
    else
        echo "[Error] The script must be run as system/root to clear the cache for multiple users."
        exit 1
    fi
fi

 

Description détaillée

Ce script Bash est polyvalent et prend en charge l’exécution paramétrée. Vous trouverez ci-dessous une explication détaillée de ses fonctionnalités :

Paramètres d’entrée

• –UserName or -u : spécifie un ou plusieurs utilisateurs (par exemple, Utilisateur1, Utilisateur2) pour lesquels le cache sera effacé. S’il n’est pas fourni, le script utilise par défaut l’utilisateur actuel.
• –Browser or -b : indique le ou les navigateurs à cibler. Les options valides sont Chrome, Firefox, Safari et Edge. Plusieurs navigateurs peuvent être spécifiés (par exemple, Chrome, Firefox).
• –Force or -f : ferme de force les navigateurs spécifiés avant de vider leur cache.

Fonctions essentielles

1. Aide et gestion des erreurs
   La fonction print_help fournit des conseils d’utilisation, tandis que la fonction “die” traite les entrées non valides ou les erreurs de manière élégante en affichant des messages d’erreur.
2. Paramètres d’analyse
   La fonction parse_commandline traite les entrées des utilisateurs afin de déterminer les navigateurs et les utilisateurs à cibler.
3. Validation de l’application
   La fonction checkAppExists vérifie l’existence des navigateurs cibles dans les répertoires d’application du système et de l’utilisateur.
4. Forcer la fermeture des navigateurs
   La fonction closeApp utilise osascript pour fermer les applications du navigateur pour les utilisateurs spécifiés, garantissant ainsi l’absence de conflits lors de la vidange du cache.
5. Effacement du cache
   La fonction clearCache identifie les répertoires de cache pour chaque navigateur et chaque utilisateur, supprime les fichiers concernés et enregistre les actions dans la console. Par exemple :
6. Chrome : supprime /Users/{username}/Library/Caches/Google/Chrome/*/Cache.
7. Safari : supprime /Users/{username}/Library/Caches/com.apple.Safari/WebKitCache.

Exécution

Le script s’assure qu’il s’exécute avec les autorisations appropriées (accès root lors de l’effacement des caches pour plusieurs utilisateurs) et utilise par défaut l’utilisateur actuel si aucun nom d’utilisateur n’est spécifié.

Cas d’utilisation concrète

Scénario

L’administrateur informatique d’une entreprise de taille moyenne gère un parc d’appareils macOS. Les employés utilisent plusieurs navigateurs, ce qui entraîne souvent des problèmes de performance dus à des fichiers cache obsolètes ou gonflés.

Questions fréquentes

1. Ai-je besoin de privilèges administratifs ?
   Oui, l’accès root est nécessaire pour effacer les caches de plusieurs utilisateurs.
2. Puis-je effacer le cache d’un seul navigateur ?
   Tout à fait. Utilisez le paramètre –Browser pour spécifier le ou les navigateurs que vous souhaitez cibler.
3. Que se passe-t-il si un navigateur est ouvert pendant l’exécution ?
   Si le paramètre –Force est utilisé, le script tentera de fermer le navigateur avant d’effacer le cache.
4. Ce script peut-il être programmé ?
   Oui, il peut être exécuté via cron ou n’importe quel planificateur de tâches sur macOS pour une gestion automatisée du cache.

Des implications plus larges

L’effacement régulier du cache du navigateur améliore les performances du système, réduit l’encombrement de l’espace de stockage et minimise les risques potentiels pour la sécurité, tels que la conservation de données sensibles dans les fichiers de cache. Pour les entreprises, cela se traduit par une réduction des tickets d’assistance et une meilleure satisfaction utilisateur.

Bonnes pratiques

• Exécutez en tant que racine : pour les opérations multi-utilisateurs, exécutez toujours le script avec des privilèges administratifs.
• Testez dans un environnement sûr : validez le script dans un environnement de test avant de le déployer à l’échelle de l’entreprise.
• Prévoyez un entretien régulier : utilisez des planificateurs de tâches pour automatiser le script afin d’assurer une gestion cohérente du cache.
• Utilisation du document : conservez les journaux des activités d’effacement du cache à des fins d’audit et de dépannage.

Conclusion

Ce script montre comment l’automatisation peut alléger les tâches répétitives des administrateurs informatiques. Alors que des outils comme NinjaOne proposent des solutions complètes de gestion informatique, des scripts comme celui-ci peuvent compléter des stratégies plus larges en s’attaquant à des défis spécifiques. Les fonctionnalités robustes de NinjaOne, notamment l’automatisation, la surveillance et la gestion, en font un allié précieux pour les professionnels de l’informatique en quête d’efficacité et de fiabilité.