Ein Release, fünf Paketmanager: wie man Nutzern Installation und Updates erleichtert

Die Installation ist einfach, entscheidend sind die Updates. Wie man aus einem einzigen Tag eine Anwendung über Homebrew, winget, Scoop, Flatpak und Docker ausliefert.

Eine neue Version einer Anwendung zu veröffentlichen ist einfach. Auf GitHub erscheint ein Release, man hängt die Archive an, fertig. Nur weiß ein Nutzer, der sich die Anwendung vor einem halben Jahr heruntergeladen hat, nichts von der neuen Version. Und schuld daran, dass er sie nicht bekommt, ist nicht er, sondern die Art, wie man ihm die Anwendung ausgeliefert hat.

Die Installation ist eine einmalige Sache. Der wirkliche Unterschied zwischen „lade es dir von der Webseite herunter“ und ordentlich verteilter Software ist das Update: wer es anstößt, wie einfach das geht und ob man es rückgängig machen kann. Das habe ich bei meinen Werkzeugen (OmniDB, PgArachne, pg_procrustes, pg_dbml und weiteren) durchdacht und bin bei einer Aufteilung gelandet, für die es nicht eine Antwort für alle Plattformen gibt.

Wonach ich auswähle

Für jede Plattform habe ich mir vier Fragen gestellt:

macOS: Homebrew

Unter macOS ist Homebrew für alles sinnvoll. Eine Formula dient für die Kommandozeile, ein Cask für Anwendungen mit grafischer Oberfläche.

brew install --cask heptau/tap/omnidb   # GUI (Cask)
brew install heptau/tap/pg-procrustes   # CLI (Formula)
brew install heptau/tap/pg-dbml         # CLI (Formula)
brew upgrade                            # alles aktualisieren

Abwägenswert ist die Entscheidung zwischen einem eigenen Tap und dem offiziellen Repository. Ein eigener Tap (heptau/tap) funktioniert sofort: Es genügt ein GitHub-Repository mit ein paar Dateien. In das offizielle homebrew-cask kommt man erst mit ausreichender Bekanntheit des Projekts und vor allem mit einer von Apple signierten und notarisierten Anwendung (das heißt: ein kostenpflichtiger Apple-Developer-Account).

Homebrew umgeht dabei Gatekeeper nicht. Eine heruntergeladene Anwendung wird genauso wie vom Browser mit Quarantäne markiert, sodass macOS sie beim ersten Start prüft. Früher gab es den Schalter --no-quarantine, mit dem der Nutzer die Quarantäne abschalten konnte, doch seit Homebrew 5.0.0 ist er veraltet, weil Homebrew das Umgehen von Sicherheitsfunktionen in macOS nicht erleichtern will. Casks ohne Signatur sind als veraltet markiert, und das offizielle Repository sollte ab September 2026 alle entfernen, die Gatekeeper nicht durchlässt (das habe ich in der Ankündigung von Homebrew 5.0.0 nachgelesen, nicht in der Praxis geprüft).

Für einen selbst folgt daraus etwas Einfaches: Signatur und Notarisierung sind die Aufgabe des Autors, nicht die von Homebrew. Ohne sie blockiert Gatekeeper dem Nutzer die Anwendung beim ersten Start, egal wie er sie installiert hat, und ins offizielle Repository kommt man nicht. In einem eigenen Tap entfernt zwar niemand den Cask, aber Gatekeeper auf dem Rechner des Nutzers gilt trotzdem.

Eine Sache, die den Nutzern hilft, egal wie sie die Anwendung installiert haben: Hat man die Anwendung schon von Hand installiert (per .dmg oder Zip) und will sie ab jetzt über Homebrew verwalten, muss man sie nicht löschen und neu herunterladen. Es genügt:

brew install --cask --adopt heptau/tap/omnidb

Der Schalter --adopt übernimmt die vorhandene Anwendung in /Applications, wenn sie mit der identisch ist, die der Cask installieren würde, und Homebrew verwaltet sie weiter, sodass brew upgrade sie danach aktualisiert. Laut Dokumentation müssen die vorhandenen Dateien mit den installierten identisch sein; praktisch ist das also vor allem dann, wenn man dieselbe Version wie der Cask hat. Mit --force lässt er sich nicht kombinieren. Für den Autor ist das eine gute Nachricht: Nutzer, die sich die Anwendung von der Webseite geholt haben, lassen sich ohne Neuinstallation zu Homebrew bringen.

