Accéder au contenu principal

Un auto-entrepreneur passionné à votre service,

Pour votre projet de site internet et vos dépannages informatiques

WinGet configure : préparer un PC Windows 11 en une seule commande grâce à un fichier YAML

Publié le 10 Novembre 2026, dernière mise à jour le 10 Novembre 2026

Installer Windows, c'est l'affaire d'une heure. Le transformer ensuite en machine prête à l'emploi, avec les bons logiciels, les bons réglages et ces petites options que j'active toujours de la même façon, c'est souvent une demi-journée de clics. WinGet, le gestionnaire de paquets de Microsoft, sait faire bien plus que de simples winget install. Couplé à DSC (Desired State Configuration), il lit un fichier YAML qui décrit l'état attendu du PC et l'applique d'un seul coup : logiciels, Registre, Explorateur, barre des tâches, fonctionnalités Windows comme WSL, scripts PowerShell. Le fichier s'écrit une fois et se rejoue autant de fois qu'on veut. Je vous montre ici comment ça marche, avec un exemple complet pour Windows 11 que vous pourrez adapter, et quelques ajouts que je n'avais pas détaillés jusqu'ici : les dépendances entre ressources, l'activation de WSL et le lancement d'un fichier hébergé sur Git.

WinGet DSC, de quoi parle-t-on exactement ?

Derrière le nom un peu barbare de « WinGet DSC » se cachent deux briques que Microsoft fait travailler ensemble.

WinGet
Le gestionnaire de paquets en ligne de commande, livré d'office avec Windows 10 et 11 via le composant « Programme d'installation d'application » (App Installer). Une commande comme winget install VideoLAN.VLC télécharge et installe VLC sans passer par un navigateur ni par un assistant d'installation. Le projet est open source et son code est disponible sur GitHub.
DSC (Desired State Configuration)
Le système de gestion de configuration de Microsoft. On n'y décrit pas les étapes à exécuter, on décrit le résultat attendu : « VLC doit être installé », « les extensions de fichiers doivent être visibles ». L'outil compare ensuite l'état réel de la machine avec cet état désiré et ne corrige que ce qui diffère. Ceux qui connaissent Ansible retrouveront la même philosophie.

Concrètement, je rédige cet état désiré dans un fichier YAML, puis je le confie à WinGet avec la commande winget configure. WinGet télécharge les modules nécessaires, demande l'élévation des droits quand il le faut et enchaîne les actions. Moi, je vais chercher un café.

Une précision qui évite bien des confusions dans les forums : on parle parfois de « PowerShell DSC » et parfois de « Microsoft DSC 3.0 ». Le format de fichier classique de WinGet (schéma 0.2, celui de ce tutoriel) s'appuie sur des ressources PowerShell DSC, comme le module PSDscResources. Microsoft DSC v3 est un moteur plus récent et autonome (l'exécutable dsc.exe), que WinGet sait aussi piloter avec un format de fichier dédié. J'y reviens plus bas.

Ce qu'un fichier de configuration peut piloter

Un fichier WinGet ne se limite pas à une liste de logiciels. Voici les principaux types d'actions que j'utilise ou que l'on croise dans les exemples officiels.

Les principales ressources disponibles avec le schéma 0.2
Domaine Ce que l'on peut faire Ressource utilisée (schéma 0.2)
Logiciels Installer une application depuis le dépôt WinGet ou le Microsoft Store Microsoft.WinGet.DSC/WinGetPackage
Registre Créer, modifier ou supprimer une clé ou une valeur PSDscResources/Registry
Variables d'environnement Ajouter ou modifier une variable système ou utilisateur PSDscResources/Environment
Services Démarrer, arrêter ou changer le mode de démarrage d'un service Windows PSDscResources/Service
Scripts Exécuter du code PowerShell pour tout ce qui n'a pas de ressource dédiée PSDscResources/Script
Réglages de Windows Explorateur de fichiers, barre des tâches, mode développeur, chemins longs, contrôle de compte d'utilisateur… Microsoft.Windows.Developer/… et Microsoft.Windows.Settings/…
Fonctionnalités Windows Activer ou désactiver une fonctionnalité facultative (WSL, Hyper-V, Bac à sable…) PSDscResources/WindowsOptionalFeature ou modules dédiés

Anatomie d'un fichier WinGet configure

