In diesem Artikel
Eine Windows-App zu bauen, ist zunächst relativ einfach. Schwieriger wird es allerdings, wenn daraus ein signiertes Paket werden soll, das wir auf einem anderen Rechner installieren können.
Denn ein erfolgreicher Build bedeutet noch nicht automatisch, dass Windows unsere Anwendung auch installieren möchte.
Die Paketidentität im Manifest, das Signing-Zertifikat und das Vertrauen auf dem Zielrechner müssen zusammenpassen. Zusätzlich können Abhängigkeiten wie die Windows App Runtime benötigt werden.
Genau hier können uns GitHub Actions unterstützen.
In diesem Beitrag zeige ich Schritt für Schritt, wie wir eine .NET MAUI Windows App innerhalb einer GitHub Action bauen und signieren. Am Ende erhalten wir ein .msix-Paket zusammen mit dem öffentlichen Testzertifikat und einer kurzen Installationsanleitung.
Unser Ziel ist also:
- die Windows-Paketidentität und den Publisher abstimmen
- ein selbstsigniertes Testzertifikat erstellen
- das Signing-Material in GitHub Secrets hinterlegen
- eine signierte
.msix-Datei mit GitHub Actions erzeugen - die benötigten Dateien als Artifact für unsere Tester bereitstellen
Für das Beispiel verwende ich .NET 10, .NET MAUI und einen Windows-basierten GitHub Actions Runner.
Wichtig: Das selbstsignierte Zertifikat in diesem Beitrag ist ausschließlich für lokale Tests und die kontrollierte Verteilung auf Rechner gedacht, die ihr selbst verwaltet. Es ersetzt keine passende Signierung für eine öffentliche Produktivverteilung. Bei einer Veröffentlichung über den Microsoft Store gelten dessen Vorgaben für die Paketidentität; die Signierung für die Store-Verteilung übernimmt Microsoft.
Die anderen Plattformen haben wir bereits in den Beiträgen Von Commit zu AAB/APK und Von Commit zu IPA betrachtet.
Warum sollten wir Windows Builds mit GitHub Actions automatisieren?
Ein automatisierter Build bietet uns auch unter Windows einige Vorteile.
Wir können die SDK-Auswahl festlegen, das Zertifikat während des Builds importieren und die erzeugten Dateien direkt zusammen mit dem jeweiligen Workflow-Run speichern.
Außerdem können wir bereits in der Pipeline prüfen, ob der Publisher im Manifest zum verwendeten Zertifikat passt.
Der entscheidende Punkt ist aber: Unsere Pipeline soll nicht nur kompilieren. Sie soll ein nachvollziehbares Testpaket erzeugen, das wir zusammen mit den benötigten Installationshinweisen weitergeben können.
Eine gültige Signatur und das Vertrauen auf einem anderen Rechner sind dabei zwei unterschiedliche Dinge. Auch ein korrekt signiertes Paket lässt sich nicht ohne Weiteres installieren, wenn der Zielrechner dem selbstsignierten Zertifikat nicht vertraut.
Voraussetzungen
Bevor wir beginnen, benötigen wir:
- eine .NET MAUI App mit
net10.0-windows10.0.19041.0 - ein GitHub Repository mit unserer Anwendung
- eine
global.jsonfür die Auswahl der .NET SDK-Version - einen geplanten Publisher, beispielsweise
CN=Sebastian Jensen - einen Windows-Rechner mit PowerShell zum Erstellen und Exportieren des Testzertifikats
- die Berechtigung, Repository-Secrets in GitHub anzulegen
In meinem Beispiel-Repository sind vor allem diese Dateien relevant:
src/MyAwesomeMauiApp/MyAwesomeMauiApp.csproj
src/MyAwesomeMauiApp/Platforms/Windows/Package.appxmanifest
.github/workflows/windows-build.yml
Die wichtigsten Bestandteile sind schnell erklärt:
Package.appxmanifestdefiniert unter anderem Paketidentität und Publisher.- Der
Publishermuss zumSubjectdes Signing-Zertifikats passen. - Die
.pfx-Datei enthält das Zertifikat inklusive privatem Schlüssel für die Signierung. - Die
.cer-Datei enthält nur das öffentliche Zertifikat für unsere Testrechner. - Der Zertifikatsspeicher Trusted People beziehungsweise Vertrauenswürdige Personen wird auf dem Zielrechner für das Vertrauen in unseren Paketsignierer verwendet.
Schritt 1: Windows-Paketidentität anpassen
Zunächst öffnen wir das Windows-Manifest unserer Anwendung:
src/MyAwesomeMauiApp/Platforms/Windows/Package.appxmanifest
In einem neuen Projekt finden wir dort häufig noch eine Paketidentität mit Vorlagenwerten:
<Identity Name="maui-package-name-placeholder"
Publisher="CN=User Name"
Version="0.0.0.0" />
Für unser Beispiel ersetzen wir die Identität durch:
<Identity Name="SebastianJensen.MyAwesomeMauiApp"
Publisher="CN=Sebastian Jensen"
Version="0.0.0.0" />
Auch die angezeigten Namen können wir anpassen:
<Properties>
<DisplayName>MyAwesomeMauiApp</DisplayName>
<PublisherDisplayName>Sebastian Jensen</PublisherDisplayName>
<Logo>$placeholder$.png</Logo>
</Properties>
Der Logo-Platzhalter wird bei einem üblichen .NET MAUI Projekt während des Builds durch die generierten App-Icon-Ressourcen ersetzt.
Entscheidend für das Signing ist der Wert von Publisher. Dieser muss exakt dem Subject unseres Zertifikats entsprechen. PublisherDisplayName ist dagegen nur der angezeigte Herausgebername.
Die Paketversion setzen wir später während des CI-Builds.
Schritt 2: SDK-Version und Pakettyp festlegen
Im Root-Verzeichnis unseres Repositories legen wir eine global.json an:
{
"sdk": {
"version": "10.0.200",
"rollForward": "latestFeature"
}
}
GitHub Actions verwendet diese Datei später über actions/setup-dotnet. Mit latestFeature darf die SDK-Auswahl auf ein neueres passendes Feature-Band weiterrollen. Die Datei ist damit keine unveränderliche Fixierung sämtlicher Build-Werkzeuge.
Außerdem sollte unser Projekt das Target Framework net10.0-windows10.0.19041.0 enthalten.
Viele .NET MAUI Vorlagen verwenden zunächst:
<WindowsPackageType>None</WindowsPackageType>
Damit ist die Anwendung standardmäßig als unpackaged konfiguriert.
Für unseren Workflow ist das in Ordnung. Wir überschreiben den Wert beim Veröffentlichen ausdrücklich mit:
-p:WindowsPackageType=MSIX
Dadurch kann das Projekt lokal weiterhin ohne Paket verwendet werden, während unsere CI-Pipeline ein MSIX-Paket erzeugt.
Schritt 3: Selbstsigniertes Testzertifikat erstellen
Für lokale Tests und die kontrollierte Verteilung erstellen wir nun ein selbstsigniertes Zertifikat.
Dafür öffnen wir PowerShell auf unserem Windows-Rechner und führen Folgendes aus:
$publisher = "CN=Sebastian Jensen"
$cert = New-SelfSignedCertificate `
-Type Custom `
-Subject $publisher `
-KeyUsage DigitalSignature `
-KeyExportPolicy Exportable `
-CertStoreLocation "Cert:\CurrentUser\My" `
-TextExtension @("2.5.29.37={text}1.3.6.1.5.5.7.3.3", "2.5.29.19={text}") `
-FriendlyName "MyAwesomeMauiApp"
Damit erzeugen wir ein Zertifikat im persönlichen Zertifikatsspeicher unseres Benutzers.
Der Subject entspricht unserem Manifest-Publisher. Über die Erweiterung mit der Kennung 1.3.6.1.5.5.7.3.3 erlauben wir die Verwendung für Code Signing. Der private Schlüssel wird exportierbar angelegt, damit wir ihn später als .pfx für die Pipeline bereitstellen können.
Anschließend prüfen wir das Ergebnis:
Get-ChildItem "Cert:\CurrentUser\My" |
Where-Object { $_.FriendlyName -eq "MyAwesomeMauiApp" } |
Format-Table Subject, Thumbprint, HasPrivateKey
HasPrivateKey muss dabei True sein.
Schritt 4: Zertifikat exportieren
Unsere Pipeline benötigt den privaten Schlüssel für die Signierung. Die Testrechner benötigen dagegen nur das öffentliche Zertifikat.
In derselben PowerShell-Sitzung exportieren wir zunächst das öffentliche Zertifikat:
Export-Certificate `
-Cert "Cert:\CurrentUser\My\$($cert.Thumbprint)" `
-FilePath ".\MyAwesomeMauiApp-Test.cer"
Anschließend exportieren wir die .pfx-Datei inklusive privatem Schlüssel. Das Exportpasswort fragen wir verdeckt ab:
$password = Read-Host "Passwort fuer den PFX-Export" -AsSecureString
Export-PfxCertificate `
-Cert "Cert:\CurrentUser\My\$($cert.Thumbprint)" `
-FilePath ".\MyAwesomeMauiApp-Test.pfx" `
-Password $password
Die .cer-Datei können wir unseren Testern mitgeben. Die .pfx-Datei darf dagegen nicht verteilt werden und gehört auch nicht in das Repository.
Schritt 5: .pfx-Datei nach Base64 konvertieren
GitHub Secrets speichern Text und keine Binärdateien.
Daher konvertieren wir unsere .pfx-Datei zunächst in einen Base64-String:
$base64 = [Convert]::ToBase64String(
[IO.File]::ReadAllBytes(".\MyAwesomeMauiApp-Test.pfx")
)
$base64 | Set-Content `
-Path .\MyAwesomeMauiApp-Test.pfx.base64.txt `
-NoNewline
Den vollständigen Inhalt der erzeugten Textdatei hinterlegen wir anschließend als GitHub Secret.
Wichtig: Base64 ist keine Verschlüsselung. Der Base64-Inhalt muss genauso geschützt werden wie die ursprüngliche .pfx-Datei. Er gehört weder ins Repository noch in Build-Logs. Die temporäre Textdatei solltet ihr nach dem sicheren Übertragen wieder entfernen.
Schritt 6: GitHub Secrets anlegen
Nun öffnen wir unser GitHub Repository und wechseln unter Settings → Secrets and variables → Actions zu den Repository-Secrets.
Für unseren Windows Build benötigen wir zwei Secrets:
PFX_BASE64: der vollständige Base64-Inhalt unserer exportierten.pfx-DateiPFX_PASSWORD: das Passwort, das wir beim Export der.pfx-Datei vergeben haben
Damit haben wir alle Signing-Informationen vorbereitet, die unsere GitHub Action benötigt.
Schritt 7: GitHub Action erstellen
Jetzt können wir unsere eigentliche GitHub Action erstellen.
Dafür legen wir folgende Datei an:
.github/workflows/windows-build.yml
Der folgende Workflow basiert auf meinem Beispiel-Repository. Wir übergeben die Secrets über Umgebungsvariablen und prüfen ausdrücklich, ob tatsächlich MSIX-Dateien erzeugt wurden:
name: Build .NET MAUI Windows App (.msix)
on:
workflow_dispatch:
jobs:
build-windows:
runs-on: windows-latest
env:
PROJECT_PATH: src/MyAwesomeMauiApp/MyAwesomeMauiApp.csproj
steps:
- name: Checkout repository
uses: actions/checkout@v6
- name: Setup .NET from global.json
uses: actions/setup-dotnet@v5
with:
global-json-file: global.json
- name: Install MAUI Workload
run: dotnet workload install maui
- name: Set version variables
run: |
$buildNumber = [long]"${{ github.run_number }}"
$packageBuild = [math]::Floor($buildNumber / 65535)
$packageRevision = $buildNumber % 65535
if ($packageBuild -gt 65535) {
throw "The run number exceeds the supported MSIX version range."
}
"VERSION_DISPLAY=1.0.$buildNumber" >> $env:GITHUB_ENV
"VERSION_CODE=$((10000 + $buildNumber))" >> $env:GITHUB_ENV
"WINDOWS_PACKAGE_VERSION=1.0.$packageBuild.$packageRevision" >> $env:GITHUB_ENV
- name: Restore NuGet packages
run: dotnet restore "$env:PROJECT_PATH"
- name: Decode and import certificate
env:
PFX_BASE64: ${{ secrets.PFX_BASE64 }}
PFX_PASSWORD: ${{ secrets.PFX_PASSWORD }}
run: |
$certPath = Join-Path $env:RUNNER_TEMP "MyMauiAppCert.pfx"
[IO.File]::WriteAllBytes(
$certPath,
[Convert]::FromBase64String($env:PFX_BASE64)
)
$password = ConvertTo-SecureString $env:PFX_PASSWORD -AsPlainText -Force
$cert = Import-PfxCertificate -FilePath $certPath `
-Password $password -CertStoreLocation "Cert:\CurrentUser\My"
$projectDir = Split-Path $env:PROJECT_PATH -Parent
$manifestPath = Join-Path $projectDir "Platforms\Windows\Package.appxmanifest"
[xml]$manifest = Get-Content -LiteralPath $manifestPath -Raw
$publisher = $manifest.Package.Identity.Publisher
if ($cert.Subject -cne $publisher) {
throw "Certificate subject '$($cert.Subject)' does not match manifest publisher '$publisher'."
}
if (-not $cert.HasPrivateKey) {
throw "The imported certificate has no private key."
}
$publicCertPath = Join-Path $env:RUNNER_TEMP "MyAwesomeMauiApp-Test.cer"
Export-Certificate `
-Cert "Cert:\CurrentUser\My\$($cert.Thumbprint)" `
-FilePath $publicCertPath | Out-Null
"CERT_THUMBPRINT=$($cert.Thumbprint)" >> $env:GITHUB_ENV
"PUBLIC_CERT_PATH=$publicCertPath" >> $env:GITHUB_ENV
Remove-Item -LiteralPath $certPath
- name: Build and Sign Windows App (Release)
run: |
dotnet publish "$env:PROJECT_PATH" `
-f net10.0-windows10.0.19041.0 `
-c Release `
-p:RuntimeIdentifierOverride=win-x64 `
-p:WindowsPackageType=MSIX `
-p:AppxPackage=true `
-p:AppxPackageSigningEnabled=true `
-p:AppxAutoIncrementPackageRevision=false `
-p:ApplicationVersion=$env:VERSION_CODE `
-p:ApplicationDisplayVersion=$env:VERSION_DISPLAY `
-p:AppxPackageVersion=$env:WINDOWS_PACKAGE_VERSION `
-p:PackageCertificateThumbprint=$env:CERT_THUMBPRINT
- name: Collect distributable files
run: |
$destination = Join-Path $env:GITHUB_WORKSPACE "output"
New-Item -ItemType Directory -Force -Path $destination | Out-Null
$projectDir = Split-Path $env:PROJECT_PATH -Parent
$packageDir = Join-Path $projectDir "bin\Release\net10.0-windows10.0.19041.0\win-x64\AppPackages"
$packageDir = (Resolve-Path -LiteralPath $packageDir).Path
$files = @(Get-ChildItem -LiteralPath $packageDir -Recurse -Filter *.msix -File)
if ($files.Count -eq 0) {
throw "No MSIX package was generated."
}
foreach ($file in $files) {
$relativePath = [IO.Path]::GetRelativePath($packageDir, $file.FullName)
$targetPath = Join-Path $destination $relativePath
New-Item -ItemType Directory -Force -Path (Split-Path $targetPath -Parent) | Out-Null
Copy-Item -LiteralPath $file.FullName -Destination $targetPath
}
Copy-Item -LiteralPath $env:PUBLIC_CERT_PATH `
-Destination (Join-Path $destination "MyAwesomeMauiApp-Test.cer")
@'
Installation auf einem verwalteten x64-Testrechner:
1. MyAwesomeMauiApp-Test.cer pruefen und nach LocalMachine\TrustedPeople importieren.
2. Falls erforderlich: passende x64-Abhaengigkeiten aus den Paketunterordnern installieren.
3. Das MSIX-Paket der Anwendung im Paketunterordner installieren.
Die Unterordnerstruktur bleibt erhalten. Bereits installierte passende
Abhaengigkeiten muessen nicht erneut installiert werden.
Dieses Zertifikat ist nur fuer kontrollierte Tests bestimmt.
'@ | Set-Content -Path (Join-Path $destination "INSTALL.txt") -Encoding utf8
- name: Upload Windows test package
uses: actions/upload-artifact@v6
with:
name: windows-build
path: output
if-no-files-found: error
Den Wert von PROJECT_PATH müsst ihr an euer eigenes Projekt anpassen. Falls ihr ein anderes Target Framework, eine andere Architektur oder eigene Ausgabepfade verwendet, passt auch das Paketverzeichnis im Kopierschritt an.
Wir übernehmen die MSIX-Dateien aus dem erzeugten Paketverzeichnis einschließlich ihrer Unterordner. So bleiben beispielsweise Abhängigkeiten für unterschiedliche Architekturen voneinander getrennt.
Die .pfx-Datei wird nicht in das Artifact kopiert. Der Workflow ist für einen kurzlebigen GitHub-gehosteten Runner gedacht. Bei eigenen, dauerhaft betriebenen Runnern müsst ihr zusätzlich die Bereinigung des Zertifikatsspeichers und den Schutz des Signing-Materials berücksichtigen.
Schritt 8: Was macht unser Workflow?
Schauen wir uns noch einmal kurz an, was innerhalb unserer GitHub Action passiert.
- Repository auschecken
- .NET SDK anhand der
global.jsoneinrichten - .NET MAUI Workload installieren
- Versionsnummern aus der Workflow-Run-Nummer erzeugen
- Zertifikat aus den Secrets wiederherstellen und importieren
- Publisher und privaten Schlüssel prüfen
- Anwendung als signiertes MSIX-Paket veröffentlichen
- MSIX-Dateien, öffentliches Zertifikat und Installationshinweise sammeln
- Dateien als Artifact bereitstellen
Die Windows-Paketversion besteht aus vier Zahlen. Mit AppxPackageVersion setzen wir sie beim Veröffentlichen ausdrücklich. AppxAutoIncrementPackageRevision=false verhindert eine zusätzliche automatische Änderung der letzten Komponente.
Die Berechnung aus github.run_number stammt aus dem Beispiel-Workflow und erzeugt bei steigenden Run-Nummern steigende Paketversionen. Sie ist für unsere Testverteilung gedacht, nicht als Versionsschema für Store-Einreichungen.
Ein erneuter Versuch desselben Workflow-Runs verwendet allerdings dieselbe Nummer. Für ein Update auf einem Testrechner benötigt ihr eine höhere Paketversion sowie eine gleichbleibende Paketidentität und einen passenden Publisher.
Schritt 9: Workflow ausführen
Aktuell verwenden wir in unserem Workflow ausschließlich:
on:
workflow_dispatch:
Dadurch wird der Build nicht automatisch bei jedem Commit gestartet.
Nachdem wir die Workflow-Datei in unser Repository gepusht haben, können wir in GitHub in den Bereich Actions wechseln und den Workflow dort manuell starten.
Das eignet sich sehr gut, um die Pipeline zunächst zu testen.
Sobald alles funktioniert, können wir den Trigger natürlich erweitern und den Workflow beispielsweise bei einem Push, einem Tag oder bei der Erstellung eines Releases ausführen.
Nach einem erfolgreichen Run sollten wir ein Artifact mit dem Namen windows-build sehen.
Schritt 10: Testpaket auf einem anderen Rechner installieren
Unser Artifact enthält:
- das
.msix-Paket unserer Anwendung im jeweiligen Paketunterordner - zusätzliche
.msix-Abhängigkeiten, soweit sie beim Packaging bereitgestellt wurden MyAwesomeMauiApp-Test.cerals öffentliches TestzertifikatINSTALL.txtmit den Installationshinweisen
Die genaue Version der Windows App Runtime hängt von den verwendeten Projektabhängigkeiten ab. Wir sollten daher nicht einfach irgendein Runtime-Paket installieren, sondern die von unserer Anwendung benötigte Version und Architektur verwenden.
Auf einem verwalteten Testrechner gehen wir folgendermaßen vor:
- Artifact herunterladen und vollständig entpacken.
- Herkunft und Fingerabdruck des öffentlichen Testzertifikats über einen vertrauenswürdigen Weg prüfen.
- Das Zertifikat in
LocalMachine\TrustedPeopleimportieren. - Fehlende Abhängigkeiten für die passende Architektur installieren.
- Das MSIX-Paket unserer Anwendung installieren.
Den Import des öffentlichen Zertifikats können wir in einer PowerShell mit Administratorrechten ausführen:
Import-Certificate `
-FilePath ".\MyAwesomeMauiApp-Test.cer" `
-CertStoreLocation "Cert:\LocalMachine\TrustedPeople"
Damit vertrauen wir dem Zertifikat auf diesem Rechner. Importiert deshalb nur Zertifikate, deren Herkunft ihr geprüft habt, und entfernt nicht mehr benötigte Testzertifikate nach Abschluss der Tests.
Wenn Windows weiterhin einen Vertrauensfehler meldet, sollten wir Signatur, Zertifikatsgültigkeit und den verwendeten Zertifikatsspeicher prüfen. Ein pauschaler Import in den Speicher für vertrauenswürdige Stammzertifizierungsstellen ist dafür keine gute Standardlösung.
Die Windows App Runtime muss nicht erneut installiert werden, wenn die benötigte Version und Architektur bereits vorhanden sind. Falls erforderliche Abhängigkeiten nicht im Artifact enthalten sind, müssen sie separat aus einer vertrauenswürdigen Quelle bereitgestellt werden.
Typische Probleme
Auch wenn unser Workflow insgesamt überschaubar ist, gibt es einige typische Fehlerquellen.
Publisher und Zertifikat passen nicht zusammen
Der Publisher in Package.appxmanifest muss exakt zum Subject des Zertifikats aus PFX_BASE64 passen.
Wenn im Manifest beispielsweise CN=Sebastian Jensen steht, das Zertifikat aber für CN=User Name erstellt wurde, kann das Paket nicht mit dieser Kombination signiert werden. Unser Workflow prüft das bereits vor dotnet publish.
Fehler beim Import der .pfx-Datei
Ein unvollständiger Base64-Wert oder ein falsches Passwort verhindert den Zertifikatsimport. Prüft außerdem, ob eure .pfx-Datei den privaten Schlüssel enthält und das Zertifikat noch gültig ist.
Die Anwendung wird weiterhin ohne Paket veröffentlicht
Wenn das Projekt effektiv noch als unpackaged konfiguriert ist, reicht AppxPackage=true allein unter Umständen nicht aus.
Im Workflow setzen wir daher zusätzlich WindowsPackageType=MSIX.
Falscher Runtime-Identifier-Parameter
Für den gezeigten .NET 10 MAUI Windows Build verwenden wir:
-p:RuntimeIdentifierOverride=win-x64
Übernehmt an dieser Stelle nicht einfach RuntimeIdentifier=win-x64 aus einem anderen Projekttyp. Der Override-Parameter entspricht der Empfehlung für die Veröffentlichung von .NET MAUI Windows Apps.
Das Zertifikat wird auf dem Testrechner nicht als vertrauenswürdig erkannt
Ein signiertes Paket ist nicht automatisch ein vertrauenswürdiges Paket.
Bei unserer selbstsignierten Testverteilung benötigt der Zielrechner das öffentliche .cer-Zertifikat im passenden Zertifikatsspeicher. Gebt deshalb nicht nur die .msix-Datei weiter.
Eine Abhängigkeit fehlt
Wenn die benötigte Windows App Runtime oder eine andere Paketabhängigkeit nicht installiert ist, kann die Installation trotz gültiger Signatur scheitern.
Prüft die konkrete Fehlermeldung und installiert die passende Version für die Zielarchitektur.
Die Paketversion steigt nicht
Windows verwendet die Paketversion, um Updates zu erkennen. Ein älteres Paket lässt sich nicht einfach als Update über eine neuere Version installieren.
Prüft daher AppxPackageVersion und achtet darauf, dass neue Testpakete eine höhere Version erhalten. Ein erneuter Versuch desselben Workflow-Runs erhöht die Version nicht.
Fazit
Das automatisierte Bauen einer .NET MAUI Windows App besteht aus mehr als einem Aufruf von dotnet publish.
Die Paketidentität, das Zertifikat, die erzeugten Dateien und die Installation auf dem Zielrechner müssen zusammenpassen.
Sobald diese Bestandteile sauber vorbereitet sind, erhalten wir mit GitHub Actions einen nachvollziehbaren Prozess: Wir bauen ein signiertes MSIX-Paket und stellen es zusammen mit dem öffentlichen Zertifikat und den benötigten Hinweisen für unsere Tester bereit.
Und genau das ist für mich der eigentliche Vorteil einer solchen Pipeline.
Wir automatisieren nicht nur einen Build, sondern machen auch die kontrollierte Testverteilung wiederholbar. Für eine spätere Store- oder Produktivveröffentlichung sollten wir die Anforderungen an Identität, Signierung und Vertrauen allerdings noch einmal gesondert betrachten.
Ein vollständiges Beispiel mit einer einfachen .NET MAUI Anwendung und den entsprechenden GitHub Actions findet ihr in meinem Repository . Der hier zugrunde liegende Stand des Windows-Workflows ist dort ebenfalls verfügbar.