Windows: winget und Scoop

winget ist ein Paketmanager, der in Windows 11 und Windows 10 enthalten ist (ab Version 1809, als Teil der Komponente App Installer). Der Nutzer tippt winget install und winget upgrade und braucht nichts weiter. Für einen selbst heißt das: Man schickt ein Manifest als Pull Request an das Repository microsoft/winget-pkgs. Voraussetzung sind eine stabile Installer-URL und eine stille Installation. Die Freigabe dauert länger als bei einem eigenen Tap, aber nach dem ersten Paket lassen sich weitere Versionen automatisch einreichen.

Ein Beispiel habe ich bei der grafischen Anwendung OmniDB. Der Nutzer tippt:

winget install heptau.OmniDB
winget upgrade heptau.OmniDB

Für eine grafische Anwendung ist ein echter Installer (.exe oder .msi) am natürlichsten, denn er muss Verknüpfungen anlegen, die Deinstallation eintragen und so weiter. Deshalb baut OmniDB beim Release einen NSIS-Installer, und ein Skript erzeugt daraus und aus den Prüfsummen das Manifest. Es besteht aus drei YAML-Dateien (Version, Installer und Beschreibung). Am wichtigsten ist die Installer-Datei:

PackageIdentifier: heptau.OmniDB
PackageVersion: 5.5.0
InstallerType: nullsoft
Scope: machine
InstallModes:
  - interactive
  - silent
  - silentWithProgress
UpgradeBehavior: install
Installers:
  - Architecture: x64
    InstallerUrl: https://github.com/heptau/omnidb/releases/download/v5.5.0/OmniDB-win-x64-setup.exe
    InstallerSha256: …
ManifestType: installer

Dieser Teil silent ist die „stille Installation“, ohne die winget upgrade nicht ohne Eingriff des Nutzers laufen könnte. Der Bezeichner heptau.OmniDB hat die Form Herausgeber.Name, das ist die Konvention von winget.

Winget hat eine Eigenschaft, die ich bei anderen Paketmanagern nicht erlebt habe: Es kann auch eine Anwendung aktualisieren, die der Nutzer von Hand installiert hat, indem er den Installer von der Webseite geladen hat. Das funktioniert, weil jeder klassische Installer unter Windows einen Eintrag in die Registry schreibt, für die Liste „Apps & Features“ (ARP, Add/Remove Programs): Name, Herausgeber und Version. Winget liest diese Einträge aus und versucht, sie mit den Paketen im Repository abzugleichen. Gelingt das, zeigt winget list die von Hand installierte Anwendung neben den anderen an, und winget upgrade kann sie aktualisieren, als hätte winget sie von Anfang an installiert.

Daraus ergibt sich ein praktischer Rat für Autoren: Darauf achten, dass Name und Herausgeber im Installer zum Manifest passen, oder sie im Manifest im Feld AppsAndFeaturesEntries aufführen. Der Abgleich stützt sich nämlich auf Namen und Versionen, und wenn er misslingt, taucht die Anwendung in winget upgrade nicht auf oder hat die Version „Unknown“. Man sollte das also nicht als Garantie verstehen, sondern als Bonus, den man im Auge behalten muss. Homebrew hat etwas Ähnliches, aber anderes: Es findet die Anwendung nicht selbst, der Nutzer muss sie von Hand „adoptieren“ (siehe den Befehl --adopt im Abschnitt zu macOS).

Das Release selbst endet dann automatisch: Ein Skript legt im Fork heptau/winget-pkgs einen Branch an und öffnet einen Pull Request mit der neuen Version. Das erste Paket musste von Hand an winget-pkgs geschickt werden, weil ein neues Paket eine andere Freigabe durchläuft als eine Versionserhöhung. Das Skript weiß das und weigert sich, ein Paket automatisch einzureichen, das im Upstream noch nicht existiert.

