Windows System

Winget Teil 12 – Rechner mit Configure automatisieren

Mit Winget Configure lassen sich komplette Windows-Rechner deklarativ konfigurieren. Lernen Sie YAML, DSC, Validierung, Tests, Configuration as Code und automatisierte Deployments kennen.

15 min Lesezeit
Grafik: Winget Configure - Windows automatisch konfigurieren

Winget Configure – Rechner automatisch konfigurieren

Teil 12 der Winget-Serie

Teaser

Mit winget configure wird aus dem Windows Package Manager ein Werkzeug für reproduzierbare Systemkonfigurationen. Software, Abhängigkeiten und Windows-Einstellungen lassen sich deklarativ in YAML-Dateien beschreiben und mithilfe von PowerShell Desired State Configuration umsetzen. Dieser Beitrag zeigt ausführlich, wie WinGet Configuration funktioniert, wie Konfigurationsdateien aufgebaut werden und wie sie validiert, getestet, versioniert und für automatisierte Deployments eingesetzt werden können.


Einleitung

Bisher haben wir Winget hauptsächlich verwendet, um einzelne Aktionen auszuführen.

Zum Beispiel:

winget install --id Microsoft.VisualStudioCode --exact

oder:

winget upgrade --all

Mit eigenen PowerShell-Skripten können bereits mehrere dieser Aktionen kombiniert werden.

Doch bei größeren oder standardisierten Umgebungen entsteht schnell eine andere Fragestellung:

Wie soll dieser Rechner eigentlich vollständig konfiguriert sein?

Genau hier setzt WinGet Configuration an.

Statt viele einzelne Installationsbefehle auszuführen, wird der gewünschte Zustand des Rechners in einer Konfigurationsdatei beschrieben.

Vereinfacht:

Manuelle Administration

Programm installieren
        ↓
Einstellung ändern
        ↓
weiteres Programm installieren
        ↓
Registry konfigurieren
        ↓
weitere Einstellungen

wird zu:

Konfigurationsdatei
        ↓
winget configure
        ↓
Desired State Configuration
        ↓
Windows wird konfiguriert
        ↓
definierter Zielzustand

Damit bewegen wir uns deutlich in Richtung Configuration as Code.


Was ist Winget Configure?

Der zentrale Befehl lautet:

winget configure

Er verwendet eine WinGet-Konfigurationsdatei, um einen Windows-Rechner in einen definierten gewünschten Zustand zu versetzen.

Eine solche Konfiguration kann beispielsweise festlegen:

Visual Studio Code soll installiert sein
Git soll installiert sein
PowerShell soll installiert sein
bestimmte Windows-Einstellungen sollen gelten
Registry-Werte sollen vorhanden sein
weitere DSC-Ressourcen sollen konfiguriert sein

Der Rechner wird anschließend anhand dieser Definition eingerichtet.

Das unterscheidet sich grundlegend von einem klassischen Installationsskript.


Imperativ versus deklarativ

Ein klassisches PowerShell-Skript arbeitet häufig imperativ.

Es beschreibt:

Führe diese Schritte aus.

Beispielsweise:

winget install Git.Git
winget install Microsoft.VisualStudioCode
winget install Microsoft.PowerShell

Eine deklarative Konfiguration beschreibt dagegen:

Dieser Zustand soll vorhanden sein.

Beispielsweise:

Git vorhanden
Visual Studio Code vorhanden
PowerShell vorhanden
bestimmte Einstellung gesetzt

Die Konfigurationsengine prüft anschließend, was erforderlich ist, um diesen Zustand herzustellen.

Das ist das Grundprinzip von Desired State Configuration.


Was ist DSC?

DSC steht für:

Desired State Configuration

Das Konzept stammt aus der PowerShell-Welt und beschreibt Systeme nicht primär über einzelne Arbeitsschritte, sondern über ihren gewünschten Zustand.

Ein einfaches Beispiel:

Gewünschter Zustand

Git                 installiert
VS Code             installiert
PowerShell          installiert
Registry-Wert       gesetzt
Windows-Einstellung konfiguriert

Die DSC-Ressourcen kümmern sich darum, diesen Zustand herzustellen beziehungsweise zu überprüfen.

Microsoft verwendet PowerShell DSC als Konfigurationsmechanismus hinter WinGet Configuration.


