Aller au contenu principal

Guide Snapcraft (Linux)

Ce guide fournit des informations sur la façon d'empaqueter votre application Electron pour n'importe quel environnement Snapcraft, y compris le centre logiciel Ubuntu.

Contexte et exigences​

Avec une plus large communauté Linux, Canonical a pour but de corriger de nombreux problèmes d'installation de logiciels courants avec le projet snapcraft . Les Snaps sont des paquets logiciels conteneurisés qui incluent les dépendances requises, la mise à jour automatique et fonctionnent sur toutes les distributions Linux majeures sans modification du système.

Il existe trois méthodes pour créer un fichier .snap :

  1. En utilisant Electron Forge ou electron-builder, les deux outils qui sont fournis avec le support de snap. C'est l'option la plus simple. 2) En utilisant electron-installer-snap, qui réceptionne les émissions d'@electron/packager. 3) En utilisant un package .deb déjà créé.

Dans certains cas, vous devrez avoir installé l'outil snapcraft. Les instructions pour installer snapcraft pour votre distribution sont disponibles ici.

Utilisation de electron-installer-snap​

Le module fonctionne comme electron-winstaller et d'autres modules similaires dans la mesure où sa portée est limitée à la construction de paquets snap. Vous pouvez installer avec :

npm install --save-dev electron-installer-snap

Étape 1 : Empaqueter votre Application Electron​