Le nom et l'extension

Rien de compliqué : un fichier YAML classique avec l'extension .yaml ou .yml. Microsoft recommande désormais l'extension .winget, qui permet de repérer ces fichiers au premier coup d'œil. Dans un projet Git, la convention veut qu'on place la configuration par défaut dans ./.config/configuration.winget. Pour ce tutoriel, je nomme mon fichier winget-dsc-windows11.yaml.

La ligne de schéma

La première ligne indique le schéma utilisé. Elle sert surtout aux éditeurs comme Visual Studio Code, qui proposent alors l'autocomplétion et signalent les erreurs de structure pendant la saisie (avec l'extension YAML de Red Hat installée) :

# yaml-language-server: $schema=https://aka.ms/configuration-dsc-schema/0.2

Les deux grandes sections

Sous le nœud properties, le fichier se découpe en deux parties :

assertions
Les conditions à remplir avant d'aller plus loin. Si une assertion échoue, rien n'est appliqué. Exemple typique : exiger une version minimale de Windows.
resources
La liste des éléments à mettre en conformité : logiciels à installer, valeurs de Registre, réglages de l'interface, fonctionnalités, scripts. C'est le cœur du fichier.

Le bloc se termine par la ligne configurationVersion: 0.2.0, qui indique à WinGet comment interpréter le contenu.

Les directives communes

Chaque bloc peut recevoir des directives. Trois reviennent tout le temps, et une quatrième propriété mérite qu'on s'y arrête :

description
Un texte libre qui s'affiche pendant l'exécution. Rien d'obligatoire, mais quand je relis mon fichier six mois plus tard, je suis content de l'avoir rempli.
securityContext
Avec la valeur elevated, l'action s'exécute avec les droits administrateur (WinGet affiche alors une demande UAC). Avec current, elle tourne dans le contexte de l'utilisateur connecté. N'élevez que ce qui en a vraiment besoin : une installation à l'échelle de la machine ou une clé sous HKLM, oui ; un réglage de l'Explorateur, non.
allowPrerelease
Autorise l'utilisation de modules en préversion. C'est encore indispensable pour le module Microsoft.Windows.Developer, publié sur la PowerShell Gallery en version préliminaire.
dependsOn
Ce n'est pas une directive mais une propriété du bloc : elle liste les id des ressources qui doivent être appliquées avant celle-ci. Je m'en sers plus bas dans l'exemple.

Enfin, dans la section resources, le champ id de chaque bloc est un nom libre. Choisissez quelque chose de parlant (Package.VLC, Registry.RegBackup) : c'est lui qui apparaît dans les journaux, et c'est lui qu'on cite dans un dependsOn.

Tutoriel pas à pas sur Windows 11

Étape 1 : activer les fonctionnalités étendues de WinGet

Ouvrez un Terminal Windows (PowerShell ou invite de commandes). Cette étape ne se fait qu'une seule fois par machine :

winget configure --enable
Enabling extended features. Requires store access.
  ██████████████████████████████  100%

Elle débloque la commande winget configure et ses sous-commandes. Comme l'indique le message, un accès au Microsoft Store est nécessaire : sur un poste où le Store est bloqué par une stratégie de groupe, cette étape échouera.

Pour connaître votre version de WinGet, tapez winget --version. Si vous êtes en retard, une mise à jour du « Programme d'installation d'application » via le Microsoft Store suffit. Début novembre 2026, la branche stable est la 1.29 (dernière version : 1.29.380, publiée le 21 septembre) et la 1.30 circule en préversion (1.30.140-preview). WinGet évolue vite : la page des versions du projet reste la référence pour savoir où on en est.

Étape 2 : définir ce que l'on veut obtenir

Mon fichier winget-dsc-windows11.yaml va réaliser les actions suivantes :

  • vérifier que la machine tourne au minimum sous Windows 11 24H2 ;
  • installer VLC Media Player, 7-Zip, Firefox ESR en français et Foxit PDF Reader depuis le dépôt WinGet ;
  • installer PowerToys depuis le Microsoft Store ;
  • activer la valeur de Registre EnablePeriodicBackup, qui remet en route la sauvegarde automatique du Registre (désactivée par défaut depuis Windows 10 1803) ;
  • régler l'Explorateur de fichiers pour afficher les extensions et masquer les fichiers cachés ;
  • aligner la barre des tâches à gauche, afficher la recherche avec son libellé, garder le bouton Vue des tâches et masquer celui des widgets ;
  • activer le Sous-système Windows pour Linux (WSL) ;
  • créer un dossier C:\sources via un script PowerShell, surtout pour montrer comment intégrer du code maison, et le faire uniquement après l'installation de 7-Zip grâce à dependsOn.

