ID d'événement Windows 7001 – Gestionnaire de contrôle des services : Échec de dépendance du service

Commencez par examiner les dépendances du service via la console des Services Windows pour identifier la chaîne de dépendance défaillante.

1. Appuyez sur Windows + R, tapez services.msc, et appuyez sur Entrée
2. Localisez le service mentionné dans le message d'erreur de l'ID d'événement 7001
3. Cliquez avec le bouton droit sur le service et sélectionnez Propriétés
4. Cliquez sur l'onglet Dépendances pour voir les services requis
5. Vérifiez chaque service dépendant listé sous Ce service dépend des composants système suivants
6. Pour chaque dépendance, vérifiez son statut dans la fenêtre principale des Services
7. Cherchez les services avec le statut Arrêté ou Désactivé
8. Cliquez avec le bouton droit sur tout service dépendant arrêté et sélectionnez Démarrer
9. Si un service est désactivé, cliquez avec le bouton droit, sélectionnez Propriétés, changez le Type de démarrage en Automatique, et cliquez sur Démarrer

Utilisez PowerShell pour obtenir des informations détaillées sur les dépendances de service et automatiser le processus d'investigation.

1. Ouvrez PowerShell en tant qu'administrateur
2. Obtenez les détails du service à partir du journal des événements :

   Get-WinEvent -FilterHashtable @{LogName='System'; Id=7001} -MaxEvents 5 | Format-List TimeCreated, Id, LevelDisplayName, Message

3. Identifiez le nom du service défaillant à partir du message d'événement
4. Vérifiez les dépendances du service :

   $serviceName = "YourServiceName"
   Get-Service -Name $serviceName -DependentServices
   Get-Service -Name $serviceName -RequiredServices

5. Vérifiez l'état de tous les services requis :

   $requiredServices = Get-Service -Name $serviceName -RequiredServices
   $requiredServices | Select-Object Name, Status, StartType

6. Démarrez tous les services requis arrêtés :

   $requiredServices | Where-Object {$_.Status -eq 'Stopped'} | Start-Service -Verbose

7. Vérifiez que le service principal peut maintenant démarrer :

   Start-Service -Name $serviceName -Verbose

Enquêter sur la configuration des dépendances de service dans le Registre Windows pour identifier et résoudre les problèmes de dépendance.

1. Appuyez sur Windows + R, tapez regedit, et appuyez sur Entrée
2. Accédez à HKLM\SYSTEM\CurrentControlSet\Services
3. Trouvez le sous-dossier correspondant au nom de votre service
4. Vérifiez la valeur DependOnService (REG_MULTI_SZ) pour la liste des services requis
5. Vérifiez que chaque service listé existe dans l'emplacement du registre Services
6. Vérifiez les dépendances circulaires en examinant les valeurs DependOnService des services dépendants
7. Utilisez PowerShell pour valider les dépendances de service du registre :

   $serviceName = "YourServiceName"
   $regPath = "HKLM:\SYSTEM\CurrentControlSet\Services\$serviceName"
   $dependencies = Get-ItemProperty -Path $regPath -Name "DependOnService" -ErrorAction SilentlyContinue
   if ($dependencies) {
       $dependencies.DependOnService | ForEach-Object {
           $depService = Get-Service -Name $_ -ErrorAction SilentlyContinue
           if ($depService) {
               Write-Output "$_ : $($depService.Status)"
           } else {
               Write-Output "$_ : SERVICE NOT FOUND"
           }
       }
   }

8. Si des dépendances invalides sont trouvées, sauvegardez la clé de registre et supprimez les entrées invalides
9. Redémarrez le service après avoir apporté des modifications au registre

Utilisez l'outil en ligne de commande Service Control (SC) pour une analyse et une configuration détaillées des dépendances de service.

1. Ouvrez l'invite de commande en tant qu'administrateur
2. Interroger la configuration du service :

   sc qc "ServiceName"

3. Vérifier les dépendances du service :

   sc enumdepend "ServiceName"