Für Kommandozeilenwerkzeuge braucht man keinen Installer. Winget kennt den Typ portable (eine eigenständige .exe) und seit Version 1.4 auch zip, aus dem es die verschachtelte Portable-Datei nimmt. Es genügt also ein Archiv, das man ohnehin veröffentlicht, und im Manifest steht nur ein anderer Typ. So würde es für das Archiv aussehen, das pg_procrustes bereits veröffentlicht (an winget-pkgs habe ich es bisher nicht geschickt, es ist ein Beispiel):

InstallerType: zip
NestedInstallerType: portable
NestedInstallerFiles:
  - RelativeFilePath: pg_procrustes.exe
Installers:
  - Architecture: x64
    InstallerUrl: https://github.com/heptau/pg_procrustes/releases/download/v0.6.1/pg_procrustes-0.6.1-windows-amd64.zip
    InstallerSha256: 6d361058befc5176516b52017428abd271d41a2b2d5192968b73097de3b549bc

Winget entpackt ein solches Werkzeug in das Benutzerverzeichnis und macht es im PATH verfügbar, ohne Admin-Rechte und ohne Installer. Diesen Weg habe ich bisher nur auf Ebene der Dokumentation ausprobiert, nicht in einem echten Pull Request an winget-pkgs, die genauen Feldnamen sollte man also vor dem Absenden im Schema des Manifests prüfen.

Scoop ist eine gute Alternative für die Kommandozeile und Portable-Anwendungen. Es installiert ohne Admin-Rechte ins Benutzerverzeichnis, und einen eigenen Bucket (das Pendant zu einem Tap) legt man in ein paar Minuten an.

scoop bucket add heptau https://github.com/heptau/scoop-bucket
scoop install pgarachne
scoop update pgarachne

Erwähnen sollte man auch Chocolatey: Das ist ein älterer Paketmanager, der vor allem im Unternehmensumfeld verwendet wird. Für neue Projekte sind winget und Scoop aber bequemer.

Linux

Hier gehen die Wege für GUI und CLI auseinander.

Grafische Anwendungen: Flatpak

Für Anwendungen mit Fenster ist Flatpak eine vernünftige Wahl. Die Anwendung wird von Flathub installiert, mit flatpak update aktualisiert und läuft in einer Sandbox. Gerade die Sandbox ist für einen PostgreSQL-Client wichtig. Die Anwendung sieht von sich aus weder ~/.pgpass noch Unix-Sockets, und die Berechtigungen müssen daher im Manifest ausdrücklich aufgeführt werden (ausführlicher schreibe ich darüber im Artikel Apps in der Sandbox: Wenn die Isolation die Datenbank von .pgpass abschneidet).

Snap und AppImage erwähne ich nur in einem Satz: Snap ist an Canonical gebunden, und AppImage hat von sich aus keinen Update-Mechanismus.

Kommandozeile: Homebrew

An dieser Stelle hatte ich ursprünglich an .deb- und .rpm-Pakete gedacht. Dabei bin ich auf zwei Dinge gestoßen:

Deshalb ist für mich unter Linux Homebrew die pragmatische Wahl. Es ist derselbe Befehl wie unter macOS, es installiert nach /home/linuxbrew/.linuxbrew, braucht kein Root und kollidiert nicht mit dem Paketmanager des Systems. Und die Formula kann ganz dieselbe sein. Meine PgArachne-Formula hat nur die Blöcke on_macos und on_linux mit Links auf vorkompilierte Archive aus dem GitHub-Release:

on_linux do
  if Hardware::CPU.arm?
    url "https://github.com/heptau/pgarachne/releases/download/v#{version}/pgarachne-linux-arm64.tar.gz"
    sha256 "…"
  else
    url "https://github.com/heptau/pgarachne/releases/download/v#{version}/pgarachne-linux-amd64.tar.gz"
    sha256 "…"
  end
end

Keine Kompilierung, nur der Download der fertigen Binärdatei und ihre Prüfung gegen die Prüfsumme.

Homebrew unter Linux hat aber auch Nachteile, die man fairerweise nennen sollte:

Server: das Beispiel PgArachne

