Come automatizzare la verifica e l’avvio dei servizi Windows con PowerShell

Con Powershell, eseguire la verifica dello stato dei servizi Windows e a mantenere l’integrità dei servizi sulle macchine Windows è fondamentale per garantire il funzionamento regolare di qualsiasi ambiente IT. I servizi impostati per l’avvio automatico, ma che non vengono eseguiti, possono causare problemi di prestazioni, tempi di inattività della rete non pianificati e inefficienze operative.

È qui che gli script di PowerShell si rivelano utili, offrendo un modo efficace e automatizzato per gestire e monitorare i servizi Windows. In questo articolo esploreremo uno script PowerShell progettato per segnalare e avviare i servizi automatici che non sono attualmente in esecuzione, ad esclusione di quelli impostati come “Avvio ritardato” o “Avvio automatico”.

Background

Per i professionisti dell’IT e i fornitori di servizi gestiti (MSP), mantenere i servizi in funzione senza interruzioni è una priorità assoluta. A volte i servizi Windows non si avviano per vari motivi, come problemi di configurazione, conflitti o limitazioni delle risorse di sistema.

Questo script risponde alla necessità di un approccio sistematico per identificare e riavviare i servizi che dovrebbero essere in esecuzione ma non lo sono. Automatizzando questo processo, i team IT possono risparmiare tempo e ridurre il rischio di errori umani.

Lo script per la verifica dello status dei servizi Windows:

#Requires -Version 5.1

<#
.SYNOPSIS
    Reports on or starts services for Automatic Services that are not currently running. Services set as 'Delayed Start' or 'Trigger Start' are ignored.
.DESCRIPTION
    Reports on or starts services for Automatic Services that are not currently running. Services set as 'Delayed Start' or 'Trigger Start' are ignored.
.EXAMPLE
    (No Parameters)
    
    Matching Services found!

    Name    Description                                         
    ----    -----------                                         
    SysMain Maintains and improves system performance over time.

PARAMETER: -IgnoreServices "ExampleServiceName"
    A comma separated list of service names to ignore.

PARAMETER: -StartFoundServices
    Attempts to start any services found matching the criteria.

.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Initial Release
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).
#>

[CmdletBinding()]
param (
    [Parameter()]
    [String]$IgnoreServices,
    [Parameter()]
    [Switch]$StartFoundServices = [System.Convert]::ToBoolean($env:startFoundServices)
)

