Comment automatiser le contrôle et le démarrage des services Windows avec PowerShell

Avec Powershell, apprendre à vérifier l’état des services Windows et à maintenir lasanté des services sur les machines Windows est crucial pour assurer le bon fonctionnement de tout environnement informatique. Les services qui sont configurés pour démarrer automatiquement mais qui ne s’exécutent pas peuvent entraîner des problèmes de performance, des temps d’arrêt imprévus du réseau et des inefficacités opérationnelles.

C’est là que les scripts PowerShell s’avèrent utiles, car ils offrent un moyen robuste et automatisé de gérer et de surveiller les services Windows. Dans ce article nous allons explorer un script PowerShell conçu pour signaler et démarrer les services automatiques qui ne sont pas en cours d’exécution, à l’exception de ceux qui sont définis comme « Démarrage différé » ou « Démarrage déclenché ».

Contexte

Pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP), le bon fonctionnement des services est une priorité absolue. Les services Windows peuvent parfois ne pas démarrer pour diverses raisons, telles que des problèmes de configuration, des conflits ou des limitations des ressources du système.

Ce script répond au besoin d’une approche systématique pour identifier et redémarrer les services qui devraient être en cours d’exécution mais ne le sont pas. En automatisant ce processus, les équipes informatiques peuvent gagner du temps et réduire le risque d’erreur humaine.

Le script :

#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/fr/conditions-dutilisation
    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 {
    
    
    
}

 

Accédez à plus de 700 scripts dans le Dojo NinjaOne

Obtenir l’accès

Description détaillée

Nous allons nous plonger dans le script pour en comprendre le fonctionnement étape par étape.

  1. Initialisation du script et paramètres : Le script commence par définir son objectif et ses paramètres. Elle accepte deux paramètres facultatifs : -IgnoreServices, une liste de services à ignorer séparée par des virgules, et -StartFoundServices, un commutateur pour démarrer les services non exécutés qui répondent aux critères.
  2. Vérification du temps de fonctionnement : Avant de poursuivre, le script vérifie le temps de fonctionnement du système pour s’assurer qu’il fonctionne depuis au moins 15 minutes. Cela permet d’éviter les problèmes liés à des services qui n’auraient pas eu le temps de démarrer correctement après un redémarrage.
  3. Contrôle des privilèges : Le script s’assure qu’il est exécuté avec des privilèges d’administrateur, car l’arrêt et le démarrage des services nécessitent des autorisations élevées.
  4. Validation du service : Les services à ignorer sont validés pour s’assurer qu’ils ne contiennent pas de caractères non valides et que leur nom n’est pas excessivement long.
  5. Identifier les services qui ne fonctionnent pas : Le script recueille une liste de services définis pour démarrer automatiquement mais qui ne sont pas en cours d’exécution. Il filtre ensuite les services dont le démarrage est retardé ou qui présentent des conditions de déclenchement.
  6. Rapports et actions : Si des services non exécutés sont trouvés, le script les signale. Si l’option -StartFoundServices est activée, il tente de démarrer chacun de ces services, en consignant les succès et les erreurs.

Cas d’utilisation potentiels

Étude de cas :

Imaginez un professionnel de l’informatique qui gère un réseau de serveurs Windows hébergeant diverses applications critiques. Un jour, les utilisateurs commencent à signaler des problèmes d’accès à une application clé. Le professionnel de l’informatique exécute ce script PowerShell, qui identifie que le service de l’application, configuré pour démarrer automatiquement, n’est pas en cours d’exécution. Le script tente de redémarrer le service, ce qui permet de résoudre rapidement le problème et de rétablir des opérations normales.

Comparaisons

Ce script fournit une approche rationalisée et automatisée par rapport à la vérification manuelle de chaque service via le snap-in Services MMC ou à l’aide d’autres scripts moins ciblés. D’autres méthodes, comme l’utilisation du planificateur de tâches pour surveiller les services, peuvent être plus complexes et plus difficiles à maintenir.

FAQ

Q : Ce script peut-il être utilisé sur d’anciennes versions de Windows ?

