La fragmentation est un problème depuis un certain temps dans l'écosystème Linux. Une variété de distributions existent aujourd'hui, avec leurs propres gestionnaires de paquets et leurs propres notions de ce qu'est un « système de base ». C'est fastidieux pour les développeurs d'applications :après avoir créé des packages spécifiques à la distribution et maintenu les référentiels, ils doivent corriger les bogues spécifiques à la distribution qui peuvent survenir. De plus, contrairement aux plates-formes mobiles telles qu'iOS et Android, les applications Linux s'exécutent sans bac à sable avec accès à toutes les fonctionnalités du système de base.
Pour résoudre ces problèmes, une grande variété de solutions ont été proposées. Dans cet article, nous examinerons Flatpak :un moyen de distribuer des applications et de les exécuter dans un bac à sable restreint.
Qu'est-ce que Flatpack ?
Flatpak est une technologie de création, de distribution, d'installation et d'exécution d'applications, principalement destinée au bureau Linux. Il permet aux applications de regrouper les dépendances et d'être livrées avec des runtimes, de sorte que les applications ne finissent pas par dépendre des bizarreries d'une distribution particulière. De plus, il augmente la sécurité des applications Linux en les isolant dans des bacs à sable.
L'architecture d'une application Flatpak est présentée dans le schéma ci-dessous :
Chaque application Flatpak est soutenue par un "runtime", qui contient les dépendances de base utilisées par les applications. Ces runtimes sont partagés entre les applications. Plusieurs runtimes et même différentes versions du même runtime peuvent coexister sur un système en même temps. De cette façon, les applications disposent d'un système de base assez cohérent sur lequel s'appuyer.
Afin de créer des applications pour ce runtime, des runtimes spéciaux appelés SDK (Software Development Kits) sont fournis. Ils contiennent des outils tels que des compilateurs et des en-têtes de développement. Si votre application dépend de bibliothèques non intégrées dans le runtime, vous devez les compiler avec le SDK, avec votre application.
De plus, il existe des "extensions", qui sont des modules complémentaires facultatifs pour les runtimes et les applications. Ils sont le plus souvent utilisés pour séparer les informations de traduction et de débogage de l'environnement d'exécution ou de l'application d'origine.
L'un des objectifs de Flatpak est d'augmenter la sécurité des applications en les isolant les unes des autres. Par défaut, Flatpak fournit un accès très limité aux ressources du système hôte. Sauf demande explicite, les applications ne sont pas autorisées à utiliser le réseau, à accéder aux fichiers sur le système de base ou à communiquer avec des services tels que X, DBus ou Pulseaudio. De plus, les "portails" permettent un accès sélectif aux ressources via des API de haut niveau.
Installation, commandes Flatpak et conventions de dénomination
Flatpak est disponible dans les dépôts de la plupart des distributions. Sur Arch Linux et Fedora, vous devez installer le flatpak package pour installer le flatpak commande, qui vous aide à installer et à créer des applications.
sudo dnf install flatpak # Fedora sudo pacman -S flatpak # Arch
Les utilisateurs d'Ubuntu ne l'ont pas dans les référentiels par défaut, donc l'installer est un peu plus compliqué. Tout d'abord, vous devez ajouter ce PPA à votre système :
sudo add-apt-repository ppa:alexlarsson/flatpak
Ensuite, vous pouvez installer le package avec :
sudo apt update sudo apt install flatpak
Alors que le flatpak La commande peut certainement vous aider à créer des applications, ce n'est pas le moyen le plus pratique. Il existe un autre outil, nommé flatpak-builder , qui vous permet de créer des applications Flatpak à partir d'un fichier JSON. (Nous aborderons cet outil plus loin dans cet article.) Vous pouvez installer cet outil avec :
sudo dnf install flatpak-builder # Fedora sudo pacman -S flatpak-builder # Arch sudo apt install flatpak-builder # Ubuntu
Désormais, pour installer des applications ou des runtimes, vous devez ajouter des référentiels à la liste des télécommandes de Flatpak. Ces télécommandes peuvent être hébergées dans un répertoire local ou en ligne. Les runtimes/applications sont identifiés à l'aide d'une adresse DNS inverse, comme com.booleanworld.foo . Dans certaines circonstances, vous devrez peut-être également spécifier l'architecture et la "branche" du runtime. Cela se fait à l'aide d'un triplet séparé par une barre oblique, comme com.booleanworld.foo/x86_64/1.3 .
Le flatpak La commande ajoute généralement des logiciels et des référentiels pour tous les utilisateurs. Cependant, cela ne convient pas pour essayer des choses, nous allons donc utiliser le --user flag pour limiter ces modifications à l'utilisateur actuel uniquement.
Maintenant que nous avons les bases en place, nous allons jeter un œil à la théorie sur la création d'applications Flatpak.
Structure de l'application Flatpack
Lorsque vous regroupez une application avec Flatpak, la structure de répertoires suivante est automatiquement créée :
-
metadata:Ce fichier contient des informations sur le SDK et l'environnement d'exécution sur lequel l'application s'exécutera, ainsi qu'une liste des ressources système de base auxquelles l'application doit accéder. -
files:Ce répertoire contient les fichiers qui composent l'application, y compris toutes les données de l'application. Lebinle sous-répertoire à l'intérieur contient les exécutables de l'application. -
export:Ce répertoire contient tous les fichiers auxquels le système de base doit accéder. Les exemples incluent les données AppStream, le.desktopfichier et l'icône de l'application. Tous les fichiers que vous placez ici doivent être précédés de l'identifiant. Par exemple, un fichier de bureau peut avoir le nomcom.booleanworld.foo.desktop.
Bien que vous puissiez construire cette structure à la main, ce n'est pas nécessaire. Flatpak dispose d'outils pour vous aider à créer automatiquement cette structure, et cela nécessite très peu de configuration si vous avez un projet typique basé sur les autotools. Avec les projets non basés sur des outils automatiques, vous devez généralement définir le répertoire "préfixe" sur /app pour que tout soit opérationnel.
Prérequis
Les sections suivantes de l'article contiennent quelques exemples de création d'applications Flatpak. Comme nous l'avons mentionné précédemment, les applications ont besoin d'un runtime pour s'exécuter et d'un SDK pour le processus de construction. Ainsi, la première étape consiste à ajouter un référentiel à partir duquel ils sont disponibles. Nous ajouterons le référentiel disponible sur sdk.gnome.org pour notre usage.
flatpak remote-add --from gnome https://sdk.gnome.org/gnome.flatpakrepo --user
Pour créer les exemples ci-dessous, nous avons besoin de deux environnements d'exécution : org.freedesktop.Platform et org.gnome.Platform , et deux SDK : org.freedesktop.Sdk et org.gnome.Sdk . Ici, nous avons utilisé les versions 1.6 et 3.24 du runtime/SDK Freedesktop et Gnome.
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 Ensuite, consultez le référentiel flatpak-resources, qui contient toutes les ressources nécessaires pour suivre cet article.
git clone https://github.com/boolean-world/flatpak-resources cd flatpak-resources
Nous examinerons deux exemples de création d'applications dans les sections suivantes.
Construire un "chaton", un "chat" léger
Dans cette section, nous allons apprendre à créer une application Flatpak de base. L'application est une petite version du cat commande, nommée kitten .
Tout d'abord, vous devez créer la structure de répertoires dont nous avons parlé précédemment. Le build-init commande peut le faire pour vous. Vous devez lui donner un répertoire de construction, le nom de votre application, ainsi que le SDK et le runtime à utiliser (dans cet ordre). Vous pouvez également ajouter un "nom de branche" facultatif, mais nous le laisserons de côté dans cet exemple.
flatpak build-init kitten-build com.booleanworld.kitten
org.freedesktop.Sdk
org.freedesktop.Platform
Comme nous l'avons mentionné précédemment, le répertoire de préfixes des applications Flatpak est /app , et vous devez créer le bin répertoire qu'il contient. Lorsque vous souhaitez exécuter une commande dans le répertoire de construction, utilisez le build commande :
flatpak build kitten-build mkdir -p /app/bin
L'étape suivante consiste à compiler kitten.c avec gcc :
flatpak build kitten-build gcc kitten.c -o /app/bin/kitten
Ensuite, vous pouvez terminer la construction avec build-finish . La commande sera kitten , et il doit accéder au système de fichiers de l'hôte (afin que vous puissiez voir n'importe quel fichier sur le système hôte). Ainsi, vous pouvez terminer la compilation avec ces paramètres définis :
flatpak build-finish kitten-build --filesystem=host --command=kitten
Maintenant, si vous voulez tester l'application, vous devez l'installer. La première étape consiste à exporter l'application dans un référentiel local. Dans notre exemple, le dossier du référentiel est my-repo :
flatpak build-export my-repo kitten-build
Ensuite, nous ajouterons le référentiel avec le nom test-repo . Puisque nous n'utilisons pas de signatures GPG, nous informerons Flatpak avec le --no-gpg-verify commutateur.
flatpak remote-add --user --no-gpg-verify test-repo my-repo
Enfin, vous pouvez l'installer avec :
flatpak install --user test-repo com.booleanworld.kitten
Maintenant, vous pouvez tester si cela fonctionne en l'exécutant comme suit :
flatpak run com.booleanworld.kitten ~/.bashrc
Si vous avez correctement suivi toutes les étapes jusqu'à présent, cela devrait afficher le contenu de votre .bashrc fichier :
Félicitations pour la création de votre première application Flatpak !
Les étapes ont été assez simples jusqu'à présent, mais le build-finish commandement justifie une discussion plus approfondie. C'est ce que nous allons faire dans la section suivante.
Un examen plus approfondi de la commande "build-finish"
L'un des principaux objectifs de Flatpak est de mettre les applications en bac à sable et de ne fournir qu'un accès minimal aux ressources du système hôte. Dans l'exemple précédent, nous avons autorisé l'application "chaton" à accéder à n'importe quel fichier du système avec build-finish . Les commutateurs que vous pouvez utiliser pour autoriser l'accès à diverses ressources sont répertoriés ci-dessous :
--filesystem={path}
Ce commutateur permet d'accéder à des chemins spécifiques sur le système. Vous pouvez fournir un chemin spécifique (par exemple, /usr/share ). home permet l'accès au répertoire personnel de l'utilisateur, et host permet d'accéder à tous les fichiers du système. De plus, vous pouvez également rendre un chemin en lecture seule avec :ro . Par exemple, --filesystem=/usr/share:ro --filesystem=home autorise l'accès en lecture seule à /usr/share et un accès en lecture-écriture au répertoire personnel de l'utilisateur.
--share={type}
Ce commutateur permet d'accéder à des ressources particulières. Les types les plus couramment utilisés sont ipc et network , qui permettent l'accès IPC et réseau. Dans la plupart des applications GUI, --share=ipc est utilisé pour que la mémoire partagée X fonctionne, ce qui améliore les performances.
--socket={type}
Ce commutateur vous permet d'utiliser des sockets particuliers. Les types de socket les plus couramment consultés sont x11 , wayland et pulseaudio . Les deux premiers sont utilisés par les applications pour restituer les éléments de l'interface graphique, et le dernier est utilisé pour lire l'audio via le démon Pulseaudio.
--device={device}
Cela permet aux applications d'accéder de manière sélective à certains appareils. Le plus souvent, dri est utilisé ici pour que les applications puissent utiliser le rendu OpenGL.
-
--talk-name={name}et--system-talk-name={name}
Ces commutateurs permettent aux applications de communiquer avec des services nommés via le bus de session et le bus système de DBus.
--env={varname}={value}
Le env switch vous permet d'exporter des variables d'environnement. {varname} est le nom de la variable, qui est défini sur le {value} donné .
Si une application nécessite l'accès à dconf, vous devez utiliser les commutateurs suivants :
--filesystem=xdg-run/dconf --filesystem=~/.config/dconf:ro --talk-name=ca.desrt.dconf --env=DCONF_USER_CONFIG_DIR=.config/dconf
Nous verrons un exemple pratique impliquant ces commutateurs dans une section ultérieure.
Créer des applications automatiquement :flatpak-builder
Bien que les étapes impliquées dans la construction d'applications Flatpak soient assez simples, il est toujours fastidieux de les construire étape par étape. flatpak-builder est un outil qui vous permet de créer des applications de manière déclarative avec un manifeste JSON. Tant que le code source est agencé conformément à la "build API", le constructeur peut compiler et installer des applications à partir des archives source. La plupart des logiciels basés sur les outils automatiques sont déjà conformes à l'API, donc aucune autre configuration n'est généralement nécessaire.
Un fichier manifeste typique ressemble généralement à ceci :
{
"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"
}
]
}
]
} Comme vous pouvez le voir, ce fichier contient les mêmes informations que nous avions spécifiées précédemment avec diverses commandes. De plus, il contient une liste de modules à construire. Dans l'exemple ci-dessus, il n'y a qu'un seul module. Si vous avez une application complexe qui dépend de plusieurs modules, vous devrez tous les lister. Par exemple, gnome-calculator dépend de mpc et mpfr, et le manifeste ressemble à ceci.
Différents types de sources sont pris en charge. Un autre type de source populaire est git , et vous devez fournir l'URL du référentiel et éventuellement, la branche qui doit être extraite.
Le manifeste est très puissant et prend en charge la définition de CFLAGS/CXXFLAGS, le renommage des fichiers pour l'exportation et la suppression des fichiers inutiles. Dans la section suivante, nous analyserons une application pratique et apprendrons comment la conditionner pour Flatpak.
Un exemple concret :le galculateur d'emballage
Dans cette section, nous allons prendre galculator, une application de calcul simple et la construire avec flatpak-builder . Nous devons effectuer une petite analyse pour savoir quels fichiers doivent être renommés ou supprimés. Ainsi, dans un premier temps, nous ferons une installation test. Ensuite, nous pouvons créer le manifeste si nécessaire.
Étant donné que galculator est une application GTK, nous utiliserons le runtime Gnome et le SDK. Vous devriez les installer maintenant si vous ne l'avez pas déjà fait. De plus, vous devez télécharger l'archive source à partir d'ici. (Nous avons utilisé la version 2.1.4, qui est la dernière version au moment de la rédaction de cet article.)
Rechercher les fichiers à exporter/supprimer
Une fois que vous avez téléchargé et extrait l'archive source, vous devez essayer de la construire à l'aide du SDK. Le SDK Gnome contient également des outils tels que bash, vous pouvez donc le démarrer en utilisant :
flatpak run --command=bash --filesystem=host --devel org.gnome.Sdk/x86_64/3.24
Maintenant, déplacez-vous dans le répertoire source du galculator et utilisez l'incantation habituelle pour le construire. Nous allons définir notre répertoire de préfixes sur ~/galculator-test .
./configure --prefix=$HOME/galculator-test make install
Maintenant, vous pouvez explorer les fichiers dans le galculator-test annuaire. Comme vous pouvez probablement le constater, les fichiers suivants doivent être exportés :
- Informations AppStream en
share/appdata/galculator.appdata.xml - Icônes en
share/icons - L'entrée de bureau en
share/applications/galculator.desktop
Malheureusement, ils ne sont pas précédés du nom de l'application. Ainsi, vous devez les renommer avec les propriétés suivantes dans le manifeste :
{
"rename-appdata-file": "galculator.appdata.xml",
"rename-icon": "galculator",
"rename-desktop-file": "galculator.desktop"
}
Une fois ces fichiers renommés, flatpak-builder les exportera automatiquement. Une fois le package Flatpak construit, cela aidera à créer des entrées de menu sur le système de base.
De plus, le share/man et share/pixmaps les répertoires ne sont pas nécessaires, vous pouvez donc les supprimer avec :
{
"cleanup": [
"/share/man",
"/share/pixmaps"
]
}
Configuration du bac à sable
Comme il s'agit d'une application GTK, vous devez lui permettre d'accéder à X11 et Wayland, et de partager les mécanismes IPC. Vous devez également lui permettre d'utiliser le rendu OpenGL. De plus, galculator a besoin d'accéder à dconf, et vous devez ajouter les entrées dont nous avons parlé plus tôt. Les commutateurs, qui auraient été passés à build-finish sont répertoriés dans le finish-args propriété dans le manifeste :
{
"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"
]
} Remplir le manifeste
À ce stade, vous avez configuré la plupart des parties importantes du manifeste. Configurer le reste devrait être assez facile, et le manifeste final que nous avons utilisé est ici. Nous avons ajouté un ensemble de build-options , qui définit CFLAGS et CXXFLAGS sur -O3 .
Construire et tester l'application
Enfin, nous pouvons créer l'application. Exécutez simplement flatpak-builder avec un répertoire de construction et le manifeste. Dans cet exemple, galculator est le répertoire de construction et org.mnim.galculator.json est le fichier manifeste.
flatpak-builder galculator org.mnim.galculator.json
Ensuite, exportez-le dans le référentiel comme nous l'avons fait précédemment :
flatpak build-export my-repo galculator
Vous pouvez maintenant tester l'application en l'installant :
flatpak install --user test-repo org.mnim.galculator
L'application est immédiatement installée, et vous obtenez même des entrées de bureau comme une application normale ! Vous pouvez le lancer à partir de l'entrée de menu ou l'exécuter avec flatpak run comme nous l'avons fait plus tôt.
Distribuer des applications
Maintenant que vous avez créé une application, comment procédez-vous pour la distribuer ? Le moyen le plus simple consiste à transférer le répertoire du référentiel sur un serveur et à le diffuser sur le Web. Ensuite, vous pouvez demander aux utilisateurs d'ajouter votre référentiel à leur liste et d'installer des applications de cette façon.
De nombreuses personnes préfèrent installer un logiciel signé avec GPG, car cela prouve que l'application provient bien du mainteneur d'origine. Vous pouvez créer facilement des clés GPG avec le gpg2 commande :
gpg2 --quick-key-gen [email protected]
Assurez-vous de noter l'ID de clé car vous en aurez besoin plus tard. Dans notre exemple, nous supposerons que l'ID de clé est A318C188C20D410A .
Ensuite, vous pouvez créer un référentiel signé GPG lors de l'exécution de build-export comme ça :
flatpak build-export my-repo galculator --gpg-sign=A318C188C20D410A
Si vous avez un référentiel non signé existant, vous pouvez le signer comme suit :
flatpak build-sign my-repo --gpg-sign=A318C188C20D410A flatpak build-update-repo my-repo --gpg-sign=A318C188C20D410A
Lorsque vous souhaitez publier le référentiel, assurez-vous de fournir aux utilisateurs une copie de la clé publique. Pour exporter votre clé publique, exécutez :
gpg2 --export A318C188C20D410A > public.gpg
Vous devez publier cette clé sur votre site Web. Lorsque vos utilisateurs souhaitent ajouter votre référentiel, ils doivent télécharger la clé publique. Si l'utilisateur a téléchargé une clé nommée public.gpg , ils peuvent maintenant ajouter le référentiel en exécutant :
flatpak remote-add --gpg-import=public.gpg test-repo https://software.example.com/repo/
Cependant, cette méthode est extrêmement peu pratique pour les utilisateurs. Heureusement, vous pouvez simplifier le processus en créant des fichiers flatpakref et flatpakrepo, qui sont décrits en détail dans la documentation.
Conclusion
Dans cet article, nous avons découvert Flatpak et comment vous pouvez distribuer des logiciels à l'aide de cette nouvelle technologie. Il est plus axé sur la sécurité et offre de meilleures capacités d'intégration et de mise à jour par rapport aux méthodes traditionnelles telles que AppImage.
Si vous souhaitez en savoir plus sur ce sujet, consultez la documentation pour les développeurs et le flatpak-manifest man page sont de bons endroits pour commencer. Si vous souhaitez lire des exemples plus complexes de fichiers manifestes/flatpakref, consultez le référentiel Gnome-apps et les exemples Flathub.