Ein Server wird anders aktualisiert als ein Desktop. Das Update des Gateways, mit dem sich Anwendungen verbinden, soll gesteuert ablaufen, nicht stillschweigend. Ich will nicht, dass es sich am Freitagabend von selbst auf die neue Version umstellt.

Homebrew ermöglicht das gut:

brew install heptau/tap/pgarachne
brew services start pgarachne      # legt den Dienst an
brew upgrade pgarachne             # neue Version
brew services restart pgarachne    # Neustart nach dem Update

Unter Linux legt brew services einen systemd-Benutzerdienst an. Damit er auch ohne angemeldeten Nutzer läuft, muss man einmalig loginctl enable-linger aktivieren. Will man Updates automatisieren, genügt es, brew upgrade aus cron oder einem systemd-Timer aufzurufen, aber bewusst und zu einem Zeitpunkt, den man selbst wählt.

Und was ist mit git pull?

Mir kam auch die einfachste Lösung in den Sinn: auf dem Server einen Klon des Repositorys halten und ihn mit git pull aktualisieren. Es gibt zwei Varianten, und beide haben einen Haken.

Interessant ist, dass Homebrew eigentlich dasselbe tut: Ein Tap ist ein Git-Repository, und brew update ist im Kern ein git pull. Der Unterschied liegt darin, dass im Repository nur kleine Textbeschreibungen (Formulas) liegen, keine Binärdateien. Die Binärdateien selbst werden aus den Releases geladen, mit einer Prüfsumme verifiziert, und die Version wählt man je nach Plattform. Es ist also ein git pull für die Metadaten und ein Download für die Daten, und genau diese Trennung macht es zu einer brauchbaren Lösung.

Für die Entwicklung genügt git pull. In der Produktion würde ich es nur über einen Tap verwenden, nicht direkt.

Docker: der kürzere Weg für den Server

Bei Serveranwendungen ist oft das Update über ein Docker-Image mit Versions-Tag am wenigsten schmerzhaft:

services:
  app:
    image: ghcr.io/dein-konto/deine-app:2.0.2

Ein Update ist eine Änderung der Versionsnummer und docker compose pull && docker compose up -d. Ein Rollback ist dasselbe mit der vorherigen Nummer. Das ist der direkteste Weg zur Versionsverwaltung, setzt aber voraus, dass man auf dem Server Docker schon hat und nutzt.

Ich gebe zu, dass ich das PgArachne-Image bisher nicht veröffentliche. Es ist ein weiterer Kanal, den GoReleaser aus demselben Tag bedienen könnte, und falls ich ihn hinzufüge, wird es nur ein weiterer Block in der Konfiguration sein.

Und was ist mit Webanwendungen (PWA)?

Bei einer PWA ist die Situation das Gegenteil von allem oben Genannten: Sie muss nicht aktualisiert werden, weil das Update beim nächsten Laden der Seite geschieht. Ein Paketmanager verbessert hier nichts. Bleibt nur die Installation, und die ist im Browser mit zwei Klicks erledigt.

Trotzdem habe ich mich gefragt, ob sich das Icon der Anwendung nicht über Homebrew installieren ließe, damit man es neben den anderen Anwendungen und im Brewfile hat. Unter macOS geht das überraschend einfach. Legt man eine PWA in Safari auf den Schreibtisch (Dock), entsteht eine .app, die nur eine Info.plist (mit dem gesamten Manifest der Webanwendung), ein Icon und eine Signatur enthält. Keinen ausführbaren Code, den liefert das System. Eine solche Anwendung braucht man nur in ein Zip zu packen und als Cask bereitzustellen. Es ist bislang nur ein Beispiel (ein Lumifex-Release mit dieser Datei veröffentliche ich noch nicht, Adresse und Prüfsumme sind daher Platzhalter):

cask "lumifex" do
  version "1.0"
  sha256 "…"

  url "https://github.com/heptau/lumifex/releases/download/v#{version}/Lumifex.app.zip"
  name "Lumifex"
  homepage "https://lumifex.80.cz/"

  depends_on macos: ">= :sonoma"

  app "Lumifex.app"
end

