Weißes Windows-Logo auf blauem Hintergrund.

Blogbeitrag

Von Commit zu MSIX: .NET MAUI Windows Builds mit GitHub Actions automatisieren

In diesem Beitrag zeige ich Schritt für Schritt, wie ihr eine .NET MAUI Windows App mit GitHub Actions als signiertes MSIX-Paket baut und für kontrollierte Tests bereitstellt.

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.json fü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.appxmanifest definiert unter anderem Paketidentität und Publisher.
  • Der Publisher muss zum Subject des 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-Datei
  • PFX_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.

  1. Repository auschecken
  2. .NET SDK anhand der global.json einrichten
  3. .NET MAUI Workload installieren
  4. Versionsnummern aus der Workflow-Run-Nummer erzeugen
  5. Zertifikat aus den Secrets wiederherstellen und importieren
  6. Publisher und privaten Schlüssel prüfen
  7. Anwendung als signiertes MSIX-Paket veröffentlichen
  8. MSIX-Dateien, öffentliches Zertifikat und Installationshinweise sammeln
  9. 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.cer als öffentliches Testzertifikat
  • INSTALL.txt mit 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:

  1. Artifact herunterladen und vollständig entpacken.
  2. Herkunft und Fingerabdruck des öffentlichen Testzertifikats über einen vertrauenswürdigen Weg prüfen.
  3. Das Zertifikat in LocalMachine\TrustedPeople importieren.
  4. Fehlende Abhängigkeiten für die passende Architektur installieren.
  5. 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.

Weiterempfehlen

Diesen Beitrag teilen

Wenn dir der Beitrag gefallen hat: gern weiterreichen. Gute Links dürfen sich ruhig schnell verbreiten.

Vorheriger/Nächster Beitrag

Weißes .NET-Maskottchen auf violettem Hintergrund. Vorheriger Beitrag .NET MAUI und ASP.NET Core mit Aspire verbinden iOS-Header zum automatisierten Erstellen und Signieren einer .NET MAUI App. Nächster Beitrag Von Commit zu IPA: .NET MAUI iOS Builds mit GitHub Actions automatisieren
Titelbild zum Beitrag Von Commit zu AAB/APK: .NET MAUI Android Builds mit GitHub Actions automatisieren Von Commit zu AAB/APK: .NET MAUI Android Builds mit GitHub Actions automatisieren iOS-Header zum automatisierten Erstellen und Signieren einer .NET MAUI App. Von Commit zu IPA: .NET MAUI iOS Builds mit GitHub Actions automatisieren Titelbild zur Seite .NET MAUI: Apps entwickeln und Builds automatisieren .NET MAUI: Apps entwickeln und Builds automatisieren Weißes .NET-Maskottchen auf violettem Hintergrund. .NET MAUI und ASP.NET Core mit Aspire verbinden
Lust auf ein kurzes digitales Hallo? Wenn du eine Idee teilen, eine Frage loswerden oder ein Projekt anschieben willst: mein Posteingang ist deutlich zuverlässiger als Brieftauben. apps@tsjdev-apps.de Mail schicken