Étape 3 : trouver l'identifiant des paquets

Pour chaque logiciel, il faut connaître son identifiant exact et sa source. WinGet les donne directement :

winget search <nom du logiciel>
winget search powertoys

Dans le résultat, repérez la colonne ID et la colonne Source. Pour PowerToys, la version du Microsoft Store porte l'identifiant XP89DCGQ3K6VLD avec la source msstore. La même application existe aussi dans le dépôt communautaire sous l'identifiant Microsoft.PowerToys (source winget), libre à vous de choisir.

Même réflexe pour Foxit : winget search foxit renvoie plusieurs variantes. J'utilise Foxit.FoxitReader, l'identifiant historique du lecteur gratuit. Vérifiez toujours l'ID avant de l'inscrire dans le fichier : une faute de frappe, et la ressource échoue. Pour lever le doute, winget show --id Foxit.FoxitReader affiche l'éditeur, la version et l'URL de l'installeur.

Si vous préférez un outil graphique pour trouver les identifiants, winstall permet de parcourir le dépôt WinGet depuis un navigateur et affiche l'ID de chaque paquet.

Étape 4 : écrire le fichier de configuration

Voici le fichier complet. Il se lit assez naturellement, même sans connaître DSC :

# yaml-language-server: $schema=https://aka.ms/configuration-dsc-schema/0.2
properties:
  assertions:
    - resource: Microsoft.Windows.Developer/OsVersion
      directives:
        description: Verifier la version minimale de Windows (11 24H2)
        allowPrerelease: true
      settings:
        MinVersion: '10.0.26100'
  resources:
    - resource: Microsoft.WinGet.DSC/WinGetPackage
      id: Package.VLC
      directives:
        description: Installation de VLC Media Player
        securityContext: elevated
      settings:
        id: VideoLAN.VLC
        source: winget
    - resource: Microsoft.WinGet.DSC/WinGetPackage
      id: Package.7Zip
      directives:
        description: Installation de 7-Zip
        securityContext: elevated
      settings:
        id: 7zip.7zip
        source: winget
    - resource: Microsoft.WinGet.DSC/WinGetPackage
      id: Package.Firefox
      directives:
        description: Installation de Mozilla Firefox ESR
        securityContext: current
      settings:
        id: Mozilla.Firefox.ESR.fr
        source: winget
    - resource: Microsoft.WinGet.DSC/WinGetPackage
      id: Package.FoxitReader
      directives:
        description: Installation de Foxit PDF Reader
        securityContext: elevated
      settings:
        id: Foxit.FoxitReader
        source: winget
    - resource: Microsoft.WinGet.DSC/WinGetPackage
      id: Package.PowerToys
      directives:
        description: Installation de PowerToys
        securityContext: current
      settings:
        id: XP89DCGQ3K6VLD
        source: msstore
    - resource: PSDscResources/Registry
      id: Registry.RegBackup
      directives:
        description: Activation de la sauvegarde automatique du Registre
        securityContext: elevated
      settings:
        Key: 'HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Configuration Manager'
        ValueName: 'EnablePeriodicBackup'
        ValueData: 1
        ValueType: Dword
        Ensure: Present
        Force: true
    - resource: Microsoft.Windows.Developer/WindowsExplorer
      id: Settings.Explorer
      directives:
        description: Reglages de l'Explorateur de fichiers
        allowPrerelease: true
      settings:
        FileExtensions: Show
        HiddenFiles: Hide
        RestartExplorer: True
    - resource: Microsoft.Windows.Developer/Taskbar
      id: Settings.Taskbar
      directives:
        description: Reglages de la barre des taches
        allowPrerelease: true
      settings:
        Alignment: Left
        SearchBoxMode: ShowIconAndLabel
        TaskViewButton: Show
        WidgetsButton: Hide
    - resource: PSDscResources/WindowsOptionalFeature
      id: Feature.WSL
      directives:
        description: Activation du Sous-systeme Windows pour Linux
        securityContext: elevated
      settings:
        Name: Microsoft-Windows-Subsystem-Linux
        Ensure: Present
    - resource: PSDscResources/Script
      id: PowerShell.SourcesFolder
      dependsOn:
        - Package.7Zip
      directives:
        description: Creation du dossier C:\sources
        securityContext: elevated
        allowPrerelease: true
      settings:
        # GetScript : renvoie l'etat actuel (obligatoire, sinon la ressource echoue)
        GetScript: |
          $exist = Test-Path 'C:\sources'
          return @{ Result = if ($exist) { "Present" } else { "Absent" } }
        # TestScript : $true si le dossier existe (rien a faire),
        # $false s'il manque (SetScript sera lance)
        TestScript: |
          return (Test-Path 'C:\sources')
        # SetScript : creation du dossier, uniquement si TestScript renvoie $false
        SetScript: |
          New-Item -Path 'C:\sources' -ItemType Directory -Force
  configurationVersion: 0.2.0

