Lorsque les MSPs gèrent plusieurs environnements clients, il peut être difficile de maintenir chaque terminal correctement mis à jour. Bien que les politiques de correctifs puissent aider à faire évoluer la gestion des correctifs et à automatiser les déploiements de routine, des obstacles tels qu’un espace disque insuffisant, des services arrêtés ou des appareils hors ligne peuvent compliquer le processus.
Les scripts d’automatisation peuvent aider les MSPs à détecter et à corriger bon nombre de ces situations avant qu’elles ne provoquent l’échec d’un déploiement. Grâce aux scripts d’automatisation, les MSPs peuvent gérer plus facilement le déploiement des correctifs en préparant les terminaux, en validant les résultats, en corrigeant les échecs et en faisant remonter les problèmes si nécessaire. Cela complète les politiques de correctifs et améliore le processus de gestion des correctifs, en contribuant à garantir que les mises à jour sont correctement déployées.
Dans cette optique, examinons comment les scripts d’automatisation peuvent améliorer la gestion des correctifs et où ils apportent le plus de valeur avant, pendant et après le déploiement.
Quel rôle les scripts d’automatisation jouent-ils dans le déploiement des correctifs ?
Les scripts d’automatisation se distinguent des politiques d’automatisation des correctifs, qui régissent les activités courantes telles que les approbations, les calendriers et les règles de redémarrage. Les scripts d’automatisation traitent des problèmes plus complexes, tels que les vérifications spécifiques aux endpoints, la validation, la remédiation et les exceptions qui peuvent sortir du cadre des politiques de correctifs habituelles.
Les scripts peuvent gérer plusieurs tâches, notamment :
Vérification si un endpoint est prêt pour l’installation du correctif.
Préparer les appareils avant le déploiement des correctifs.
Confirmation que les mises à jour ont bien été installées.
Correction des conditions courantes pouvant entraîner l’échec des correctifs.
Nouvelle tentative des actions échouées dans les limites définies.
Collecte d’informations de diagnostic.
Faire remonter les problèmes non résolus aux techniciens.
L’utilisation de scripts pour des contrôles ciblés de préparation, de validation et de gestion des exceptions permet de garder des politiques de correctifs centrées sur le déploiement de routine.
Comment les MSPs peuvent-ils utiliser des scripts avant le déploiement des correctifs ?
Une fois cela établi, nous pouvons examiner comment les MSPs peuvent utiliser des scripts pour améliorer la gestion et le déploiement des correctifs. Les scripts de pré-déploiement sont très utiles pour aider les MSPs à identifier les conditions pouvant affecter le déploiement des correctifs et à y remédier, notamment :
1. Vérifier l’espace disque disponible
Parfois, la seule chose qui empêche le déploiement d’un correctif est un manque d’espace. Les scripts peuvent comparer l’espace de stockage disponible à des seuils définis avant le déploiement du correctif pour vérifier qu’il y a suffisamment d’espace disque pour le correctif. Si l’espace disponible tombe en dessous du seuil, le terminal peut être exclu du déploiement, envoyé dans un workflow de nettoyage approuvé ou signalé pour examen par un technicien.
Gardez à l’esprit que le script ne doit pas supprimer des fichiers de manière indiscriminée pour libérer de l’espace. Sans supervision ni approbation appropriées, il existe toujours un risque qu’il supprime un élément vital.
2. Détecter les redémarrages en attente
Les endpoints peuvent rester dans un état d’attente de redémarrage après une mise à jour, l’installation d’une application ou une modification du système. Les scripts sont utiles pour identifier les endpoints qui doivent redémarrer après l’installation d’une mise à jour ou des modifications du système.
Les MSPs peuvent planifier une action de redémarrage pendant une fenêtre de maintenance approuvée ou exécuter un script qui lance le redémarrage dans des conditions définies. Ainsi, les mises à jour sont correctement installées sans interrompre les workflows habituels.
3. Vérifier les services requis
Les scripts sont également utiles pour confirmer que les services de mise à jour du système d’exploitation et les autres outils requis fonctionnent correctement. Par exemple, si un service est arrêté ou renvoie des messages d’erreur, les scripts peuvent tenter de redémarrer le service ou transmettre le problème à un technicien afin qu’il puisse être traité avant le déploiement de la mise à jour.
4. Confirmer les prérequis des correctifs
Les correctifs ont parfois des prérequis à respecter avant de pouvoir être installés, comme des versions spécifiques du système d’exploitation, des frameworks dépendants, des processus requis ou une connectivité vers des sources de mise à jour approuvées. Les scripts peuvent vérifier ces prérequis et renvoyer des résultats clairs, afin que les endpoints qui ne les remplissent pas puissent être traités ou exclus.
5. Fermer ou arrêter les applications en conflit
Il arrive que des applications ouvertes ou des processus en cours empêchent une mise à jour de se lancer ou de se terminer. Dans ce cas, les scripts peuvent détecter ces problèmes, avertir les utilisateurs ou les arrêter pendant une période de maintenance afin que la mise à jour puisse se terminer.
Gardez à l’esprit que les applications ne doivent pas être fermées sans laisser d’abord les utilisateurs enregistrer leur travail. Il y a peu de choses plus frustrantes que de perdre des heures de travail à cause d’un redémarrage inattendu.
Comment les MSPs peuvent-ils exécuter des scripts sur des groupes de terminaux clients ?
Si les MSPs veulent exécuter des scripts sur différents endpoints clients, ils ont besoin de contrôles centralisés capables d’exécuter des scripts sans nécessiter de connexions manuelles à chaque endpoint. Les scripts réutilisables peuvent être standardisés d’un client à l’autre tout en restant personnalisables selon les besoins de chacun, y compris les variables, les seuils, les calendriers et les exclusions.
Les scripts peuvent cibler divers groupes et besoins, notamment :
Client
Site ou emplacement
Système d'exploitation
Rôle de l’appareil
Service
Fenêtre de maintenance
En réalité, pouvoir exécuter des scripts personnalisés et ciblés est essentiel pour s’assurer que chaque client et appareil reçoit le support dont il a besoin. Si un script fonctionne sur des ordinateurs portables standard d’employés, rien ne garantit qu’il fonctionnera de la même manière sur des serveurs, des bornes ou d’autres appareils critiques pour l’activité ; un ciblage approprié des scripts est donc important.
Comment les scripts peuvent-ils vérifier que les correctifs ont bien été installés ?
Un aspect essentiel, mais souvent négligé, de la gestion des correctifs consiste à vérifier l’installation. Les commandes de déploiement automatisé peuvent lancer l’installation, mais ne vérifient pas que le terminal a bien atteint l’état de correctif prévu. Sans preuve d’installation appropriée, il est facile que des correctifs échouent sans être remarqués.
Avec les scripts d’automatisation, il est possible de vérifier l’installation des correctifs de plusieurs façons, notamment :
1. Confirmer l’état des correctifs du système d’exploitation
Avec des scripts, vous pouvez vérifier des détails clés, tels que les identifiants des mises à jour installées, l’historique des mises à jour, les numéros de build du système d’exploitation, la date de la dernière installation réussie et l’état du redémarrage. Il s’agit d’une vérification simple qui compare l’état actuel du terminal à l’état qu’il devrait avoir si le correctif est correctement installé, ce qui permet de vérifier facilement l’installation.
2. Vérifier les versions des applications
Les scripts peuvent également vérifier les logiciels installés après la mise à jour des applications afin de s’assurer qu’ils exécutent bien la dernière version. Cela aide les MSPs à identifier les installations qui ont pu être signalées comme réussies mais qui n’ont pas été mises à jour vers la version attendue, afin qu’ils puissent les vérifier et finaliser la mise à jour.
3. Renvoyer des résultats structurés
Les scripts peuvent vérifier l’état des correctifs et fournir une sortie standardisée, telle que « réussi », « redémarrage requis », « vérification manuelle requise » ou un échec accompagné de sa raison. C’est un moyen rapide et clair de vérifier les correctifs, car cela inclut l’appareil, l’horodatage et des messages d’erreur concis, ce qui permet de les traiter rapidement.
4. Revérifier après le redémarrage
De nombreux correctifs ne peuvent pas être entièrement validés tant que le terminal n’a pas redémarré. Dans ces cas, après le redémarrage du terminal, les MSPs peuvent exécuter ou planifier un script de validation pour confirmer la build finale du système d’exploitation ou la version de l’application, et signaler les erreurs restantes.
Comment les scripts peuvent-ils corriger les échecs courants des correctifs ?
Si un correctif échoue, les scripts peuvent également y remédier et tenter de réinstaller correctement le correctif. Cela fonctionne mieux pour des situations prévisibles et à faible risque, mais les scripts peuvent aussi signaler aux techniciens les échecs inhabituels ou à fort impact, afin qu’ils puissent enquêter manuellement si nécessaire.
1. Redémarrer les services de mise à jour en échec
Si un service doit être redémarré pour qu’une mise à jour se termine, les scripts d’automatisation peuvent s’en charger. Les scripts peuvent être configurés pour vérifier l’état des services liés aux mises à jour et les redémarrer lorsqu’il est possible de le faire en toute sécurité, permettant ainsi à l’installation de se poursuivre lorsqu’un service arrêté est à l’origine de l’échec. S’il y a des défaillances répétées du service, elles doivent être consignées et remontées, donc les scripts doivent également inclure un nombre maximal de redémarrages avant escalade.
2. Corriger les conditions temporaires de mise à jour
Les scripts d’automatisation peuvent inclure des actions de remédiation approuvées en cas d’échec des mises à jour, comme la réinitialisation de composants de mise à jour bloqués, l’effacement des données temporaires de mise à jour ou la réparation de prérequis connus. Cela peut aider à automatiser le dépannage et les nouvelles tentatives de mise à jour. Les scripts de remédiation doivent avoir une portée limitée, être testés, approuvés et restreints à des conditions connues. Les actions destructrices doivent nécessiter l’examen d’un technicien.
3. Réessayer les installations de correctifs ayant échoué
En cas d’échec d’une installation, les scripts peuvent être configurés pour la relancer une fois le problème résolu. Cela permet d’automatiser la réponse aux échecs prévisibles et de réduire le nombre de terminaux nécessitant l’intervention d’un technicien. Cependant, les nouvelles tentatives doivent être configurées avec un nombre maximal d’essais, des délais entre chaque tentative, et l’enregistrement des raisons de chaque échec, afin qu’elles puissent être transmises à des techniciens si nécessaire.
4. Déclencher les redémarrages requis
Lorsqu’une mise à jour nécessite un redémarrage avant d’être entièrement installée, des scripts peuvent planifier et lancer des redémarrages conformément aux politiques du client. Cela permet de garantir que les mises à jour sont correctement installées sans interrompre le travail quotidien, en planifiant les redémarrages pendant des fenêtres de maintenance prévues, avec des notifications utilisateur conviviales afin qu’aucun travail important ne soit perdu à cause d’un redémarrage.
5. Collecter les journaux pour examen par un technicien
Les scripts peuvent également être utilisés pour recueillir des informations, telles que des journaux, l’historique des mises à jour, des informations système et des codes d’échec. Ainsi, lorsque la mise à jour doit être transmise à un technicien, les informations dont il a besoin seront déjà prêtes. Cela réduit le temps que les techniciens consacrent à la collecte d’informations de diagnostic de base et améliore l’efficacité en leur fournissant tout ce dont ils ont besoin au même endroit.
Quand l’automatisation des correctifs doit-elle s’arrêter et être transmise à un technicien ?
Bien que l’automatisation des correctifs soit un outil précieux pour maintenir les terminaux à jour et sécurisés, il arrive que des techniciens doivent tout de même intervenir. Il existe de nombreuses situations dans lesquelles l’automatisation doit s’effacer et laisser intervenir un technicien, en particulier lorsque les problèmes nécessitent l’expertise et l’investigation d’un technicien.
Ces situations incluent :
Le même correctif échoue après le nombre de tentatives autorisé
Un service requis ne peut pas être restauré
Le terminal renvoie à plusieurs reprises des résultats incohérents
Une application essentielle à l’activité est affectée
Un serveur ou un appareil spécialisé nécessite une vérification
Un correctif provoque un comportement inattendu de l’application ou du système
Un script rencontre une erreur inconnue
L’endpoint ne correspond pas à la configuration approuvée
La remédiation nécessiterait des modifications destructrices ou à haut risque
Dans toutes ces situations, les équipes IT doivent être alertées afin de pouvoir intervenir. Veillez à ce que les alertes incluent le client, le terminal, la version du script, le correctif, les actions tentées, les résultats et les prochaines étapes recommandées afin d’aider les techniciens à diagnostiquer et résoudre efficacement le problème.
Rappelez-vous : l’objectif de l’automatisation est de réduire le travail répétitif, pas de masquer les problèmes non résolus. Si un problème survient que les scripts ne peuvent pas résoudre, les équipes IT doivent être prêtes à le gérer.
Comment les MSPs doivent-ils standardiser les scripts d’automatisation des correctifs en toute sécurité ?
Les scripts d’automatisation des correctifs sont des outils puissants et flexibles, à la fois pour le déploiement des correctifs et le dépannage. Cependant, ils doivent tout de même être conçus correctement. Voici quelques étapes importantes à suivre lors de la création de vos scripts d’automatisation des correctifs :
Définissez un seul objectif par script : Il n’y a aucune raison d’utiliser un seul script pour tout. Les tâches telles que les vérifications de préparation, la remédiation, la validation et le reporting doivent être séparées partout où c’est possible et pratique.
Tester dans un environnement contrôlé : il est important de tester les scripts et de s’assurer qu’ils fonctionnent comme prévu avant de les déployer sur l’ensemble des appareils. Veillez à valider les scripts sur un groupe représentatif d’appareils avant de les utiliser sur les terminaux de production.
Utilisez des groupes pilotes d’endpoints : Lorsque vous déployez vos scripts, vous ne voulez pas les déployer sur tous les appareils en même temps. Commencez par un groupe de déploiement limité avant d’étendre le déploiement à l’ensemble de l’environnement client, afin que tout problème imprévu puisse être détecté et traité rapidement.
Maintenez le contrôle des versions : il est important de garder le contrôle de vos scripts et de toutes les modifications qui leur sont apportées. Veillez à consigner, pour chaque script, les modifications, les responsables, les dates d’approbation et les versions de restauration.
Utilisez des entrées et des variables claires : Les scripts doivent être simples et faciles à modifier pour des clients spécifiques. Conservez les paramètres, seuils et fenêtres de maintenance propres au client séparés de la logique principale du script, afin qu’ils puissent être ajustés selon les besoins.
Protégez les identifiants et les données sensibles : Il est important d’assurer la sécurité des données sensibles partout, y compris dans les scripts. N’intégrez jamais de mots de passe en texte brut, de jetons d’accès ou d’informations client sensibles dans les scripts, car cela risque d’exposer les données.
Définissez des délais d’expiration et des limites de tentatives : bien que les scripts puissent réessayer les mises à jour ayant échoué, vous ne voulez pas qu’ils restent bloqués dans une boucle infinie. Assurez-vous de définir des limites pour empêcher les scripts de s’exécuter indéfiniment ou de créer des boucles de remédiation répétées.
Capturer les journaux et les codes de sortie : Chaque exécution doit être traçable et compréhensible. Cela contribue à améliorer la supervision et la responsabilité tout en fournissant des enregistrements clairs si quelque chose doit être examiné ou annulé.
Contrôler les autorisations des scripts : veillez à limiter les personnes pouvant créer, modifier, approuver et exécuter des scripts afin d’éviter tout accès non autorisé ou tout script non approuvé.
Vérifiez régulièrement la bibliothèque de scripts : Les scripts doivent souvent être vérifiés, mis à jour ou supprimés lorsqu’ils ne fonctionnent plus comme prévu. Veillez à passer en revue votre bibliothèque, à retirer les scripts obsolètes et à mettre à jour les workflows lorsque les systèmes d’exploitation, les applications ou les exigences des clients changent.
Comment les MSPs peuvent-ils mesurer l’efficacité du patching assisté par script ?
Les MSPs doivent mesurer si les scripts améliorent le taux d’achèvement des correctifs, réduisent les échecs répétés et limitent les interventions inutiles des techniciens. Vous pouvez mesurer l’efficacité de l’application de correctifs assistée par script à travers des résultats opérationnels qui indiquent la réussite et l’efficacité, plutôt que par le simple nombre de scripts exécutés.
Veillez à suivre ces indicateurs :
Taux de réussite des correctifs
Taux d’installation dès la première tentative
Le pourcentage d’échecs corrigés automatiquement
Le nombre d’endpoints nécessitant l’intervention d’un technicien
Temps moyen de résolution des correctifs en échec
Terminaux en attente d’un redémarrage
Appareils qui manquent régulièrement les fenêtres de maintenance
Taux d’échec et d’expiration des scripts
Achèvement des correctifs par client ou groupe de terminaux
Délai entre l’approbation du correctif et son installation vérifiée
Erreurs courantes que les MSPs doivent éviter avec les scripts d’automatisation des correctifs
L’écriture de scripts peut être un processus complexe, il existe donc plusieurs erreurs que les MSPs commettent fréquemment lors de la création et de l’utilisation de scripts d’automatisation. Veillez à repérer ces erreurs pour garantir que vos scripts s’exécutent comme prévu.
Les erreurs courantes incluent :
Utiliser des scripts à la place de politiques de gestion des correctifs centralisées, au lieu d’en faire un outil complémentaire pour les renforcer et les prendre en charge.
Exécuter des scripts non testés chez tous les clients, au lieu de tester les scripts et de les adapter à chaque client.
Appliquer le même script à tous les types de terminaux, ce qui peut entraîner l’exécution de scripts sur des appareils ou des systèmes d’exploitation incompatibles.
Autoriser un nombre illimité de nouvelles tentatives, ce qui peut enfermer les scripts dans des boucles infinies d’échecs et de nouvelles tentatives sans remédiation.
Considérer l’exécution d’un script comme une preuve de réussite du correctif, au lieu de vérifier l’installation.
Ne pas tenir compte des appareils hors ligne, ce qui peut entraîner l’absence de mises à jour clés sur certains appareils.
Intégrer des identifiants dans les scripts, ce qui crée des risques de cybersécurité.
Supprimer les erreurs au lieu de les faire remonter.
Effectuer des modifications à haut risque sans approbation.
Le fait de ne pas documenter la propriété des scripts et leurs modifications réduit la responsabilité et le contrôle.
Créer une vaste bibliothèque de scripts avec des fonctions qui se chevauchent, ce qui peut devenir lourd et redondant.
Ignorer les calendriers et les exigences de redémarrage propres aux clients.
Comment Splashtop AEM prend en charge le déploiement de correctifs assisté par script
Les scripts et le déploiement des correctifs n’ont pas à être compliqués, encore moins insurmontables. Avec Splashtop AEM (Autonomous Endpoint Management), les MSPs peuvent gérer le déploiement des correctifs, exécuter des scripts sur des groupes de terminaux gérés, vérifier l’état des terminaux et traiter à distance les exceptions depuis la console Splashtop.
Avec Splashtop AEM, vous pouvez :
1. Automatiser les correctifs du système d’exploitation et des applications tierces
Splashtop AEM permet aux MSPs d’automatiser les correctifs. Ils peuvent ainsi définir des politiques pour automatiser les mises à jour de routine sur les appareils gérés, y compris les systèmes d’exploitation et les applications tierces. Ces politiques constituent la base du processus de correction, tandis que les scripts peuvent gérer les exceptions et effectuer des vérifications supplémentaires afin d’améliorer encore la gestion des correctifs.
2. Exécutez des scripts sur plusieurs terminaux
Splashtop AEM permet aux MSPs de planifier et d’exécuter des scripts sur des groupes de terminaux sélectionnés. Cela prend en charge plusieurs appareils à la fois, au lieu d’exiger que chacun soit connecté individuellement, ce qui permet de gagner du temps et d’améliorer l’efficacité. Les scripts peuvent également s’exécuter en arrière-plan, ce qui permet d’effectuer la maintenance de routine sans interrompre les utilisateurs.
3. Examiner l’exécution et les résultats des correctifs
En centralisant les informations sur l’état des appareils et des correctifs en un seul endroit, Splashtop AEM aide les techniciens à identifier quels correctifs ont été installés avec succès, où les échecs se sont produits et quels appareils nécessitent une attention particulière. Cela contribue à garantir une application correcte des correctifs sur l’ensemble des endpoints, car les MSPs peuvent vérifier les résultats et savoir quand ils doivent corriger les échecs.
4. Résoudre à distance les exceptions restantes
Si les terminaux nécessitent une attention supplémentaire, les techniciens MSP peuvent utiliser les capacités de support à distance de Splashtop pour accéder aux appareils à distance et les dépanner.
Améliorez le déploiement des correctifs sans créer davantage de travail manuel
Les scripts d’automatisation sont des outils puissants pour améliorer le déploiement des correctifs, mais ils doivent être utilisés correctement. Les scripts sont plus efficaces lorsqu’ils sont utilisés pour des rôles précis dans un flux de correctifs contrôlé, comme vérifier l’état de préparation, valider les résultats et corriger les problèmes de base.
Les scripts jouent un rôle clé dans le déploiement des correctifs, en complément de l’automatisation des correctifs et des politiques, pour maintenir les endpoints à jour. Lorsque les MSPs établissent des règles claires de nouvelle tentative et d’escalade, maintiennent des contrôles spécifiques à chaque client et transmettent les problèmes non résolus aux techniciens, le déploiement des correctifs devient plus cohérent, traçable et gérable.
Avec Splashtop AEM, l’automatisation des correctifs est encore plus efficace. Les MSPs peuvent utiliser Splashtop AEM pour configurer des politiques de correctifs, planifier ou exécuter des scripts sur des groupes d’endpoints gérés, surveiller les résultats de déploiement et traiter les exceptions.
Vous voulez voir comment Splashtop AEM peut automatiser le correctif, exécuter des scripts sur les terminaux et surveiller les résultats de performance ? Démarrer un essai gratuit aujourd’hui.