begin {
    # Replace script parameters with form variables
    if($env:servicesToExclude -and $env:servicesToExclude -notlike "null"){ $IgnoreServices = $env:servicesToExclude }

    # Get the last startup time of the operating system.
    $LastBootDateTime = Get-CimInstance -ClassName Win32_OperatingSystem | Select-Object -ExpandProperty LastBootUpTime
    if ($LastBootDateTime -gt $(Get-Date).AddMinutes(-15)) {
        $Uptime = New-TimeSpan $LastBootDateTime (Get-Date) | Select-Object -ExpandProperty TotalMinutes
        Write-Host "Current uptime is $([math]::Round($Uptime)) minutes."
        Write-Host "[Error] Please wait at least 15 minutes after startup before running this script."
        exit 1
    }

    # Define a function to test if the current user has elevated (administrator) privileges.
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    $ExitCode = 0
}
process {
    # Check if the script is running with Administrator privileges.
    if (!(Test-IsElevated)) {
        Write-Host -Object "[Error] Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # Define a string of characters that are invalid for service names.
    $InvalidServiceNameCharacters = "\\|/|:"
    # Create a list to hold the names of services to ignore.
    $ServicesToIgnore = New-Object System.Collections.Generic.List[string]

    # If there are services to ignore and they are separated by commas, split the string into individual service names.
    if ($IgnoreServices -and $IgnoreServices -match ",") {
        $IgnoreServices -split "," | ForEach-Object {
            # Check each service name for invalid characters or excessive length.
            if ($_.Trim() -match $InvalidServiceNameCharacters) {
                Write-Host "[Error] Service Name contains one of the invalid characters '\/:'. $_ is not a valid service to ignore."
                $ExitCode = 1
                return
            }

            if (($_.Trim()).Length -gt 256) {
                Write-Host "[Error] Service Name is greater than 256 characters. $_ is not a valid service to ignore. "
                $ExitCode = 1
                return
            }

            # Add valid services to the ignore list.
            $ServicesToIgnore.Add($_.Trim())
        }
    }
    elseif ($IgnoreServices) {
        # For a single service name, perform similar validation and add if valid.
        $ValidService = $True

        if ($IgnoreServices.Trim() -match $InvalidServiceNameCharacters) {
            Write-Host "[Error] Service Name contains one of the invalid characters '\/:'. '$IgnoreServices' is not a valid service to ignore. "
            $ExitCode = 1
            $ValidService = $False
        }

        if (($IgnoreServices.Trim()).Length -gt 256) {
            Write-Host "[Error] Service Name is greater than 256 characters. '$IgnoreServices' is not a valid service to ignore. "
            $ExitCode = 1
            $ValidService = $False
        }

        if ($ValidService) {
            $ServicesToIgnore.Add($IgnoreServices.Trim())
        }
    }

    # Create a list to hold non-running services that are set to start automatically.
    $NonRunningAutoServices = New-Object System.Collections.Generic.List[object]
    Get-Service | Where-Object { $_.StartType -like "Automatic" -and $_.Status -ne "Running" } | ForEach-Object {
        $NonRunningAutoServices.Add($_)
    }

    # Remove services from the list that have triggers or are set to delayed start,
    if ($NonRunningAutoServices.Count -gt 0) {
        $TriggerServices = Get-ChildItem -Path "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\*\*" -ErrorAction SilentlyContinue | Where-Object { $_.Name -match "TriggerInfo" }
        $TriggerServices = $TriggerServices | Select-Object -ExpandProperty PSParentPath | Split-Path -Leaf
        foreach ($TriggerService in $TriggerServices) {
            $NonRunningAutoServices.Remove(($NonRunningAutoServices | Where-Object { $_.ServiceName -match $TriggerService })) | Out-Null
        }

        $DelayedStartServices = Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\*" | Where-Object { $_.DelayedAutoStart -eq 1 }
        $DelayedStartServices = $DelayedStartServices | Select-Object -ExpandProperty PSChildName
        foreach ($DelayedStartService in $DelayedStartServices) {
            $NonRunningAutoServices.Remove(($NonRunningAutoServices | Where-Object { $_.ServiceName -match $DelayedStartService })) | Out-Null
        }
    }

    # Remove explicitly ignored services from the list of non-running automatic services.
    if ($ServicesToIgnore.Count -gt 0 -and $NonRunningAutoServices.Count -gt 0) {
        foreach ($ServiceToIgnore in $ServicesToIgnore) {
            if ($NonRunningAutoServices.ServiceName -contains $ServiceToIgnore) {
                $NonRunningAutoServices.Remove(($NonRunningAutoServices | Where-Object { $_.ServiceName -match [Regex]::Escape($ServiceToIgnore) })) | Out-Null
            }
        }
    }

    # If there are still non-running automatic services left, display their names.
    # Otherwise, indicate no stopped automatic services were detected.
    if ($NonRunningAutoServices.Count -gt 0) {
        Write-Host "Matching Services found!"

        # Add Description to report.
        $ServicesReport = New-Object System.Collections.Generic.List[object]
        $NonRunningAutoServices | ForEach-Object {
            $Description = Get-CimInstance -ClassName Win32_Service -Filter "Name = '$($_.ServiceName)'" | Select-Object @{
                Name       = "Description"
                Expression = {
                    $Characters = $_.Description | Measure-Object -Character | Select-Object -ExpandProperty Characters
                    if ($Characters -gt 100) {
                        "$(($_.Description).SubString(0,100))..."
                    }
                    else {
                        $_.Description
                    }
                }
            }
            $ServicesReport.Add(
                [PSCustomObject]@{
                    Name = $_.ServiceName
                    Description = $Description | Select-Object -ExpandProperty Description
                }
            )
        }

        # Output report to activity log.
        $ServicesReport | Sort-Object Name | Format-Table -Property Name,Description -AutoSize | Out-String | Write-Host
    }
    else {
        Write-Host "No stopped automatic services detected!"
    }

    # Exit the script if there are no services to start or if starting services is not requested.
    if (!$StartFoundServices -or !($NonRunningAutoServices.Count -gt 0)) {
        exit $ExitCode
    }

    # Attempt to start each non-running automatic service up to three times.
    # Log success or error messages accordingly.
    $NonRunningAutoServices | ForEach-Object {
        Write-Host "`nAttempting to start $($_.ServiceName)."
        $Attempt = 1
        while ($Attempt -le 3) {
            Write-Host -Object "Attempt: $Attempt"
            try {
                $_ | Start-Service -ErrorAction Stop
                Write-Host -Object "Successfully started $($_.ServiceName)."
                $Attempt = 4
            }
            catch {
                Write-Host -Object "[Error] $($_.Exception.Message)"
                if ($Attempt -eq 3) { $ExitCode = 1 }
            }
            $Attempt++
        }
    }
    
    exit $ExitCode
}
end {
    
    
    
}

 

Analisi dettagliata

Approfondiamo lo script per comprenderne il funzionamento passo dopo passo.

1. Inizializzazione e parametri dello script: Lo script inizia definendo il suo scopo e i suoi parametri. Accetta due parametri opzionali: -IgnoreServices, un elenco separato da virgole di servizi da ignorare, e -StartFoundServices, uno switch per avviare i servizi non in esecuzione che soddisfano i criteri.
2. Verifica dei tempi di attività: Prima di procedere, lo script controlla il tempo di attività del sistema per verificare che sia in funzione da almeno 15 minuti. In questo modo si evitano problemi legati ai servizi che potrebbero non aver avuto il tempo di avviarsi correttamente dopo un riavvio.
3. Controllo dei privilegi: Lo script assicura di essere eseguito con privilegi di amministratore, poiché l’arresto e l’avvio dei servizi richiedono autorizzazioni elevate.
4. Convalida del servizio: I servizi da ignorare vengono convalidati per garantire che non contengano caratteri non validi e che i loro nomi non siano eccessivamente lunghi.
5. Identificazione dei servizi non funzionanti: Lo script raccoglie un elenco di servizi impostati per l’avvio automatico ma non attualmente in esecuzione. Successivamente, vengono esclusi i servizi che sono impostati su “Avvio ritardato” o che presentano condizioni di attivazione.
6. Reportistica e azioni: Se vengono trovati servizi non in esecuzione, lo script li segnala. Se l’opzione -StartFoundServices è impostata, tenta di avviare ciascuno di questi servizi, registrando i successi e gli errori.

Casi d’uso potenziali

Caso di studio:

Immagina un professionista IT che gestisce una rete di server Windows che ospitano diverse applicazioni critiche. Un giorno, gli utenti iniziano a segnalare problemi di accesso a un’applicazione chiave. Il professionista IT esegue questo script PowerShell, grazie al quale identifica che il servizio dell’applicazione, impostato per l’avvio automatico, non è in esecuzione. Lo script tenta di riavviare il servizio, risolvendo rapidamente il problema e ripristinando le normali operazioni.

Confronti

Questo script offre un approccio semplificato e automatizzato rispetto alla verifica manuale di ogni servizio tramite lo snap-in dei servizi MMC o all’uso di altri script meno mirati. Metodi alternativi, come l’uso del pianificatore di attività per monitorare i servizi, possono essere più complessi e difficili da mantenere.

Domande frequenti

D: Questo script può essere utilizzato su versioni precedenti di Windows?

R: Lo script è progettato per Windows 10 e Windows Server 2016 e versioni successive. La compatibilità con le versioni precedenti potrebbe richiedere delle modifiche.

D: Cosa succede se un servizio non si avvia?

R: Lo script tenta di avviare ogni servizio fino a tre volte e registra gli errori se non riesce.

D: Posso escludere più servizi dalla verifica?

R: Sì, utilizza il parametro -IgnoreServices con un elenco di nomi di servizi separati da virgole.

Implicazioni

L’automatizzazione del monitoraggio e della gestione dei servizi Windows migliora l’efficienza operativa e riduce la probabilità di inattività. Garantire che i servizi critici siano sempre in funzione può migliorare l’affidabilità e la sicurezza del sistema.

Raccomandazioni

• Monitoraggio regolare: Pianifica l’esecuzione dello script a intervalli regolari utilizzando Task Scheduler per un monitoraggio continuo.

• Registrazione: Implementa meccanismi di registrazione aggiuntivi per mantenere una cronologia delle azioni intraprese dallo script.

• Test: Testa lo script in un ambiente controllato prima di distribuirlo in produzione.

Considerazioni finali

Automatizzando la gestione dei servizi Windows, i professionisti IT possono garantire una maggiore operatività e affidabilità dei loro sistemi. Per chi desidera ottimizzare ulteriormente le proprie operazioni IT, strumenti come NinjaOne offrono soluzioni complete per il monitoraggio, la gestione e l’automazione di vari aspetti dell’infrastruttura IT, integrando le funzionalità fornite da questo script.