Erstellung von Cross-Distribution-Linux-Anwendungen mit Flatpak

Fragmentierung ist seit geraumer Zeit ein Problem im Linux-Ökosystem. Heutzutage gibt es eine Vielzahl von Distributionen mit eigenen Paketmanagern und eigenen Vorstellungen davon, woraus ein „Basissystem“ besteht. Dies ist für Anwendungsentwickler mühsam – nachdem sie verteilungsspezifische Pakete erstellt und Repositories gewartet haben, müssen sie alle verteilungsspezifischen Fehler beheben, die möglicherweise auftreten. Außerdem werden Linux-Anwendungen im Gegensatz zu mobilen Plattformen wie iOS und Android ohne Sandbox ausgeführt und haben Zugriff auf alle Funktionen des Basissystems.

Um diese Probleme anzugehen, wurde eine Vielzahl von Lösungen vorgeschlagen. In diesem Artikel werfen wir einen Blick auf Flatpak – eine Möglichkeit, Anwendungen zu verteilen und in einer eingeschränkten Sandbox auszuführen.

Was ist Flatpak?

Flatpak ist eine Technologie zum Erstellen, Verteilen, Installieren und Ausführen von Anwendungen, die hauptsächlich auf den Linux-Desktop ausgerichtet sind. Es ermöglicht Anwendungen, Abhängigkeiten zu bündeln und mit Laufzeiten auszuliefern, sodass Anwendungen nicht von den Macken einer bestimmten Distribution abhängen. Darüber hinaus erhöht es die Sicherheit von Linux-Anwendungen, indem es sie in Sandboxes isoliert.

Die Architektur einer Flatpak-Anwendung ist im folgenden Diagramm dargestellt:

Jede Flatpak-Anwendung wird von einer „Laufzeit“ unterstützt, die die grundlegenden Abhängigkeiten enthält, die von Anwendungen verwendet werden. Diese Laufzeiten werden von Anwendungen gemeinsam genutzt. Mehrere Laufzeiten und sogar verschiedene Versionen derselben Laufzeit können gleichzeitig auf einem System vorhanden sein. Auf diese Weise haben Anwendungen ein ziemlich konsistentes Basissystem, auf das sie sich verlassen können.

Um Anwendungen für diese Laufzeit zu erstellen, werden spezielle Laufzeiten namens SDKs (Software Development Kits) bereitgestellt. Sie enthalten Tools wie Compiler und Entwicklungsheader. Wenn Ihre Anwendung von Bibliotheken abhängt, die nicht in der Laufzeit gebündelt sind, müssen Sie sie zusammen mit Ihrer Anwendung mit dem SDK kompilieren.

Darüber hinaus gibt es „Extensions“, also optionale Erweiterungen für Laufzeiten und Anwendungen. Sie werden am häufigsten verwendet, um Übersetzungs- und Debugging-Informationen von der ursprünglichen Laufzeit oder Anwendung zu trennen.

Eines der Ziele von Flatpak ist es, die Sicherheit von Anwendungen zu erhöhen, indem sie sie voneinander isolieren. Standardmäßig bietet Flatpak einen sehr eingeschränkten Zugriff auf die Ressourcen des Hostsystems. Sofern nicht ausdrücklich verlangt, ist es Anwendungen nicht gestattet, das Netzwerk zu nutzen, auf Dateien auf dem Basissystem zuzugreifen oder mit Diensten wie X, DBus oder Pulsaudio zu kommunizieren. Darüber hinaus ermöglichen „Portale“ den selektiven Zugriff auf Ressourcen über High-Level-APIs.

Installation, Flatpak-Befehle und Namenskonventionen

Flatpak ist in den Repositories der meisten Distributionen verfügbar. Unter Arch Linux und Fedora müssen Sie den flatpak installieren Paket, um flatpak zu installieren Befehl, der Ihnen hilft, Anwendungen zu installieren und zu erstellen.

sudo dnf install flatpak # Fedora
sudo pacman -S flatpak # Arch

Ubuntu-Benutzer haben es nicht in den Standard-Repositories, daher ist die Installation etwas aufwändiger. Zuerst müssen Sie dieses PPA zu Ihrem System hinzufügen:

sudo add-apt-repository ppa:alexlarsson/flatpak

