Comment résoudre les politiques Intune provoquant des redémarrages inattendus pendant l'OOBE de Windows Autopilot

Après un redémarrage inattendu pendant Autopilot OOBE, connectez-vous à l'appareil affecté avec le compte administrateur local créé automatiquement. La première étape consiste à identifier quelles politiques ont déclenché le redémarrage coalescé.

Ouvrez l'Observateur d'événements et accédez aux journaux spécifiques à Intune :

eventvwr.msc

Accédez à : Journaux des applications et des services > Microsoft > Windows > DeviceManagement-Enterprise-Diagnostics-Provider > Admin

Filtrez pour l'ID d'événement 2800 qui indique un redémarrage coalescé. Recherchez les entrées contenant des URI de politique comme :

• ./Device/Vendor/MSFT/Policy/Config/DeviceGuard/EnableVirtualizationBasedSecurity
• ./Device/Vendor/MSFT/Policy/Config/CredentialGuard/ConfigureSystemGuard
• ./Device/Vendor/MSFT/Policy/Config/Defender/AttackSurfaceReductionRules

Vérifiez également le journal Système pour les erreurs CloudExperienceHostBroker.exe et examinez les journaux de l'extension de gestion Intune :

Get-ChildItem "C:\ProgramData\Microsoft\IntuneManagementExtension\Logs" | Sort-Object LastWriteTime -Descending | Select-Object -First 5

Vérification : Vous devriez voir des URI de politique spécifiques dans les journaux d'événements qui correspondent au moment du redémarrage. Notez ces URI pour l'étape suivante.

Recoupez les résultats de l'Observateur d'événements avec le registre pour identifier exactement quelles politiques provoquent des redémarrages. Ouvrez l'Éditeur du Registre et examinez les clés de suivi des redémarrages :

regedit

Accédez à : HKLM\SOFTWARE\Microsoft\Provisioning\SyncML\RebootRequiredURIs

Documentez tous les URIs listés ici. Ensuite, exécutez ce script PowerShell pour comparer avec les politiques actuelles de l'appareil :

# Connect to Microsoft Graph
Connect-MgGraph -Scopes "DeviceManagementConfiguration.Read.All"

# Collect RebootRequiredURIs from registry
$rebootURIs = Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Provisioning\SyncML\RebootRequiredURIs" -ErrorAction SilentlyContinue

# Get current device policies
$policyURIs = Get-ChildItem "HKLM:\SOFTWARE\Microsoft\PolicyManager\current\device" | ForEach-Object { $_.PSChildName }

# Compare and identify problematic policies
$problematicPolicies = Compare-Object $rebootURIs.PSObject.Properties.Name $policyURIs | Where-Object SideIndicator -eq "<="

Write-Host "Policies causing reboots:" -ForegroundColor Red
$problematicPolicies | ForEach-Object { Write-Host $_.InputObject -ForegroundColor Yellow }

Vérification : La sortie du script affichera les URIs de politiques spécifiques qui déclenchent des redémarrages. Les coupables courants incluent les politiques Device Guard, Credential Guard et Attack Surface Reduction.

La solution la plus efficace consiste à déplacer les politiques de sécurité problématiques des affectations de groupes d'appareils vers les affectations de groupes d'utilisateurs. Cela retarde l'application des politiques jusqu'à ce que la page d'état d'inscription soit terminée.

Dans le centre d'administration Microsoft Intune, accédez à Sécurité des points de terminaison et examinez ces types de politiques :

• Politiques de Device Guard
• Politiques de Credential Guard
• Sécurité basée sur la virtualisation (VBS)
• Règles de réduction de la surface d'attaque

Pour chaque politique problématique identifiée dans les étapes précédentes :

1. Cliquez sur le nom de la politique
2. Allez à Affectations
3. Supprimez tous les Groupes d'appareils (en particulier les groupes d'appareils Autopilot)
4. Ajoutez à la place des Groupes d'utilisateurs équivalents
5. Cliquez sur Enregistrer

Utilisez ce script PowerShell pour auditer les affectations actuelles :

# Obtenez toutes les politiques de configuration des appareils
$policies = Get-MgDeviceManagementDeviceConfiguration

foreach ($policy in $policies) {
    $assignments = Get-MgDeviceManagementDeviceConfigurationAssignment -DeviceConfigurationId $policy.Id
    
    foreach ($assignment in $assignments) {
        if ($assignment.Target.AdditionalProperties["@odata.type"] -eq "#microsoft.graph.groupAssignmentTarget") {
            $group = Get-MgGroup -GroupId $assignment.Target.AdditionalProperties.groupId
            Write-Host "Policy: $($policy.DisplayName)" -ForegroundColor Cyan
            Write-Host "Assigned to group: $($group.DisplayName)" -ForegroundColor Yellow
            Write-Host "Group type: $($group.GroupTypes)" -ForegroundColor White
            Write-Host "---"
        }
    }
}

