Bye Bye Prof

GPO

1. Introduction aux stratégies de groupe

Les stratégies de groupe (Group Policy Objects - GPO) constituent un mécanisme central dans Windows Server 2022 pour gérer et configurer de manière centralisée les paramètres des ordinateurs et des utilisateurs dans un environnement Active Directory. Elles permettent aux administrateurs de définir des politiques de sécurité, de déployer des logiciels, d'exécuter des scripts et de configurer l'environnement de travail des utilisateurs de façon uniforme et automatisée.

Source: https://www.youtube.com/watch?v=EB6IYcVqQSI&t=7s

1.1 Ordre d'attribution sur les postes de travail

L'application des GPO suit un ordre hiérarchique précis, connu sous l'acronyme LSDOU :

L - Local : Les stratégies de groupe locales s'appliquent en premier. Elles sont stockées directement sur chaque ordinateur et constituent le premier niveau de configuration.

S - Site : Les GPO liées au site Active Directory s'appliquent ensuite. Un site représente un emplacement physique dans l'infrastructure réseau.

D - Domain (Domaine) : Les stratégies liées au domaine s'appliquent après celles du site. Elles affectent tous les objets du domaine, sauf indication contraire.

OU - Organizational Unit (Unité d'Organisation) : Les GPO liées aux unités d'organisation s'appliquent en dernier et peuvent remplacer les paramètres précédents. Si plusieurs OU sont imbriquées, l'ordre d'application va de la plus éloignée à la plus proche de l'objet.

Principe important : En cas de conflit entre plusieurs GPO, c'est le dernier paramètre appliqué qui prévaut. Ainsi, une GPO liée à une OU peut remplacer un paramètre défini au niveau du domaine.

Ordre d'application des GPO multiples : Lorsque plusieurs GPO sont liées au même niveau (par exemple, plusieurs GPO sur une même OU), elles s'appliquent de bas en haut dans la liste affichée dans la console GPMC. La GPO située en haut de la liste a donc la priorité la plus élevée.

Comparatif en un coup d’œil

Concept À quoi sert-il ? Exemple
gpedit.msc Modifier les stratégies locales d’un poste. Restreindre le Panneau de configuration.
gpmc.msc Gérer et lier les GPO du domaine Active Directory. Configurer une OU de laboratoire.
Starter GPO Servir de modèle initial pour de nouvelles GPO. Créer une base commune pour plusieurs laboratoires.
CSE Appliquer les catégories de paramètres sur le client. Mapper un lecteur réseau.
Loopback Déterminer les stratégies utilisateur en fonction du poste. Restreindre les sessions dans un labo.
ADMX / ADML Décrire les paramètres et leurs textes d’interface. Afficher les stratégies Microsoft Edge.

Commandes pratiques

Commande Usage
gpupdate /force Demander la réapplication des stratégies de groupe.
gpresult /r Afficher un résumé des stratégies résultantes.
gpresult /h C:\Temp\rapport-gpo.html Produire un rapport HTML (le dossier de destination doit exister).

Exercice GPO

Créer une GPO dans ACTIVE DIRECTORY (12 min)

https://www.youtube.com/watch?v=nNerx5ZcU58

1.2 Outil de gestion des GPO (GPMC)

La Group Policy Management Console (GPMC) est l'outil graphique principal pour administrer les stratégies de groupe dans Windows Server 2022.

Installation de GPMC : Sur Windows Server 2022, GPMC s'installe automatiquement lors de la promotion du serveur en contrôleur de domaine. Pour l'installer manuellement sur un serveur membre ou un poste d'administration (en powershell) :

Install-WindowsFeature GPMC

Source: https://www.youtube.com/watch?v=hn6SCYxCPR0

Accès à GPMC :

Interface et fonctionnalités principales :

L'interface GPMC se compose de plusieurs sections :

Exemple de fenêtre GPMC (Source: https://www.techtarget.com/searchwindowsserver/definition/Group-Policy-Management-Console)

Forêt : Niveau racine affichant la forêt Active Directory et ses domaines.

Domaines : Contient les domaines de la forêt avec leur structure d'unités d'organisation.

Objets de stratégie de groupe : Dossier central contenant toutes les GPO créées dans le domaine. C'est ici que les GPO sont physiquement stockées.

Filtres WMI : Permet de créer des requêtes WMI pour appliquer conditionnellement des GPO en fonction des caractéristiques matérielles ou logicielles.

Objets GPO Starter : Modèles de GPO prédéfinis servant de base à la création de nouvelles stratégies.

Fonctionnalités clés de GPMC :

1.3 Objets GPO Starter

Les GPO Starter (objets de stratégie de groupe de démarrage) sont des modèles de GPO qui contiennent une collection prédéfinie de paramètres de modèles d'administration. Ils servent de point de départ pour créer de nouvelles GPO avec des configurations standardisées.

Source: https://www.404techsupport.com/2012/08/23/use-starter-gpos-in-group-policy-as-a-template-to-prevent-tedium

Avantages des GPO Starter :

Création d'une GPO Starter :

  1. Dans GPMC, faire un clic droit sur le dossier "Objets GPO Starter"
  2. Sélectionner "Nouveau"
  3. Nommer la GPO Starter (ex : "Modèle Sécurité Standard")
  4. Ajouter un commentaire décrivant son usage
  5. Configurer les paramètres souhaités dans les modèles d'administration

Utilisation d'une GPO Starter :

Lors de la création d'une nouvelle GPO, vous pouvez sélectionner une GPO Starter comme modèle source :

  1. Clic droit sur le dossier "Objets de stratégie de groupe"
  2. Sélectionner "Nouveau"
  3. Dans la fenêtre de création, dérouler "GPO Starter source"
  4. Choisir le modèle approprié
  5. La nouvelle GPO contiendra tous les paramètres du modèle

Gestion des GPO Starter :

# Sauvegarder une GPO Starter Backup-GPStarterGPO -Name "Modèle Sécurité" -Path "C:\GPOBackup"  # Créer une GPO depuis un Starter New-GPO -Name "GPO Production" -StarterGPOName "Modèle Sécurité"

Remarque importante : Les GPO Starter ne contiennent que des paramètres de modèles d'administration (registre). Elles n'incluent pas les paramètres de sécurité, les scripts ou les préférences.

1.4 Présentation des CSE (extensions côté client)

Les Client-Side Extensions (CSE) sont des composants DLL qui s'exécutent sur les ordinateurs clients pour traiter et appliquer les différents types de paramètres contenus dans les GPO.

Fonctionnement des CSE :

Lorsqu'un ordinateur démarre ou qu'un utilisateur ouvre une session, le service Client de stratégie de groupe télécharge les GPO applicables depuis le contrôleur de domaine. Les CSE appropriées sont ensuite invoquées pour traiter chaque section de la GPO.

Principales CSE dans Windows Server 2022 :

Extension GUID Fonction
Registry {35378EAC-683F-11D2-A89A-00C04FBBCFA2} Applique les paramètres du registre
Security {827D319E-6EAC-11D2-A4EA-00C04F79F83A} Configure les politiques de sécurité
Scripts {42B5FAAE-6536-11D2-AE5A-0000F87571E3} Exécute les scripts de démarrage/arrêt
Folder Redirection {25537BA6-77A8-11D2-9B6C-0000F8080861} Redirige les dossiers utilisateurs
Software Installation {C6DC5466-785A-11D2-84D0-00C04FB169F7} Déploie les applications
Group Policy Preferences {00000000-0000-0000-0000-000000000000} Traite les préférences

Traitement des CSE :

Les CSE peuvent fonctionner de deux manières :

Traitement synchrone : Les extensions s'exécutent les unes après les autres. L'utilisateur doit attendre la fin du traitement avant d'accéder à son bureau. Ce mode garantit que tous les paramètres sont appliqués avant le début de la session.

Traitement asynchrone : Les extensions s'exécutent en arrière-plan pendant que l'utilisateur accède à son bureau. Plus rapide, mais certains paramètres peuvent ne pas être immédiatement disponibles.

Configuration du traitement :

Le comportement peut être contrôlé via les paramètres de stratégie :

Diagnostic des CSE :

Pour vérifier quelles CSE ont été traitées en powershell :

# Afficher le dernier traitement des GPO gpresult /r
 # Générer un rapport détaillé HTML gpresult /h rapport.html
 # Forcer la mise à jour des GPO gpupdate /force

Journalisation des CSE :

Les événements liés au traitement des CSE sont enregistrés dans l'Observateur d'événements :

Intervalles de rafraîchissement :

Par défaut, les GPO sont rafraîchies selon les intervalles suivants :

Ces intervalles peuvent être modifiés via la stratégie "Intervalle d'actualisation de la stratégie de groupe pour les ordinateurs/utilisateurs".

2. Traitement en boucle (loopback)

2.1 Introduction

Le traitement en boucle (Loopback Processing) est une fonctionnalité avancée des stratégies de groupe qui modifie le comportement normal d'application des GPO utilisateur. Dans des circonstances normales, les paramètres utilisateur proviennent des GPO liées à l'emplacement de l'objet utilisateur dans Active Directory. Le traitement en boucle permet d'appliquer des paramètres utilisateur basés sur l'emplacement de l'ordinateur plutôt que sur celui de l'utilisateur.

Cas d'usage typiques :

Environnements de bureau partagés : Dans les salles de formation, bibliothèques ou espaces publics où différents utilisateurs se connectent sur les mêmes ordinateurs, il est nécessaire d'imposer une configuration uniforme indépendamment de l'identité de l'utilisateur.

Serveurs Terminal Server / RDS : Pour garantir une expérience cohérente sur les serveurs de sessions distantes, quelle que soit l'OU d'appartenance de l'utilisateur.

Postes à usage spécifique : Kiosques d'information, caisses enregistreuses ou stations de travail dédiées nécessitant des configurations verrouillées.

Salles de réunion : Ordinateurs de présentation où tous les utilisateurs doivent avoir les mêmes applications et restrictions.

Fonctionnement du traitement en boucle :

Sans traitement en boucle, le processus d'application suit ce schéma :

  1. L'ordinateur traite les GPO ordinateur basées sur son emplacement
  2. L'utilisateur traite les GPO utilisateur basées sur son emplacement

Avec le traitement en boucle activé :

  1. L'ordinateur traite les GPO ordinateur basées sur son emplacement
  2. L'utilisateur traite les GPO utilisateur basées sur l'emplacement de l'ordinateur (et non de l'utilisateur)

Configuration du traitement en boucle :

Le paramètre se trouve dans :

Trois options sont disponibles :

2.2 Les modes Fusion et Remplacer

Mode Fusion (Merge) :

Dans ce mode, les GPO utilisateur sont traitées dans l'ordre suivant :

  1. GPO utilisateur liées à l'emplacement de l'utilisateur (ordre LSDOU normal)
  2. GPO utilisateur liées à l'emplacement de l'ordinateur (ordre LSDOU de l'ordinateur)

Les GPO de l'ordinateur s'appliquent en dernier et ont donc la priorité en cas de conflit.

Exemple pratique - Mode Fusion :

Contexte :

Résultat en mode Fusion :

Si les deux GPO configuraient le même paramètre (ex : fond d'écran), c'est la GPO-Formation qui l'emporterait.

Mode Remplacer (Replace) :

Dans ce mode beaucoup plus restrictif :

  1. Les GPO utilisateur liées à l'emplacement de l'utilisateur sont ignorées
  2. Seules les GPO utilisateur liées à l'emplacement de l'ordinateur sont appliquées

Exemple pratique - Mode Remplacer :

Avec le même contexte que précédemment :

Résultat en mode Remplacer :

Comparaison des modes :

Aspect Mode Fusion Mode Remplacer
GPO utilisateur originales Appliquées en premier Ignorées complètement
GPO utilisateur de l'ordinateur Appliquées en second Seules appliquées
Priorité en cas de conflit GPO de l'ordinateur N/A (pas de conflit possible)
Flexibilité Plus grande Plus restrictive
Usage recommandé Environnements semi-partagés Kiosques et postes verrouillés

Configuration via PowerShell :

# Créer une GPO avec traitement en boucle en mode Fusion New-GPO -Name "GPO-BoucleFusion" -Comment "Mode Fusion activé" Set-GPRegistryValue -Name "GPO-BoucleFusion" `
    -Key "HKLM\Software\Policies\Microsoft\Windows\System" `
    -ValueName "UserPolicyMode" -Type DWord -Value 1
 # Mode Remplacer (Value 2) Set-GPRegistryValue -Name "GPO-BoucleRemplacer" `
    -Key "HKLM\Software\Policies\Microsoft\Windows\System" `
    -ValueName "UserPolicyMode" -Type DWord -Value 2

Vérification du mode appliqué :

Pour vérifier quel mode est actif sur un poste en powershell :

# Afficher le résultat de stratégie gpresult /r /scope:user
 # Dans la section "La stratégie de groupe a été appliquée depuis" # Si traitement en boucle actif, le nom de l'ordinateur apparaîtra

Considérations importantes :

3. Gestion des stratégies de groupe

3.1 Création d'un objet et liaison à une OU

La création et la liaison d'une GPO sont deux opérations distinctes qui peuvent être effectuées simultanément ou séparément.

Création d'une GPO via GPMC :

Méthode 1 - Création et liaison simultanées :

  1. Ouvrir la console GPMC (gpmc.msc)
  2. Naviguer vers l'OU cible dans l'arborescence du domaine
  3. Clic droit sur l'OU > "Créer un objet GPO dans ce domaine, et le lier ici"
  4. Nommer la GPO (ex : "GPO-Securite-Comptabilite")
  5. Optionnel : Sélectionner une GPO Starter comme source
  6. Cliquer sur OK

Méthode 2 - Création puis liaison séparée :

  1. Clic droit sur le conteneur "Objets de stratégie de groupe"
  2. Sélectionner "Nouveau"
  3. Nommer la GPO
  4. Clic droit sur l'OU cible > "Lier un objet GPO existant"
  5. Sélectionner la GPO créée dans la liste

Création via PowerShell :

# Créer une GPO simple New-GPO -Name "GPO-Config-Serveurs" -Comment "Configuration des serveurs de production"  # Créer et lier immédiatement à une OU New-GPO -Name "GPO-Users-RH" -Comment "Paramètres utilisateurs RH" | 
    New-GPLink -Target "OU=RessourcesHumaines,DC=entreprise,DC=local"  # Créer depuis une GPO Starter New-GPO -Name "GPO-Standard-Desktop" -StarterGPOName "Modèle Desktop"  # Lier une GPO existante New-GPLink -Name "GPO-Config-Serveurs" -Target "OU=Serveurs,DC=entreprise,DC=local"  # Créer avec un ordre de lien spécifique (1 = priorité la plus haute) New-GPLink -Name "GPO-Securite-Critique" `
    -Target "OU=Finance,DC=entreprise,DC=local" -LinkEnabled Yes -Order 1

Configuration initiale de la GPO :

Après création, il faut configurer les paramètres :

  1. Clic droit sur la GPO > "Modifier"
  2. L'Éditeur de gestion des stratégies de groupe s'ouvre avec deux branches principales :
    • Configuration ordinateur : Paramètres appliqués aux ordinateurs
    • Configuration utilisateur : Paramètres appliqués aux utilisateurs

Structure des sections :

Chaque configuration (ordinateur/utilisateur) contient :

Stratégies :

Préférences :

Exemple de configuration complète en powershell :

# Créer une GPO de sécurité pour les postes de travail $GPOName = "GPO-Securite-Postes" $TargetOU = "OU=Postes,OU=Workstations,DC=entreprise,DC=local"  # Création New-GPO -Name $GPOName -Comment "Politique de sécurité des postes de travail"  # Liaison New-GPLink -Name $GPOName -Target $TargetOU -LinkEnabled Yes
 # Configuration - Désactiver l'invite de commande Set-GPRegistryValue -Name $GPOName `
    -Key "HKCU\Software\Policies\Microsoft\Windows\System" `
    -ValueName "DisableCMD" -Type DWord -Value 1
 # Configuration - Définir un fond d'écran Set-GPRegistryValue -Name $GPOName `
    -Key "HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\System" `
    -ValueName "Wallpaper" -Type String -Value "\\serveur\partage\wallpaper.jpg"  # Configuration - Complexité du mot de passe Set-GPRegistryValue -Name $GPOName `
    -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System" `
    -ValueName "PasswordComplexity" -Type DWord -Value 1

Bonnes pratiques de création :

Nommage cohérent : Adopter une convention de nommage claire (ex : GPO-[Type]-[Cible]-[Description])

Une GPO = Un objectif : Éviter les GPO fourre-tout. Préférer plusieurs GPO ciblées.

Documentation : Utiliser le champ "Commentaire" pour décrire l'objectif et le contexte.

Tests : Créer d'abord dans une OU de test avant déploiement en production.

Désactivation des sections inutiles : Si une GPO ne contient que des paramètres ordinateur, désactiver la section utilisateur pour optimiser le traitement.

# Désactiver la section utilisateur (Get-GPO -Name "GPO-Config-Serveurs").GpoStatus = "UserSettingsDisabled"  # Désactiver la section ordinateur (Get-GPO -Name "GPO-Profils-Users").GpoStatus = "ComputerSettingsDisabled"  # Désactiver complètement une GPO (Get-GPO -Name "GPO-Temporaire").GpoStatus = "AllSettingsDisabled"

Vérification après création :

# Lister toutes les GPO du domaine Get-GPO -All | Select-Object DisplayName, GpoStatus, CreationTime
 # Afficher les liens d'une GPO Get-GPOReport -Name "GPO-Securite-Postes" -ReportType Html -Path "C:\Rapports\GPO.html"  # Vérifier les paramètres configurés Get-GPRegistryValue -Name "GPO-Securite-Postes" -Key "HKCU\Software\Policies"

3.2 Suppression d'une liaison

La suppression d'une liaison de GPO déconnecte la stratégie de groupe d'une unité d'organisation sans supprimer l'objet GPO lui-même. C'est une opération réversible et sans risque pour la GPO.

Distinction importante :

Suppression via GPMC :

  1. Naviguer vers l'OU contenant le lien
  2. Dans le volet de détails, onglet "Objets de stratégie de groupe liés"
  3. Clic droit sur la GPO liée > "Supprimer le lien"
  4. Confirmer l'opération

Alternative :

Suppression via PowerShell :

# Supprimer un lien spécifique Remove-GPLink -Name "GPO-Config-Temporaire" `
    -Target "OU=Test,DC=entreprise,DC=local"  # Supprimer tous les liens d'une GPO Get-GPO -Name "GPO-Obsolete" | Remove-GPLink -Target * -Confirm:$false  # Supprimer le lien avec confirmation Remove-GPLink -Name "GPO-Production" `
    -Target "OU=Serveurs,DC=entreprise,DC=local" -Confirm
 # Supprimer uniquement si le lien est désactivé $Link = Get-GPInheritance -Target "OU=Marketing,DC=entreprise,DC=local" $Link.GpoLinks | Where-Object {$_.Enabled -eq $false} | ForEach-Object {     Remove-GPLink -Name $_.DisplayName -Target "OU=Marketing,DC=entreprise,DC=local" }

Désactivation temporaire d'un lien :

Plutôt que supprimer, il est souvent préférable de désactiver temporairement :

# Désactiver un lien Set-GPLink -Name "GPO-Maintenance" `
    -Target "OU=Postes,DC=entreprise,DC=local" -LinkEnabled No
 # Réactiver un lien Set-GPLink -Name "GPO-Maintenance" `
    -Target "OU=Postes,DC=entreprise,DC=local" -LinkEnabled Yes
 # Lister les liens désactivés Get-GPO -All | ForEach-Object {     $gpo = $_     Get-GPInheritance -Target "OU=Postes,DC=entreprise,DC=local" | 
    Select-Object -ExpandProperty GpoLinks | 
    Where-Object {$_.Enabled -eq $false -and $_.DisplayName -eq $gpo.DisplayName} }

Vérification après suppression :

# Vérifier les GPO liées à une OU Get-GPInheritance -Target "OU=Finance,DC=entreprise,DC=local" | 
    Select-Object -ExpandProperty GpoLinks
 # Vérifier où une GPO est encore liée (Get-GPO -Name "GPO-Securite").GpoLinks
 # Générer un rapport des liens Get-GPOReport -All -ReportType Html -Path "C:\Rapports\Liens-GPO.html"

Impact de la suppression :

Après suppression d'un lien :

Suppression définitive d'une GPO :

Si vous souhaitez réellement supprimer la GPO :

# Supprimer tous les liens puis la GPO Remove-GPO -Name "GPO-Obsolete"  # Avec sauvegarde préalable Backup-GPO -Name "GPO-Archive" -Path "C:\Backups\GPO" -Comment "Avant suppression" Remove-GPO -Name "GPO-Archive"

3.3 Utilisation des filtres sur le modèle d'administration

Les filtres permettent d'affiner l'application des GPO en ciblant spécifiquement certains objets plutôt que tous les objets d'une OU. Windows Server 2022 propose trois mécanismes principaux de filtrage.

1. Filtrage de sécurité

Le filtrage de sécurité utilise les permissions pour contrôler quels utilisateurs ou ordinateurs peuvent appliquer une GPO.

Principe : Pour qu'une GPO s'applique, l'objet doit avoir les permissions "Lecture" ET "Appliquer la stratégie de groupe".

Configuration via GPMC :

  1. Sélectionner la GPO dans "Objets de stratégie de groupe"
  2. Onglet "Étendue" > Section "Filtrage de sécurité"
  3. Par défaut, "Utilisateurs authentifiés" est présent
  4. Cliquer sur "Ajouter" pour cibler des groupes spécifiques
  5. Supprimer "Utilisateurs authentifiés" si nécessaire

Exemple pratique :

Objectif : Appliquer une GPO uniquement aux ordinateurs portables.

  1. Créer un groupe de sécurité "GRP-Portables"
  2. Ajouter les comptes ordinateurs des portables à ce groupe
  3. Dans la GPO :
    • Supprimer "Utilisateurs authentifiés"
    • Ajouter "GRP-Portables"

Via PowerShell :

# Supprimer les utilisateurs authentifiés Set-GPPermission -Name "GPO-Config-Portables" `
    -TargetName "Utilisateurs authentifiés" -TargetType Group `
    -PermissionLevel None
 # Ajouter un groupe avec droit d'application Set-GPPermission -Name "GPO-Config-Portables" `
    -TargetName "GRP-Portables" -TargetType Group `
    -PermissionLevel GpoApply
 # Créer un filtre pour les ordinateurs d'un site spécifique Set-GPPermission -Name "GPO-Site-Paris" `
    -TargetName "GRP-Ordinateurs-Paris" -TargetType Group `
    -PermissionLevel GpoApply

Exclusion d'objets :

Pour exclure certains objets de l'application d'une GPO :

  1. Onglet "Délégation" de la GPO
  2. Bouton "Avancé"
  3. Ajouter l'utilisateur ou groupe à exclure
  4. Cocher "Lecture" mais décocher "Appliquer la stratégie de groupe"
  5. Cocher "Refuser" pour "Appliquer la stratégie de groupe"
# Refuser explicitement l'application à un groupe Set-GPPermission -Name "GPO-Standard" `
    -TargetName "GRP-Admins-IT" -TargetType Group `
    -PermissionLevel GpoApply -Replace $false  # Puis définir le refus explicite (nécessite manipulation des ACL) $GPO = Get-GPO -Name "GPO-Standard" $GPO.SetSecurityInfo([Microsoft.GroupPolicy.GPPermissionType]::GpoApply, 
    "GRP-Admins-IT", [System.Security.AccessControl.AccessControlType]::Deny)

2. Filtres WMI

Les filtres WMI (Windows Management Instrumentation) permettent d'appliquer des GPO en fonction de critères matériels ou logiciels dynamiques.

Source: https://www.youtube.com/watch?v=QkYToD_suQc&list=PLSuzYIVSEUT46K2OUT987CwC5djqwUlbw&index=29

Cas d'usage :

Création d'un filtre WMI :

  1. Dans GPMC, clic droit sur "Filtres WMI" > "Nouveau"
  2. Nommer le filtre (ex : "RAM-Superieure-8Go")
  3. Ajouter une description
  4. Cliquer sur "Ajouter" et saisir la requête WMI

Exemples de requêtes WMI courantes (en sql) :

-- Ordinateurs avec plus de 8 Go de RAM (8192 Mo) SELECT * FROM Win32_ComputerSystem WHERE TotalPhysicalMemory > 8589934592  -- Systèmes d'exploitation Windows 11 SELECT * FROM Win32_OperatingSystem WHERE Caption LIKE "%Windows 11%"  -- Ordinateurs portables uniquement SELECT * FROM Win32_SystemEnclosure WHERE ChassisTypes = 8 OR ChassisTypes = 9 OR ChassisTypes = 10  -- Disque C: avec plus de 100 Go libres SELECT * FROM Win32_LogicalDisk WHERE DeviceID = "C:" AND FreeSpace > 107374182400  -- Machines virtuelles (Hyper-V) SELECT * FROM Win32_ComputerSystem WHERE Model LIKE "%Virtual%"  -- Ordinateurs d'un site spécifique selon leur adresse IP SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPAddress LIKE "192.168.10.%"  -- Processeurs avec plus de 4 cœurs SELECT * FROM Win32_Processor WHERE NumberOfCores > 4

Association du filtre WMI à une GPO :

  1. Sélectionner la GPO
  2. Onglet "Étendue"
  3. Section "Filtrage WMI" > "Ce filtre est actuellement lié"
  4. Sélectionner le filtre WMI dans la liste
# Créer un filtre WMI via PowerShell nécessite des manipulations ADSI # Voici un exemple pour Windows 11 uniquement $FilterName = "Windows11-Uniquement" $FilterDesc = "Applique uniquement aux postes Windows 11" $FilterQuery = "SELECT * FROM Win32_OperatingSystem WHERE Caption LIKE '%Windows 11%'"  # Création (nécessite module spécifique ou script personnalisé) # La gestion WMI via PowerShell est limitée nativement

Association manuelle :

# Lier un filtre WMI existant (par manipulation de propriétés AD) $GPO = Get-GPO -Name "GPO-Config-Win11" $FilterGuid = (Get-ADObject -Filter "Name -eq 'Windows11-Uniquement'" `
    -SearchBase "CN=SOM,CN=WMIPolicy,CN=System,DC=entreprise,DC=local").ObjectGUID
 Set-ADObject -Identity $GPO.Path -Replace @{gPCWQLFilter=$FilterGuid}

Test d'un filtre WMI :

Sur un ordinateur client (en powershell):

# Tester une requête WMI localement Get-WmiObject -Query "SELECT * FROM Win32_ComputerSystem WHERE TotalPhysicalMemory > 8589934592"  # Si le résultat est vide, la GPO ne s'appliquera pas # Si le résultat retourne des informations, la GPO s'appliquera

3. Ciblage au niveau des éléments (Préférences)

Pour les préférences de stratégie de groupe, un ciblage encore plus fin est disponible au niveau de chaque élément individuel.

Critères de ciblage disponibles :

Configuration du ciblage :

  1. Dans l'éditeur de GPO, créer un élément de préférence
  2. Onglet "Commun"
  3. Cocher "Ciblage au niveau de l'élément"
  4. Cliquer sur "Ciblage..."
  5. Construire les critères avec les opérateurs logiques (ET/OU)

Exemple avec PowerShell :

# Le ciblage des préférences se configure principalement via l'interface graphique # Mais on peut vérifier les préférences configurées Get-GPOReport -Name "GPO-Preferences" -ReportType Xml | Select-Xml -XPath "//User//Drive"

Comparaison des méthodes de filtrage :

Méthode Avantages Inconvénients Usage
Filtrage de sécurité Simple, rapide Nécessite groupes Ciblage par identité
Filtres WMI Très flexible, dynamique Impact performance Ciblage matériel/logiciel
Ciblage préférences Très granulaire Seulement pour préférences Éléments individuels

Bonnes pratiques :

4. Modèles d'administration

4.1 Fichiers ADMX/ADML

Les modèles d'administration définissent les paramètres de registre que les administrateurs peuvent configurer via les stratégies de groupe. Windows Server 2022 utilise le format ADMX/ADML, une évolution du format ADM utilisé dans les versions antérieures.

Source: https://www.youtube.com/watch?v=ECyZtfzWAW8

Fichier ADMX/ADML provenant du livre

/intranet/chapitre_12.zip

Évolution des formats :

Format ADM (ancien) :

Format ADMX/ADML (actuel) :

Structure des fichiers :

Fichiers ADMX :

Fichiers ADML :

Exemples de fichiers :

Fichier ADMX Fonction Fichier ADML associé
Windows.admx Paramètres Windows de base fr-FR\Windows.adml
inetres.admx Internet Explorer fr-FR\inetres.adml
MSEdge.admx Microsoft Edge fr-FR\MSEdge.adml
WindowsDefender.admx Windows Defender fr-FR\WindowsDefender.adml
Office16.admx Microsoft Office 2016/2019 fr-FR\Office16.adml

Structure d'un fichier ADMX (en xml) :

<?xml version="1.0" encoding="utf-8"?> <policyDefinitions xmlns="http://schemas.microsoft.com/GroupPolicy/2006/07/PolicyDefinitions">   <policyNamespaces>     <target prefix="exemple" namespace="Exemple.Policies.Exemple"/>   </policyNamespaces>   
  <resources minRequiredRevision="1.0" />   
  <categories>     <category name="ExempleCategory" displayName="$(string.ExempleCategory)"/>   </categories>   
  <policies>     <policy name="ExemplePolicy" class="Machine" displayName="$(string.ExemplePolicy)"
            explainText="$(string.ExemplePolicy_Help)" key="Software\Policies\Exemple"
            valueName="Parametre">       <parentCategory ref="ExempleCategory"/>       <supportedOn ref="windows:SUPPORTED_Windows_10_0"/>       <enabledValue>         <decimal value="1"/>       </enabledValue>       <disabledValue>         <decimal value="0"/>       </disabledValue>     </policy>   </policies> </policyDefinitions>

Structure d'un fichier ADML (en xml) :

<?xml version="1.0" encoding="utf-8"?> <policyDefinitionResources xmlns="http://schemas.microsoft.com/GroupPolicy/2006/07/PolicyDefinitions">   <displayName>Nom affiché</displayName>   <description>Description</description>   
  <resources>     <stringTable>       <string id="ExempleCategory">Paramètres Exemple</string>       <string id="ExemplePolicy">Activer la fonctionnalité</string>       <string id="ExemplePolicy_Help">         Ce paramètre permet d'activer ou désactiver la fonctionnalité exemple.
        
        Si vous activez ce paramètre, la fonctionnalité sera activée.
        Si vous désactivez ce paramètre, la fonctionnalité sera désactivée.
        Si vous ne configurez pas ce paramètre, le comportement par défaut s'appliquera.
      </string>     </stringTable>   </resources> </policyDefinitionResources>

Ajout de nouveaux modèles :

Pour ajouter des modèles tiers (Office, Chrome, Firefox, Adobe, etc.) :

  1. Télécharger les fichiers ADMX/ADML depuis l'éditeur
  2. Copier les fichiers .admx dans C:\Windows\PolicyDefinitions\
  3. Copier les fichiers .adml dans C:\Windows\PolicyDefinitions\fr-FR\
  4. Redémarrer l'éditeur de stratégie de groupe

Via PowerShell :

# Copier des modèles Office $Source = "\\serveur\partage\Templates\Office" $Dest = "C:\Windows\PolicyDefinitions"  Copy-Item "$Source\*.admx" -Destination $Dest Copy-Item "$Source\fr-FR\*.adml" -Destination "$Dest\fr-FR\"  # Vérifier les modèles installés Get-ChildItem "C:\Windows\PolicyDefinitions\*.admx" | 
    Select-Object Name, Length, LastWriteTime
 # Lister les catégories disponibles Get-ChildItem "C:\Windows\PolicyDefinitions\*.admx" | ForEach-Object {     [xml]$Content = Get-Content $_.FullName
    $Content.policyDefinitions.categories.category | Select-Object name
}

