254 lines
8.9 KiB
Markdown
254 lines
8.9 KiB
Markdown
# Installation sur Bazzite OS
|
||
|
||
[Bazzite](https://bazzite.gg/) est une distribution **immuable** basée sur Fedora Atomic
|
||
(rpm-ostree). Le système de fichiers racine est en lecture seule : on **n'installe pas** de
|
||
paquets de développement (`webkit2gtk-devel`, compilateurs…) directement sur l'hôte comme on
|
||
le ferait sur une Fedora classique.
|
||
|
||
Cette contrainte vaut aussi pour les autres systèmes atomiques (Fedora Silverblue, Kinoite,
|
||
Universal Blue, openSUSE MicroOS…).
|
||
|
||
La méthode recommandée est le **Flatpak** : on construit **une seule fois** un fichier
|
||
`.flatpak` (le « bundle »), on l'héberge (par ex. sur un dépôt Gitea), puis on l'installe sur
|
||
n'importe quelle machine **en une commande**, sans rien compiler ni installer de dépendance
|
||
sur l'hôte.
|
||
|
||
| Vous voulez… | Allez à… |
|
||
|---|---|
|
||
| **Installer Pena** depuis un `.flatpak` déjà construit (récupéré sur Gitea) | [1. Méthode simple](#1-méthode-simple--installer-le-paquet-pré-construit) |
|
||
| **Produire** le fichier `.flatpak` (une fois, sur une machine de build) | [2. Compiler](#2-compiler-le-binaire-une-fois) puis [3. Construire le bundle](#3-construire-le-paquet-flatpak-une-fois) |
|
||
| **Développer / itérer** sur le code sans empaqueter | [4. Alternative développeur (distrobox)](#4-alternative-développeur--lancer-via-distrobox) |
|
||
|
||
> Bazzite fournit **`flatpak`** (avec le dépôt Flathub), **`distrobox`** et **`podman`**
|
||
> préinstallés. Aucune surcouche rpm-ostree (`rpm-ostree install`) n'est nécessaire.
|
||
|
||
---
|
||
|
||
## 1. Méthode simple — installer le paquet pré-construit
|
||
|
||
C'est le scénario du quotidien : le fichier `pena.flatpak` a déjà été construit (voir
|
||
sections 2 et 3) et déposé sur votre Gitea. Sur la machine cible, il suffit de le récupérer et
|
||
de l'installer.
|
||
|
||
### 1.1 — Installer
|
||
|
||
```bash
|
||
# Récupérer le bundle depuis Gitea (adaptez l'URL à votre dépôt)
|
||
curl -L -o pena.flatpak \
|
||
https://git.goutailler-olivier.com/<utilisateur>/<depot>/raw/branch/main/pena.flatpak
|
||
|
||
# Installer pour l'utilisateur courant (aucun droit root nécessaire)
|
||
flatpak install --user pena.flatpak
|
||
```
|
||
|
||
> Le runtime `org.gnome.Platform` (qui fournit WebKitGTK) est téléchargé automatiquement
|
||
> depuis Flathub lors de l'installation s'il n'est pas déjà présent. C'est la seule dépendance,
|
||
> et elle est gérée par Flatpak — rien à compiler ni à installer sur l'hôte.
|
||
|
||
### 1.2 — Lancer
|
||
|
||
```bash
|
||
flatpak run com.pena.app
|
||
```
|
||
|
||
Pena apparaît aussi dans le menu des applications de Bazzite.
|
||
|
||
### 1.3 — Mettre à jour / désinstaller
|
||
|
||
```bash
|
||
# Mettre à jour : récupérer le nouveau bundle puis réinstaller par-dessus
|
||
flatpak install --user --reinstall pena.flatpak
|
||
|
||
# Désinstaller
|
||
flatpak uninstall com.pena.app
|
||
```
|
||
|
||
### 1.4 — (Optionnel) Installation en une ligne
|
||
|
||
Vous pouvez déposer à côté du bundle, sur Gitea, un script `install.sh` qui automatise le
|
||
téléchargement et l'installation :
|
||
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
set -euo pipefail
|
||
URL="https://git.goutailler-olivier.com/<utilisateur>/<depot>/raw/branch/main/pena.flatpak"
|
||
TMP="$(mktemp --suffix=.flatpak)"
|
||
curl -L -o "$TMP" "$URL"
|
||
flatpak install --user -y "$TMP"
|
||
rm -f "$TMP"
|
||
echo "Pena installé. Lancez-le avec : flatpak run com.pena.app"
|
||
```
|
||
|
||
L'installation se résume alors à :
|
||
```bash
|
||
curl -L https://git.goutailler-olivier.com/<utilisateur>/<depot>/raw/branch/main/install.sh | bash
|
||
```
|
||
|
||
---
|
||
|
||
## 2. Compiler le binaire (une fois)
|
||
|
||
Cette étape et la suivante se font **sur une machine de build** (la vôtre, dans un container).
|
||
Le résultat est un fichier `pena.flatpak` que vous n'aurez plus qu'à héberger.
|
||
|
||
Pena se compile dans un container Ubuntu via **distrobox**, pour ne rien installer sur l'hôte
|
||
immuable. WebKitGTK et le compilateur restent dans le container.
|
||
|
||
```bash
|
||
# 1. Créer et entrer dans un container Ubuntu
|
||
distrobox create --name pena-build --image ubuntu:24.04
|
||
distrobox enter pena-build
|
||
|
||
# 2. (dans le container) installer les dépendances de build
|
||
sudo apt update
|
||
sudo apt install -y \
|
||
libwebkit2gtk-4.1-dev build-essential curl wget file \
|
||
libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev git
|
||
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
|
||
source "$HOME/.cargo/env"
|
||
cargo install tauri-cli --version "^2"
|
||
|
||
# 3. (dans le container) compiler
|
||
cd ~/Pena/Pena-tauri # adaptez le chemin vers les sources
|
||
cargo tauri build
|
||
```
|
||
|
||
Le binaire est produit dans `src-tauri/target/release/pena-taury`. Vous pouvez ensuite
|
||
quitter le container (`exit`) : la suite (section 3) se fait sur l'hôte, où `flatpak` est
|
||
disponible. Comme `$HOME` est partagé entre l'hôte et le container, le binaire compilé est
|
||
accessible des deux côtés.
|
||
|
||
---
|
||
|
||
## 3. Construire le paquet `.flatpak` (une fois)
|
||
|
||
À partir du binaire compilé, on produit le fichier unique `pena.flatpak`.
|
||
|
||
### 3.1 — Outillage Flatpak (sur l'hôte)
|
||
|
||
```bash
|
||
flatpak install -y flathub org.gnome.Platform//47 org.gnome.Sdk//47 org.flatpak.Builder
|
||
```
|
||
|
||
### 3.2 — Fichiers d'empaquetage
|
||
|
||
Depuis la racine `Pena-tauri/`, créez deux fichiers.
|
||
|
||
**`com.pena.app.desktop`** :
|
||
```ini
|
||
[Desktop Entry]
|
||
Type=Application
|
||
Name=Pena
|
||
Comment=Lecteur Markdown
|
||
Exec=pena
|
||
Icon=com.pena.app
|
||
Terminal=false
|
||
Categories=Utility;Office;
|
||
```
|
||
|
||
**`com.pena.app.yml`** (manifeste Flatpak) :
|
||
```yaml
|
||
id: com.pena.app
|
||
runtime: org.gnome.Platform
|
||
runtime-version: '47'
|
||
sdk: org.gnome.Sdk
|
||
command: pena
|
||
|
||
finish-args:
|
||
- --share=ipc
|
||
- --socket=wayland
|
||
- --socket=fallback-x11
|
||
- --device=dri
|
||
# Accès en lecture aux fichiers Markdown de l'utilisateur
|
||
- --filesystem=home:ro
|
||
|
||
modules:
|
||
- name: pena
|
||
buildsystem: simple
|
||
build-commands:
|
||
- install -Dm755 pena-taury /app/bin/pena
|
||
- install -Dm644 com.pena.app.desktop /app/share/applications/com.pena.app.desktop
|
||
- install -Dm644 icon.png /app/share/icons/hicolor/512x512/apps/com.pena.app.png
|
||
sources:
|
||
- type: file
|
||
path: src-tauri/target/release/pena-taury
|
||
- type: file
|
||
path: com.pena.app.desktop
|
||
- type: file
|
||
path: src-tauri/icons/icon.png
|
||
```
|
||
|
||
> L'identifiant `com.pena.app` correspond au champ `identifier` de
|
||
> `src-tauri/tauri.conf.json`. Le runtime `org.gnome.Platform` embarque WebKitGTK : l'app
|
||
> fonctionnera sans aucune dépendance installée sur la machine cible.
|
||
|
||
### 3.3 — Construire le bundle
|
||
|
||
Depuis `Pena-tauri/` :
|
||
|
||
```bash
|
||
# 1. Construire l'app dans un dépôt OSTree local (dossier "repo")
|
||
flatpak run org.flatpak.Builder --force-clean --repo=repo \
|
||
--install-deps-from=flathub build-dir com.pena.app.yml
|
||
|
||
# 2. Exporter en UN SEUL fichier .flatpak
|
||
flatpak build-bundle repo pena.flatpak com.pena.app \
|
||
--runtime-repo=https://flathub.org/repo/flathub.flatpakrepo
|
||
```
|
||
|
||
Vous obtenez **`pena.flatpak`** : c'est ce fichier unique, autoportant, que vous installez
|
||
partout (section 1). L'option `--runtime-repo` y inscrit la référence vers Flathub, pour que
|
||
le runtime soit récupéré automatiquement à l'installation.
|
||
|
||
### 3.4 — Héberger sur Gitea
|
||
|
||
Déposez `pena.flatpak` sur votre dépôt Gitea, soit :
|
||
- en l'ajoutant au dépôt (`git add pena.flatpak`) — simple, mais alourdit l'historique ;
|
||
- **de préférence**, en l'attachant à une **release** Gitea (onglet *Releases* → *New Release*
|
||
→ joindre le binaire). L'URL de téléchargement direct est alors stable et n'encombre pas le
|
||
dépôt.
|
||
|
||
Adaptez ensuite l'URL utilisée à la [section 1.1](#11--installer).
|
||
|
||
---
|
||
|
||
## 4. Alternative développeur — lancer via distrobox
|
||
|
||
Si vous **développez** sur Pena et n'avez pas besoin d'un paquet installable, vous pouvez
|
||
exécuter l'application directement depuis le container, sans passer par Flatpak.
|
||
|
||
```bash
|
||
# Lancement direct (la fenêtre s'affiche sur le bureau de l'hôte)
|
||
distrobox enter pena-build -- bash -lc 'cd ~/Pena/Pena-tauri && cargo tauri dev'
|
||
```
|
||
|
||
Pour exposer le binaire compilé à l'hôte comme une commande :
|
||
|
||
```bash
|
||
# Depuis le container, après "cargo tauri build"
|
||
distrobox-export --bin ~/Pena/Pena-tauri/src-tauri/target/release/pena-taury \
|
||
--export-path ~/.local/bin
|
||
```
|
||
|
||
Le binaire devient lançable depuis l'hôte (`~/.local/bin` doit être dans le `PATH`). Cette
|
||
voie est pratique pour itérer, mais le Flatpak (sections 1–3) reste la méthode recommandée
|
||
pour une **installation** propre et reproductible.
|
||
|
||
---
|
||
|
||
## Note — AppImage
|
||
|
||
Une autre forme de « fichier unique à exécuter » est l'**AppImage** : un binaire autoportant
|
||
qui se lance sans installation (`chmod +x Pena.AppImage && ./Pena.AppImage`). Tauri sait en
|
||
produire, mais cela nécessite d'activer le bundler (`bundle.active: true` dans
|
||
`tauri.conf.json`, cible `appimage`) et l'outillage associé. Le **bundle Flatpak** décrit
|
||
ci-dessus est privilégié ici car il s'intègre au menu, se met à jour proprement et gère
|
||
automatiquement ses dépendances via Flathub.
|
||
|
||
## Voir aussi
|
||
|
||
- [Release et distribution](3.4-Release-et-distribution.md) — pourquoi le Flatpak, portabilité et trade-offs des formats
|
||
- [Build et compilation](3.3-Build.md)
|
||
- [Installation (Linux générique / Fedora)](3.1-Installation.md)
|
||
- [Architecture](../2-technique/2.1-Architecture.md)
|