Vérification : Exécutez le script d'audit pour confirmer qu'aucune politique de sécurité n'est affectée à des groupes d'appareils. Toutes les affectations doivent cibler des groupes d'utilisateurs ou la portée "Tous les utilisateurs".

Les anneaux de mise à jour Windows avec les paramètres de build préliminaire peuvent déclencher des redémarrages inattendus pendant Autopilot. C'est un problème connu qui persiste même après la mise à jour de service 2111 de Microsoft.

Accédez à Appareils > Windows > Anneaux de mise à jour Windows dans le centre d'administration Intune. Pour chaque anneau de mise à jour assigné aux appareils Autopilot :

1. Cliquez sur le nom de l'anneau de mise à jour
2. Allez dans Paramètres
3. Trouvez Activer les builds préliminaires
4. Changez-le en Activé
5. Cliquez sur Enregistrer
6. Attendez 5 minutes, puis changez-le à nouveau en Non configuré
7. Cliquez sur Enregistrer à nouveau

Cette séquence de basculement efface le paramètre problématique ./Device/Vendor/MSFT/Policy/Config/Update/ManagePreviewBuilds qui cause des redémarrages pendant ESP.

Alternativement, utilisez PowerShell pour vérifier et corriger les anneaux de mise à jour :

# Obtenez tous les anneaux de mise à jour Windows
$updateRings = Get-MgDeviceManagementDeviceConfiguration | Where-Object { $_.AdditionalProperties["@odata.type"] -eq "#microsoft.graph.windowsUpdateForBusinessConfiguration" }

foreach ($ring in $updateRings) {
    Write-Host "Anneau de mise à jour : $($ring.DisplayName)" -ForegroundColor Cyan
    
    # Vérifiez le paramètre de build préliminaire
    $previewSetting = $ring.AdditionalProperties.previewBuildSetting
    if ($previewSetting -ne "notConfigured") {
        Write-Host "Paramètre de builds préliminaires : $previewSetting - BESOIN DE CORRECTION" -ForegroundColor Red
    } else {
        Write-Host "Paramètre de builds préliminaires : Non configuré - OK" -ForegroundColor Green
    }
}

Vérification : Vérifiez que tous les anneaux de mise à jour affichent "Non configuré" pour les builds préliminaires. Testez avec un nouveau déploiement Autopilot pour confirmer qu'aucun redémarrage ne se produit.

Déployez un profil de configuration personnalisé qui empêche les redémarrages automatiques pendant la phase OOBE. Ce profil définit les heures actives et désactive les notifications de redémarrage automatique.

Utilisez ce script PowerShell pour créer le profil de prévention via Microsoft Graph :

# Assurez-vous d'être connecté à Graph avec les autorisations appropriées
Connect-MgGraph -Scopes "DeviceManagementConfiguration.ReadWrite.All"

# Définir le profil de prévention de redémarrage OOBE
$oobeProfile = @{
    "@odata.type" = "#microsoft.graph.windows10CustomConfiguration"
    displayName = "Prévention de redémarrage OOBE - Autopilot"
    description = "Empêche les redémarrages inattendus pendant l'OOBE de Windows et l'inscription Autopilot"
    omaSettings = @(
        @{ 
            "@odata.type" = "#microsoft.graph.omaSettingString"
            displayName = "Désactiver la notification de redémarrage automatique requis"
            omaUri = "./Device/Vendor/MSFT/Policy/Config/Update/AutoRestartRequiredNotificationDismissal"
            value = "1"
        },
        @{ 
            "@odata.type" = "#microsoft.graph.omaSettingString"
            displayName = "Définir l'heure de début des heures actives"
            omaUri = "./Device/Vendor/MSFT/Policy/Config/Update/ActiveHoursStart"
            value = "8"
        },
        @{ 
            "@odata.type" = "#microsoft.graph.omaSettingString"
            displayName = "Définir l'heure de fin des heures actives"
            omaUri = "./Device/Vendor/MSFT/Policy/Config/Update/ActiveHoursEnd"
            value = "18"
        },
        @{ 
            "@odata.type" = "#microsoft.graph.omaSettingString"
            displayName = "Configurer les notifications de redémarrage"
            omaUri = "./Device/Vendor/MSFT/Policy/Config/Update/ScheduleRestartWarning"
            value = "4"
        }
    )
}

# Créer le profil
$newProfile = New-MgDeviceManagementDeviceConfiguration -BodyParameter $oobeProfile
Write-Host "Profil créé avec ID : $($newProfile.Id)" -ForegroundColor Green