Modèles tiers courants :

Microsoft Office :

Google Chrome :

Mozilla Firefox :

Adobe Reader :

Dépannage des modèles :

# Vérifier les erreurs de syntaxe XML $ADMXPath = "C:\Windows\PolicyDefinitions" Get-ChildItem "$ADMXPath\*.admx" | ForEach-Object {     try {         [xml]$xml = Get-Content $_.FullName
        Write-Host "✓ $($_.Name) : Valide" -ForegroundColor Green
    }     catch {         Write-Host "✗ $($_.Name) : ERREUR" -ForegroundColor Red
        $_.Exception.Message
    } }  # Vérifier la présence des fichiers ADML correspondants Get-ChildItem "$ADMXPath\*.admx" | ForEach-Object {     $ADMLFile = "$ADMXPath\fr-FR\$($_.BaseName).adml"     if (Test-Path $ADMLFile) {         Write-Host "✓ $($_.Name) a son ADML" -ForegroundColor Green
    }     else {         Write-Host "✗ $($_.Name) MANQUE son ADML" -ForegroundColor Yellow
    } }

Création de modèles personnalisés :

Pour créer vos propres modèles ADMX :

  1. Définir les paramètres de registre à gérer
  2. Créer le fichier ADMX avec la structure XML appropriée
  3. Créer le fichier ADML avec les traductions
  4. Tester dans un environnement de laboratoire