Quelques remarques sur ce fichier :

  • Firefox ESR et PowerToys s'installent dans le contexte utilisateur (current), alors que VLC, 7-Zip et Foxit, installés pour toute la machine, demandent l'élévation.
  • Les ressources WindowsExplorer et Taskbar touchent des réglages propres à l'utilisateur : pas besoin de droits administrateur. Le paramètre RestartExplorer: True relance l'Explorateur pour que les changements soient visibles tout de suite. J'ai ajouté un id à ces deux blocs, ce n'est pas obligatoire mais les journaux sont plus lisibles.
  • La ressource Script repose sur un trio GetScript / TestScript / SetScript. C'est ce qui la rend idempotente : si le dossier existe déjà, le script de création n'est jamais lancé.
  • J'ai volontairement retiré les accents des descriptions. Certaines consoles les affichent mal selon l'encodage du fichier ; si vous les gardez, enregistrez le YAML en UTF-8.

Zoom sur dependsOn : imposer un ordre

Par défaut, WinGet ne garantit pas que les ressources s'exécutent dans l'ordre où elles sont écrites. La plupart du temps, ça n'a aucune importance. Mais dès qu'une étape a besoin d'une autre (un script qui utilise 7z.exe, un réglage de Visual Studio Code qui suppose que l'éditeur est installé, une extension WSL qui attend que la fonctionnalité soit active), il faut le dire explicitement. C'est le rôle de dependsOn, placé au même niveau que resource et id :

    - resource: PSDscResources/Script
      id: PowerShell.SourcesFolder
      dependsOn:
        - Package.7Zip

On peut citer plusieurs identifiants. Si une ressource dont on dépend échoue, celle qui en dépend n'est pas exécutée, ce qui évite des erreurs en cascade difficiles à lire. Dans mon exemple la dépendance est un peu artificielle (créer un dossier n'a pas besoin de 7-Zip), mais elle montre la syntaxe. Dans la vraie vie, je l'utilise surtout pour mes scripts qui configurent un logiciel juste après son installation.

Zoom sur WSL : activer une fonctionnalité de Windows

La ressource PSDscResources/WindowsOptionalFeature active ou désactive une fonctionnalité facultative de Windows, exactement comme le panneau « Activer ou désactiver des fonctionnalités Windows ». Le nom à fournir est le nom technique : pour le retrouver, lancez dans un PowerShell administrateur Get-WindowsOptionalFeature -Online | Select-Object FeatureName, State. Quelques valeurs que j'utilise souvent :

  • Microsoft-Windows-Subsystem-Linux pour WSL ;
  • VirtualMachinePlatform, nécessaire à WSL 2 ;
  • Containers-DisposableClientVM pour le Bac à sable Windows (éditions Pro et supérieures) ;
  • Microsoft-Hyper-V-All pour Hyper-V (éditions Pro et supérieures).

Activer une fonctionnalité Windows demande presque toujours un redémarrage pour être effectif. WinGet ne redémarre pas la machine tout seul : relancez le PC à la fin de la configuration, puis installez votre distribution avec wsl --install -d Ubuntu. Si vous voulez WSL 2, ajoutez un second bloc pour VirtualMachinePlatform.

Étape 5 : valider la syntaxe

Avant de toucher à la machine, je passe toujours le fichier au vérificateur intégré :