Anschließend können Sie das Paket installieren mit:

sudo apt update
sudo apt install flatpak

Während die flatpak Der Befehl kann Ihnen sicherlich beim Erstellen von Anwendungen helfen, es ist jedoch nicht der bequemste Weg. Es gibt ein weiteres Tool namens flatpak-builder , mit dem Sie Flatpak-Anwendungen aus einer JSON-Datei erstellen können. (Wir werden dieses Tool später in diesem Artikel besprechen.) Sie können dieses Tool installieren mit:

sudo dnf install flatpak-builder # Fedora
sudo pacman -S flatpak-builder # Arch
sudo apt install flatpak-builder # Ubuntu

Um Anwendungen oder Laufzeiten zu installieren, müssen Sie nun Repositories zu Flatpaks Liste der Remotes hinzufügen. Diese Remotes können in einem lokalen Verzeichnis oder online gehostet werden. Laufzeiten/Anwendungen werden anhand einer inversen DNS-Adresse wie com.booleanworld.foo identifiziert . Unter Umständen müssen Sie auch die Architektur und den „Zweig“ der Laufzeit angeben. Dies geschieht mit Hilfe eines durch Schrägstriche getrennten Tripletts, wie com.booleanworld.foo/x86_64/1.3 .

Die flatpak Der Befehl fügt normalerweise Software und Repositories für alle Benutzer hinzu. Zum Ausprobieren ist dies jedoch ungeeignet, daher verwenden wir die --user Flag, um solche Änderungen nur auf den aktuellen Benutzer zu beschränken.

Nachdem wir nun die Grundlagen geschaffen haben, werfen wir einen Blick auf die Theorie zum Erstellen von Flatpak-Anwendungen.

Flatpak-Anwendungsstruktur

Wenn Sie eine Anwendung mit Flatpak bündeln, wird automatisch die folgende Verzeichnisstruktur erstellt:

• metadata :Diese Datei enthält Informationen über das SDK und die Laufzeit, auf der die Anwendung ausgeführt wird, sowie eine Liste der Basissystemressourcen, auf die die Anwendung zugreifen muss.
• files :Dieses Verzeichnis enthält Dateien, aus denen die Anwendung besteht, einschließlich aller Anwendungsdaten. Die bin Das Unterverzeichnis hier enthält die ausführbaren Dateien der Anwendung.
• export :Dieses Verzeichnis enthält alle Dateien, auf die das Basissystem zugreifen muss. Beispiele sind AppStream-Daten, der .desktop Datei und das Anwendungssymbol. Allen Dateien, die Sie hier ablegen, sollte der Bezeichner vorangestellt werden. Beispielsweise kann eine Desktop-Datei den Namen com.booleanworld.foo.desktop haben .

Sie könnten diese Struktur zwar von Hand erstellen, dies ist jedoch nicht erforderlich. Flatpak verfügt über Tools, mit denen Sie diese Struktur automatisch erstellen können, und erfordert nur sehr wenig Konfiguration, wenn Sie ein typisches auf Autotools basierendes Projekt haben. Bei Projekten, die nicht auf Autotools basieren, müssen Sie normalerweise das „Präfix“-Verzeichnis auf /app setzen um die Dinge zum Laufen zu bringen.

Voraussetzungen

In den folgenden Abschnitten des Artikels finden Sie einige Beispiele zum Erstellen von Flatpak-Anwendungen. Wie bereits erwähnt, benötigen Anwendungen eine Laufzeitumgebung und ein SDK für den Build-Prozess. Daher besteht der erste Schritt darin, ein Repository hinzuzufügen, aus dem sie verfügbar sind. Wir werden das auf sdk.gnome.org verfügbare Repository für unsere Verwendung hinzufügen.

flatpak remote-add --from gnome https://sdk.gnome.org/gnome.flatpakrepo --user

Um die folgenden Beispiele zu erstellen, benötigen wir zwei Laufzeiten: org.freedesktop.Platform und org.gnome.Platform , und zwei SDKs: org.freedesktop.Sdk und org.gnome.Sdk . Hier haben wir die Versionen 1.6 und 3.24 von Freedesktop und Gnome Runtime/SDK verwendet.