Winget und DSC

Das Zusammenspiel lässt sich vereinfacht so darstellen:

WinGet Configuration
        │
        │ YAML
        ▼
winget configure
        │
        ▼
Configuration Processor
        │
        ▼
DSC-Ressourcen
        │
        ├── Pakete
        ├── Registry
        ├── Windows-Einstellungen
        ├── Dateien
        ├── Skripte
        └── weitere Ressourcen
        │
        ▼
Windows-System

Winget übernimmt also nicht jede denkbare Systemkonfiguration selbst.

Stattdessen verbindet WinGet Configuration die Paketverwaltung mit DSC-Ressourcen.


Voraussetzungen

Für winget configure nennt Microsoft als grundlegende Voraussetzungen:

Windows 10 Version 1809 / Build 17763 oder neuer
oder
Windows 11

WinGet mindestens Version 1.6.2631

Bei einer aktuellen Installation sollte zunächst geprüft werden:

winget --version

Zusätzlich:

winget configure --help

Da WinGet Configuration aktiv weiterentwickelt wird, ist gerade bei diesem Teil der Serie ein Blick auf die Möglichkeiten der installierten Version sinnvoll.


Aliase

Für configure existieren außerdem die Aliase:

winget configuration

und:

winget dsc

Im weiteren Artikel verwenden wir jedoch konsequent:

winget configure

weil dieser Befehl seine Funktion am deutlichsten beschreibt.


YAML als Konfigurationsformat

WinGet-Konfigurationsdateien verwenden YAML.

YAML steht für:

YAML Ain't Markup Language

Das Format wird häufig für Konfigurationsdateien verwendet, weil komplexe Strukturen vergleichsweise übersichtlich dargestellt werden können.

Ein YAML-Dokument könnte beispielsweise enthalten:

resources:
  - type: Microsoft.WinGet/Package
    name: PowerShell

YAML verwendet Einrückungen, um Strukturen abzubilden.

Deshalb ist die korrekte Einrückung besonders wichtig.


Warum YAML?

YAML bietet einige Vorteile:

  • menschenlesbar
  • textbasiert
  • gut versionierbar
  • für Git geeignet
  • leicht zu vergleichen
  • maschinenlesbar
  • in vielen DevOps-Werkzeugen verbreitet

Dadurch eignen sich WinGet-Konfigurationsdateien hervorragend für Configuration-as-Code-Ansätze.


WinGet Configuration v3

Aktuelle WinGet-Versionen unterstützen Konfigurationsdateien auf Basis von DSC v3.

Eine v3-Datei besitzt im Wesentlichen drei zentrale Bereiche:

$schema
metadata
resources

Die Struktur sieht grundsätzlich so aus:

$schema: <DSC-Schema>

metadata:
  winget:
    processor:
      identifier: dscv3

resources:
  - type: ...
    name: ...
    properties:
      ...

Der entscheidende Hinweis lautet:

identifier: dscv3

Damit weiß WinGet, dass der DSC-v3-Prozessor verwendet werden soll.


Dateiendung

Für aktuelle WinGet-Configuration-Dateien empfiehlt Microsoft die Dateiendung:

.winget

Beispielsweise:

configuration.winget

Für Git-basierte Projekte wird außerdem eine Struktur wie:

.config/
└── configuration.winget

empfohlen.

In älteren Beispielen findet man häufig noch Namen wie:

configuration.dsc.yaml

Da WinGet Configuration weiterentwickelt wurde, sollte bei neuen Projekten möglichst die aktuelle Dateistruktur verwendet werden.


Eine erste Konfigurationsdatei

Ein vereinfachtes Beispiel für DSC v3 könnte folgendermaßen aussehen:

$schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2023/08/config/document.json

metadata:
  winget:
    processor:
      identifier: dscv3

resources:

  - type: Microsoft.WinGet/Package
    name: PowerShell
    properties:
      id: Microsoft.PowerShell
      source: winget
      useLatest: true

Diese Konfiguration beschreibt:

Ressource:
PowerShell

Paket-ID:
Microsoft.PowerShell

Quelle:
winget

Version:
aktuell verfügbare Version

Damit wird nicht beschrieben, wie PowerShell manuell heruntergeladen und installiert werden soll.

Es wird lediglich der gewünschte Zustand definiert.