Empaqueter l'application à l'aide de @electron/packager (ou d'un outil similaire). Assurez vous de supprimer les node_modules dont vous n'avez plus besoin dans votre application finale, puisque tout module dont vous n'avez pas besoin augmentera inutilement sa taille.

La sortie devrait ressembler à peu près à ceci :

.
└── dist
    └── app-linux-x64
        ├── LICENSE
        ├── LICENSES.chromium.html
        ├── content_shell.pak
        ├── app
        ├── icudtl.dat
        ├── libgcrypt.so.11
        ├── libnode.so
        ├── locales
        ├── resources
        ├── v8_context_snapshot.bin
        └── version

Étape 2 : Exécuter electron-installer-snap​

Depuis un terminal qui a snapcraft dans son PATH, exécutez electron-installer-snap avec seulement --src, qui est l'emplacement de votre application Electron créée à la première étape.

npx electron-installer-snap --src=out/myappname-linux-x64

Si vous avez un pipeline de construction existant, vous pouvez utiliser programmer electron-installer-snap. Pour plus d'informations, consultez la documentation de l'API Snapcraft.

const snap = require('electron-installer-snap')

snap(options)
  .then(snapPath => console.log(`Created snap at ${snapPath}!`))

Utiliser snapcraft avec @electron/packager​

Étape 1 : Créer un exemple de projet Snapcraft​

Créez votre répertoire de projet et ajoutez ce qui suit au fichier snap/snapcraft.yaml:

name: electron-packager-hello-world
version: '0.1'
summary: Hello World Electron app
description: |
  Simple Hello World Electron app as an example
base: core22
confinement: strict
grade: stable

apps:
  electron-packager-hello-world:
    command: electron-quick-start/electron-quick-start --no-sandbox
    extensions: [gnome]
    plugs:
    - browser-support
    - network
    - network-bind
    environment:
      # Corrige le chemin TMPDIR pour Chromium Framework/Electron pour s'assurer que
      # libappindicator a des ressources lisables.
      TMPDIR: $XDG_RUNTIME_DIR

parts:
  electron-quick-start:
    plugin: nil
    source: https://github.com/electron/electron-quick-start.git
    override-build: |
        npm install electron electron-packager
        npx electron-packager . --overwrite --platform=linux --output=release-build --prune=true
        cp -rv ./electron-quick-start-linux-* $SNAPCRAFT_PART_INSTALL/electron-quick-start
    build-snaps:
    - node/14/stable
    build-packages:
    - unzip
    stage-packages:
    - libnss3
    - libnspr4

Pour appliquer cet exemple à un projet existant:

  • Remplaczr source: https://github.com/electron/electron-quick-start.git par source: ..
  • Remplacez toutes les instances de electron-quick-start par le nom de votre projet.

Étape 2 : Construire le Snap​

$ snapcraft

<output snipped>
Snapped electron-packager-hello-world_0.1_amd64.snap

Étape 3 : Installer le Snap​

sudo snap install electron-packager-hello-world_0.1_amd64.snap --dangerous

Étape 4 : Exécuter le Snap​

electron-packager-hello-world

En utilisant un package Debian existant​

Snapcraft est capable de prendre un fichier .deb existant et de le convertir en un fichier .snap. La création d'un snap est configurée via un fichier snapcraft.yaml qui décrit les sources, dépendances, descriptions, et d'autres blocs de construction cruciaux.

Étape 1 : Créer un package Debian​

Si vous n’avez pas encore de package .deb, utiliser electron-installer-snap peut être une solution simple pour créer des packages snap. Cependant, il existe plusieurs solutions pour créer des paquets Debian, notamment Electron Forge, electron-builder ou electron-installer-debian.

Étape 2 : Créer un snapcraft.yaml​

Pour plus d’informations sur les options de configuration disponibles, consultez la documentation sur la syntaxe snapcraft. Examinons un exemple :

name: myApp
version: '2.0.0'
summary: Une breve description de mon apli.
description: |
 You know what? This app is amazing! It does all the things
 for you. Some say it keeps you young, maybe even happy.

grade: stable
confinement: classic

parts:
  slack:
    plugin: dump
    source: my-deb.deb
    source-type: deb
    after:
      - desktop-gtk3
    stage-packages:
      - libasound2
      - libnotify4
      - libnspr4
      - libnss3
      - libpcre3
      - libpulse0
      - libxss1
      - libxtst6
  electron-launch:
    plugin: dump
    source: files/
    prepare: |
      chmod +x bin/electron-launch

apps:
  myApp:
    command: bin/electron-launch $SNAP/usr/lib/myApp/myApp
    desktop: usr/share/applications/myApp.desktop
    # Correction du chemin TMPDIR pour le Framework Chromium/Electron pour s'assurer que 
    # libappindicator puisse lire les ressources.
    environment:
      TMPDIR: $XDG_RUNTIME_DIR

Comme vous pouvez le voir, le snapcraft.yaml demande au système d'exécuter le fichier nommé electron-launch. Dans cet exemple, il transmet des informations au code binaire de l'application :

#!/bin/sh

exec "$@" --executed-from="$(pwd)" --pid=$$ > /dev/null 2>&1 &

Alternativement, si vous générez votre snap avec la restriction strict , vous pouvez utiliser la commande desktop-launch:

apps:
  myApp:
    # Correct the TMPDIR path for Chromium Framework/Electron to ensure
    # libappindicator has readable resources.
    command: env TMPDIR=$XDG_RUNTIME_DIR PATH=/usr/local/bin:${PATH} ${SNAP}/bin/desktop-launch $SNAP/myApp/desktop
    desktop: usr/share/applications/desktop.desktop

Facultatif: Activation de la capture de bureau​

La capture du bureau nécessite la bibliothèque PipeWire dans certaines configurations Linux qui utilisent le protocole Wayland. Pour regrouper PipeWire avec votre application, assurez-vous que l’ancrage de base est réglé sur core22 ou plus récent. Ensuite, créez une pièce appelée pipewire et ajoutez-la à la section after de votre application :

  pipewire:
    plugin: nil
    build-packages: [libpipewire-0.3-dev]
    stage-packages: [pipewire]
    prime:
      - usr/lib/*/pipewire-*
      - usr/lib/*/spa-*
      - usr/lib/*/libpipewire*.so*
      - usr/share/pipewire

Enfin, configurez l'environnement de votre application pour PipeWire :

    environment:
      SPA_PLUGIN_DIR: $SNAP/usr/lib/$CRAFT_ARCH_TRIPLET/spa-0.2
      PIPEWIRE_CONFIG_NAME: $SNAP/usr/share/pipewire/pipewire.conf
      PIPEWIRE_MODULE_DIR: $SNAP/usr/lib/$CRAFT_ARCH_TRIPLET/pipewire-0.3