flatpak install --user gnome org.freedesktop.Platform/x86_64/1.6
                             org.freedesktop.Sdk/x86_64/1.6
                             org.gnome.Plaform/x86_64/3.24
                             org.gnome.Sdk/x86_64/3.24

Sehen Sie sich als Nächstes das flatpak-resources-Repository an, das alle Ressourcen enthält, die zum Durcharbeiten dieses Artikels erforderlich sind.

git clone https://github.com/boolean-world/flatpak-resources
cd flatpak-resources

In den folgenden Abschnitten werden wir uns zwei Beispiele für Bauanträge ansehen.

Baue „Kätzchen“, eine leichte „Katze“

In diesem Abschnitt erfahren Sie, wie Sie eine grundlegende Flatpak-Anwendung erstellen. Die Anwendung ist eine kleine Version von cat Befehl namens kitten .

Zuerst müssen Sie die zuvor besprochene Verzeichnisstruktur erstellen. Die build-init Befehl kann dies für Sie tun. Sie müssen ihm ein Build-Verzeichnis, den Namen Ihrer Anwendung und das zu verwendende SDK und die zu verwendende Laufzeit (in dieser Reihenfolge) geben. Sie können auch einen optionalen „Zweignamen“ hinzufügen, aber wir lassen ihn in diesem Beispiel weg.

flatpak build-init kitten-build com.booleanworld.kitten
                                org.freedesktop.Sdk
                                org.freedesktop.Platform

Wie bereits erwähnt, lautet das Präfixverzeichnis von Flatpak-Anwendungen /app , und Sie müssen den bin erstellen Verzeichnis darin. Wenn Sie einen Befehl innerhalb des Build-Verzeichnisses ausführen möchten, verwenden Sie den build Befehl:

flatpak build kitten-build mkdir -p /app/bin

Der nächste Schritt besteht darin, kitten.c zu kompilieren mit gcc :

flatpak build kitten-build gcc kitten.c -o /app/bin/kitten

Anschließend können Sie den Build mit build-finish abschließen . Der Befehl lautet kitten , und es muss auf das Dateisystem des Hosts zugreifen (damit Sie jede Datei auf dem Hostsystem anzeigen können). Sie können also den Build mit diesen Parametern abschließen:

flatpak build-finish kitten-build --filesystem=host --command=kitten

Wenn Sie die Anwendung jetzt testen möchten, müssen Sie sie installieren. Der erste Schritt besteht darin, die Anwendung in ein lokales Repository zu exportieren. In unserem Beispiel ist der Repository-Ordner my-repo :

flatpak build-export my-repo kitten-build

Als nächstes fügen wir das Repository mit dem Namen test-repo hinzu . Da wir keine GPG-Signaturen verwenden, teilen wir Flatpak dies mit dem --no-gpg-verify mit wechseln.

flatpak remote-add --user --no-gpg-verify test-repo my-repo

Schließlich können Sie es installieren mit:

flatpak install --user test-repo com.booleanworld.kitten

Jetzt können Sie testen, ob es funktioniert, indem Sie es folgendermaßen ausführen:

flatpak run com.booleanworld.kitten ~/.bashrc

Wenn Sie bisher alle Schritte korrekt befolgt haben, sollte dies den Inhalt Ihres .bashrc anzeigen Datei:

Herzlichen Glückwunsch zum Erstellen Ihrer ersten Flatpak-App!

Die Schritte waren bisher ziemlich einfach, aber die build-finish Befehl rechtfertigt eine weitere Diskussion. Das werden wir im nächsten Abschnitt tun.

Ein genauerer Blick auf den „Build-Finish“-Befehl

Eines der Hauptziele von Flatpak ist es, Anwendungen in eine Sandbox zu versetzen und nur minimalen Zugriff auf die Ressourcen des Hostsystems zu gewähren. Im vorherigen Beispiel haben wir der „Kätzchen“-App erlaubt, mit build-finish auf jede Datei auf dem System zuzugreifen . Die Schalter, die Sie verwenden können, um den Zugriff auf verschiedene Ressourcen zuzulassen, sind unten aufgeführt:

• --filesystem={path}