Ich habe ausprobiert, dass sich eine Kopie mit gesetztem Quarantäne-Flag (wie nach einem Download aus dem Internet) ohne einen einzigen Fehler starten lässt, obwohl sie nur ad hoc signiert ist. Getestet habe ich das aber bisher nur auf demselben Mac, auf dem das Bundle entstanden ist, es ist also eine Überprüfung mit Vorbehalt.

Man muss zugeben, was man damit gewinnt und was nicht. Die Updates passieren weiterhin innerhalb der PWA, und brew upgrade ändert daran nichts. Man gewinnt einen einheitlichen Installationsbefehl, ein Icon im Launchpad und die Möglichkeit, die Anwendung im Brewfile zu haben. Unter Windows und Linux würde ich nichts ähnlich Einfaches erwarten. Eine Verknüpfung, die den Browser im App-Modus startet, ließe sich über Scoop oder einen kleinen Installer erzeugen, aber das habe ich noch nicht ausprobiert, und unter Linux wäre Flatpak eine Hülle mit eigenem Kern, keine Verknüpfung.

Vergleich

WegInstallationUpdateRollbackWer pflegt
Manueller Downloadherunterladen und entpackenvon Handvon HandNutzer
Homebrew (macOS, Linux)brew installbrew upgradebrew install einer bestimmten Version (eingeschränkt)ich (Tap)
wingetwinget installwinget upgradebestimmte Versionich + Prüfer
Scoopscoop installscoop updatescoop resetich (Bucket)
Flatpakflatpak installflatpak updateflatpak update --commitich + Flathub
Dockerdocker pullTag ändernTag ändernich (Registry)

Wie man es hinbekommt, dass es keine Mehrarbeit wird

Fünf Kanäle klingen nach fünf Aufgaben bei jedem Release. Die Lösung ist Automatisierung: Aus einem Tag sollen sich alle Artefakte von selbst erzeugen. Dafür verwende ich GoReleaser, der aus einem Quellcode Binärdateien für alle Plattformen baut, sie in Archive packt und Prüfsummen berechnet.

Die Grundlage der PgArachne-Konfiguration sieht so aus:

version: 2

project_name: pgarachne

builds:
  - id: cli
    main: ./cmd/pgarachne
    binary: pgarachne
    env:
      - CGO_ENABLED=0
    goos: [darwin, linux, windows]
    goarch: [amd64, arm64]
    ldflags:
      - -s -w
      - -X github.com/heptau/pgarachne/internal/version.Version={{ .Version }}

archives:
  - id: cli-archive
    ids: [cli]
    name_template: "{{ .ProjectName }}-{{ .Os }}-{{ .Arch }}"
    formats: [tar.gz]
    format_overrides:
      - goos: darwin
        formats: [zip]
      - goos: windows
        formats: [zip]

checksum:
  name_template: checksums.txt

Das ist die echte Konfiguration. Die Formula für den Tap erzeugt dann mein Skript aus den Prüfsummen, die GoReleaser liefert. GoReleaser kann aber mehr und kann die Formula, das Scoop-Manifest und das winget-Manifest selbst erstellen und in das jeweilige Repository schicken:

brews:
  - repository:
      owner: heptau
      name: homebrew-tap
    homepage: "https://www.pgarachne.com/"
    description: "PostgreSQL JSON-RPC gateway"

scoops:
  - repository:
      owner: heptau
      name: scoop-bucket
    homepage: "https://www.pgarachne.com/"
    description: "PostgreSQL JSON-RPC gateway"

(Diesen zweiten Teil führe ich als Beispiel für die Möglichkeiten an, bei PgArachne nutze ich ihn bisher nicht.)

Was sich nicht oder nur schwer automatisieren lässt: die Notarisierung bei Apple, die Freigabe auf Flathub und der Pull Request an winget-pkgs, wo am Ende immer ein Mensch oder ein Bot sitzt, der das Paket prüft.

Fazit

Meine Empfehlung, die ich jetzt nutze:

Der gemeinsame Kern ist einer: Das Update ist ein Produktmerkmal, kein Anhängsel. Der Nutzer sollte es genauso leicht bekommen wie die Installation, und man selbst sollte es aus einem einzigen Tag ohne manuelles Klicken bereitstellen können.