Mehrere Programme konfigurieren

Natürlich kann eine Konfigurationsdatei mehrere Ressourcen enthalten.

Beispielsweise:

resources:

  - type: Microsoft.WinGet/Package
    name: PowerShell
    properties:
      id: Microsoft.PowerShell
      source: winget
      useLatest: true

  - type: Microsoft.WinGet/Package
    name: VisualStudioCode
    properties:
      id: Microsoft.VisualStudioCode
      source: winget
      useLatest: true

  - type: Microsoft.WinGet/Package
    name: Git
    properties:
      id: Git.Git
      source: winget
      useLatest: true

Damit wird bereits ein kleiner Entwicklungsarbeitsplatz beschrieben.


Was bedeutet type?

Eine wichtige Zeile lautet:

type: Microsoft.WinGet/Package

Sie bestimmt, welche DSC-Ressource verwendet werden soll.

Die Ressource kennt bestimmte Eigenschaften und weiß, wie der gewünschte Zustand geprüft beziehungsweise hergestellt wird.

Bei:

Microsoft.WinGet/Package

geht es um ein mit Winget verwaltetes Paket.

Andere DSC-Ressourcen können dagegen beispielsweise:

Registry-Einstellungen
Dateien
Windows-Konfigurationen
Dienste
Entwicklereinstellungen
Skripte

verwalten.

Welche Möglichkeiten vorhanden sind, hängt von den verfügbaren DSC-Ressourcen ab.


Was bedeutet properties?

Unter:

properties:

werden die Eigenschaften der Ressource definiert.

Bei einem Winget-Paket beispielsweise:

properties:
  id: Microsoft.PowerShell
  source: winget
  useLatest: true

Damit wird genauer beschrieben, welchen Zustand die Ressource herstellen soll.


Die Source explizit festlegen

Wie bereits in Teil 10 unserer Serie behandelt, ist die Paketquelle ein wichtiger Bestandteil einer kontrollierten Softwarebereitstellung.

Deshalb ist:

source: winget

eine interessante Angabe.

Dadurch wird nicht nur festgelegt:

PowerShell soll installiert sein.

sondern:

PowerShell soll über diese definierte Paketquelle bereitgestellt werden.

Gerade in Unternehmensumgebungen kann das wichtig sein.


Konfiguration anzeigen

Bevor eine Datei ausgeführt wird, sollte sie geprüft werden.

Dafür steht:

winget configure show -f .\configuration.winget

zur Verfügung.

Der Befehl zeigt Details der Konfiguration an.

Das sollte Teil eines normalen Workflows sein:

Konfiguration erhalten
        ↓
Datei manuell lesen
        ↓
winget configure show
        ↓
Ressourcen kontrollieren
        ↓
Vertrauen prüfen
        ↓
validieren
        ↓
testen
        ↓
erst dann anwenden

Konfiguration validieren

Bevor eine Konfiguration eingesetzt wird, sollte ihre Gültigkeit geprüft werden.

Dafür existiert:

winget configure validate -f .\configuration.winget

Damit wird die WinGet-Konfigurationsdatei validiert.

Das ist besonders nützlich:

  • nach Änderungen
  • vor einem Commit
  • vor einem Deployment
  • innerhalb einer CI/CD-Pipeline
  • vor einer Freigabe

Wichtiger Unterschied zu winget validate

Aus Teil 4 kennen wir:

winget validate --manifest ...

Dieser Befehl ist für Winget-Paketmanifeste vorgesehen.

Für WinGet Configuration verwenden wir dagegen:

winget configure validate

Also:

winget validate
      ↓
Paketmanifest

winget configure validate
      ↓
Konfigurationsdatei

Diese beiden Befehle sollten nicht verwechselt werden.


Konfiguration testen

Eine besonders leistungsfähige Funktion ist:

winget configure test -f .\configuration.winget

Damit wird geprüft, ob der aktuelle Rechner dem in der Datei beschriebenen gewünschten Zustand entspricht.

Das bedeutet vereinfacht:

configuration.winget
        ↓
Soll-Zustand

aktueller Rechner
        ↓
Ist-Zustand

        ↓

Vergleich

Damit lässt sich beispielsweise feststellen, ob die geforderten Anwendungen und Einstellungen bereits vorhanden sind.