Exemple simple de modèle personnalisé :

Fichier : CompanySettings.admx

<?xml version="1.0" encoding="utf-8"?> <policyDefinitions xmlns="http://schemas.microsoft.com/GroupPolicy/2006/07/PolicyDefinitions">   <policyNamespaces>     <target prefix="company" namespace="Company.Policies.Settings"/>   </policyNamespaces>   <resources minRequiredRevision="1.0"/>   
  <categories>     <category name="CompanyCategory" displayName="$(string.CompanyCategory)"/>   </categories>   
  <policies>     <policy name="ProxyServer" class="Machine" 
            displayName="$(string.ProxyServer)" 
            explainText="$(string.ProxyServer_Help)"
            key="Software\Company\NetworkSettings" valueName="ProxyAddress">       <parentCategory ref="CompanyCategory"/>       <supportedOn ref="windows:SUPPORTED_Windows_10_0"/>       <elements>         <text id="ProxyAddress" valueName="ProxyAddress" required="true"/>       </elements>     </policy>   </policies> </policyDefinitions>

Fichier : fr-FR\CompanySettings.adml

<?xml version="1.0" encoding="utf-8"?> <policyDefinitionResources xmlns="http://schemas.microsoft.com/GroupPolicy/2006/07/PolicyDefinitions">   <displayName>Paramètres Entreprise</displayName>   <description>Modèles personnalisés de l'entreprise</description>   
  <resources>     <stringTable>       <string id="CompanyCategory">Paramètres Entreprise</string>       <string id="ProxyServer">Configurer le serveur proxy</string>       <string id="ProxyServer_Help">         Définit l'adresse du serveur proxy pour l'accès Internet.
        Format : adresse:port (exemple : proxy.entreprise.local:8080)
      </string>       <string id="ProxyAddress">Adresse du proxy:</string>     </stringTable>   </resources> </policyDefinitionResources> ```
 ### 4.2 Création d'un magasin central
 Le **magasin central de stratégies** (Central Store) est un emplacement de stockage centralisé pour les fichiers ADMX/ADML, permettant de standardiser les modèles d'administration disponibles dans tout le domaine.
 **Avantages du magasin central** :
 **Cohérence** : Tous les administrateurs utilisent les mêmes versions de modèles
**Centralisation** : Un seul emplacement à maintenir au lieu de chaque poste
**Performance** : Réduit la taille des GPO (les modèles ne sont plus dupliqués)
**Gestion simplifiée** : Mise à jour des modèles en un seul endroit
**Réplication automatique** : Les fichiers sont répliqués via SYSVOL sur tous les DC
 **Emplacement du magasin central** :
 Le magasin central doit être créé dans SYSVOL :
```
\\domaine.local\SYSVOL\domaine.local\Policies\PolicyDefinitions\
```
 Ou localement sur le DC :
```
C:\Windows\SYSVOL\domain\Policies\PolicyDefinitions\

