Creación de aplicaciones Linux de distribución cruzada con Flatpak

La fragmentación ha sido un problema durante bastante tiempo en el ecosistema Linux. Hoy en día existe una variedad de distribuciones, con sus propios administradores de paquetes y sus propias nociones de en qué consiste un "sistema base". Esto es tedioso para los desarrolladores de aplicaciones:después de crear paquetes específicos de distribución y mantener repositorios, tienen que corregir los errores específicos de distribución que puedan surgir. Además, a diferencia de las plataformas móviles como iOS y Android, las aplicaciones de Linux se ejecutan fuera de la zona de pruebas con acceso a todas las funciones del sistema base.

Para hacer frente a estos problemas, se han propuesto una amplia variedad de soluciones. En este artículo, echaremos un vistazo a Flatpak, una forma de distribuir aplicaciones y ejecutarlas en una zona de pruebas restringida.

¿Qué es Flatpack?

Flatpak es una tecnología para crear, distribuir, instalar y ejecutar aplicaciones, dirigida principalmente al escritorio de Linux. Permite que las aplicaciones agrupen dependencias y se envíen con tiempos de ejecución, de modo que las aplicaciones no terminen dependiendo de las peculiaridades de una distribución en particular. Además, aumenta la seguridad de las aplicaciones Linux aislándolas en sandboxes.

La arquitectura de una aplicación Flatpak se muestra en el siguiente diagrama:

Cada aplicación Flatpak está respaldada por un "tiempo de ejecución", que contiene las dependencias básicas utilizadas por las aplicaciones. Estos tiempos de ejecución se comparten entre las aplicaciones. Múltiples tiempos de ejecución, e incluso diferentes versiones del mismo tiempo de ejecución, pueden coexistir en un sistema al mismo tiempo. De esta forma, las aplicaciones tienen un sistema base bastante consistente en el que confiar.

Para crear aplicaciones para este tiempo de ejecución, se proporcionan tiempos de ejecución especiales denominados SDK (Software Development Kits). Contienen herramientas como compiladores y encabezados de desarrollo. Si su aplicación depende de bibliotecas que no están incluidas en el tiempo de ejecución, debe compilarlas con el SDK, junto con su aplicación.

Además, hay "extensiones", que son complementos opcionales para tiempos de ejecución y aplicaciones. Se utilizan con mayor frecuencia para separar la información de traducción y depuración del tiempo de ejecución o la aplicación original.

Uno de los objetivos de Flatpak es aumentar la seguridad de las aplicaciones aislándolas unas de otras. De forma predeterminada, Flatpak proporciona un acceso muy limitado a los recursos del sistema host. A menos que se solicite explícitamente, las aplicaciones no pueden usar la red, acceder a archivos en el sistema base o comunicarse con servicios como X, DBus o Pulseaudio. Además, los "portales" permiten el acceso selectivo a recursos a través de API de alto nivel.

Instalación, comandos de Flatpak y convenciones de nomenclatura

Flatpak está disponible en los repositorios de la mayoría de las distribuciones. En Arch Linux y Fedora, debe instalar el flatpak paquete para instalar el flatpak comando, que le ayuda a instalar y crear aplicaciones.

sudo dnf install flatpak # Fedora
sudo pacman -S flatpak # Arch

Los usuarios de Ubuntu no lo tienen en los repositorios predeterminados, por lo que instalarlo es un poco más complicado. Primero, debe agregar este PPA a su sistema:

sudo add-apt-repository ppa:alexlarsson/flatpak

Luego, puede instalar el paquete con:

sudo apt update
sudo apt install flatpak

Mientras que el flatpak El comando sin duda puede ayudarlo a crear aplicaciones, no es la forma más conveniente. Hay otra herramienta, llamada flatpak-builder , que le permite crear aplicaciones Flatpak a partir de un archivo JSON. (Hablaremos de esta herramienta más adelante en este artículo). Puede instalar esta herramienta con:

sudo dnf install flatpak-builder # Fedora
sudo pacman -S flatpak-builder # Arch
sudo apt install flatpak-builder # Ubuntu

Ahora, para instalar aplicaciones o tiempos de ejecución, debe agregar repositorios a la lista de controles remotos de Flatpak. Estos controles remotos se pueden alojar en un directorio local o en línea. Los tiempos de ejecución/aplicaciones se identifican mediante una dirección DNS inversa, como com.booleanworld.foo . En algunas circunstancias, es posible que también deba especificar la arquitectura y la "rama" del tiempo de ejecución. Esto se hace con la ayuda de un triplete separado por barras, como com.booleanworld.foo/x86_64/1.3 .

El flatpak El comando generalmente agrega software y repositorios para todos los usuarios. Sin embargo, esto no es adecuado para probar cosas, por lo que usaremos el --user marcar para restringir dichos cambios solo al usuario actual.

Ahora que tenemos los conceptos básicos en su lugar, veremos algo de teoría sobre la creación de aplicaciones Flatpak.

Estructura de la aplicación Flatpak

Cuando empaqueta una aplicación con Flatpak, se crea automáticamente la siguiente estructura de directorios:

• metadata :este archivo contiene información sobre el SDK y el tiempo de ejecución en el que se ejecutará la aplicación, así como una lista de los recursos básicos del sistema a los que la aplicación necesita acceder.
• files :este directorio contiene archivos que componen la aplicación, incluidos los datos de la aplicación. El bin El subdirectorio dentro de aquí contiene los ejecutables de la aplicación.
• export :este directorio contiene todos los archivos a los que el sistema base necesita acceder. Los ejemplos incluyen datos de AppStream, el .desktop archivo y el icono de la aplicación. Cualquier archivo que coloque aquí debe tener el prefijo del identificador. Por ejemplo, un archivo de escritorio puede tener el nombre com.booleanworld.foo.desktop .

Si bien puedes construir esta estructura a mano, esto no es necesario. Flatpak tiene herramientas para ayudarlo a crear automáticamente esta estructura y requiere muy poca configuración si tiene un proyecto típico basado en herramientas automáticas. Con proyectos que no están basados ​​en autotools, generalmente debe establecer el directorio "prefijo" en /app para poner las cosas en marcha.

Requisitos

Las siguientes secciones del artículo tienen algunos ejemplos de creación de aplicaciones Flatpak. Como mencionamos anteriormente, las aplicaciones necesitan un tiempo de ejecución para ejecutarse y un SDK para el proceso de compilación. Así, el primer paso es añadir un repositorio desde el que estén disponibles. Agregaremos el repositorio disponible en sdk.gnome.org para nuestro uso.

flatpak remote-add --from gnome https://sdk.gnome.org/gnome.flatpakrepo --user

Para construir los ejemplos a continuación, necesitamos dos tiempos de ejecución: org.freedesktop.Platform y org.gnome.Platform y dos SDK: org.freedesktop.Sdk y org.gnome.Sdk . Aquí, hemos utilizado las versiones 1.6 y 3.24 de Freedesktop y 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

A continuación, consulte el repositorio de recursos flatpak, que contiene todos los recursos necesarios para seguir este artículo.

git clone https://github.com/boolean-world/flatpak-resources
cd flatpak-resources

Echaremos un vistazo a dos ejemplos de creación de aplicaciones en las siguientes secciones.

Construyendo “gatito”, un “gato” liviano

En esta sección, aprenderemos cómo crear una aplicación Flatpak básica. La aplicación es una versión pequeña del cat comando, llamado kitten .

Primero, debe crear la estructura de directorios que hemos discutido anteriormente. El build-init comando puede hacer esto por usted. Debe proporcionarle un directorio de compilación, el nombre de su aplicación y el SDK y el tiempo de ejecución para usar (en ese orden). También puede agregar un "nombre de sucursal" opcional, pero lo dejaremos fuera en este ejemplo.