Dieser Schalter ermöglicht den Zugriff auf bestimmte Pfade auf dem System. Sie können einen bestimmten Pfad angeben (z. B. /usr/share ). home ermöglicht den Zugriff auf das Home-Verzeichnis des Benutzers und host ermöglicht den Zugriff auf alle Dateien auf dem System. Zusätzlich können Sie einen Pfad auch mit :ro schreibgeschützt machen . Beispiel:--filesystem=/usr/share:ro --filesystem=home ermöglicht Lesezugriff auf /usr/share und Lese-/Schreibzugriff auf das Home-Verzeichnis des Benutzers.

• --share={type}

Dieser Schalter ermöglicht den Zugriff auf bestimmte Ressourcen. Die am häufigsten verwendeten Typen sind ipc und network , die IPC- und Netzwerkzugriff ermöglichen. In den meisten GUI-Anwendungen --share=ipc wird verwendet, damit X Shared Memory funktioniert, was die Leistung verbessert.

• --socket={type}

Mit diesem Schalter können Sie bestimmte Steckdosen verwenden. Die Socket-Typen, auf die am häufigsten zugegriffen wird, sind x11 , wayland und pulseaudio . Die ersten beiden werden von Anwendungen zum Rendern von GUI-Elementen verwendet, und letzteres wird zum Abspielen von Audio über den Pulseaudio-Daemon verwendet.

• --device={device}

Damit können Anwendungen selektiv auf einige Geräte zugreifen. Meistens dri wird hier verwendet, damit Anwendungen OpenGL-Rendering verwenden können.

• --talk-name={name} und --system-talk-name={name}

Diese Schalter ermöglichen es Anwendungen, mit benannten Diensten über den Sitzungsbus und den Systembus von DBus zu kommunizieren.

• --env={varname}={value}

Der env Mit switch können Sie Umgebungsvariablen exportieren. {varname} ist der Variablenname, der auf den angegebenen {value} gesetzt wird .

Wenn eine Anwendung Zugriff auf dconf benötigt, müssen Sie die folgenden Schalter verwenden:

--filesystem=xdg-run/dconf
--filesystem=~/.config/dconf:ro
--talk-name=ca.desrt.dconf
--env=DCONF_USER_CONFIG_DIR=.config/dconf

Wir werden ein praktisches Beispiel mit diesen Schaltern in einem späteren Abschnitt sehen.

Anwendungen automatisch erstellen:flatpak-builder

Obwohl die Schritte zum Erstellen von Flatpak-Anwendungen ziemlich einfach sind, ist es dennoch mühsam, sie Schritt für Schritt zu erstellen. flatpak-builder ist ein Tool, mit dem Sie Anwendungen deklarativ mit einem JSON-Manifest erstellen können. Solange der Quellcode gemäß der „Build-API“ ausgelegt ist, kann der Builder Anwendungen aus den Quellarchiven kompilieren und installieren. Die meisten auf Autotools basierenden Programme entsprechen bereits der API, sodass normalerweise keine weitere Konfiguration erforderlich ist.

Eine typische Manifestdatei sieht normalerweise so aus:

{
  "app-id": "com.booleanworld.kitten",
  "runtime": "org.freedesktop.Platform",
  "runtime-version": "1.6",
  "sdk": "org.freedesktop.Sdk",
  "command": "kitten",
  "finish-args": [
     "--filesystem=host"
  ],
  "modules": [
    {
      "name": "kitten",
      "sources": [
        {
          "type": "archive",
          "url": "https://opensource.example.com/kitten-0.0.1.tar.gz",
          "sha256": "38ecfd39b76a2505376f5a57ebcc7b19d35efaf9f8c724a24382c45aa1378018"
        }
      ]
    }
  ]
}

Wie Sie sehen können, enthält diese Datei die gleichen Informationen, die wir zuvor mit verschiedenen Befehlen angegeben hatten. Darüber hinaus enthält es eine Liste der zu erstellenden Module. Im obigen Beispiel gibt es nur ein einziges Modul. Wenn Sie eine komplexe Anwendung haben, die von mehreren Modulen abhängt, müssen Sie alle auflisten. Beispielsweise hängt gnome-calculator von mpc und mpfr ab und das Manifest sieht so aus.

Es werden verschiedene Quelltypen unterstützt. Ein weiterer beliebter Quelltyp ist git , und Sie müssen die Repository-URL und optional den Zweig angeben, der ausgecheckt werden muss.