Warum configure test so interessant ist

Angenommen, ein Entwickler-PC soll enthalten:

PowerShell
Git
Visual Studio Code

Die Konfiguration beschreibt genau diesen Zustand.

Dann kann regelmäßig:

winget configure test -f .\developer.winget

ausgeführt werden.

Dadurch lässt sich prüfen:

Entspricht dieser Rechner noch unserer definierten Standardkonfiguration?

Damit wird die Konfigurationsdatei gleichzeitig zu einer Art Compliance-Definition.


Die Konfiguration anwenden

Nachdem die Datei kontrolliert, validiert und gegebenenfalls getestet wurde, kann sie angewendet werden:

winget configure -f .\configuration.winget

Winget verarbeitet anschließend die enthaltenen Ressourcen und versucht, den beschriebenen Zielzustand herzustellen.

Je nach Konfiguration können dabei:

  • Pakete installiert,
  • DSC-Module beziehungsweise Ressourcen benötigt,
  • Einstellungen verändert,
  • administrative Berechtigungen erforderlich

sein.


Sicherheitswarnung

Dieser Punkt ist bei winget configure besonders wichtig.

Eine Konfigurationsdatei kann wesentlich mehr bewirken als eine einfache Liste von Winget-Paketen.

Je nach verwendeten DSC-Ressourcen können Systemänderungen vorgenommen werden.

Deshalb sollte niemals eine unbekannte Konfigurationsdatei einfach mit:

winget configure -f ...

ausgeführt werden.

Vorher sollte immer geprüft werden:

Woher stammt die Datei?

Wer hat sie erstellt?

Welche DSC-Ressourcen werden verwendet?

Welche Module werden geladen?

Welche Pakete werden installiert?

Welche Quellen werden verwendet?

Welche Systemeinstellungen werden verändert?

Werden Skripte ausgeführt?

Eine .winget-Datei sollte sicherheitstechnisch eher wie ein Administrationsskript als wie eine harmlose Textdatei behandelt werden.


Configuration Agreements

Beim Anwenden einer Konfiguration zeigt Winget Sicherheits- beziehungsweise Konfigurationshinweise an.

Für automatisierte Szenarien existiert:

--accept-configuration-agreements

Beispielsweise:

winget configure `
    -f .\configuration.winget `
    --accept-configuration-agreements

Damit können entsprechende interaktive Bestätigungen unterdrückt werden.

Diese Option sollte allerdings nur eingesetzt werden, wenn die betreffende Konfiguration zuvor kontrolliert und freigegeben wurde.


Nicht interaktive Ausführung

Für automatisierte Deployments steht zusätzlich:

--disable-interactivity

zur Verfügung.

Beispiel:

