Quando os MSPs gerem vários ambientes de clientes, manter cada endpoint corretamente atualizado com patches pode ser um desafio. Embora as políticas de patching possam ajudar a dimensionar a gestão de patches e automatizar implementações de rotina, obstáculos como pouco espaço em disco, serviços interrompidos ou dispositivos offline podem complicar o processo.
Os scripts de automação podem ajudar os MSPs a detetar e resolver muitas destas situações antes de causarem a falha de uma implementação. Com scripts de automação, os MSPs podem gerir a implementação de patches com mais facilidade, preparando endpoints, validando resultados, corrigindo falhas e escalando problemas quando necessário. Isto complementa as políticas de patches e melhora o processo de gestão de patches, ajudando a garantir que as atualizações são implementadas corretamente.
Tendo isso em conta, vejamos como os scripts de automação podem melhorar a gestão de patches e onde oferecem mais valor antes, durante e após a implementação.
Que papel desempenham os scripts de automatização na implementação de patches?
Os scripts de automação diferem das políticas de automação de patches, que regem atividades de rotina como aprovações, agendamentos e regras de reinício. Os scripts de automação tratam de questões mais complexas, como verificações específicas de endpoints, validação, remediação e exceções que podem ficar fora das políticas normais de aplicação de patches.
Os scripts podem gerir várias tarefas, incluindo:
A verificar se um endpoint está pronto para a instalação de patches.
Preparar dispositivos antes de as correções serem implementadas.
Confirmar que as atualizações foram instaladas com sucesso.
Corrigir condições comuns que podem fazer com que os patches falhem.
Tentar novamente ações com falha dentro dos limites definidos.
Recolher informações de diagnóstico.
Encaminhar problemas não resolvidos para técnicos.
A utilização de scripts para verificações de prontidão direcionadas, validação e tratamento de exceções ajuda a manter as políticas de patching focadas na implementação de rotina.
Como podem os MSPs usar scripts antes da implementação de patches?
Com isso estabelecido, podemos analisar como os MSPs podem usar scripts para melhorar a gestão e a implementação de patches. Os scripts de pré-implementação são excelentes para ajudar os MSPs a identificar condições que podem afetar a implementação de patches e resolvê-las, incluindo:
1. Verificar o espaço disponível em disco
Por vezes, a única coisa que impede a implementação de um patch é a falta de espaço. Os scripts podem comparar o armazenamento disponível com limites definidos antes da implementação do patch para verificar se existe espaço em disco suficiente para o patch. Se o espaço disponível ficar abaixo do limite definido, o endpoint pode ser excluído da implementação, encaminhado para um fluxo de limpeza aprovado ou assinalado para revisão por um técnico.
Tenha em conta que o script não deve eliminar ficheiros indiscriminadamente para libertar espaço. Sem supervisão e aprovação adequadas, existe sempre o risco de eliminar algo vital.
2. Detetar reinícios pendentes
Os endpoints podem permanecer num estado de reinício pendente após uma atualização, instalação de aplicação ou alteração do sistema. Os scripts são úteis para identificar endpoints que precisam de reiniciar após instalar uma atualização ou fazer alterações no sistema.
Os MSPs podem agendar uma ação de reinício durante uma janela de manutenção aprovada ou executar um script que inicia o reinício sob condições definidas. Desta forma, as atualizações são instaladas corretamente sem interromper os fluxos de trabalho regulares.
3. Verifique os serviços necessários
Os scripts também são úteis para confirmar que os serviços de atualização do SO e outras ferramentas necessárias estão a funcionar corretamente. Por exemplo, se um serviço estiver parado ou devolver mensagens de erro, os scripts podem tentar reiniciá-lo ou encaminhar o problema para um técnico, para que possa ser resolvido antes da implementação da atualização.
4. Confirmar pré-requisitos do patch
Por vezes, as correções têm pré-requisitos que precisam de ser cumpridos antes de poderem ser instaladas, como versões específicas do SO, frameworks dependentes, processos necessários ou conectividade a fontes de atualização aprovadas. Os scripts podem verificar estes pré-requisitos e devolver resultados claros, para que os endpoints que não os cumpram possam ser tratados ou excluídos.
5. Feche ou pare aplicações em conflito
Por vezes, aplicações abertas ou processos em execução podem impedir que uma atualização seja iniciada ou concluída. Nestes casos, os scripts podem detetar estes problemas, notificar os utilizadores ou pará-los durante um período de manutenção para que a atualização possa ser concluída.
Tenha em atenção que as aplicações não devem ser fechadas sem primeiro permitir que os utilizadores guardem o seu trabalho. Há poucas coisas mais frustrantes do que perder horas de trabalho devido a um reinício inesperado.
Como podem os MSPs executar scripts em grupos de endpoints de clientes?
Se os MSPs quiserem executar scripts em vários endpoints de clientes, precisam de controlos centralizados que possam executar scripts sem exigir ligações manuais a cada endpoint. Os scripts reutilizáveis podem ser padronizados entre clientes e, ainda assim, personalizados para necessidades individuais, incluindo variáveis, limiares, agendamentos e exclusões.
Os scripts podem ser direcionados para vários grupos e necessidades, incluindo:
Cliente
Site ou localização
Sistema operativo
Função do dispositivo
Departamento
Janela de manutenção
Na verdade, a capacidade de executar scripts personalizados e direcionados é essencial para garantir que cada cliente e dispositivo recebe o suporte de que precisa. Se um script funciona em portáteis padrão de colaboradores, isso não garante que funcione da mesma forma em servidores, quiosques ou outros dispositivos essenciais para a empresa, por isso é importante direcionar corretamente os scripts.
Como podem os scripts verificar que os patches foram instalados com sucesso?
Um aspeto vital, mas muitas vezes negligenciado, da gestão de patches é verificar a instalação. Os comandos de implementação automatizada podem iniciar a instalação, mas não verificam se o endpoint atingiu o estado de patch pretendido. Sem uma prova adequada da instalação, é fácil que as falhas dos patches passem despercebidas.
Com scripts de automação, é possível verificar a instalação de patches de várias formas, incluindo:
1. Confirmar o estado do patch do sistema operativo
Com scripts, é possível verificar detalhes importantes, como identificadores de atualizações instaladas, histórico de atualizações, números de compilação do sistema operativo, a data da última instalação bem-sucedida e o estado de reinício. Esta é uma verificação simples que compara o estado atual do endpoint com o estado que deveria ter se o patch estiver corretamente instalado, facilitando a verificação da instalação.
2. Verificar versões da aplicação
Os scripts também podem verificar o software instalado depois de as aplicações serem atualizadas para garantir que estão a executar a versão mais recente. Isto ajuda os MSPs a identificar instalações que possam ter sido indicadas como bem-sucedidas, mas que não foram atualizadas para a versão esperada, para que possam verificar e concluir a atualização.
3. Devolver resultados estruturados
Os scripts podem verificar o estado dos patches e fornecer resultados padronizados, como “bem-sucedido”, “reinício necessário”, “revisão manual necessária” ou falha com um motivo anexado. Esta é uma forma rápida e clara de verificar patches, pois inclui o dispositivo, o carimbo temporal e mensagens de erro concisas, permitindo que sejam resolvidos prontamente.
4. Verificar novamente após o reinício
Muitos patches não podem ser totalmente validados até que o endpoint reinicie. Nestes casos, após o endpoint reiniciar, os MSPs podem executar ou agendar um script de validação para confirmar a versão final do sistema operativo ou da aplicação e comunicar quaisquer erros restantes.
Como podem os scripts corrigir falhas comuns de patches?
Se um patch falhar, o scripting também pode tratar o problema e tentar reinstalar o patch corretamente. Isto funciona melhor em condições previsíveis e de baixo risco, mas os scripts também podem encaminhar falhas invulgares ou de grande impacto para técnicos, para que possam investigá-las manualmente quando necessário.
1. Reiniciar serviços de atualização com falha
Se for necessário reiniciar um serviço para concluir uma atualização, os scripts de automação podem tratar disso. Os scripts podem ser configurados para verificar o estado dos serviços relacionados com atualizações e reiniciá-los quando for seguro fazê-lo, permitindo que a instalação continue quando a causa da falha é um serviço parado. Se houver falhas repetidas do serviço, estas devem ser registadas e escaladas, por isso os scripts também devem incluir um número máximo de reinícios antes da escalada.
2. Reparar condições temporárias de atualização
Os scripts de automação podem incluir ações de remediação aprovadas para quando as atualizações falham, como repor componentes de atualização bloqueados, limpar dados temporários de atualização ou reparar pré-requisitos conhecidos. Isto pode ajudar a automatizar a resolução de problemas e as novas tentativas de atualização. Os scripts de remediação devem ter um âmbito restrito, ser testados, aprovados e limitados a condições conhecidas. As ações destrutivas devem exigir revisão por um técnico.
3. Repetir instalações de patches com falha
Se uma instalação falhar, os scripts podem ser configurados para voltar a tentá-la depois de o problema ser resolvido. Isto pode automatizar a resposta a falhas previsíveis e reduzir o número de endpoints que exigem intervenção de técnicos. No entanto, as novas tentativas devem ser configuradas com um número máximo de tentativas, com intervalos entre cada uma, e registar os motivos de cada falha, para que possam ser encaminhadas para técnicos, se necessário.
4. Acionar os reinícios necessários
Quando uma atualização requer um reinício antes de ficar totalmente instalada, os scripts podem agendar e iniciar reinícios de acordo com as políticas do cliente. Isto ajuda a garantir que as atualizações são instaladas corretamente sem interromper o trabalho diário, ao agendar reinícios durante janelas de manutenção planeadas, juntamente com notificações amigáveis ao utilizador para garantir que nenhum trabalho importante se perde devido a um reinício.
5. Recolher registos para análise do técnico
Os scripts também podem ser utilizados para recolher informações, como registos, histórico de atualizações, informações do sistema e códigos de falha. Depois, quando a atualização precisar de ser escalada para um técnico, a informação de que ele precisa já estará pronta. Isto reduz o tempo que os técnicos gastam a recolher informações básicas de diagnóstico e melhora a eficiência ao fornecer tudo o que precisam num só lugar.
Quando é que a automação de patches deve parar e escalar para um técnico?
Embora a automação de patches seja uma ferramenta valiosa para manter os endpoints atualizados e seguros, há momentos em que os técnicos ainda precisam de intervir. Há muitas circunstâncias em que a automação deve dar lugar à intervenção de um técnico, especialmente quando os problemas exigem a sua experiência e investigação.
Estas situações incluem:
O mesmo patch falha após o número permitido de tentativas
Não é possível restaurar um serviço necessário
O endpoint devolve repetidamente resultados inconsistentes
Uma aplicação crítica para o negócio é afetada
Um servidor ou dispositivo especializado requer análise
Um patch causa um comportamento inesperado na aplicação ou no sistema
Um script encontra um erro desconhecido
O endpoint está fora da configuração aprovada
A remediação exigiria alterações destrutivas ou de alto risco
Em qualquer uma destas situações, as equipas de TI devem ser alertadas para poderem intervir. Certifique-se de que os alertas incluem o cliente, o endpoint, a versão do script, o patch, as ações tentadas, os resultados e os próximos passos recomendados, para ajudar os técnicos a diagnosticar e resolver o problema com eficiência.
Lembre-se: o objetivo da automatização é reduzir o trabalho repetitivo, não esconder problemas por resolver. Se surgir um problema que os scripts não consigam resolver, as equipas de TI devem estar preparadas para geri-lo.
Como devem os MSPs padronizar scripts de automação de patches com segurança?
Os scripts de automatização de patches são ferramentas poderosas e flexíveis, tanto para a implementação de patches como para a resolução de problemas. No entanto, continuam a ter de ser concebidos corretamente. Eis alguns passos importantes a seguir ao criar os seus scripts de automatização de patches:
Defina um objetivo por script: Não há razão para usar um único script para tudo. Tarefas como verificações de prontidão, remediação, validação e relatórios devem ser separadas sempre que possível e prático.
Teste num ambiente controlado: É importante testar os scripts e garantir que funcionam como previsto antes de os implementar em todos os dispositivos. Valide os scripts num grupo representativo de dispositivos antes de os utilizar nos endpoints de produção.
Use grupos de endpoints piloto: Ao implementar os seus scripts, não convém implantá-los em todos os dispositivos ao mesmo tempo. Comece com um grupo de implementação limitado antes de expandir por todo o ambiente do cliente, para que quaisquer problemas inesperados possam ser detetados e resolvidos antecipadamente.
Manter o controlo de versões: É importante manter o controlo sobre os seus scripts e quaisquer alterações feitas aos mesmos. Registe as alterações aos scripts, os responsáveis, as datas de aprovação e as versões de reversão de cada script.
Use entradas e variáveis claras: Os scripts devem ser diretos e fáceis de modificar para clientes específicos. Mantenha as definições, os limites e as janelas de manutenção específicos de cada cliente separados da lógica principal do script, para que possam ser ajustados conforme necessário.
Proteger credenciais e dados sensíveis: Manter os dados sensíveis seguros em todo o lado é importante, incluindo nos scripts. Nunca incorpore palavras-passe em texto simples, tokens de acesso ou informações sensíveis de clientes em scripts, pois isso cria o risco de fuga de dados.
Defina tempos limite e limites de tentativas: Embora os scripts possam voltar a tentar atualizações falhadas, não convém que fiquem presos num ciclo infinito. Certifique-se de que define limites para evitar que os scripts sejam executados indefinidamente ou criem ciclos repetidos de remediação.
Capturar registos e códigos de saída: Cada execução deve ser rastreável e compreensível. Isto ajuda a melhorar a supervisão e a responsabilização, ao mesmo tempo que fornece registos claros caso seja necessário investigar ou reverter algo.
Controlar permissões de scripts: Limite quem pode criar, editar, aprovar e executar scripts para evitar acessos não autorizados ou scripts não aprovados.
Reveja regularmente a biblioteca de scripts: Os scripts muitas vezes precisam de ser revistos, atualizados ou removidos quando já não funcionam como pretendido. Certifique-se de rever a sua biblioteca, retirar scripts obsoletos e atualizar fluxos de trabalho quando os sistemas operativos, as aplicações ou os requisitos dos clientes mudarem.
Como podem os MSPs medir a eficácia da aplicação de patches com assistência de scripts?
Os MSPs devem avaliar se os scripts estão a melhorar a conclusão dos patches, a reduzir falhas repetidas e a limitar intervenções desnecessárias dos técnicos. É possível medir a eficácia do patching assistido por scripts através de resultados operacionais que indiquem sucesso e eficiência, em vez de apenas pelo número de scripts executados.
Acompanhe estas métricas:
Taxa de sucesso de patches
Taxa de instalação na primeira tentativa
A percentagem de falhas corrigidas automaticamente
O número de endpoints que requerem intervenção de um técnico
Tempo médio para resolver patches com falha
Endpoints à espera de reinício
Dispositivos que falham repetidamente as janelas de manutenção
Taxas de falha e de timeout dos scripts
Conclusão dos patches por cliente ou grupo de endpoints
Tempo entre a aprovação da correção e a instalação verificada
Erros comuns que os MSPs devem evitar com scripts de automação de patches
O scripting pode ser um processo complicado, por isso há vários erros que os MSPs podem cometer com frequência ao criar e utilizar scripts de automação. Esteja atento a estes erros para garantir que os seus scripts funcionam como previsto.
Os erros comuns incluem:
Usar scripts como substituição de políticas centralizadas de patches, em vez de uma ferramenta para as complementar e apoiar.
Executar scripts não testados em todos os clientes, em vez de testar os scripts e ajustá-los para cada cliente.
Aplicar o mesmo script a todos os tipos de endpoints, o que pode fazer com que os scripts sejam executados em dispositivos ou sistemas operativos incompatíveis.
Permitir tentativas ilimitadas, o que pode prender os scripts em ciclos infinitos de falhas e novas tentativas sem remediação.
Tratar a execução do script como prova de que o patch foi aplicado com sucesso, em vez de verificar a instalação.
Não ter em conta os dispositivos offline, o que pode fazer com que os dispositivos não recebam atualizações essenciais.
Incorporar credenciais em scripts, o que cria riscos de cibersegurança.
Suprimir erros em vez de os escalar.
Fazer alterações de alto risco sem aprovação.
Não documentar a responsabilidade pelos scripts e as alterações, o que reduz a responsabilização e o controlo.
Criar uma grande biblioteca de scripts com funções sobrepostas, que pode tornar-se difícil de gerir e redundante.
Ignorar os agendamentos e requisitos de reinício específicos de cada cliente.
Como o Splashtop AEM suporta a implementação de patches assistida por scripts
Os scripts e a implementação de patches não precisam de ser um desafio, muito menos algo intransponível. Com o Splashtop AEM (Autonomous Endpoint Management), os MSPs podem gerir a implementação de patches, executar scripts em grupos de endpoints geridos, rever o estado dos endpoints e resolver remotamente exceções a partir da consola Splashtop.
Com Splashtop AEM, pode:
1. Automatizar a aplicação de patches do sistema operativo e de terceiros
O Splashtop AEM dá aos MSPs recursos de automatização de patches. Com ele, podem definir políticas para automatizar atualizações de rotina em dispositivos geridos, incluindo sistemas operativos e aplicações de terceiros. Estas políticas formam a base do processo de aplicação de patches, enquanto os scripts podem dar suporte a exceções e verificações adicionais para melhorar ainda mais a gestão de patches.
2. Executar scripts em vários endpoints
O Splashtop AEM permite que os MSPs agendem e executem scripts em grupos de endpoints selecionados. Isto permite dar suporte a vários dispositivos em simultâneo, em vez de exigir que cada um seja ligado individualmente, poupando tempo e melhorando a eficiência. Os scripts também podem ser executados em segundo plano, permitindo manutenção de rotina sem interromper os utilizadores.
3. Rever a execução e os resultados dos patches
Ao centralizar num só local as informações sobre o estado dos dispositivos e dos patches, o Splashtop AEM ajuda os técnicos a identificar que patches foram instalados com sucesso, onde ocorreram falhas e que dispositivos precisam de atenção adicional. Isto ajuda a garantir a aplicação correta de patches em todos os endpoints, uma vez que os MSPs podem verificar os resultados e perceber quando é necessário resolver falhas.
4. Resolver remotamente as exceções restantes
Se os endpoints precisarem de atenção adicional, os técnicos dos MSPs podem usar as capacidades de suporte remoto da Splashtop para aceder remotamente aos dispositivos e resolver problemas.
Melhore a implementação de patches sem criar mais trabalho manual
Os scripts de automatização são ferramentas poderosas para melhorar a implementação de patches, mas têm de ser utilizados corretamente. Os scripts são mais eficazes quando são utilizados para funções específicas dentro de um fluxo de trabalho de aplicação de patches controlado, como verificar a prontidão, validar resultados e corrigir problemas básicos.
Os scripts desempenham um papel fundamental na implementação de patches, em conjunto com a automação de patches e as políticas, para manter os endpoints atualizados. Quando os MSPs estabelecem regras claras de nova tentativa e escalonamento, mantêm controlos específicos por cliente e encaminham problemas não resolvidos para técnicos, a implementação de patches torna-se mais consistente, rastreável e gerível.
Com Splashtop AEM, a automação de patches é ainda mais eficiente. Os MSPs podem usar o Splashtop AEM para configurar políticas de patches, agendar ou executar scripts em grupos de endpoints geridos, monitorizar os resultados da implementação e tratar exceções.
Quer ver como o Splashtop AEM pode automatizar a aplicação de patches, executar scripts em endpoints e monitorizar resultados de desempenho? Comece hoje com uma avaliação gratuita.