Après avoir créé le profil, assignez-le à votre groupe de dispositifs Autopilot avec une haute priorité (ordre 1).

Vérification : Vérifiez que le profil apparaît dans Appareils > Profils de configuration et est assigné au bon groupe de dispositifs. Le profil doit être déployé avant toute politique de sécurité.

Les applications Win32 déployées pendant Autopilot peuvent déclencher des redémarrages inattendus si elles ne sont pas correctement configurées. Modifiez vos packages d'applications Win32 pour supprimer les invites de redémarrage et gérer les exigences de redémarrage de manière fluide.

Pour chaque application Win32 qui pourrait nécessiter un redémarrage :

1. Accédez à Applications > Applications Windows dans Intune
2. Sélectionnez votre application Win32
3. Allez dans les paramètres Programme
4. Modifiez la Commande d'installation pour inclure des paramètres de suppression de redémarrage

Paramètres courants de suppression de redémarrage :

# Pour les installateurs MSI
msiexec /i "package.msi" /quiet /norestart REBOOT=ReallySuppress

# Pour les installateurs EXE (varie selon le fournisseur)
setup.exe /S /norestart
setup.exe /quiet /noreboot
setup.exe /silent /suppressmsgboxes

Configurez les codes de retour pour gérer les exigences de redémarrage :

1. Dans les paramètres Programme de l'application
2. Définissez les Codes de retour :
3. Ajoutez le code de retour 3010 avec le type Redémarrage doux
4. Ajoutez le code de retour 1641 avec le type Redémarrage dur
5. Définissez le Comportement de redémarrage de l'appareil sur Déterminer le comportement en fonction des codes de retour

Utilisez ce script PowerShell pour auditer les configurations des applications Win32 :

# Obtenez toutes les applications Win32
$win32Apps = Get-MgDeviceAppManagementMobileApp | Where-Object { $_.AdditionalProperties["@odata.type"] -eq "#microsoft.graph.win32LobApp" }

foreach ($app in $win32Apps) {
    Write-Host "App: $($app.DisplayName)" -ForegroundColor Cyan
    
    # Obtenez des informations détaillées sur l'application
    $appDetails = Get-MgDeviceAppManagementMobileApp -MobileAppId $app.Id
    $installCommand = $appDetails.AdditionalProperties.installCommandLine
    
    Write-Host "Commande d'installation : $installCommand" -ForegroundColor Yellow
    
    # Vérifiez les paramètres de suppression de redémarrage
    if ($installCommand -match "/norestart|/noreboot|REBOOT=ReallySuppress") {
        Write-Host "Suppression de redémarrage : CONFIGURÉE" -ForegroundColor Green
    } else {
        Write-Host "Suppression de redémarrage : MANQUANTE - BESOIN DE CORRECTION" -ForegroundColor Red
    }
    Write-Host "---"
}

Vérification : Testez les installations d'applications sur un appareil de test pour confirmer qu'aucune invite de redémarrage inattendue n'apparaît. Vérifiez les journaux d'installation des applications Intune pour une gestion correcte des codes de retour.

Après avoir mis en œuvre les correctifs, testez minutieusement l'expérience Autopilot pour vous assurer qu'aucun redémarrage inattendu ne se produit. Réinitialisez un appareil de test et surveillez l'ensemble du processus OOBE.

Réinitialisez l'appareil de test aux paramètres d'usine :

1. Allez dans Paramètres > Mise à jour et sécurité > Récupération
2. Cliquez sur Commencer sous Réinitialiser ce PC
3. Choisissez Tout supprimer
4. Sélectionnez Supprimer les fichiers et nettoyer le lecteur

Durant le processus Autopilot, surveillez les problèmes en utilisant ces techniques :

Surveillance en temps réel avec PowerShell :

# Surveiller la progression d'Autopilot (exécuter sur l'appareil pendant l'OOBE)
$autopilotLog = "C:\Windows\Logs\Autopilot\AutopilotDiagnostics.log"
if (Test-Path $autopilotLog) {
    Get-Content $autopilotLog -Tail 10 -Wait
}

# Surveiller l'extension de gestion Intune
$imeLog = "C:\ProgramData\Microsoft\IntuneManagementExtension\Logs\IntuneManagementExtension.log"
if (Test-Path $imeLog) {
    Get-Content $imeLog -Tail 5 -Wait | Where-Object { $_ -match "reboot|restart" }
}

Générer des diagnostics complets après achèvement :

# Générer un rapport de diagnostics MDM
mdmdiagnosticstool.exe -out C:\temp\AutopilotDiagnostics