Création du magasin central - Méthode manuelle :

  1. Se connecter à un contrôleur de domaine
  2. Naviguer vers C:\Windows\SYSVOL\domain\Policies\
  3. Créer le dossier PolicyDefinitions
  4. Copier tous les fichiers .admx de C:\Windows\PolicyDefinitions\
  5. Créer les sous-dossiers de langue (ex : fr-FR, en-US)
  6. Copier les fichiers .adml correspondants

Création via PowerShell :

# Variables $DomainName = $env:USERDNSDOMAIN
$SysvolPath = "\\$DomainName\SYSVOL\$DomainName\Policies" $CentralStore = "$SysvolPath\PolicyDefinitions" $LocalADMX = "C:\Windows\PolicyDefinitions"  # Création du magasin central Write-Host "Création du magasin central..." -ForegroundColor Cyan
 # Créer le dossier principal if (-not (Test-Path $CentralStore)) {     New-Item -Path $CentralStore -ItemType Directory -Force
    Write-Host "✓ Dossier PolicyDefinitions créé" -ForegroundColor Green
} else {     Write-Host "! Le magasin central existe déjà" -ForegroundColor Yellow
}  # Copier les fichiers ADMX Write-Host "Copie des fichiers ADMX..." -ForegroundColor Cyan
Copy-Item "$LocalADMX\*.admx" -Destination $CentralStore -Force
Write-Host "✓ Fichiers ADMX copiés" -ForegroundColor Green
 # Copier les dossiers de langue Write-Host "Copie des fichiers de langue..." -ForegroundColor Cyan
