Comment créer un package flatpak

Nous avons déjà parlé de l’utilisation des packages flatpak dans un tutoriel précédent : avec cette technologie, nous distribuons universellement des applications, qui sont empaquetées avec leurs dépendances et s’exécutent à l’intérieur d’un bac à sable, isolé du reste du système. Dans ce tutoriel, nous voyons comment construire et distribuer une application à l’intérieur d’un flatpak.

Dans ce tutoriel, vous allez apprendre :

Comment installer flatpak et flatpak-builder sur les distributions Linux les plus utilisées
Comment créer et remplir un fichier manifeste avec les paramètres nécessaires
Comment générer, installer et exécuter l’application générée

Configuration logicielle requise et conventions utilisées

Installation du logiciel requis

La première chose que nous devons faire pour commencer à créer un paquet flatpak pour une application, est d’installer le logiciel nécessaire pour construire et exécuter des flatpaks : flatpak et flatpak-builder. Nous pouvons effectuer une telle opération en utilisant le gestionnaire de paquets de notre distribution Linux préférée. Sur Fedora, nous devons exécuter :

sudo dnf install flatpak flatpak-builder

Sur Debian, ou l’une des nombreuses distributions basées sur celle-ci, à la place :

sudo apt-get update && sudo apt-get install flatpak flatpak-builder

Sur Archlinux, nous pouvons utiliser pacman pour effectuer la même opération :

sudo pacman -Sy flatpak flatpak-builder

Dans de nombreux cas, le paquet flatpak-builder dépend déjà de flatpak, il peut donc être superflu de spécifier explicitement ce dernier ; Il devrait être installé de toute façon en tant que dépendance.

Création d’un flatpak : les bases

L’ensemble du processus d’empaquetage d’une application dans un flatpak est basé sur un fichier manifeste. Un fichier manifeste peut être écrit au format YAML ou JSON. Dans ce tutoriel, nous allons voir comment créer un flatpak pour ffmpeg : pour ceux d’entre vous qui ne le connaissent pas, il s’agit d’un cadre complet qui peut être utilisé pour convertir et diffuser de l’audio et de la vidéo. Le fichier manifeste doit contenir des informations telles que l’identifiant de l’application, le runtime et le sdk qu’elle utilise, la commande qui doit être utilisée pour l’invoquer une fois construit, la liste des modules utilisés pour le construire avec le package flatpak-builder et les autorisations dont l’application doit disposer. Dans un instant, nous examinerons ces paramètres en détail, mais créons d’abord un répertoire pour notre projet, nous l’appellerons ffmpeg-flatpak :

mkdir ffmpeg-flatpak

Création et remplissage du fichier manifeste

Dans le répertoire du projet, nous devons créer notre manifeste. Comment nommer le fichier manifeste ? Le fichier manifeste doit être nommé d’après l’ID de l’application : chaque application flatpak doit avoir un ID unique, créé à l’aide d’un style DNS inversé. Il est composé de deux sections :

Domaine contrôlé par le projet
Le nom spécifique du projet

L’ID d’application de l’application gnome-dictionary, par exemple, est org.gnome.Dictionary. Pour les besoins de ce tutoriel, nous allons utiliser l’ID org.linuxconfig.FFmpeg pour construire notre flatpak. Dans le répertoire de notre projet, nous créons le fichier org.linuxconfig.FFmpeg.yml et commençons à signaler l’ID de l’application en tant que valeur du paramètre app-id :

app-id: org.linuxconfig.FFmpeg

Après l’ID de l’application, nous devons spécifier le runtime et la version du runtime utilisés par l’application. Qu’est-ce que c’est? Un runtime est essentiellement « l’environnement » dans lequel l’application va s’exécuter, et contient un ensemble de bibliothèques et de services essentiels. Il y a actuellement 3 runtimes disponibles :

Freedesktop
GNOME
KDE

Le premier contient un ensemble de bibliothèques et de services essentiels, les deux autres sont basés sur celui-ci, et l’étend avec un ensemble d’utilitaires et de bibliothèques pour les environnements spécifiques qu’ils représentent.

Que devrions-nous utiliser comme exemple ? Étant donné que l’application que nous essayons de construire et de distribuer via flatpak (ffmpeg) n’a pas d’exigences spécifiques à l’environnement de bureau, nous pouvons éviter d’utiliser les runtimes GNOME ou KDE et simplement utiliser org.freedesktop.Platform. Il existe généralement de nombreuses versions d’un runtime disponibles. Dans ce cas, nous utiliserons la version 21.08 de la version freedesktop. À l’intérieur du fichier manifeste, la version d’exécution est spécifiée via le paramètre runtime-version :

