La frammentazione è stata un problema per un po' di tempo nell'ecosistema Linux. Oggi esiste una varietà di distribuzioni, con i propri gestori di pacchetti e le proprie nozioni su cosa consiste in un "sistema di base". Questo è noioso per gli sviluppatori di applicazioni:dopo aver creato pacchetti specifici per la distribuzione e aver mantenuto i repository, devono correggere eventuali bug specifici della distribuzione che potrebbero sorgere. Inoltre, a differenza delle piattaforme mobili come iOS e Android, le applicazioni Linux funzionano senza sandbox con accesso a tutte le funzionalità del sistema di base.
Per affrontare questi problemi, è stata proposta un'ampia varietà di soluzioni. In questo articolo daremo un'occhiata a Flatpak , un modo per distribuire le applicazioni ed eseguirle in una sandbox con restrizioni.
Cos'è Flatpak?
Flatpak è una tecnologia per la creazione, la distribuzione, l'installazione e l'esecuzione di applicazioni, destinata principalmente al desktop Linux. Consente alle applicazioni di raggruppare dipendenze e spedire con i runtime, in modo che le applicazioni non finiscano per dipendere dalle stranezze di una particolare distribuzione. Inoltre, aumenta la sicurezza delle applicazioni Linux isolandole in sandbox.
L'architettura di un'applicazione Flatpak è mostrata nel diagramma seguente:
Ogni applicazione Flatpak è supportata da un "runtime", che contiene le dipendenze di base utilizzate dalle applicazioni. Questi runtime sono condivisi tra le applicazioni. Più runtime e anche versioni diverse dello stesso runtime possono coesistere su un sistema contemporaneamente. In questo modo, le applicazioni hanno un sistema di base abbastanza coerente su cui fare affidamento.
Per creare applicazioni per questo runtime, vengono forniti runtime speciali chiamati SDK (Software Development Kit). Contengono strumenti come compilatori e intestazioni di sviluppo. Se la tua applicazione dipende da librerie non incluse nel runtime, devi compilarle con l'SDK, insieme alla tua applicazione.
Inoltre, ci sono "estensioni", che sono componenti aggiuntivi opzionali per runtime e applicazioni. Vengono spesso utilizzati per separare le informazioni di traduzione e debug dal runtime o dall'applicazione originali.
Uno degli obiettivi di Flatpak è aumentare la sicurezza delle applicazioni isolandole l'una dall'altra. Per impostazione predefinita, Flatpak fornisce un accesso molto limitato alle risorse del sistema host. Se non esplicitamente richiesto, le applicazioni non possono utilizzare la rete, accedere ai file sul sistema di base o parlare con servizi come X, DBus o Pulseaudio. Inoltre, i "portali" consentono l'accesso selettivo alle risorse tramite API di alto livello.
Installazione, comandi Flatpak e convenzioni di denominazione
Flatpak è disponibile nei repository della maggior parte delle distribuzioni. Su Arch Linux e Fedora, devi installare flatpak pacchetto per installare il flatpak comando, che ti aiuta a installare e creare applicazioni.
sudo dnf install flatpak # Fedora sudo pacman -S flatpak # Arch
Gli utenti di Ubuntu non lo hanno nei repository predefiniti, quindi installarlo è un po' più complicato. Innanzitutto, devi aggiungere questo PPA al tuo sistema:
sudo add-apt-repository ppa:alexlarsson/flatpak
Quindi, puoi installare il pacchetto con:
sudo apt update sudo apt install flatpak
Mentre il flatpak command può sicuramente aiutarti a creare applicazioni, non è il modo più conveniente. C'è un altro strumento, chiamato flatpak-builder , che ti consente di creare applicazioni Flatpak da un file JSON. (Discuteremo di questo strumento più avanti in questo articolo.) Puoi installare questo strumento con:
sudo dnf install flatpak-builder # Fedora sudo pacman -S flatpak-builder # Arch sudo apt install flatpak-builder # Ubuntu
Ora, per installare applicazioni o runtime, devi aggiungere repository all'elenco dei telecomandi di Flatpak. Questi telecomandi possono essere ospitati in una directory locale o online. I runtime/le applicazioni vengono identificati utilizzando un indirizzo DNS inverso, come com.booleanworld.foo . In alcune circostanze, potrebbe essere necessario specificare anche l'architettura e il "ramo" del runtime. Questo viene fatto con l'aiuto di una tripletta separata da barre, come com.booleanworld.foo/x86_64/1.3 .
Il flatpak comando di solito aggiunge software e repository per tutti gli utenti. Tuttavia, questo non è adatto per provare le cose, quindi useremo il --user flag per limitare tali modifiche solo all'utente corrente.
Ora che abbiamo le basi in atto, daremo un'occhiata ad alcune teorie sulla creazione di applicazioni Flatpak.
Struttura dell'applicazione Flatpak
Quando si raggruppa un'applicazione con Flatpak, viene creata automaticamente la seguente struttura di directory:
-
metadata:questo file contiene informazioni sull'SDK e sul runtime su cui verrà eseguita l'applicazione, oltre a un elenco di risorse di sistema di base a cui l'applicazione deve accedere. -
files:questa directory contiene i file che compongono l'applicazione, inclusi i dati dell'applicazione. Ilbinla sottodirectory all'interno di qui contiene gli eseguibili dell'applicazione. -
export:questa directory contiene tutti i file a cui il sistema di base deve accedere. Gli esempi includono i dati AppStream, il.desktopfile e l'icona dell'applicazione. Tutti i file inseriti qui devono essere preceduti dall'identificatore. Ad esempio, un file desktop può avere il nomecom.booleanworld.foo.desktop.
Sebbene tu possa costruire questa struttura a mano, questo non è necessario. Flatpak ha strumenti per aiutarti a creare automaticamente questa struttura e richiede pochissima configurazione se hai un tipico progetto basato su autotools. Con i progetti non basati su autotools, di solito è necessario impostare la directory "prefisso" su /app per far funzionare le cose.
Prerequisiti
Le sezioni seguenti dell'articolo presentano alcuni esempi di creazione di applicazioni Flatpak. Come accennato in precedenza, le applicazioni richiedono un runtime per l'esecuzione e un SDK per il processo di compilazione. Pertanto, il primo passaggio consiste nell'aggiungere un repository da cui sono disponibili. Aggiungeremo il repository disponibile su sdk.gnome.org per il nostro uso.
flatpak remote-add --from gnome https://sdk.gnome.org/gnome.flatpakrepo --user
Per creare gli esempi seguenti, abbiamo bisogno di due runtime: org.freedesktop.Platform e org.gnome.Platform e due SDK: org.freedesktop.Sdk e org.gnome.Sdk . Qui abbiamo utilizzato le versioni 1.6 e 3.24 di Freedesktop e Gnome runtime/SDK.
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 Quindi, controlla il repository flatpak-resources, che contiene tutte le risorse necessarie per seguire questo articolo.
git clone https://github.com/boolean-world/flatpak-resources cd flatpak-resources
Nelle sezioni seguenti daremo un'occhiata a due esempi di creazione di applicazioni.
Costruire un “gattino”, un “gatto” leggero
In questa sezione impareremo come creare un'applicazione Flatpak di base. L'applicazione è una versione ridotta di cat comando, denominato kitten .
Innanzitutto, devi creare la struttura di directory di cui abbiamo discusso in precedenza. Il build-init comando può farlo per te. Devi assegnargli una directory di build, il nome della tua applicazione e l'SDK e il runtime da usare (in quest'ordine). Puoi anche aggiungere un "nome filiale" facoltativo, ma in questo esempio lo lasceremo fuori.
flatpak build-init kitten-build com.booleanworld.kitten
org.freedesktop.Sdk
org.freedesktop.Platform
Come accennato in precedenza, la directory dei prefissi delle applicazioni Flatpak è /app e devi creare il bin directory in esso. Quando vuoi eseguire un comando all'interno della directory build, usa il build comando:
flatpak build kitten-build mkdir -p /app/bin
Il prossimo passo è compilare kitten.c con gcc :
flatpak build kitten-build gcc kitten.c -o /app/bin/kitten
Quindi, puoi completare la build con build-finish . Il comando sarà kitten e deve accedere al filesystem dell'host (in modo da poter visualizzare qualsiasi file sul sistema host). Quindi, puoi completare la build con quei parametri impostati:
flatpak build-finish kitten-build --filesystem=host --command=kitten
Ora, se vuoi testare l'applicazione, devi installarla. Il primo passaggio consiste nell'esportare l'applicazione in un repository locale. Nel nostro esempio, la cartella del repository è my-repo :
flatpak build-export my-repo kitten-build
Successivamente, aggiungeremo il repository con il nome test-repo . Dal momento che non stiamo utilizzando firme GPG, informeremo Flatpak con il --no-gpg-verify interruttore.
flatpak remote-add --user --no-gpg-verify test-repo my-repo
Infine, puoi installarlo con:
flatpak install --user test-repo com.booleanworld.kitten
Ora puoi verificare se funziona eseguendo in questo modo:
flatpak run com.booleanworld.kitten ~/.bashrc
Se hai seguito correttamente tutti i passaggi finora, questo dovrebbe visualizzare il contenuto del tuo .bashrc file:
Congratulazioni per aver creato la tua prima app Flatpak!
Finora i passaggi sono stati abbastanza semplici, ma il build-finish il comando merita ulteriori discussioni. Questo è ciò che faremo nella prossima sezione.
Uno sguardo più approfondito al comando "fine costruzione"
Uno degli obiettivi primari di Flatpak è creare applicazioni sandbox e fornire solo un accesso minimo alle risorse del sistema host. Nell'esempio precedente, abbiamo consentito all'app "kitten" di accedere a qualsiasi file sul sistema con build-finish . Di seguito sono elencate le opzioni che puoi utilizzare per consentire l'accesso a varie risorse:
--filesystem={path}
Questo interruttore consente l'accesso a percorsi specifici sul sistema. Puoi fornire un percorso specifico (come /usr/share ). home consente l'accesso alla home directory dell'utente e host consente l'accesso a tutti i file del sistema. Inoltre, puoi anche rendere un percorso di sola lettura con :ro . Ad esempio, --filesystem=/usr/share:ro --filesystem=home consente l'accesso in sola lettura a /usr/share e accesso in lettura e scrittura alla home directory dell'utente.
--share={type}
Questo interruttore consente l'accesso a risorse particolari. I tipi più comunemente usati sono ipc e network , che consentono l'IPC e l'accesso alla rete. Nella maggior parte delle applicazioni GUI, --share=ipc viene utilizzato per il funzionamento della memoria condivisa X, il che migliora le prestazioni.
--socket={type}
Questo interruttore ti consente di utilizzare prese particolari. I tipi di socket a cui si accede più comunemente sono x11 , wayland e pulseaudio . I primi due vengono utilizzati dalle applicazioni per eseguire il rendering degli elementi della GUI e il secondo viene utilizzato per riprodurre l'audio tramite il demone Pulseaudio.
--device={device}
Ciò consente alle applicazioni di accedere selettivamente ad alcuni dispositivi. Molto spesso, dri viene utilizzato qui in modo che le applicazioni possano utilizzare il rendering OpenGL.
-
--talk-name={name}e--system-talk-name={name}
Questi switch consentono alle applicazioni di comunicare con servizi denominati tramite il bus di sessione e il bus di sistema di DBus.
--env={varname}={value}
Il env switch consente di esportare le variabili di ambiente. {varname} è il nome della variabile, che è impostato sul dato {value} .
Se un'applicazione richiede l'accesso a dconf, è necessario utilizzare le seguenti opzioni:
--filesystem=xdg-run/dconf --filesystem=~/.config/dconf:ro --talk-name=ca.desrt.dconf --env=DCONF_USER_CONFIG_DIR=.config/dconf
Vedremo un esempio pratico che coinvolge queste opzioni in una sezione successiva.
Creazione automatica di applicazioni:flatpak-builder
Sebbene i passaggi coinvolti nella creazione di applicazioni Flatpak siano abbastanza semplici, è comunque noioso costruirli passo dopo passo. flatpak-builder è uno strumento che ti consente di creare applicazioni in modo dichiarativo con manifesti JSON. Finché il codice sorgente è strutturato secondo la "build API", il builder può compilare e installare applicazioni dagli archivi sorgenti. La maggior parte dei software basati su autotools sono già conformi all'API, quindi di solito non sono necessarie ulteriori configurazioni.
Un tipico file manifest di solito ha questo aspetto:
{
"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"
}
]
}
]
} Come puoi vedere, questo file contiene le stesse informazioni che avevamo specificato in precedenza con vari comandi. Inoltre, contiene un elenco di moduli da costruire. Nell'esempio sopra, c'è un solo modulo. Se hai un'applicazione complessa che dipende da più moduli, dovresti elencarli tutti. Ad esempio, gnome-calculator dipende da mpc e mpfr e il manifest è simile a questo.
Sono supportati diversi tipi di sorgenti. Un altro tipo di sorgente popolare è git , e devi fornire l'URL del repository e, facoltativamente, il ramo che deve essere estratto.
Il manifest è molto potente e supporta l'impostazione di CFLAGS/CXXFLAGS, la ridenominazione dei file per l'esportazione e la rimozione di file non necessari. Nella prossima sezione analizzeremo un'applicazione pratica e impareremo come confezionarla per Flatpak.
Un esempio reale:il galculator per imballaggi
In questa sezione prenderemo galculator, una semplice applicazione calcolatrice e la costruiremo con flatpak-builder . Dobbiamo eseguire un po' di analisi per scoprire quali file devono essere rinominati o eliminati. Pertanto, come primo passo, faremo un'installazione di prova. Quindi, possiamo creare il manifest se necessario.
Poiché galculator è un'applicazione GTK, utilizzeremo il runtime e l'SDK di Gnome. Dovresti installarli ora se non l'hai già fatto. Inoltre, dovresti scaricare l'archivio sorgente da qui. (Abbiamo utilizzato la versione 2.1.4, che è l'ultima versione al momento della stesura di questo articolo.)
Trovare i file che dovrebbero essere esportati/eliminati
Dopo aver scaricato ed estratto l'archivio di origine, dovresti provare a compilarlo utilizzando l'SDK. L'SDK di Gnome contiene anche strumenti come bash, quindi puoi avviarlo utilizzando:
flatpak run --command=bash --filesystem=host --devel org.gnome.Sdk/x86_64/3.24
Ora, spostati nella directory dei sorgenti del galculator e usa l'incantesimo normale per compilarlo. Imposteremo la nostra directory dei prefissi su ~/galculator-test .
./configure --prefix=$HOME/galculator-test make install
Ora puoi esplorare i file nel galculator-test directory. Come probabilmente puoi vedere, è necessario esportare i seguenti file:
- Informazioni su AppStream in
share/appdata/galculator.appdata.xml - Icone in
share/icons - La voce desktop in
share/applications/galculator.desktop
Sfortunatamente, non sono preceduti dal nome dell'applicazione. Pertanto, devi rinominarli con le seguenti proprietà nel manifest:
{
"rename-appdata-file": "galculator.appdata.xml",
"rename-icon": "galculator",
"rename-desktop-file": "galculator.desktop"
}
Una volta rinominati questi file, flatpak-builder li esporterà automaticamente. Una volta creato il pacchetto Flatpak, questo aiuterà a creare voci di menu sul sistema di base.
Inoltre, il share/man e share/pixmaps le directory non sono necessarie, quindi puoi rimuoverle con:
{
"cleanup": [
"/share/man",
"/share/pixmaps"
]
}
Configurazione della sandbox
Poiché si tratta di un'applicazione GTK, è necessario consentirle di accedere a X11 e Wayland e condividere i meccanismi IPC. Devi anche consentirgli di utilizzare il rendering OpenGL. Inoltre, galculator ha bisogno dell'accesso a dconf e devi aggiungere le voci di cui abbiamo discusso in precedenza. Gli switch, che sarebbero stati passati a build-finish sono elencati nel finish-args proprietà nel 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"
]
} Completamento del manifest
A questo punto, hai configurato la maggior parte delle parti importanti del manifest. La configurazione del resto dovrebbe essere abbastanza semplice e il manifest finale che abbiamo utilizzato è qui. Abbiamo aggiunto un set di build-options , che imposta CFLAGS e CXXFLAGS su -O3 .
Creazione e test dell'applicazione
Infine, possiamo creare l'applicazione. Esegui semplicemente flatpak-builder con una directory build e il manifest. In questo esempio, galculator è la directory di build e org.mnim.galculator.json è il file manifest.
flatpak-builder galculator org.mnim.galculator.json
Quindi, esportalo nel repository come abbiamo fatto in precedenza:
flatpak build-export my-repo galculator
Ora puoi testare l'applicazione installandola:
flatpak install --user test-repo org.mnim.galculator
L'applicazione viene immediatamente installata e ottieni persino voci sul desktop come una normale applicazione! Puoi avviarlo dalla voce di menu o eseguirlo con flatpak run come abbiamo fatto prima.
Distribuzione delle applicazioni
Ora che hai creato un'applicazione, come fai a distribuirla? Il modo più semplice per farlo è trasferire la directory del repository su un server e servirla sul Web. Quindi, puoi chiedere agli utenti di aggiungere il tuo repository al loro elenco e installare le applicazioni in questo modo.
Molte persone preferiscono installare software firmato con GPG, poiché dimostra che l'applicazione proviene effettivamente dal manutentore originale. Puoi creare facilmente chiavi GPG con il gpg2 comando:
gpg2 --quick-key-gen [email protected]
Assicurati di annotare l'ID della chiave poiché ti servirà in seguito. Nel nostro esempio, assumeremo che l'ID chiave sia A318C188C20D410A .
Quindi, puoi creare un repository firmato GPG durante l'esecuzione di build-export così:
flatpak build-export my-repo galculator --gpg-sign=A318C188C20D410A
Se disponi di un repository non firmato esistente, puoi firmarlo in questo modo:
flatpak build-sign my-repo --gpg-sign=A318C188C20D410A flatpak build-update-repo my-repo --gpg-sign=A318C188C20D410A
Quando desideri pubblicare il repository, assicurati di fornire agli utenti una copia della chiave pubblica. Per esportare la tua chiave pubblica, esegui:
gpg2 --export A318C188C20D410A > public.gpg
Dovresti pubblicare questa chiave sul tuo sito web. Quando i tuoi utenti vogliono aggiungere il tuo repository, dovrebbero scaricare la chiave pubblica. Se l'utente ha scaricato una chiave denominata public.gpg , ora possono aggiungere il repository eseguendo:
flatpak remote-add --gpg-import=public.gpg test-repo https://software.example.com/repo/
Tuttavia, questo metodo è estremamente scomodo per gli utenti. Fortunatamente, puoi semplificare il processo creando file flatpakref e flatpakrepo, che sono discussi in dettaglio nella documentazione.
Conclusione
In questo articolo abbiamo appreso di Flatpak e di come distribuire software utilizzando questa nuova tecnologia. È più orientato alla sicurezza e offre migliori capacità di integrazione e aggiornamento rispetto ai metodi tradizionali come AppImage.
Se sei interessato a leggere di più su questo argomento, la documentazione per gli sviluppatori e il flatpak-manifest la pagina man sono buoni punti di partenza. Se vuoi leggere esempi più complessi di file manifest/flatpakref, dai un'occhiata al repository Gnome-apps e agli esempi Flathub.