# Collecter les journaux Autopilot
Get-AutopilotDiagnostics -OutputPath C:\temp\AutopilotLogs

# Vérifier les URI nécessitant encore un redémarrage
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Provisioning\SyncML\RebootRequiredURIs" -ErrorAction SilentlyContinue

Documenter la chronologie complète d'Autopilot :

• Heure de début de l'OOBE
• Achèvement de la phase de configuration de l'appareil ESP
• Connexion de l'utilisateur
• Achèvement de la phase de configuration de l'utilisateur ESP
• Présentation du bureau
• Toute interruption ou redémarrage inattendu

Vérification : Un déploiement Autopilot réussi doit se terminer sans aucun redémarrage inattendu. L'appareil doit passer de l'OOBE directement au bureau après l'achèvement de l'ESP. Vérifiez que toutes les politiques et applications sont correctement appliquées après le déploiement.

Établir des processus de surveillance pour prévenir les problèmes de redémarrage d'Autopilot à l'avenir. Créer des vérifications et des alertes automatisées pour les affectations de politiques problématiques.

Créer un script PowerShell pour l'audit régulier des politiques :

# Script d'audit des politiques Autopilot
# Exécuter chaque semaine pour vérifier les affectations problématiques

Connect-MgGraph -Scopes "DeviceManagementConfiguration.Read.All", "Group.Read.All"

# Définir les types de politiques problématiques
$problematicPolicyTypes = @(
    "#microsoft.graph.windows10EndpointProtectionConfiguration",
    "#microsoft.graph.windowsDefenderAdvancedThreatProtectionConfiguration",
    "#microsoft.graph.windows10CustomConfiguration"
)

# Obtenir les groupes de dispositifs Autopilot
$autopilotGroups = Get-MgGroup | Where-Object { $_.DisplayName -like "*Autopilot*" -or $_.DisplayName -like "*OOBE*" }

Write-Host "Vérification des affectations de politiques problématiques..." -ForegroundColor Cyan

foreach ($policyType in $problematicPolicyTypes) {
    $policies = Get-MgDeviceManagementDeviceConfiguration | Where-Object { $_.AdditionalProperties["@odata.type"] -eq $policyType }
    
    foreach ($policy in $policies) {
        $assignments = Get-MgDeviceManagementDeviceConfigurationAssignment -DeviceConfigurationId $policy.Id
        
        foreach ($assignment in $assignments) {
            if ($assignment.Target.AdditionalProperties["@odata.type"] -eq "#microsoft.graph.groupAssignmentTarget") {
                $groupId = $assignment.Target.AdditionalProperties.groupId
                
                if ($groupId -in $autopilotGroups.Id) {
                    Write-Host "ATTENTION : Politique '$($policy.DisplayName)' assignée à un groupe de dispositifs Autopilot" -ForegroundColor Red
                    Write-Host "Groupe : $($autopilotGroups | Where-Object Id -eq $groupId | Select-Object -ExpandProperty DisplayName)" -ForegroundColor Yellow
                    Write-Host "Recommandation : Passer à une affectation de groupe d'utilisateurs" -ForegroundColor Green
                    Write-Host "---"
                }
            }
        }
    }
}

Write-Host "Audit terminé." -ForegroundColor Green

Configurer des alertes automatisées en utilisant Azure Logic Apps ou Power Automate :

1. Créer une Logic App avec un déclencheur de récurrence (hebdomadaire)
2. Ajouter une action HTTP pour appeler l'API Microsoft Graph
3. Interroger les affectations de configuration des dispositifs
4. Filtrer les affectations de groupes de dispositifs pour les politiques de sécurité
5. Envoyer des alertes par e-mail lorsque des affectations problématiques sont détectées

Créer une documentation pour votre équipe :

# Directives d'affectation des politiques Autopilot

## NE JAMAIS assigner à des groupes de dispositifs :
- Politiques Device Guard
- Politiques Credential Guard  
- Règles de réduction de la surface d'attaque
- Politiques VBS/HVCI
- Anneaux de mise à jour Windows avec builds de prévisualisation

## TOUJOURS assigner à des groupes d'utilisateurs :
- Toutes les politiques de sécurité des points de terminaison
- Politiques de conformité (si possible)
- Politiques de protection des applications

## Sûr pour les groupes de dispositifs :
- Profils Wi-Fi
- Profils de certificats
- Profils VPN (non liés à la sécurité)
- Restrictions de base des dispositifs

Vérification : Exécuter le script d'audit chaque semaine et confirmer qu'aucune alerte n'est générée. Tester les nouveaux déploiements de politiques sur un petit groupe avant une affectation large. Maintenir un journal des modifications de toutes les politiques liées à Autopilot.