Das Manifest ist sehr leistungsfähig und unterstützt das Festlegen von CFLAGS/CXXFLAGS, das Umbenennen von Dateien für den Export und das Entfernen unnötiger Dateien. Im nächsten Abschnitt werden wir eine praktische Anwendung analysieren und lernen, wie man sie für Flatpak verpackt.

Ein echtes Beispiel:Verpackungsgalculator

In diesem Abschnitt nehmen wir galculator, eine einfache Rechneranwendung, und erstellen sie mit flatpak-builder . Wir müssen ein wenig analysieren, um herauszufinden, welche Dateien umbenannt oder gelöscht werden müssen. Daher werden wir im ersten Schritt eine Testinstallation vornehmen. Dann können wir das Manifest nach Bedarf erstellen.

Da galculator eine GTK-Anwendung ist, verwenden wir die Gnome-Laufzeitumgebung und das SDK. Sie sollten sie jetzt installieren, falls Sie dies noch nicht getan haben. Außerdem sollten Sie das Quellarchiv hier herunterladen. (Wir haben Version 2.1.4 verwendet, die zum Zeitpunkt der Erstellung dieses Dokuments die neueste Version ist.)

Dateien finden, die exportiert/gelöscht werden sollen

Nachdem Sie das Quellarchiv heruntergeladen und extrahiert haben, sollten Sie versuchen, es mit dem SDK zu erstellen. Das Gnome-SDK enthält auch Tools wie Bash, sodass Sie diese starten können, indem Sie Folgendes verwenden:

flatpak run --command=bash --filesystem=host --devel org.gnome.Sdk/x86_64/3.24

Wechseln Sie nun in das Quellverzeichnis von galculator und verwenden Sie die reguläre Beschwörung, um es zu erstellen. Wir werden unser Präfixverzeichnis auf ~/galculator-test setzen .

./configure --prefix=$HOME/galculator-test
make install

Jetzt können Sie die Dateien im galculator-test durchsuchen Verzeichnis. Wie Sie wahrscheinlich erkennen können, müssen die folgenden Dateien exportiert werden:

• AppStream-Informationen in share/appdata/galculator.appdata.xml
• Symbole in share/icons
• Der Desktop-Eintrag in share/applications/galculator.desktop

Leider ist ihnen nicht der Anwendungsname vorangestellt. Daher müssen Sie sie mit den folgenden Eigenschaften im Manifest umbenennen:

{
	"rename-appdata-file": "galculator.appdata.xml",
	"rename-icon": "galculator",
	"rename-desktop-file": "galculator.desktop"
}

Sobald diese Dateien umbenannt sind, flatpak-builder exportiert sie automatisch. Sobald das Flatpak-Paket erstellt ist, hilft dies beim Erstellen von Menüeinträgen auf dem Basissystem.

Außerdem die share/man und share/pixmaps Verzeichnisse sind nicht notwendig, also können Sie sie entfernen mit:

{
    "cleanup": [
        "/share/man",
        "/share/pixmaps"
    ]
}

Sandbox konfigurieren

Da es sich um eine GTK-Anwendung handelt, müssen Sie ihr den Zugriff auf X11 und Wayland sowie die gemeinsame Nutzung von IPC-Mechanismen gestatten. Sie müssen ihm auch erlauben, OpenGL-Rendering zu verwenden. Außerdem benötigt galculator Zugriff auf dconf, und Sie müssen die zuvor besprochenen Einträge hinzufügen. Die Schalter, die an build-finish übergeben worden wären sind im finish-args aufgeführt Eigenschaft im Manifest:

{
    "finish-args": [
        "--share=ipc",
        "--socket=x11",
        "--socket=wayland",
        "--device=dri",
        "--filesystem=xdg-run/dconf",
        "--filesystem=~/.config/dconf:ro",
        "--talk-name=ca.desrt.dconf",
        "--env=DCONF_USER_CONFIG_DIR=.config/dconf"
    ]
}

Ausfüllen des Manifests

An diesem Punkt haben Sie die meisten wichtigen Teile des Manifests konfiguriert. Die Konfiguration des Rests sollte ziemlich einfach sein, und das endgültige Manifest, das wir verwendet haben, ist hier . Wir haben eine Reihe von build-options hinzugefügt , wodurch CFLAGS und CXXFLAGS auf -O3 gesetzt werden .