$LanguageFolders = Get-ChildItem $LocalADMX -Directory
 foreach ($Folder in $LanguageFolders) {     $DestLang = "$CentralStore\$($Folder.Name)"     
    if (-not (Test-Path $DestLang)) {         New-Item -Path $DestLang -ItemType Directory -Force
    }     
    Copy-Item "$LocalADMX\$($Folder.Name)\*.adml" -Destination $DestLang -Force
    Write-Host "✓ Langue $($Folder.Name) copiée" -ForegroundColor Green
}  # Vérification Write-Host "`nVérification du magasin central..." -ForegroundColor Cyan
$ADMXCount = (Get-ChildItem "$CentralStore\*.admx").Count
$ADMLCount = (Get-ChildItem "$CentralStore\fr-FR\*.adml" -ErrorAction SilentlyContinue).Count
 Write-Host "Fichiers ADMX : $ADMXCount" -ForegroundColor White
Write-Host "Fichiers ADML (fr-FR) : $ADMLCount" -ForegroundColor White
 Write-Host "`n✓ Magasin central créé avec succès!" -ForegroundColor Green
Write-Host "Emplacement : $CentralStore" -ForegroundColor White

Script complet avec gestion des erreurs :

function New-CentralStore {     [CmdletBinding()]     param(         [string]$SourcePath = "C:\Windows\PolicyDefinitions",         [string[]]$Languages = @("fr-FR", "en-US")     )     
    try {         # Récupération du domaine         $Domain = $env:USERDNSDOMAIN
        if (-not $Domain) {             throw "Impossible de déterminer le domaine. Êtes-vous sur un DC?"         }         
        $CentralStore = "\\$Domain\SYSVOL\$Domain\Policies\PolicyDefinitions"         
        Write-Host "=== Création du magasin central ===" -ForegroundColor Cyan
        Write-Host "Domaine : $Domain"         Write-Host "Destination : $CentralStore`n"         
        # Test de l'accès         if (-not (Test-Path "\\$Domain\SYSVOL")) {             throw "Impossible d'accéder à SYSVOL. Vérifiez les permissions."         }         
        # Création du dossier principal         if (-not (Test-Path $CentralStore)) {             New-Item -Path $CentralStore -ItemType Directory -Force | Out-Null             Write-Host "[OK] Dossier PolicyDefinitions créé" -ForegroundColor Green
        }         else {             Write-Host "[INFO] Le magasin central existe déjà" -ForegroundColor Yellow
        }         
        # Copie des ADMX         Write-Host "`nCopie des fichiers ADMX..."         $ADMXFiles = Get-ChildItem "$SourcePath\*.admx"         
        foreach ($File in $ADMXFiles) {             Copy-Item $File.FullName -Destination $CentralStore -Force
        }         Write-Host "[OK] $($ADMXFiles.Count) fichiers ADMX copiés" -ForegroundColor Green
        
        # Copie des langues         Write-Host "`nCopie des fichiers de langue..."         foreach ($Lang in $Languages) {             $SourceLang = "$SourcePath\$Lang"             $DestLang = "$CentralStore\$Lang"             
            if (Test-Path $SourceLang) {                 if (-not (Test-Path $DestLang)) {                     New-Item -Path $DestLang -ItemType Directory -Force | Out-Null                 }                 
                $ADMLFiles = Get-ChildItem "$SourceLang\*.adml"                 foreach ($File in $ADMLFiles) {                     Copy-Item $File.FullName -Destination $DestLang -Force
                }                 Write-Host "[OK] Langue $Lang : $($ADMLFiles.Count) fichiers" -ForegroundColor Green
            }             else {                 Write-Host "[WARN] Langue $Lang non trouvée" -ForegroundColor Yellow
            }         }         
        # Statistiques finales         Write-Host "`n=== Résumé ===" -ForegroundColor Cyan
        $TotalADMX = (Get-ChildItem "$CentralStore\*.admx").Count
        Write-Host "Total ADMX : $TotalADMX"         
        foreach ($Lang in $Languages) {             $LangPath = "$CentralStore\$Lang"             if (Test-Path $LangPath) {                 $TotalADML = (Get-ChildItem "$LangPath\*.adml").Count
                Write-Host "Total ADML ($Lang) : $TotalADML"             }         }         
        Write-Host "`n[SUCCESS] Magasin central créé!" -ForegroundColor Green
        
    }     catch {         Write-Host "`n[ERREUR] $($_.Exception.Message)" -ForegroundColor Red
        return $false     }     
    return $true }  # Exécution New-CentralStore -Languages @("fr-FR", "en-US")