winget configure validate <fichier de configuration>
winget configure validate winget-dsc-windows11.yaml
La validation n'a détecté aucun problème.

La commande distingue les erreurs bloquantes des simples avertissements. Exemple d'avertissement fréquent : écrire Registry au lieu de PSDscResources/Registry. Ce n'est pas faux en soi, mais plusieurs modules proposent une ressource portant ce nom, et WinGet préfère que vous précisiez lequel vous voulez. Un dependsOn qui cite un id inexistant est lui aussi signalé à cette étape.

Étape 6 : appliquer la configuration

Quand tout est vert, je lance :

winget configure --file winget-dsc-windows11.yaml --accept-configuration-agreements

WinGet télécharge les modules nécessaires, puis déroule chaque ressource en affichant sa progression. Un petit bouclier à côté d'une ligne signale une action exécutée avec des droits élevés. Les changements sont visibles en direct : la barre des tâches bascule à gauche, l'Explorateur redémarre, les logiciels apparaissent dans le menu Démarrer. Sur une machine fraîchement installée, comptez une dizaine de minutes selon votre connexion, l'essentiel du temps passant dans les téléchargements.

L'option --accept-configuration-agreements accepte d'office l'avertissement de sécurité affiché au lancement. C'est pratique avec vos propres fichiers, mais ne l'utilisez jamais avec un fichier récupéré sur Internet sans l'avoir lu ligne par ligne : il peut installer n'importe quoi et exécuter n'importe quel script avec les droits administrateur. Microsoft détaille d'ailleurs, dans sa présentation de WinGet Configuration, comment vérifier la fiabilité d'un fichier de configuration.

Étape 7 : vérifier que la machine est conforme

Une fois la configuration appliquée, la sous-commande test compare l'état réel du PC avec le fichier, sans rien modifier :

winget configure test -f winget-dsc-windows11.yaml --accept-configuration-agreements

C'est très utile pour contrôler un poste quelques semaines plus tard : si quelqu'un a désinstallé 7-Zip ou réactivé les widgets, le test le signalera. Et si vous relancez winget configure avec le même fichier, seules les différences seront corrigées. Le reste est simplement vérifié puis ignoré.

Lancer un fichier hébergé sur un dépôt Git

Une fois mon fichier au point, je ne le garde pas sur une clé USB. Je le range dans un dépôt Git, ce qui me donne un historique de chaque modification et me permet de le récupérer depuis n'importe quel PC. Le paramètre -f accepte directement une URL, il suffit de pointer vers la version « brute » du fichier :

winget configure -f https://raw.githubusercontent.com/votre-compte/votre-depot/main/.config/configuration.winget

Sur un PC neuf, c'est imbattable : un Terminal, l'activation des fonctionnalités étendues, cette commande, et c'est parti. Le même principe fonctionne avec GitLab, Forgejo ou n'importe quel serveur qui renvoie le fichier en texte brut.

Pointer vers une branche (main) veut dire que la prochaine exécution prendra la dernière version du fichier, quelle qu'elle soit. Si le dépôt est public ou partagé, protégez la branche, ou utilisez l'URL d'un commit précis pour figer le contenu. Et n'y mettez jamais de mot de passe ni de clé de licence en clair.

Les autres sous-commandes à connaître

La commande winget configure en propose d'autres, que la plupart des tutoriels passent sous silence.

Sous-commandes de winget configure
Sous-commande Rôle Exemple
validate Vérifie la syntaxe et la cohérence du fichier winget configure validate -f config.winget
show Affiche le détail de chaque ressource sans rien appliquer winget configure show -f config.winget
test Indique si la machine respecte l'état décrit winget configure test -f config.winget
list Liste les configurations déjà appliquées sur le système winget configure list
export Génère un fichier de configuration à partir de paquets ou de ressources winget configure export -o config.winget --all

La référence de la commande winget configure détaille toutes les options de chacune.

Gagner du temps avec winget configure export

Écrire un fichier à la main, c'est formateur. Mais quand j'ai déjà un PC configuré comme je l'aime, autant partir de lui. La sous-commande export sert exactement à ça :

winget configure export -o mon-pc.winget --all

