Wanneer MSPs meerdere clientomgevingen beheren, kan het een uitdaging zijn om elk endpoint correct gepatcht te houden. Hoewel patchbeleid kan helpen om patchbeheer op te schalen en routinematige uitrol te automatiseren, kunnen obstakels zoals weinig schijfruimte, gestopte services of offline apparaten het proces ingewikkelder maken.
Automatiseringsscripts kunnen MSPs helpen veel van deze situaties te detecteren en aan te pakken voordat een uitrol mislukt. Met automatiseringsscripts kunnen MSPs het uitrollen van patches eenvoudiger beheren door endpoints voor te bereiden, resultaten te valideren, fouten te verhelpen en problemen indien nodig te escaleren. Dit vormt een aanvulling op patchbeleid en verbetert het patchmanagementproces, zodat updates correct worden uitgerold.
Laten we daarom eens kijken hoe automatiseringsscripts patchbeheer kunnen verbeteren en waar ze de meeste waarde bieden vóór, tijdens en na de uitrol.
Welke rol spelen automatiseringsscripts bij patchimplementatie?
Automatiseringsscripts verschillen van patchautomatiseringsbeleid, dat routinematige activiteiten regelt zoals goedkeuringen, planningen en herstartregels. Automatiseringsscripts pakken complexere kwesties aan, zoals endpointspecifieke controles, validatie, herstel en uitzonderingen die mogelijk buiten het normale patchbeleid vallen.
Scripts kunnen meerdere taken beheren, waaronder:
Controleren of een endpoint klaar is voor patchinstallatie.
Apparaten voorbereiden voordat patches worden uitgerold.
Bevestigen dat updates succesvol zijn geïnstalleerd.
Veelvoorkomende omstandigheden corrigeren die ervoor kunnen zorgen dat patches mislukken.
Mislukte acties binnen vastgestelde limieten opnieuw proberen.
Diagnostische informatie verzamelen.
Onopgeloste problemen escaleren naar technici.
Het gebruik van scripts voor gerichte gereedheidscontroles, validatie en afhandeling van uitzonderingen helpt patchbeleid gericht te houden op routinematige implementatie.
Hoe kunnen MSPs scripts gebruiken vóór patchuitrol?
Nu dat duidelijk is, kunnen we kijken hoe MSPs scripts kunnen gebruiken om patchbeheer en uitrol te verbeteren. Pre-deployment-scripts zijn ideaal om MSPs te helpen omstandigheden te identificeren die de uitrol van patches kunnen beïnvloeden en die aan te pakken, waaronder:
1. Controleer beschikbare schijfruimte
Soms is het enige wat de uitrol van een patch tegenhoudt een gebrek aan ruimte. Scripts kunnen vóór de uitrol van patches de beschikbare opslag vergelijken met gedefinieerde drempelwaarden om te controleren of er genoeg schijfruimte is voor de patch. Als de beschikbare ruimte onder de drempelwaarde komt, kan het endpoint worden uitgesloten van uitrol, door een goedgekeurde opschoningsworkflow worden geleid of worden gemarkeerd voor beoordeling door een technicus.
Houd er rekening mee dat het script niet lukraak bestanden moet verwijderen om ruimte vrij te maken. Zonder goed toezicht en goedkeuring bestaat altijd het risico dat het iets belangrijks verwijdert.
2. Detecteer openstaande herstarts
Endpoints kunnen na een update, applicatie-installatie of systeemwijziging in een status blijven waarin een herstart in behandeling is. Scripts zijn handig om endpoints te identificeren die opnieuw moeten worden opgestart na het installeren van een update of het aanbrengen van systeemwijzigingen.
MSPs kunnen tijdens een goedgekeurd onderhoudsvenster een herstartactie inplannen of een script uitvoeren dat onder gedefinieerde voorwaarden de herstart initieert. Zo worden de updates correct geïnstalleerd zonder reguliere workflows te onderbreken.
3. Controleer vereiste services
Scripts zijn ook nuttig om te bevestigen dat OS-updateservices en andere vereiste tools goed werken. Als bijvoorbeeld een service is gestopt of foutmeldingen retourneert, kunnen scripts proberen de service opnieuw te starten of het probleem escaleren naar een technicus, zodat het kan worden opgelost voordat de update wordt uitgerold.
4. Bevestig patchvereisten
Patches hebben soms vereisten waaraan moet worden voldaan voordat ze kunnen worden geïnstalleerd, zoals specifieke OS-versies, afhankelijke frameworks, vereiste processen of connectiviteit met goedgekeurde updatebronnen. Scripts kunnen deze vereisten controleren en duidelijke resultaten teruggeven, zodat endpoints die niet aan deze vereisten voldoen kunnen worden aangepakt of uitgesloten.
5. Sluit conflicterende applicaties af of stop ze
Soms kunnen open applicaties of actieve processen ervoor zorgen dat een update niet kan starten of voltooien. In deze gevallen kunnen scripts deze problemen detecteren, gebruikers waarschuwen of ze tijdens een onderhoudsperiode stoppen, zodat de update kan worden voltooid.
Houd er rekening mee dat applicaties niet mogen worden afgesloten zonder gebruikers eerst de kans te geven hun werk op te slaan. Er zijn maar weinig dingen frustrerender dan uren werk verliezen door een onverwachte herstart.
Hoe kunnen MSPs scripts uitvoeren voor groepen client-endpoints?
Als MSPs scripts willen uitvoeren op verschillende client-endpoints, hebben ze gecentraliseerde besturing nodig die scripts kan uitvoeren zonder dat er handmatige verbindingen met elk endpoint nodig zijn. Herbruikbare scripts kunnen worden gestandaardiseerd voor verschillende clients en toch worden aangepast aan individuele behoeften, waaronder variabelen, drempelwaarden, schema's en uitzonderingen.
Scripts kunnen worden gericht op verschillende groepen en behoeften, waaronder:
Client
Site of locatie
Besturingssysteem
Apparaatrol
Afdeling
Onderhoudsvenster
Sterker nog, de mogelijkheid om aangepaste, gerichte scripts uit te voeren is essentieel om ervoor te zorgen dat elke client en elk apparaat de ondersteuning krijgt die nodig is. Als een script werkt voor standaard laptops van medewerkers, is dat geen garantie dat het hetzelfde werkt op servers, kiosken of andere bedrijfskritische apparaten, dus goede scripttargeting is belangrijk.
Hoe kunnen scripts verifiëren dat patches succesvol zijn geïnstalleerd?
Een cruciaal maar vaak over het hoofd gezien aspect van patchbeheer is het verifiëren van de installatie. Geautomatiseerde implementatieopdrachten kunnen de installatie starten, maar verifiëren niet dat het endpoint de beoogde patchstatus heeft bereikt. Zonder goed bewijs van installatie is het makkelijk dat patches ongemerkt mislukken.
Met automatiseringsscripts kun je de patchinstallatie op verschillende manieren verifiëren, waaronder:
1. Bevestig de patchstatus van het besturingssysteem
Met scripts kun je belangrijke details controleren, zoals geïnstalleerde update-id's, updategeschiedenis, buildnummers van het besturingssysteem, de datum van de laatste succesvolle installatie en de herstartstatus. Dit is een eenvoudige controle die de huidige status van het endpoint vergelijkt met hoe die zou moeten zijn als de patch correct is geïnstalleerd, waardoor je de installatie eenvoudig kunt verifiëren.
2. Controleer applicatieversies
Scripts kunnen na het bijwerken van applicaties ook geïnstalleerde software controleren om te garanderen dat deze de nieuwste versie gebruikt. Dit helpt MSPs installaties te identificeren die mogelijk als succesvol zijn gemeld, maar niet zijn bijgewerkt naar de verwachte versie, zodat ze dit kunnen controleren en de update kunnen voltooien.
3. Gestructureerde resultaten retourneren
Scripts kunnen patchstatussen controleren en gestandaardiseerde output geven, zoals “succesvol”, “opnieuw opstarten vereist”, “handmatige controle vereist” of een mislukking met een bijgevoegde reden. Dit is een snelle en duidelijke manier om patches te verifiëren, omdat het apparaat, de tijdstempel en beknopte foutmeldingen bevat, zodat die snel kunnen worden aangepakt.
4. Opnieuw controleren na herstart
Veel patches kunnen pas volledig worden gevalideerd nadat het endpoint opnieuw is opgestart. In deze gevallen kunnen MSPs na het opnieuw opstarten van het endpoint een validatiescript uitvoeren of plannen om de uiteindelijke build van het besturingssysteem of de applicatieversie te bevestigen en eventuele resterende fouten te rapporteren.
Hoe kunnen scripts veelvoorkomende patchfouten verhelpen?
Als een patch mislukt, kan scripting dit ook aanpakken en proberen de patch opnieuw correct te installeren. Dit werkt het best bij voorspelbare omstandigheden met een laag risico, maar scripts kunnen ongebruikelijke of ingrijpende fouten ook doorsturen naar technici, zodat zij indien nodig handmatig onderzoek kunnen doen.
1. Opnieuw opstarten van mislukte updateservices
Als een service opnieuw moet worden gestart om een update te voltooien, kunnen automatiseringsscripts dat afhandelen. Scripts kunnen zo worden geconfigureerd dat ze de status van updategerelateerde services controleren en deze opnieuw starten wanneer dat veilig is, zodat de installatie kan doorgaan wanneer een gestopte service de oorzaak van de storing is. Als er herhaaldelijk storingen bij services optreden, moeten die worden gelogd en geëscaleerd, dus scripts moeten ook een maximumaantal herstarts bevatten voordat er wordt geëscaleerd.
2. Tijdelijke updatevoorwaarden herstellen
Automatiseringsscripts kunnen goedgekeurde herstelacties bevatten voor wanneer updates mislukken, zoals het resetten van vastgelopen updatecomponenten, het wissen van tijdelijke updategegevens of het herstellen van bekende vereisten. Dit kan helpen bij het automatiseren van probleemoplossing en het opnieuw proberen van updates. Herstelscripts moeten een beperkte scope hebben, getest, goedgekeurd en beperkt zijn tot bekende omstandigheden. Destructieve acties moeten door een technicus worden beoordeeld.
3. Mislukte patchinstallaties opnieuw proberen
Als een installatie mislukt, kunnen scripts zo worden geconfigureerd dat ze het opnieuw proberen nadat het probleem is opgelost. Dit kan de reactie op voorspelbare fouten automatiseren en het aantal endpoints dat tussenkomst van een technicus vereist, verminderen. Retries moeten echter worden geconfigureerd met een maximaal aantal pogingen, met vertragingen tussen de pogingen, en de redenen voor elke mislukking vastleggen, zodat ze indien nodig kunnen worden geëscaleerd naar technici.
4. Vereiste herstarts activeren
Wanneer een update een herstart vereist voordat deze volledig is geïnstalleerd, kunnen scripts herstarts plannen en initiëren in overeenstemming met het beleid van de klant. Dit helpt ervoor te zorgen dat updates correct worden geïnstalleerd zonder het dagelijkse werk te onderbreken, door herstarts te plannen tijdens geplande onderhoudsvensters, samen met gebruiksvriendelijke meldingen zodat er geen belangrijk werk verloren gaat door een herstart.
5. Logs verzamelen voor beoordeling door een technicus
Scripts kunnen ook worden gebruikt om informatie te verzamelen, zoals logs, updategeschiedenis, systeeminformatie en foutcodes. Als de update vervolgens moet worden geëscaleerd naar een technicus, staat de informatie die diegene nodig heeft al klaar. Hierdoor besteden technici minder tijd aan het verzamelen van basisdiagnostische informatie en verbetert de efficiëntie doordat alles wat ze nodig hebben op één plek beschikbaar is.
Wanneer moet patchautomatisering stoppen en escaleren naar een technicus?
Hoewel patchautomatisering een waardevol hulpmiddel is om endpoints up-to-date en veilig te houden, zijn er momenten waarop technici nog steeds moeten ingrijpen. Er zijn veel situaties waarin automatisering een stap terug moet doen en een technicus het moet overnemen, vooral wanneer problemen de expertise en het onderzoek van een technicus vereisen.
Deze situaties zijn onder andere:
Dezelfde patch mislukt na het toegestane aantal nieuwe pogingen
Een vereiste service kan niet worden hersteld
Het endpoint geeft herhaaldelijk inconsistente resultaten terug
Een bedrijfskritische applicatie wordt beïnvloed
Een server of gespecialiseerd apparaat vereist controle
Een patch veroorzaakt onverwacht gedrag van applicaties of het systeem
Een script stuit op een onbekende fout
Het endpoint valt buiten de goedgekeurde configuratie
Herstel zou destructieve of risicovolle wijzigingen vereisen
In elk van deze situaties moeten IT-teams worden gewaarschuwd, zodat ze kunnen ingrijpen. Zorg ervoor dat waarschuwingen de klant, het endpoint, de scriptversie, de patch, de ondernomen acties, de resultaten en aanbevolen volgende stappen bevatten, zodat technici het probleem efficiënt kunnen diagnosticeren en oplossen.
Onthoud: het doel van automatisering is om repetitief werk te verminderen, niet om onopgeloste problemen onder het tapijt te vegen. Als er een probleem ontstaat dat scripts niet kunnen oplossen, moeten IT-teams klaarstaan om het te beheren.
Hoe moeten MSPs scripts voor patchautomatisering veilig standaardiseren?
Scripts voor patchautomatisering zijn krachtige, flexibele tools voor zowel patchimplementatie als probleemoplossing. Ze moeten echter nog steeds goed worden ontworpen. Hier zijn enkele belangrijke stappen om te volgen bij het maken van je scripts voor patchautomatisering:
Definieer één doel per script: Er is geen reden om één script voor alles te gebruiken. Taken zoals gereedheidscontroles, herstel, validatie en rapportage moeten waar mogelijk en praktisch gescheiden blijven.
Test in een gecontroleerde omgeving: Het is belangrijk om scripts te testen en te controleren of ze werken zoals bedoeld voordat je ze op apparaten uitrolt. Zorg ervoor dat je scripts valideert op een representatieve groep apparaten voordat je ze gebruikt op productie-endpoints.
Gebruik pilot-endpointgroepen: Wanneer je scripts uitrolt, wil je ze niet in één keer naar elk apparaat implementeren. Begin met een beperkte implementatiegroep voordat je uitbreidt naar een clientomgeving, zodat onverwachte problemen vroegtijdig kunnen worden opgemerkt en aangepakt.
Behoud versiebeheer: Het is belangrijk om controle te houden over je scripts en alle wijzigingen die daarin worden aangebracht. Zorg ervoor dat je voor elk script wijzigingen, eigenaren, goedkeuringsdatums en rollbackversies vastlegt.
Gebruik duidelijke invoer en variabelen: Scripts moeten overzichtelijk zijn en eenvoudig aanpasbaar voor specifieke klanten. Houd klantspecifieke instellingen, drempelwaarden en onderhoudsvensters gescheiden van de hoofdlogica van het script, zodat ze indien nodig kunnen worden aangepast.
Bescherm inloggegevens en gevoelige data: Het is belangrijk om gevoelige data overal veilig te houden, ook in scripts. Neem nooit wachtwoorden in platte tekst, toegangstokens of gevoelige clientinformatie op in scripts, omdat dit het risico vergroot dat de data uitlekt.
Stel time-outs en herhaallimieten in: Hoewel scripts mislukte updates opnieuw kunnen proberen, wil je niet dat ze vastlopen in een oneindige lus. Zorg ervoor dat je limieten instelt om te voorkomen dat scripts onbeperkt blijven draaien of herhaalde herstel-lussen veroorzaken.
Leg logboeken en exitcodes vast: Elke uitvoering moet traceerbaar en begrijpelijk zijn. Dit helpt het toezicht en de verantwoordingsplicht te verbeteren en biedt tegelijk duidelijke registraties als iets moet worden onderzocht of ongedaan gemaakt.
Beheer scriptmachtigingen: Zorg ervoor dat je beperkt wie scripts kan maken, bewerken, goedkeuren en uitvoeren om ongeautoriseerde toegang of niet-goedgekeurde scripts te voorkomen.
Controleer de Script Library regelmatig: Scripts moeten vaak worden gecontroleerd, bijgewerkt of verwijderd wanneer ze niet langer naar behoren werken. Zorg ervoor dat je je bibliotheek controleert, verouderde scripts uitfaseert en workflows bijwerkt wanneer besturingssystemen, applicaties of klantvereisten veranderen.
Hoe kunnen MSPs de effectiviteit van patching met scriptondersteuning meten?
MSPs moeten meten of scripts de voltooiing van patches verbeteren, herhaalde fouten verminderen en onnodige tussenkomst van technici beperken. Je kunt de effectiviteit van patching met scriptondersteuning meten aan de hand van operationele resultaten die succes en efficiëntie aangeven, in plaats van alleen het aantal uitgevoerde scripts.
Zorg dat je deze statistieken bijhoudt:
Succespercentage van patches
Installatiepercentage bij de eerste poging
Het percentage mislukkingen dat automatisch wordt opgelost
Het aantal endpoints dat tussenkomst van een technicus vereist
Gemiddelde tijd om mislukte patches op te lossen
Endpoints die wachten op een herstart
Apparaten die herhaaldelijk onderhoudsvensters missen
Mislukkings- en time-outpercentages van scripts
Voltooiing van patches per client of endpointgroep
Tijd tussen patchgoedkeuring en geverifieerde installatie
Veelgemaakte fouten die MSPs moeten vermijden bij patchautomatiseringsscripts
Scripting kan een complex proces zijn, dus er zijn verschillende fouten die MSPs vaak kunnen maken bij het maken en gebruiken van automatiseringsscripts. Let goed op deze fouten om ervoor te zorgen dat je scripts werken zoals bedoeld.
Veelgemaakte fouten zijn:
Scripts gebruiken als vervanging van gecentraliseerd patchbeleid, in plaats van als hulpmiddel om dit aan te vullen en te ondersteunen.
Niet-geteste scripts uitvoeren bij elke klant, in plaats van scripts te testen en ze voor elke klant aan te passen.
Hetzelfde script toepassen op alle typen endpoints, wat ertoe kan leiden dat scripts worden uitgevoerd op incompatibele apparaten of besturingssystemen.
Onbeperkte nieuwe pogingen toestaan, waardoor scripts vast kunnen komen te zitten in oneindige lussen van mislukte pogingen en nieuwe pogingen zonder herstelmaatregelen.
Scriptuitvoering beschouwen als bewijs van patchsucces, in plaats van de installatie te verifiëren.
Geen rekening houden met offline apparaten, waardoor apparaten belangrijke updates kunnen missen.
Referenties in scripts insluiten, wat cybersecurityrisico's creëert.
Fouten onderdrukken in plaats van ze te escaleren.
Wijzigingen met een hoog risico aanbrengen zonder goedkeuring.
Het niet documenteren van scripteigenaarschap en wijzigingen, wat de verantwoordelijkheid en controle vermindert.
Een grote scriptbibliotheek maken met overlappende functies, wat omslachtig en dubbelop kan worden.
Het negeren van klantspecifieke schema's en rebootvereisten.
Hoe Splashtop AEM patchimplementatie met scripts ondersteunt
Scripting en patch-uitrol hoeven geen uitdaging te zijn, laat staan een onoverkomelijke. Met Splashtop AEM (Autonomous Endpoint Management) kunnen MSPs patch-uitrol beheren, scripts uitvoeren binnen beheerde endpointgroepen, de endpointstatus bekijken en uitzonderingen op afstand afhandelen vanuit de Splashtop-console.
Met Splashtop AEM kun je:
1. Patching van het besturingssysteem en toepassingen van derden automatiseren
Splashtop AEM geeft MSPs de kracht van patchautomatisering. Hiermee kunnen ze beleid instellen om routinematige updates op beheerde apparaten te automatiseren, waaronder besturingssystemen en applicaties van derden. Dit beleid vormt de basis van het patchproces, terwijl scripts uitzonderingen en extra controles kunnen ondersteunen om patchbeheer verder te verbeteren.
2. Scripts uitvoeren op meerdere endpoints
Splashtop AEM stelt MSPs in staat om scripts te plannen en uit te voeren voor geselecteerde endpointgroepen. Dit ondersteunt meerdere apparaten tegelijk, in plaats van dat elk apparaat afzonderlijk verbonden moet zijn, wat tijd bespaart en de efficiëntie verbetert. Scripts kunnen ook op de achtergrond worden uitgevoerd, zodat routineonderhoud mogelijk is zonder gebruikers te onderbreken.
3. Uitvoering en patchresultaten beoordelen
Door informatie over apparaat- en patchstatus op één plek te centraliseren, helpt Splashtop AEM technici te identificeren welke patches succesvol zijn geïnstalleerd, waar fouten zijn opgetreden en welke apparaten extra aandacht nodig hebben. Dit helpt te zorgen voor correcte patching op alle endpoints, omdat MSPs de resultaten kunnen verifiëren en kunnen zien wanneer ze storingen moeten aanpakken.
4. Los resterende uitzonderingen op afstand op
Als endpoints extra aandacht nodig hebben, kunnen MSP-technici de remote support-mogelijkheden van Splashtop gebruiken om apparaten op afstand te benaderen en problemen op te lossen.
Patch-uitrol verbeteren zonder meer handmatig werk te creëren
Automatiseringsscripts zijn krachtige hulpmiddelen om de uitrol van patches te verbeteren, maar ze moeten wel op de juiste manier worden gebruikt. Scripts zijn het meest effectief wanneer ze voor specifieke rollen binnen een gecontroleerde patchworkflow worden gebruikt, zoals het controleren van gereedheid, het valideren van resultaten en het oplossen van eenvoudige problemen.
Scripts spelen een belangrijke rol bij patchimplementatie en werken samen met patchautomatisering en beleid om endpoints up-to-date te houden. Wanneer MSPs duidelijke regels opstellen voor opnieuw proberen en escalatie, klantspecifieke controles handhaven en onopgeloste problemen doorsturen naar technici, wordt patchimplementatie consistenter, beter traceerbaar en beter beheersbaar.
Met Splashtop AEM is patchautomatisering nog efficiënter. MSPs kunnen Splashtop AEM gebruiken om patchbeleid te configureren, scripts te plannen of uit te voeren voor groepen beheerde endpoints, implementatieresultaten te monitoren en uitzonderingen aan te pakken.
Wil je zien hoe Splashtop AEM patching kan automatiseren, scripts op endpoints kan uitvoeren en prestatieresultaten kan monitoren? Begin vandaag nog met een gratis proefperiode.