Ajout de modèles supplémentaires au magasin central :

# Fonction pour ajouter des modèles (Office, Chrome, etc.) function Add-ADMXToCentralStore {     param(         [Parameter(Mandatory=$true)]         [string]$SourceFolder,         
        [Parameter(Mandatory=$true)]         [string]$ProductName     )     
    $Domain = $env:USERDNSDOMAIN
    $CentralStore = "\\$Domain\SYSVOL\$Domain\Policies\PolicyDefinitions"     
    Write-Host "Ajout des modèles $ProductName..." -ForegroundColor Cyan
    
    # Copier les ADMX     $ADMXFiles = Get-ChildItem "$SourceFolder\*.admx"     foreach ($File in $ADMXFiles) {         Copy-Item $File.FullName -Destination $CentralStore -Force
        Write-Host "  ✓ $($File.Name)" -ForegroundColor Green
    }     
    # Copier les ADML     $LangFolders = Get-ChildItem $SourceFolder -Directory
    foreach ($Lang in $LangFolders) {         $DestLang = "$CentralStore\$($Lang.Name)"         
        if (-not (Test-Path $DestLang)) {             New-Item -Path $DestLang -ItemType Directory -Force | Out-Null         }         
        $ADMLFiles = Get-ChildItem "$SourceFolder\$($Lang.Name)\*.adml"         foreach ($File in $ADMLFiles) {             Copy-Item $File.FullName -Destination $DestLang -Force
        }         Write-Host "  ✓ Langue $($Lang.Name) : $($ADMLFiles.Count) fichiers" -ForegroundColor Green
    }     
    Write-Host "✓ $ProductName ajouté au magasin central" -ForegroundColor Green
}  # Exemples d'utilisation Add-ADMXToCentralStore -SourceFolder "C:\Temp\Office_Templates" -ProductName "Microsoft Office" Add-ADMXToCentralStore -SourceFolder "C:\Temp\Chrome_Templates" -ProductName "Google Chrome"