4. Interroger le statut du service et les informations détaillées :

   sc query "ServiceName"
   sc queryex "ServiceName"

5. Vérifier si les services dépendants sont en cours d'exécution :

   for /f "tokens=2" %i in ('sc enumdepend "ServiceName" ^| findstr "SERVICE_NAME"') do sc query %i

6. Essayer de démarrer le service avec une sortie détaillée :

   sc start "ServiceName"

7. Si le service a des dépendances configurables, modifiez-les :

   sc config "ServiceName" depend= "Dependency1/Dependency2"

8. Utilisez PowerShell pour créer un rapport de dépendance complet :

   $services = Get-Service
   $dependencyReport = @()
   foreach ($service in $services) {
       $required = Get-Service -Name $service.Name -RequiredServices -ErrorAction SilentlyContinue
       if ($required) {
           $dependencyReport += [PSCustomObject]@{
               ServiceName = $service.Name
               Status = $service.Status
               RequiredServices = ($required.Name -join ", ")
               RequiredServicesStatus = ($required.Status -join ", ")
           }
       }
   }
   $dependencyReport | Where-Object {$_.RequiredServicesStatus -like "*Stopped*"} | Format-Table -AutoSize

Mettre en œuvre une résolution complète des dépendances de service, y compris la configuration de récupération automatique et le dépannage au niveau système.

1. Créer un script PowerShell pour la résolution automatisée des dépendances :

   function Resolve-ServiceDependencies {
       param([string]$ServiceName)
       
       $service = Get-Service -Name $ServiceName -ErrorAction SilentlyContinue
       if (-not $service) {
           Write-Error "Service $ServiceName not found"
           return
       }
       
       $requiredServices = Get-Service -Name $ServiceName -RequiredServices
       
       foreach ($reqService in $requiredServices) {
           if ($reqService.Status -ne 'Running') {
               Write-Output "Starting required service: $($reqService.Name)"
               try {
                   Start-Service -Name $reqService.Name -ErrorAction Stop
                   Start-Sleep -Seconds 2
               } catch {
                   Write-Error "Failed to start $($reqService.Name): $($_.Exception.Message)"
               }
           }
       }
       
       # Attempt to start the main service
       try {
           Start-Service -Name $ServiceName -ErrorAction Stop
           Write-Output "Successfully started $ServiceName"
       } catch {
           Write-Error "Failed to start $ServiceName after resolving dependencies: $($_.Exception.Message)"
       }
   }

2. Configurer les options de récupération du service :

   sc failure "ServiceName" reset= 86400 actions= restart/5000/restart/5000/restart/5000

3. Vérifier le journal des événements Windows pour des détails d'erreur supplémentaires :

   Get-WinEvent -FilterHashtable @{LogName='System'; Id=7000,7001,7009,7011,7023,7024} -MaxEvents 20 | Where-Object {$_.Message -like "*ServiceName*"} | Format-List TimeCreated, Id, LevelDisplayName, Message

4. Analyser la performance de démarrage du service :

   Get-WinEvent -FilterHashtable @{LogName='System'; Id=7036} -MaxEvents 50 | Where-Object {$_.Message -like "*entered the running state*"} | Select-Object TimeCreated, @{Name='ServiceName';Expression={($_.Message -split ' ')[0]}} | Sort-Object TimeCreated -Descending

5. Créer une tâche planifiée pour la surveillance automatique du service :

   $action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File C:\Scripts\ServiceMonitor.ps1"
   $trigger = New-ScheduledTaskTrigger -AtStartup
   $principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount
   Register-ScheduledTask -TaskName "ServiceDependencyMonitor" -Action $action -Trigger $trigger -Principal $principal

6. Mettre en œuvre une journalisation complète pour un dépannage futur :

   Start-Transcript -Path "C:\Logs\ServiceDependency-$(Get-Date -Format 'yyyyMMdd-HHmmss').log"
   Resolve-ServiceDependencies -ServiceName "YourServiceName"
   Stop-Transcript