Anwendung erstellen und testen

Schließlich können wir die Anwendung erstellen. Führen Sie einfach flatpak-builder aus mit einem Build-Verzeichnis und dem Manifest. In diesem Beispiel galculator ist das Build-Verzeichnis und org.mnim.galculator.json ist die Manifestdatei.

flatpak-builder galculator org.mnim.galculator.json

Exportieren Sie es als Nächstes wie zuvor in das Repository:

flatpak build-export my-repo galculator

Jetzt können Sie die Anwendung testen, indem Sie sie installieren:

flatpak install --user test-repo org.mnim.galculator

Die Anwendung wird sofort installiert und Sie erhalten sogar Desktop-Einträge wie bei einer normalen Anwendung! Sie können es über den Menüeintrag starten oder mit flatpak run ausführen wie wir es früher getan haben.

Verteilen von Anwendungen

Nun, da Sie eine Anwendung erstellt haben, wie gehen Sie vor, um sie zu verteilen? Der einfachste Weg, dies zu tun, besteht darin, das Repository-Verzeichnis auf einen Server zu übertragen und es über das Internet bereitzustellen. Anschließend können Sie Benutzer bitten, Ihr Repository zu ihrer Liste hinzuzufügen und auf diese Weise Anwendungen zu installieren.

Viele Leute ziehen es vor, mit GPG signierte Software zu installieren, da dies beweist, dass die Anwendung tatsächlich vom ursprünglichen Betreuer stammt. Mit dem gpg2 können Sie ganz einfach GPG-Schlüssel erstellen Befehl:

gpg2 --quick-key-gen [email protected]

Notieren Sie sich unbedingt die Schlüssel-ID, da Sie sie später benötigen. In unserem Beispiel gehen wir davon aus, dass die Schlüssel-ID A318C188C20D410A ist .

Dann können Sie ein GPG-signiertes Repository erstellen, wenn Sie build-export ausführen so:

flatpak build-export my-repo galculator --gpg-sign=A318C188C20D410A

Wenn Sie ein vorhandenes unsigniertes Repository haben, können Sie es folgendermaßen signieren:

flatpak build-sign my-repo --gpg-sign=A318C188C20D410A
flatpak build-update-repo my-repo --gpg-sign=A318C188C20D410A

Wenn Sie das Repository veröffentlichen möchten, stellen Sie sicher, dass Sie den Benutzern eine Kopie des öffentlichen Schlüssels zur Verfügung stellen. Um Ihren öffentlichen Schlüssel zu exportieren, führen Sie Folgendes aus:

gpg2 --export A318C188C20D410A > public.gpg

Sie sollten diesen Schlüssel auf Ihrer Website veröffentlichen. Wenn Ihre Benutzer Ihr Repository hinzufügen möchten, sollten sie den öffentlichen Schlüssel herunterladen. Wenn der Benutzer einen Schlüssel namens public.gpg heruntergeladen hat , können sie nun das Repository hinzufügen, indem sie Folgendes ausführen:

flatpak remote-add --gpg-import=public.gpg test-repo https://software.example.com/repo/

Dieses Verfahren ist jedoch für Benutzer äußerst unpraktisch. Glücklicherweise können Sie den Prozess vereinfachen, indem Sie flatpakref- und flatpakrepo-Dateien erstellen, die in der Dokumentation ausführlich besprochen werden.

Schlussfolgerung

In diesem Artikel haben wir etwas über Flatpak erfahren und wie Sie Software mit dieser neuen Technologie verteilen können. Es ist sicherheitsorientierter und bietet bessere Integrations- und Aktualisierungsfunktionen im Vergleich zu herkömmlichen Methoden wie AppImage.

Wenn Sie mehr zu diesem Thema lesen möchten, finden Sie in der Entwicklerdokumentation und im flatpak-manifest Manpages sind gute Ausgangspunkte. Wenn Sie komplexere Beispiele für Manifest-/Flatpakref-Dateien durchlesen möchten, werfen Sie einen Blick auf das Gnome-Apps-Repository und die Flathub-Beispiele.