Vérification du magasin central :

# Script de vérification function Test-CentralStore {     $Domain = $env:USERDNSDOMAIN
    $CentralStore = "\\$Domain\SYSVOL\$Domain\Policies\PolicyDefinitions"     
    Write-Host "=== Vérification du magasin central ===" -ForegroundColor Cyan
    Write-Host "Emplacement : $CentralStore`n"     
    if (-not (Test-Path $CentralStore)) {         Write-Host "[ERREUR] Le magasin central n'existe pas!" -ForegroundColor Red
        return $false     }     
    # Compter les fichiers     $ADMXCount = (Get-ChildItem "$CentralStore\*.admx" -ErrorAction SilentlyContinue).Count
    Write-Host "Fichiers ADMX : $ADMXCount" -ForegroundColor White
    
    # Langues disponibles     $Languages = Get-ChildItem $CentralStore -Directory
    Write-Host "`nLangues disponibles :"     foreach ($Lang in $Languages) {         $ADMLCount = (Get-ChildItem "$($Lang.FullName)\*.adml").Count
        Write-Host "  - $($Lang.Name) : $ADMLCount fichiers ADML" -ForegroundColor White
    }     
    # Produits détectés     Write-Host "`nProduits détectés :"     $Products = @{         "Office16.admx" = "Microsoft Office 2016/2019/2021"         "chrome.admx" = "Google Chrome"         "firefox.admx" = "Mozilla Firefox"         "inetres.admx" = "Internet Explorer"         "MSEdge.admx" = "Microsoft Edge"     }     
    foreach ($File in $Products.Keys) {         if (Test-Path "$CentralStore\$File") {             Write-Host "  ✓ $($Products[$File])" -ForegroundColor Green
        }         else {             Write-Host "  ✗ $($Products[$File])" -ForegroundColor Gray
        }     }     
    return $true }  # Exécution Test-CentralStore