winget configure `
    -f .\configuration.winget `
    --accept-configuration-agreements `
    --disable-interactivity

Damit eignet sich WinGet Configuration grundsätzlich auch für automatisierte Bereitstellungsprozesse.


Beispiel: Entwicklungsrechner

Angenommen, ein neuer Entwickler benötigt:

PowerShell
Git
Visual Studio Code

Die Datei:

developer.winget

könnte diese drei Anwendungen als Ressourcen definieren.

Der Ablauf wäre anschließend:

winget configure validate -f .\developer.winget

danach:

winget configure test -f .\developer.winget

und schließlich:

winget configure -f .\developer.winget

Damit kann ein neuer Entwickler-PC wesentlich reproduzierbarer eingerichtet werden.


Beispiel: Administrator-PC

Ein Administrator-Arbeitsplatz könnte beispielsweise folgende Pakete benötigen:

PowerShell
Windows Terminal
Visual Studio Code
Git
WinSCP
weitere freigegebene Werkzeuge

Statt eine Installationsanleitung mit zahlreichen Einzelschritten zu pflegen, wird der gewünschte Zustand in:

administrator.winget

beschrieben.

Der Vorteil:

Die Dokumentation ist gleichzeitig maschinenlesbar.


Konfigurationen für verschiedene Rechnerrollen

Wie bei unseren Softwarelisten aus Teil 9 können verschiedene Profile gepflegt werden:

winget-configurations/
│
├── .config/
│   └── configuration.winget
│
├── profiles/
│   ├── office.winget
│   ├── developer.winget
│   ├── administrator.winget
│   └── testclient.winget
│
└── README.md

Damit kann für jeden Einsatzzweck ein eigener gewünschter Systemzustand definiert werden.


Von der Paketliste zur Systemkonfiguration

Der Unterschied zu Teil 9 ist wichtig.

Eine einfache Softwareliste beschreibt beispielsweise:

Git
VS Code
PowerShell

WinGet Configuration kann darüber hinaus beschreiben:

Git installiert
VS Code installiert
PowerShell installiert
Registry-Einstellung gesetzt
Windows-Einstellung gesetzt
weitere DSC-Ressource konfiguriert

Damit verlassen wir die reine Paketverwaltung.


Winget Import oder Winget Configure?

Aus Teil 8 kennen wir:

winget import -i packages.json

Das ist hervorragend geeignet, um eine Liste von Anwendungen wieder zu installieren.

winget configure geht jedoch weiter.

Vereinfacht:

winget import
      ↓
Welche Programme sollen installiert werden?

winget configure
      ↓
Welchen Zustand soll dieser Rechner besitzen?

Für eine einfache Softwaremigration ist import häufig ausreichend.

Für reproduzierbare Umgebungen ist configure wesentlich mächtiger.


PowerShell-Skript oder Winget Configure?

Auch PowerShell kann einen kompletten Rechner konfigurieren.

Ein Skript könnte beispielsweise:

winget install ...
Set-ItemProperty ...
New-Item ...
Set-Service ...

enthalten.

Das funktioniert.

Der Unterschied liegt vor allem im Ansatz.

PowerShell-Skript:

Schritt 1 ausführen
Schritt 2 ausführen
Schritt 3 ausführen

Desired State Configuration:

Dieser Zustand soll gelten.

Gerade bei wiederholbaren und überprüfbaren Konfigurationen besitzt der deklarative Ansatz große Vorteile.


Idempotenz als Ziel

Ein wichtiges Konzept in Configuration Management ist Idempotenz.

Vereinfacht bedeutet dies:

Eine Konfiguration kann mehrfach angewendet werden, ohne bei jeder Ausführung unnötig denselben Zustand erneut zu erzeugen.

Beispielsweise:

PowerShell ist bereits installiert
        ↓
Konfiguration prüft Zustand
        ↓
keine unnötige Neuinstallation

Das unterscheidet gutes Configuration Management von einem simplen Skript, das bei jedem Start blind dieselben Befehle ausführt.

Ob eine konkrete Ressource vollständig idempotent arbeitet, hängt allerdings von ihrer jeweiligen Implementierung ab.


Konfigurationen exportieren

Aktuelle Winget-Versionen bieten außerdem:

winget configure export

Damit können Konfigurationsressourcen in eine Konfigurationsdatei exportiert werden.

Beispielsweise:

winget configure export --all -o .\configuration.winget

Für einzelne Pakete kann auch mit einer Paket-ID gearbeitet werden.

Das eröffnet interessante Möglichkeiten, einen bestehenden Rechner als Ausgangspunkt für eine neue Konfiguration zu verwenden.


Von einem Referenzsystem zur Konfiguration

Ein möglicher Workflow:

Referenz-PC
     ↓
Software installieren
     ↓
Einstellungen konfigurieren
     ↓
Konfiguration exportieren
     ↓
Datei prüfen
     ↓
bereinigen
     ↓
validieren
     ↓
Git
     ↓
Testsystem
     ↓
Deployment

Ein automatisch erzeugter Export sollte allerdings niemals ungeprüft direkt zum Unternehmensstandard erklärt werden.


Konfigurationen auflisten

Mit:

winget configure list

lassen sich Informationen über Konfigurationen anzeigen, die auf dem System angewendet wurden.

Das kann bei der Administration und Fehleranalyse hilfreich sein.

Damit lässt sich nachvollziehen, welche Configuration-Vorgänge Winget kennt.


Konfigurationen versionieren

Da .winget-Dateien textbasiert sind, eignen sie sich hervorragend für Git.

Beispielsweise:

git init

Datei hinzufügen:

git add .config/configuration.winget

Commit:

git commit -m "Initiale Entwicklerkonfiguration"

Später wird beispielsweise Git ergänzt:

git add .config/configuration.winget
git commit -m "Git zur Entwicklerkonfiguration hinzugefügt"

Damit ist nachvollziehbar, wann sich die Standardkonfiguration geändert hat.


Warum Git und Winget Configure gut zusammenpassen

Eine Git-Historie beantwortet wichtige Fragen:

Was wurde geändert?

Wann wurde es geändert?

Wer hat es geändert?

Warum wurde es geändert?

Wie sah die vorherige Version aus?

Damit wird die Rechnerkonfiguration zu einem versionierten Bestandteil der IT-Dokumentation.


Konfiguration per Pull Request freigeben

In größeren Umgebungen kann daraus ein kontrollierter Prozess entstehen:

Änderung an configuration.winget
          ↓
Git Branch
          ↓
Pull Request
          ↓
Review
          ↓
automatische Validierung
          ↓
Testsystem
          ↓
Freigabe
          ↓
Merge
          ↓
Deployment

Damit wird eine Änderung an einem Standard-PC ähnlich behandelt wie eine Änderung an Softwarecode.

Das ist Configuration as Code in der Praxis.


Validierung in einer Pipeline

Vor einem Deployment sollte automatisch geprüft werden:

winget configure validate -f .\configuration.winget

Schlägt die Validierung fehl, wird die Konfiguration nicht verteilt.

Ein einfaches Prinzip:

Commit
   ↓
Validate
   ↓
erfolgreich?
 ┌───────┴───────┐
Nein             Ja
 ↓                ↓
Stop             Test
                  ↓
               Deployment

Damit werden fehlerhafte Konfigurationsdateien früh erkannt.


Test vor Deployment

Nach der syntaktischen beziehungsweise strukturellen Validierung sollte ein funktionaler Test folgen.

Dafür kann auf einem Testsystem:

winget configure -f .\configuration.winget

ausgeführt werden.

Anschließend:

winget configure test -f .\configuration.winget

Damit wird überprüft, ob der gewünschte Zustand tatsächlich erreicht wurde.


Virtuelle Maschinen als Testsysteme

Für WinGet Configuration eignen sich virtuelle Maschinen hervorragend.

Ein möglicher Prozess:

saubere Windows-VM
       ↓
aktueller Patchstand
       ↓
Konfiguration anwenden
       ↓
Fehler prüfen
       ↓
configure test
       ↓
Anwendungen testen
       ↓
Snapshot zurücksetzen
       ↓
nächste Version testen

Damit kann eine Konfiguration reproduzierbar getestet werden, ohne produktive Systeme zu gefährden.


Deployment auf neue PCs

Bei einem neuen Arbeitsplatz könnte der Prozess beispielsweise so aussehen:

Windows installieren
       ↓
Windows Update
       ↓
Winget prüfen
       ↓
Konfigurationsrepository bereitstellen
       ↓
passendes Profil auswählen
       ↓
Konfiguration validieren
       ↓
winget configure
       ↓
configure test
       ↓
Rechner freigeben

Damit lässt sich die manuelle Einrichtung neuer Arbeitsplätze erheblich reduzieren.


Deployment nach Rechnerrollen

Eine Organisation könnte beispielsweise folgende Rollen definieren:

Standard
Office
Entwicklung
Administration
Test

Jede Rolle erhält eine eigene Konfiguration:

standard.winget
office.winget
developer.winget
administrator.winget
test.winget

Ein Deployment-System muss anschließend nur noch wissen:

Welche Rolle besitzt dieser Rechner?

Die entsprechende Konfiguration beschreibt den gewünschten Zustand.


Konfiguration und Unternehmensquellen kombinieren

Aus Teil 10 kennen wir eigene Winget-Sources.

Damit lässt sich beispielsweise festlegen:

properties:
  id: Firma.Fachverfahren
  source: company

Das ermöglicht eine interessante Kombination:

Winget Configure
       ↓
Unternehmenskonfiguration
       ↓
interne Winget Source
       ↓
freigegebene Unternehmenssoftware

Damit können auch interne Anwendungen Bestandteil einer standardisierten Rechnerkonfiguration werden.


Konfiguration und Softwarefreigabe

Ein professioneller Prozess könnte folgendermaßen aussehen:

Neue Anwendung
      ↓
Sicherheitsprüfung
      ↓
Lizenzprüfung
      ↓
Paket erstellen/freigeben
      ↓
Unternehmens-Source
      ↓
configuration.winget anpassen
      ↓
Pull Request
      ↓
Validierung
      ↓
Test
      ↓
Freigabe
      ↓
Deployment

Damit werden Softwarebereitstellung und Systemkonfiguration miteinander verbunden.


Sicherheitsmodell

WinGet Configuration besitzt erhebliche Möglichkeiten.

Deshalb sollte eine Konfigurationsdatei grundsätzlich als ausführbarer Administrationsinhalt betrachtet werden.

Besonders geprüft werden sollten:

DSC-Ressourcen
PowerShell-Module
Skripte
Paketquellen
Downloadquellen
Registry-Änderungen
Systemeinstellungen
Berechtigungen

Eine Konfiguration aus dem Internet sollte niemals allein deshalb als sicher betrachtet werden, weil die Dateiendung .winget lautet.


Konfiguration zuerst lesen

Vor:

winget configure -f .\configuration.winget

sollte deshalb immer der Inhalt geprüft werden.

Danach:

winget configure show -f .\configuration.winget

und:

winget configure validate -f .\configuration.winget

Anschließend möglichst ein Test in einer isolierten Umgebung.

Erst danach sollte die Konfiguration produktiv eingesetzt werden.


Logging

Bei umfangreichen Konfigurationen ist Logging besonders wichtig.

Winget unterstützt:

--verbose-logs

Beispielsweise:

winget configure `
    -f .\configuration.winget `
    --verbose-logs

Logs können außerdem geöffnet werden:

winget configure `
    -f .\configuration.winget `
    --open-logs

Gerade wenn eine einzelne DSC-Ressource innerhalb einer umfangreichen Konfiguration fehlschlägt, sind diese Protokolle sehr hilfreich.


Proxy-Umgebungen

Auch winget configure unterstützt aktuelle Winget-Optionen für Proxy-Szenarien.

Beispielsweise:

winget configure `
    -f .\configuration.winget `
    --proxy https://proxy.example.org:8080

Oder:

winget configure `
    -f .\configuration.winget `
    --no-proxy

Das kann in Unternehmensnetzen relevant sein, insbesondere wenn Pakete oder DSC-Ressourcen aus externen Quellen bezogen werden müssen.


Ein praktischer Entwicklungsworkflow

Für eine Entwicklerkonfiguration könnte ein sinnvoller Workflow so aussehen:

developer.winget bearbeiten
        ↓
Git Diff prüfen
        ↓
winget configure validate
        ↓
Commit
        ↓
Pull Request
        ↓
Review
        ↓
Test-VM
        ↓
winget configure
        ↓
winget configure test
        ↓
Freigabe
        ↓
Deployment

Damit wird die Einrichtung eines Entwickler-PCs vollständig nachvollziehbar.


Beispiel für mehrere Entwicklungsrechner

Angenommen, zehn Entwickler benötigen dieselbe Umgebung.

Ohne Configuration Management:

PC 1 manuell konfigurieren
PC 2 manuell konfigurieren
PC 3 manuell konfigurieren
...
PC 10 manuell konfigurieren

Das birgt die Gefahr:

PC 1 ≠ PC 2 ≠ PC 3 ≠ ...

Mit einer gemeinsamen Konfiguration:

developer.winget
      ↓
PC 1
PC 2
PC 3
...
PC 10

Das Ziel lautet:

PC 1 ≈ PC 2 ≈ PC 3 ≈ ... ≈ PC 10

Damit werden Abweichungen deutlich reduziert.


Konfigurationsdrift erkennen

Mit der Zeit können Benutzer oder Administratoren Systeme verändern.

Beispielsweise:

Software entfernt
Einstellung geändert
Paket verändert
Konfiguration angepasst

Dadurch entsteht sogenannter Configuration Drift.

Mit:

winget configure test -f .\developer.winget

kann geprüft werden, ob der Rechner noch dem definierten Sollzustand entspricht.

Das ist einer der interessantesten Aspekte deklarativer Konfiguration.


Dokumentation wird ausführbar

Traditionelle Dokumentation könnte lauten:

1. Installieren Sie PowerShell.
2. Installieren Sie Git.
3. Installieren Sie Visual Studio Code.
4. Ändern Sie Einstellung X.
5. Setzen Sie Registry-Wert Y.

Das Problem:

Jemand muss diese Anleitung lesen und korrekt umsetzen.

Mit Configuration as Code wird daraus:

configuration.winget

und anschließend:

winget configure -f .\configuration.winget

Die Dokumentation beschreibt damit nicht nur den Sollzustand – sie kann ihn auch technisch herstellen.


Best Practices

Für WinGet Configuration empfehlen sich einige grundlegende Regeln.

Konfigurationen klein und nachvollziehbar halten.

Eine gigantische Datei mit hunderten ungeklärten Ressourcen ist schwer zu warten.

Konfigurationen versionieren.

Git eignet sich hervorragend.

Jede Änderung validieren.

winget configure validate -f .\configuration.winget

Vor dem Produktiveinsatz testen.

Am besten auf einer frischen virtuellen Maschine.

Nach dem Deployment testen.

winget configure test -f .\configuration.winget

Nur vertrauenswürdige DSC-Ressourcen verwenden.

Paketquellen explizit festlegen, wenn dies organisatorisch erforderlich ist.

Konfigurationsänderungen dokumentieren und reviewen.

Keine unbekannten Konfigurationsdateien ungeprüft ausführen.

Administrative Rechte nur dort einsetzen, wo sie erforderlich sind.


Die wichtigsten Befehle

Hilfe anzeigen:

winget configure --help

Konfiguration anzeigen:

winget configure show -f .\configuration.winget

Konfiguration validieren:

winget configure validate -f .\configuration.winget

System gegen Konfiguration testen:

winget configure test -f .\configuration.winget

Konfiguration anwenden:

winget configure -f .\configuration.winget

Angewendete Konfigurationen anzeigen:

winget configure list

Konfiguration exportieren:

winget configure export --all -o .\configuration.winget

Nicht interaktiv anwenden:

winget configure `
    -f .\configuration.winget `
    --accept-configuration-agreements `
    --disable-interactivity