app-id: org.linuxconfig.FFmpeg
runtime: org.freedesktop.Platform
runtime-version: '21.08'

Après l’exécution, nous devons également spécifier son SDK correspondant. Qu’est-ce qu’un SDK ? Chaque runtime que nous avons vu ci-dessus a un SDK correspondant, qui contient tout ce qui est contenu dans l’environnement, et, en plus, des outils de développement et des en-têtes de package. Dans notre cas, nous utiliserons le SDK org.freedesktop.Sdk :

app-id: org.linuxconfig.FFmpeg
runtime: org.freedesktop.Platform
runtime-version: '21.08'
sdk: org.freedesktop.Sdk

Le runtime et le sdk spécifiés ne sont pas installés automatiquement, nous devons le faire manuellement. Pour les installer uniquement pour notre utilisateur, depuis le référentiel flathub, nous utilisons la commande suivante :

flatpak install flathub --user org.feedesktop.Platform.ffmpeg-full//21.08 org.freedesktop.Sdk//21.08

Après avoir spécifié l’app-id, le runtime, le runtime-version et le sdk, nous devons fournir le nom du binaire principal de l’application. Nous le faisons via le paramètre de commande :

app-id: org.linuxconfig.FFmpeg
runtime: org.freedesktop.Platform
runtime-version: '21.08'
sdk: org.freedesktop.Sdk
command: ffmpeg

Les modules de l’application

Une autre chose très importante que nous devons spécifier à l’intérieur du fichier manifeste est la liste des modules qui doivent être construits. Le module le plus important est celui dédié à l’application elle-même (ffmpeg dans ce cas), les (éventuels) autres sont dédiés à ses dépendances. Les modules sont répertoriés sous le paramètre modules du fichier manifeste :

app-id: org.linuxconfig.FFmpeg
runtime: org.freedesktop.Platform
runtime-version: '21.08'
sdk: org.freedesktop.Sdk
modules:
  - name: ffmpeg
    sources:
      - type: archive
        url: https://www.ffmpeg.org/releases/ffmpeg-4.4.1.tar.xz
        sha256: eadbad9e9ab30b25f5520fbfde99fae4a92a1ae3c0257a8d68569a4651e30e02
    config-opts:
      - --enable-gpl
      - --enable-libmp3lame
      - --enable-libopus
      - --enable-libvpx
      - --enable-libx264
      - --disable-static
      - --enable-shared
      - --disable-doc

Analysons ce que nous avons ajouté dans le manifeste sous la section modules. Tout d’abord, nous avons spécifié le nom du module, ffmpeg. Nous avons ensuite ajouté le dictionnaire des sources, où nous avons spécifié divers paramètres. Tout d’abord, le type de source, qui peut être l’un des suivants :

archive (nous l’utilisons pour les sources dans les archives tar)
git (pour cloner un dépôt git)
fichier (pour les fichiers locaux)
dir (pour les annuaires locaux)
script (tableau de commandes shell)
shell (tableau de commandes shell exécutées lors de l’extraction de la source)
rapiécer
extra-data (données supplémentaires à télécharger au moment de l’installation)