Avec --all, WinGet recense les paquets installés depuis ses sources configurées et les réglages qu'il sait lire, puis écrit le tout dans un fichier prêt à être rejoué. On peut aussi exporter un seul paquet avec --package-id. Le résultat demande presque toujours un peu de ménage : on y trouve des pilotes, des runtimes et des composants qu'on n'a pas forcément envie de réinstaller ailleurs. Mais pour obtenir une première base, c'est bien plus rapide que de tout taper.

Pour un simple inventaire de logiciels, sans aucun réglage, le couple plus ancien winget export / winget import (au format JSON) reste plus simple. winget configure prend tout son intérêt dès qu'on veut ajouter des paramètres Windows, du Registre, des fonctionnalités ou des scripts.

Schéma 0.2 ou format v3 : lequel choisir en 2026 ?

Depuis la version 1.11, WinGet sait lire un second format de fichier, basé directement sur le moteur Microsoft DSC v3, documenté dans la documentation de Microsoft DSC. La structure change : plus de nœud properties, les ressources sont à la racine, et les noms de ressources sont simplifiés. Voici à quoi ressemblent l'installation de VLC et la valeur de Registre de mon exemple dans ce format, avec l'URL de schéma « bundled » qu'utilisent les exemples récents :

# yaml-language-server: $schema=https://aka.ms/dsc/schemas/v3/bundled/config/document.vscode.json
$schema: https://aka.ms/dsc/schemas/v3/bundled/config/document.json
metadata:
  winget:
    processor:
      identifier: dscv3
resources:
- type: Microsoft.WinGet/Package
  name: VLC
  properties:
    id: VideoLAN.VLC
    source: winget
    useLatest: true
  metadata:
    winget:
      securityContext: elevated
    description: Installation de VLC Media Player
- type: Microsoft.Windows/Registry
  name: RegBackup
  properties:
    keyPath: HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Configuration Manager
    valueName: EnablePeriodicBackup
    valueData:
      DWord: 1
    _exist: true
  metadata:
    winget:
      securityContext: elevated
    description: Activation de la sauvegarde automatique du Registre

La première ligne commentée sert, comme pour le schéma 0.2, à l'autocomplétion dans VS Code ; la ligne $schema est celle que lit le moteur. Si votre version de DSC refuse cette URL, ouvrez un exemple récent du dépôt officiel et reprenez la ligne qui y figure : Microsoft a déjà fait évoluer ces adresses et pourrait recommencer. Le moteur v3 (paquet Microsoft.DesiredStateConfiguration) est installé automatiquement par WinGet la première fois qu'il en a besoin. Voici comment je résume les différences :

Schéma 0.2 et format v3 comparés
Critère Schéma 0.2 Format v3 (dscv3)
Version de WinGet requise 1.6 et suivantes 1.11 et suivantes
Structure Ressources imbriquées sous properties Ressources à la racine du document
Installation des modules PowerShell Automatique À déclarer soi-même pour les ressources « adaptées »
Rapidité Correcte, mais certaines ressources PowerShell sont lentes Nettement plus rapide avec les ressources natives (Registre, paquets)
Dépendances entre ressources dependsOn disponible dependsOn disponible
Maturité et exemples Très documenté, nombreux exemples Plus récent, quelques bugs encore ouverts
Mon verdict Le bon choix pour débuter et pour un fichier court À privilégier quand le fichier grossit ou contient beaucoup de Registre

Mon conseil : pour débuter ou pour une configuration simple, le schéma 0.2 reste le plus confortable, justement parce que WinGet installe tout seul les modules dont il a besoin. Le format v3 devient intéressant quand le fichier grossit. Le gain de vitesse est surtout spectaculaire avec le Registre : selon le guide de conversion publié dans le dépôt d'exemples WinGet DSC, un fichier rempli de ressources PSDscResources/Registry peut passer de plusieurs dizaines de minutes d'évaluation à quelques minutes une fois converti vers la ressource native Microsoft.Windows/Registry. Ce guide explique aussi, ressource par ressource, comment passer d'un format à l'autre.