Verbose Logging:

winget configure `
    -f .\configuration.winget `
    --verbose-logs

Logs öffnen:

winget configure `
    -f .\configuration.winget `
    --open-logs

Winget Configure im Gesamtbild

Nach zwölf Teilen unserer Serie können wir nun sehr schön sehen, wie sich Winget von einem einfachen Paketmanager zu einem umfassenderen Administrationswerkzeug entwickelt.

winget search
      ↓
Software finden

winget install
      ↓
Software installieren

winget upgrade
      ↓
Software aktualisieren

winget uninstall
      ↓
Software entfernen

winget export / import
      ↓
Softwarebestände reproduzieren

Softwareprofile
      ↓
Arbeitsplätze standardisieren

winget source
      ↓
Paketquellen kontrollieren

winget settings
      ↓
Client konfigurieren

winget configure
      ↓
gewünschten Systemzustand definieren

Gerade der letzte Schritt verändert den Charakter von Winget erheblich.


Fazit

winget configure gehört zu den leistungsfähigsten Funktionen des Windows Package Managers.

Statt nur einzelne Installationsbefehle auszuführen, können komplette gewünschte Systemzustände in einer textbasierten Konfigurationsdatei beschrieben werden.

Die Kombination aus:

Winget
+
YAML
+
DSC
+
Git

ermöglicht reproduzierbare und versionierbare Windows-Konfigurationen.

Besonders interessant ist:

winget configure test

Denn damit lässt sich nicht nur eine Konfiguration anwenden, sondern auch überprüfen, ob ein Rechner weiterhin dem definierten Sollzustand entspricht.

Zusammen mit:

winget configure validate

entsteht ein sauberer Workflow:

Definieren
    ↓
Validieren
    ↓
Review
    ↓
Testen
    ↓
Anwenden
    ↓
Sollzustand überprüfen

Für einzelne private PCs mag dieser Aufwand zunächst überdimensioniert erscheinen. Bei Entwicklerrechnern, Testsystemen, standardisierten Arbeitsplätzen und größeren IT-Umgebungen zeigt sich jedoch schnell der Vorteil.

Die Rechnerkonfiguration befindet sich nicht mehr nur in Dokumentationen oder im Wissen einzelner Administratoren.

Sie wird zu versioniertem, überprüfbarem und ausführbarem Code.

Damit ist WinGet Configuration ein wichtiger Baustein für moderne Windows-Automatisierung und Configuration as Code.