flatpak build-init kitten-build com.booleanworld.kitten
                                org.freedesktop.Sdk
                                org.freedesktop.Platform

Como mencionamos anteriormente, el directorio de prefijos de las aplicaciones Flatpak es /app , y necesitas crear el bin directorio en él. Cuando desee ejecutar un comando dentro del directorio de compilación, use el build comando:

flatpak build kitten-build mkdir -p /app/bin

El siguiente paso es compilar kitten.c con gcc :

flatpak build kitten-build gcc kitten.c -o /app/bin/kitten

Luego, puede completar la compilación con build-finish . El comando será kitten , y necesita acceder al sistema de archivos del host (para que pueda ver cualquier archivo en el sistema host). Entonces, puede completar la compilación con esos parámetros establecidos:

flatpak build-finish kitten-build --filesystem=host --command=kitten

Ahora, si desea probar la aplicación, debe instalarla. El primer paso es exportar la aplicación a un repositorio local. En nuestro ejemplo, la carpeta del repositorio es my-repo :

flatpak build-export my-repo kitten-build

A continuación, agregaremos el repositorio con el nombre test-repo . Como no estamos usando firmas GPG, se lo haremos saber a Flatpak con el --no-gpg-verify cambiar.

flatpak remote-add --user --no-gpg-verify test-repo my-repo

Finalmente, puedes instalarlo con:

flatpak install --user test-repo com.booleanworld.kitten

Ahora, puede probar si funciona ejecutándolo así:

flatpak run com.booleanworld.kitten ~/.bashrc

Si ha seguido correctamente todos los pasos hasta ahora, esto debería mostrar el contenido de su .bashrc archivo:

¡Felicidades por crear tu primera aplicación Flatpak!

Los pasos han sido bastante simples hasta ahora, pero el build-finish el comando merece más discusión. Esto es lo que haremos en la siguiente sección.

Una mirada más profunda al comando "construir-terminar"

Uno de los objetivos principales de Flatpak es aislar las aplicaciones y proporcionar solo un acceso mínimo a los recursos del sistema host. En el ejemplo anterior, permitimos que la aplicación "gatito" acceda a cualquier archivo en el sistema con build-finish . Los interruptores que puede usar para permitir el acceso a varios recursos se enumeran a continuación:

• --filesystem={path}

Este modificador permite el acceso a rutas específicas en el sistema. Puede proporcionar una ruta específica (como /usr/share ). home permite el acceso al directorio de inicio del usuario, y host permite el acceso a todos los archivos en el sistema. Además, también puede hacer una ruta de solo lectura con :ro . Por ejemplo, --filesystem=/usr/share:ro --filesystem=home permite el acceso de solo lectura a /usr/share y acceso de lectura y escritura al directorio de inicio del usuario.

• --share={type}

Este modificador permite el acceso a recursos particulares. Los tipos más utilizados son ipc y network , que permiten IPC y acceso a la red. En la mayoría de las aplicaciones GUI, --share=ipc se utiliza para que funcione la memoria compartida X, lo que mejora el rendimiento.

• --socket={type}

Este interruptor le permite usar enchufes particulares. Los tipos de socket a los que se accede con más frecuencia son x11 , wayland y pulseaudio . Los dos primeros son usados ​​por aplicaciones para renderizar elementos GUI, y el último se usa para reproducir audio a través del daemon Pulseaudio.

• --device={device}

Esto permite que las aplicaciones accedan selectivamente a algunos dispositivos. La mayoría de las veces, dri se usa aquí para que las aplicaciones puedan usar el renderizado OpenGL.

• --talk-name={name} y --system-talk-name={name}

Estos conmutadores permiten que las aplicaciones se comuniquen con los servicios designados a través del bus de sesión y el bus del sistema de DBus.

• --env={varname}={value}

El env switch le permite exportar variables de entorno. {varname} es el nombre de la variable, que se establece en el {value} dado .

Si una aplicación requiere acceso a dconf, debe usar los siguientes modificadores:

--filesystem=xdg-run/dconf
--filesystem=~/.config/dconf:ro
--talk-name=ca.desrt.dconf
--env=DCONF_USER_CONFIG_DIR=.config/dconf

Veremos un ejemplo práctico relacionado con estos interruptores en una sección posterior.

Crear aplicaciones automáticamente:flatpak-builder

Aunque los pasos involucrados en la construcción de aplicaciones Flatpak son bastante simples, aún es tedioso construirlos paso a paso. flatpak-builder es una herramienta que le permite crear aplicaciones de forma declarativa con manifiestos JSON. Siempre que el código fuente esté diseñado de acuerdo con la "API de compilación", el constructor puede compilar e instalar aplicaciones desde los archivos fuente. La mayoría del software basado en autotools ya se ajusta a la API, por lo que normalmente no se necesita más configuración.

Un archivo de manifiesto típico suele tener este aspecto:

{
  "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"
        }
      ]
    }
  ]
}

Como puede ver, este archivo contiene la misma información que habíamos especificado anteriormente con varios comandos. Además, contiene una lista de módulos para construir. En el ejemplo anterior, solo hay un módulo. Si tiene una aplicación compleja que depende de varios módulos, deberá enumerarlos todos. Por ejemplo, gnome-calculator depende de mpc y mpfr, y el manifiesto tiene este aspecto.

Se admiten diferentes tipos de fuentes. Otro tipo de fuente popular es git , y debe proporcionar la URL del repositorio y, opcionalmente, la rama que debe verificarse.

El manifiesto es muy potente y admite la configuración de CFLAGS/CXXFLAGS, el cambio de nombre de los archivos para exportar y la eliminación de archivos innecesarios. En la siguiente sección, analizaremos una aplicación práctica y aprenderemos a empaquetarla para Flatpak.

Un ejemplo real:galculadora de embalaje

En esta sección, tomaremos galculator, una aplicación de calculadora simple y la construiremos con flatpak-builder . Necesitamos realizar un poco de análisis para averiguar qué archivos deben renombrarse o eliminarse. Así, como primer paso, haremos una instalación de prueba. Luego, podemos construir el manifiesto según sea necesario.

Dado que galculator es una aplicación GTK, usaremos el tiempo de ejecución y el SDK de Gnome. Debe instalarlos ahora si aún no lo ha hecho. Además, debe descargar el archivo fuente desde aquí. (Hemos utilizado la versión 2.1.4, que es la última versión en el momento de escribir este artículo).

Buscar archivos que deben exportarse/eliminarse

Una vez que haya descargado y extraído el archivo fuente, debe intentar compilarlo con el SDK. El SDK de Gnome también contiene herramientas como bash, por lo que puede iniciarlo usando:

flatpak run --command=bash --filesystem=host --devel org.gnome.Sdk/x86_64/3.24

Ahora, muévete al directorio fuente de galculator y usa el conjuro regular para construirlo. Estableceremos nuestro directorio de prefijos en ~/galculator-test .

./configure --prefix=$HOME/galculator-test
make install

Ahora, puede explorar los archivos en el galculator-test directorio. Como probablemente sabrá, es necesario exportar los siguientes archivos:

• Información de AppStream en share/appdata/galculator.appdata.xml
• Iconos en share/icons
• La entrada del escritorio en share/applications/galculator.desktop

Desafortunadamente, no tienen el prefijo del nombre de la aplicación. Por lo tanto, debe cambiarles el nombre con las siguientes propiedades en el manifiesto:

{
	"rename-appdata-file": "galculator.appdata.xml",
	"rename-icon": "galculator",
	"rename-desktop-file": "galculator.desktop"
}

Una vez que se cambia el nombre de estos archivos, flatpak-builder los exportará automáticamente. Una vez que se crea el paquete Flatpak, esto ayudará a crear entradas de menú en el sistema base.

Además, el share/man y share/pixmaps los directorios no son necesarios, por lo que puede eliminarlos con:

{
    "cleanup": [
        "/share/man",
        "/share/pixmaps"
    ]
}

Configuración de la zona de pruebas

Dado que esta es una aplicación GTK, debe permitirle acceder a X11 y Wayland, y compartir mecanismos IPC. También debe permitirle usar el renderizado OpenGL. Además, galculator necesita acceso a dconf, y debe agregar las entradas que discutimos anteriormente. Los interruptores, que se habrían pasado a build-finish se enumeran en el finish-args propiedad en el manifiesto:

{
    "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"
    ]
}

Completar el manifiesto

En este punto, ha configurado la mayoría de las partes importantes del manifiesto. Configurar el resto debería ser bastante fácil, y el manifiesto final que usamos está aquí. Hemos añadido un conjunto de build-options , que establece CFLAGS y CXXFLAGS en -O3 .

Construyendo y probando la aplicación

Finalmente, podemos construir la aplicación. Simplemente ejecute flatpak-builder con un directorio de compilación y el manifiesto. En este ejemplo, galculator es el directorio de compilación y org.mnim.galculator.json es el archivo de manifiesto.

flatpak-builder galculator org.mnim.galculator.json

Luego, expórtalo al repositorio como lo hicimos anteriormente:

flatpak build-export my-repo galculator

Ahora, puede probar la aplicación instalándola:

flatpak install --user test-repo org.mnim.galculator

La aplicación se instala de inmediato, ¡e incluso obtiene entradas de escritorio como una aplicación normal! Puede iniciarlo desde la entrada del menú o ejecutarlo con flatpak run como hicimos antes.

Distribución de aplicaciones

Ahora que ha creado una aplicación, ¿cómo hace para distribuirla? La forma más sencilla de hacerlo es transferir el directorio del repositorio a un servidor y servirlo a través de la web. Luego, puede pedirles a los usuarios que agreguen su repositorio a su lista e instalen las aplicaciones de esa manera.

Mucha gente prefiere instalar software firmado con GPG, ya que prueba que la aplicación realmente proviene del mantenedor original. Puede crear claves GPG fácilmente con el gpg2 comando:

gpg2 --quick-key-gen [email protected]

Asegúrese de anotar el ID de la clave, ya que lo necesitará más adelante. En nuestro ejemplo, supondremos que el ID de clave es A318C188C20D410A .

Luego, puede crear un repositorio firmado por GPG al ejecutar build-export así:

flatpak build-export my-repo galculator --gpg-sign=A318C188C20D410A

Si tiene un repositorio existente sin firmar, puede firmarlo así:

flatpak build-sign my-repo --gpg-sign=A318C188C20D410A
flatpak build-update-repo my-repo --gpg-sign=A318C188C20D410A

Cuando desee publicar el repositorio, asegúrese de proporcionar a los usuarios una copia de la clave pública. Para exportar su clave pública, ejecute:

gpg2 --export A318C188C20D410A > public.gpg

Debe publicar esta clave en su sitio web. Cuando sus usuarios quieran agregar su repositorio, deben descargar la clave pública. Si el usuario descargó una clave llamada public.gpg , ahora pueden agregar el repositorio ejecutando:

flatpak remote-add --gpg-import=public.gpg test-repo https://software.example.com/repo/

Sin embargo, este método es extremadamente inconveniente para los usuarios. Afortunadamente, puede simplificar el proceso creando archivos flatpakref y flatpakrepo, que se analizan en detalle en la documentación.

Conclusión

En este artículo, hemos aprendido sobre Flatpak y cómo puede distribuir software utilizando esta nueva tecnología. Está más orientado a la seguridad y cuenta con mejores capacidades de integración y actualización en comparación con los métodos tradicionales como AppImage.

Si está interesado en leer más sobre este tema, la documentación para desarrolladores y el flatpak-manifest página de manual son buenos lugares para empezar. Si desea leer ejemplos más complejos de manifiestos/archivos flatpakref, consulte el repositorio de aplicaciones de Gnome y los ejemplos de Flathub.