Dans notre cas, nous avons utilisé archive comme type de source, car nous voulons télécharger l’archive contenant le code source de ffmpeg. Avec la clé url, nous avons fourni l’URL de ladite archive, et avec le paramètre sha256, la somme de contrôle qui est utilisée pour la vérifier (la liste complète des paramètres qui peuvent être utilisés pour un type de source est disponible ici. Nous avons ensuite spécifié une liste de config-opts, qui sont ceux que nous passerions au script ./configure lors de la construction manuelle de l’application.

Ajout des autorisations de l’environnement de test

Les applications Flatpak s’exécutent dans un bac à sable, isolé du système principal, et sont conçues pour avoir le moins d’accès possible à l’hôte. Si l’application que nous empaquetons a besoin d’autorisations spécifiques, nous devons les spécifier dans le fichier manifeste. Dans notre cas, par exemple, l’application doit lire et écrire des fichiers dans le système de fichiers hôte. Les autorisations sont spécifiées sous forme de liste, sous le paramètre finish-args :

app-id: org.linuxconfig.FFmpeg
runtime: org.freedesktop.Platform
runtime-version: '21.08'
sdk: org.freedesktop.Sdk
modules:
  - name: ffmpeg
    sources:
      - type: archive
        url: https://www.ffmpeg.org/releases/ffmpeg-4.4.1.tar.xz
        sha256: eadbad9e9ab30b25f5520fbfde99fae4a92a1ae3c0257a8d68569a4651e30e02
    config-opts:
      - --enable-gpl
      - --enable-libmp3lame
      - --enable-libopus
      - --enable-libvpx
      - --enable-libx264
      - --disable-static
      - --enable-shared
      - --disable-doc
finish-args:
  - --filesystem=home:rw

Dans ce cas, nous avons utilisé les permissions --filesystem=home :rw : cela accorde à l’application empaquetée un accès complet (lecture et écriture) aux fichiers à l’intérieur de notre répertoire personnel. Cela pourrait être trop, mais ce ne sera pas grave pour le bien de ce tutoriel. Pour une liste complète des autorisations disponibles qui peuvent être spécifiées dans cette section, vous pouvez consulter la page dédiée de la documentation officielle. Le principe est cependant simple : donner à une application le moins de privilèges possible.

Création de l’application

À ce stade, nous avons théoriquement tout ce dont nous avons besoin à l’intérieur du manifeste pour construire le flatpak. Nous ouvrons un terminal à l’intérieur du répertoire où se trouve le fichier manifeste, et nous exécutons la commande suivante :

flatpak-builder build org.linuxconfig.Ffmpeg.yml

La commande flatpak-builder prend le répertoire dans lequel la construction doit se produire en premier argument, et le manifeste de l’application en second. Cependant, si nous lançons la commande avec notre manifeste actuel, nous sommes notifiés d’une erreur :

ERROR: libx264 not found

Pourquoi cela s’est-il produit ? Puisque nous avons spécifié l’option de configuration --enable-libx264 pour ffmpeg à l’intérieur du manifeste, nous devrions également ajouter un module pour construire la bibliothèque qui est nécessaire à ffmpeg. Allons-y. Notre manifeste devient :

app-id: org.linuxconfig.FFmpeg
runtime: org.freedesktop.Platform
runtime-version: '21.08'
sdk: org.freedesktop.Sdk
modules:
  - name: x264
    sources:
      - type: git
        url: https://code.videolan.org/videolan/x264.git
    config-opts:
      - --enable-shared
  - name: ffmpeg
    sources:
      - type: archive
        url: https://www.ffmpeg.org/releases/ffmpeg-4.4.1.tar.xz
        sha256: eadbad9e9ab30b25f5520fbfde99fae4a92a1ae3c0257a8d68569a4651e30e02
    config-opts:
      - --enable-gpl
      - --enable-libmp3lame
      - --enable-libopus
      - --enable-libvpx
      - --enable-libx264
      - --disable-static
      - --enable-shared
      - --disable-doc
finish-args:
  - --filesystem=home:rw

Dans ce cas, pour cloner le dépôt contenant les sources x264, nous avons spécifié git comme type de sources, et fourni l’url du dépôt. Essayons de reconstruire l’application. Cette fois, nous ajoutons l’option --force-clean à la commande, pour nettoyer le répertoire de construction qui contient déjà des choses (une erreur serait générée sinon) :

flatpak-builder build org.linuxconfig.FFmpeg.yml --force-clean

Cette fois, le processus de construction doit être terminé avec succès.

Installation et exécution de l’application

Une fois l’application construite, nous pouvons l’installer. Tout ce que nous avons à faire est d’exécuter la commande suivante :

flatpak-builder --user --install build --force-clean org.linuxconfig.FFmpeg.yml

Une fois l’installation terminée, nous pouvons tester le fonctionnement de l’application comme prévu. À titre d’exemple, nous pouvons essayer de convertir un fichier musical flac au format vorbis opus. Voici ce que nous allions exécuter :

flatpak run org.linuxconfig.FFmpeg \
  -i /home/egdoc/bk/Music/ripped/ac_dc/highway_to_hell/01_highway_to_hell.flac \
  -acodec libopus \
  -b:a 192K \
  01_highway_to_hell.opus

Avec la commande ci-dessus, nous avons converti le fichier flac /home/egdoc/bk/Music/ripped/ac_dc/highway_to_hell/01_highway_to_hell.flac en opus (-acodec libopus) avec un débit variable de 192K (-b :a 192K) et l’avons enregistré sous 01_highway_to_hell.opus. Tout aurait dû fonctionner correctement !

Conclusions

La technologie flatpak fournit une méthode universelle de distribution d’applications packagées avec toutes leurs dépendances nécessaires. Dans ce tutoriel, nous avons vu comment créer un paquet flatpak pour une application (ffmpeg) : nous avons vu comment installer les logiciels nécessaires sur les distributions Linux les plus couramment utilisées, comment créer et remplir le fichier « manifest » avec tous les paramètres nécessaires (consulter le manuel flatpak-manifest pour la liste complète des paramètres qui peuvent être utilisés à l’intérieur d’un manifeste), et enfin comment construire, installer et exécuter l’application.