Les pièges à connaître avant de se lancer

  • Le Microsoft Store bloqué. L'activation des fonctionnalités étendues et l'installation de paquets msstore passent par le Store. En entreprise, vérifiez les stratégies de groupe avant de vous arracher les cheveux.
  • Les modules en préversion. Sans allowPrerelease: true, les ressources Microsoft.Windows.Developer ne se chargent pas, faute de version stable publiée.
  • L'élévation à tout-va. Mettre securityContext: elevated partout semble pratique, mais certaines applications s'installent alors dans le mauvais profil et certains réglages utilisateur ne s'appliquent pas au bon compte.
  • Les identifiants qui changent. Un éditeur peut renommer son paquet ou en publier une variante (Foxit en est un bon exemple). Un winget search de contrôle avant chaque grosse campagne de déploiement évite les surprises.
  • Le redémarrage oublié. Une fonctionnalité Windows activée (WSL, Hyper-V, Bac à sable) n'est pas utilisable avant un redémarrage. Si une ressource suivante en dépend, elle échouera au premier passage : redémarrez et relancez simplement le fichier.
  • Les fichiers trouvés en ligne. Un fichier de configuration est l'équivalent d'un script exécuté en administrateur. Lisez-le avant de le lancer, toujours, même s'il vient de votre propre dépôt et que quelqu'un d'autre y a accès.

Questions fréquentes

WinGet configure fonctionne-t-il sous Windows 10 ?
Oui, la commande est disponible sur Windows 10 comme sur Windows 11, à condition d'avoir une version récente de WinGet. Pensez à adapter l'assertion de version minimale de l'exemple, qui exige Windows 11 24H2 (build 26100). Gardez aussi en tête que Windows 10 n'est plus supporté depuis le 14 octobre 2025 et que le programme de mises à jour de sécurité étendues (ESU) pour les particuliers a pris fin en octobre 2026 : je réserve donc ce cas aux postes en transition, avant leur passage à Windows 11.
Mon assertion 24H2 bloque-t-elle les versions plus récentes de Windows 11 ?
Non. MinVersion fixe un plancher, pas une version exacte. Windows 11 25H2 (build 26200) et 26H2, plus récents, passent l'assertion sans problème. Si vous voulez exiger la 25H2 au minimum, remplacez simplement la valeur par '10.0.26200'. Pour connaître la build d'un PC, tapez winver.
Peut-on lancer un fichier de configuration hébergé en ligne ?
Oui, le paramètre -f accepte une URL, comme je l'explique plus haut avec un dépôt Git. C'est pratique pour centraliser ses configurations, à condition de maîtriser ce dépôt.
Que se passe-t-il si je relance le même fichier ?
Rien de fâcheux. DSC teste chaque ressource et n'agit que sur celles qui ne sont pas conformes. On peut donc rejouer le fichier régulièrement pour remettre un poste d'aplomb.
Faut-il installer PowerShell 7 ?
Pas pour le schéma 0.2 : WinGet gère son propre environnement. Pour le format v3, certaines ressources de script s'appuient sur PowerShell 7, que l'on peut installer dans le même fichier avec le paquet Microsoft.PowerShell.
WinGet configure remplace-t-il Intune ou un outil de déploiement d'entreprise ?
Non. Il n'y a ni console centrale ni rapport de conformité sur un parc. Pour quelques postes, un PC personnel ou une machine de développement, c'est en revanche largement suffisant. En entreprise, Microsoft Intune reste l'outil prévu pour gérer une flotte.

Mon avis sur WinGet configure

WinGet configure apporte à Windows une approche que les administrateurs Linux connaissent depuis longtemps : décrire une machine plutôt que la bricoler. Par rapport au script PowerShell maison, le gain tient en deux points. Le fichier est lisible par n'importe qui, même sans être développeur. Et il est idempotent : on peut le relancer sans crainte, seules les étapes manquantes seront exécutées.

Tout n'est pas parfait. La cohabitation entre le schéma 0.2 et le format v3 sème un peu de confusion, le module Microsoft.Windows.Developer reste en préversion et la documentation française a souvent un temps de retard sur l'anglaise. Mais pour préparer un PC neuf, remonter un poste de développement ou remettre d'aplomb une machine après une réinstallation, je le recommande sans hésiter. Écrivez votre fichier une fois, rangez-le sur un dépôt Git, et la prochaine installation de Windows se terminera par une seule commande.

Pour aller plus loin, la documentation officielle de Microsoft reste la meilleure source :

Source

Comment cet article a-t-il été réalisé ? Le texte a été rédigé par mes soins, puis relu avec l'aide d'une intelligence artificielle afin de corriger d'éventuelles erreurs d'orthographe ou de grammaire. L'illustration de présentation a également été créée à l'aide de l'IA.