Utilisation du magasin central :

Une fois créé, le magasin central est automatiquement utilisé :

  1. Fermer tous les éditeurs de stratégie de groupe ouverts
  2. Rouvrir l'éditeur de GPO
  3. Les modèles du magasin central sont automatiquement chargés
  4. Vérification dans : Configuration ordinateur/utilisateur > Stratégies > Modèles d'administration

Priorité de chargement :

L'éditeur de GPO charge les modèles dans cet ordre :

  1. Magasin central (si présent)
  2. Répertoire local C:\Windows\PolicyDefinitions

Maintenance du magasin central :

# Synchroniser le magasin central avec les modèles locaux function Sync-CentralStore {     $Domain = $env:USERDNSDOMAIN
    $CentralStore = "\\$Domain\SYSVOL\$Domain\Policies\PolicyDefinitions"     $LocalStore = "C:\Windows\PolicyDefinitions"     
    Write-Host "Synchronisation du magasin central..." -ForegroundColor Cyan
    
    # Synchroniser les ADMX     robocopy $LocalStore $CentralStore "*.admx" /MIR /NJH /NJS /NDL /NC /NS
    
    # Synchroniser les langues     robocopy "$LocalStore\fr-FR" "$CentralStore\fr-FR" "*.adml" /MIR /NJH /NJS /NDL /NC /NS
    robocopy "$LocalStore\en-US" "$CentralStore\en-US" "*.adml" /MIR /NJH /NJS /NDL /NC /NS
    
    Write-Host "✓ Synchronisation terminée" -ForegroundColor Green
}

Dépannage :

# Vérifier quel magasin est utilisé # L'éditeur de GPO utilise le magasin central si disponible $Domain = $env:USERDNSDOMAIN
$CentralStore = "\\$Domain\SYSVOL\$Domain\Policies\PolicyDefinitions"  if (Test-Path $CentralStore) {     Write-Host "Magasin central ACTIF" -ForegroundColor Green
    Write-Host "Les GPO utilisent : $CentralStore" } else {     Write-Host "Magasin LOCAL utilisé" -ForegroundColor Yellow
    Write-Host "Les GPO utilisent : C:\Windows\PolicyDefinitions" }

Références

Console GPMC : https://learn.microsoft.com/fr-fr/windows-server/identity/ad-ds/manage/group-policy/group-policy-management-console

Starter GPO : https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/dn789192(v=ws.11)

Magasin central ADMX : https://learn.microsoft.com/en-us/troubleshoot/windows-client/group-policy/create-and-manage-central-store

Fonctionnement de Group Policy : https://learn.microsoft.com/en-us/windows-server/identity/ad-ds/manage/group-policy/group-policy-overview