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.