R : Le script est conçu pour Windows 10 et Windows Server 2016 et les versions plus récentes. La compatibilité avec les versions antérieures peut nécessiter des ajustements.

Q : Que se passe-t-il si un service ne démarre pas ?

R : Le script tente de démarrer chaque service jusqu’à trois fois et enregistre les erreurs en cas d’échec.

Q : Puis-je exclure plusieurs services de la vérification ?

R : Oui, utilisez le paramètre -IgnoreServices avec une liste de noms de services séparés par des virgules.

Implications

L’automatisation de la surveillance et de la gestion des services Windows améliore l’ efficacité opérationnelle et réduit la probabilité de temps d’arrêt. Veiller à ce que les services essentiels fonctionnent en permanence permet d’améliorer la fiabilité et la sécurité du système.

Recommandations

  • Contrôle régulier : Planifiez l’exécution du script à intervalles réguliers à l’aide du planificateur de tâches pour une surveillance continue.
  • Enregistrement : Implémentez des mécanismes de journalisation supplémentaires pour conserver un historique des actions effectuées par le script.
  • Test : Testez le script dans un environnement contrôlé avant de le déployer dans l’environnement de production.

Conclusion

En automatisant la gestion des services Windows, les professionnels de l’informatique peuvent garantir une meilleure disponibilité et une plus grande fiabilité de leurs systèmes. Pour ceux qui cherchent à rationaliser davantage leurs opérations informatiques, des outils tels que NinjaOne offrent des solutions complètes pour la surveillance, la gestion et l’automatisation de divers aspects de l’infrastructure informatique, complétant ainsi les capacités fournies par ce script.

Pour aller plus loin

Créer une équipe informatique efficace et performante nécessite une solution centralisée qui soit l’outil principal pour fournir vos services. NinjaOne permet aux équipes informatiques de surveiller, gérer, sécuriser et prendre en charge tous les appareils, où qu’ils soient, sans avoir besoin d’une infrastructure complexe sur site.

Pour en savoir plus sur NinjaOne Endpoint Management, participez à une visite guidée ou commencez votre essai gratuit de la plateforme NinjaOne.

Catégories :

Vous pourriez aussi aimer

Voir la démo×
×

Voir NinjaOne en action !

En soumettant ce formulaire, j'accepte la politique de confidentialité de NinjaOne.

Termes et conditions NinjaOne

En cliquant sur le bouton « J’accepte » ci-dessous, vous indiquez que vous acceptez les termes juridiques suivants ainsi que nos conditions d’utilisation:

  • Droits de propriété: NinjaOne possède et continuera de posséder tous les droits, titres et intérêts relatifs au script (y compris les droits d’auteur). NinjaOne vous accorde une licence limitée pour l’utilisation du script conformément à ces conditions légales.
  • Limitation de l’utilisation: Les scripts ne peuvent être utilisés qu’à des fins personnelles ou professionnelles internes légitimes et ne peuvent être partagés avec d’autres entités.
  • Interdiction de publication: Vous n’êtes en aucun cas autorisé à publier le script dans une bibliothèque de scripts appartenant à, ou sous le contrôle d’un autre fournisseur de logiciels.
  • Clause de non-responsabilité: Le texte est fourni « tel quel » et « tel que disponible », sans garantie d’aucune sorte. NinjaOne ne promet ni ne garantit que le script sera exempt de défauts ou qu’il répondra à vos besoins ou attentes particulières.
  • Acceptation des risques: L’utilisation du script est sous votre propre responsabilité. Vous reconnaissez qu’il existe certains risques inhérents à l’utilisation du script, et vous comprenez et assumez chacun de ces risques.
  • Renonciation et exonération de responsabilité: Vous ne tiendrez pas NinjaOne pour responsable des conséquences négatives ou involontaires résultant de votre utilisation du script, et vous renoncez à tout droit ou recours légal ou équitable que vous pourriez avoir contre NinjaOne en rapport avec votre utilisation du script.
  • EULA: Si vous êtes un client de NinjaOne, votre utilisation du script est soumise au contrat de licence d’utilisateur final qui vous est applicable (End User License Agreement (EULA)).