RPM

Nota

Algunas secciones de esta guía son opcionales. Esto incluye la configuración de scripts y ciertos otros pasos. Siéntete libre de adaptar las instrucciones según tus necesidades y requisitos específicos.

Esta guía cubre cómo distribuir y gestionar paquetes RPM, incluyendo la obtención de información del paquete, la configuración de scripts, la definición de dependencias y la firma de paquetes.

Nota

Las aplicaciones GUI en macOS y Linux no heredan el $PATH de los dotfiles de tu shell (.bashrc, .bash_profile, .zshrc, etc.). Consulta el crate fix-path-env-rs de Tauri para solucionar este problema.

Limitaciones

Las bibliotecas fundamentales como glibc frecuentemente rompen la compatibilidad con sistemas más antiguos. Por esta razón, debes compilar tu aplicación Tauri utilizando el sistema base más antiguo que pretendas admitir y que también proporcione los paquetes requeridos de WebKitGTK 4.1 para Tauri v2. Ubuntu 22.04 y Debian 12 son ejemplos adecuados de referencia porque proporcionan libwebkit2gtk-4.1-dev desde sus repositorios estándar de paquetes. Compilar en un sistema base más nuevo puede aumentar la versión mínima de glibc requerida por tu aplicación, por lo que al ejecutarla en un sistema más antiguo, podrías enfrentarte a un error de tiempo de ejecución como /usr/lib/libc.so.6: version 'GLIBC_2.33' not found. Recomendamos usar un contenedor Docker o GitHub Actions para compilar tu aplicación Tauri para Linux.

Consulta los problemas tauri-apps/tauri#1355 y rust-lang/rust#57497, además de la guía de AppImage para obtener más información.

Configurar el paquete RPM

Tauri te permite configurar el paquete RPM añadiendo scripts, definiendo dependencias, añadiendo una licencia, incluyendo archivos personalizados y más. Para obtener información detallada sobre las opciones configurables, consulta: RpmConfig.

Añadir script de post, pre-instalación/eliminación al paquete

El gestor de paquetes RPM te permite ejecutar scripts antes o después de la instalación o eliminación del paquete. Por ejemplo, puedes usar estos scripts para iniciar un servicio después de instalar el paquete.

Aquí tienes un ejemplo de cómo añadir estos scripts:

1. Crea una carpeta llamada scripts en el directorio src-tauri de tu proyecto.

mkdir src-tauri/scripts

2. Crea los archivos de script en la carpeta.

touch src-tauri/scripts/postinstall.sh \
touch src-tauri/scripts/preinstall.sh \
touch src-tauri/scripts/preremove.sh \
touch src-tauri/scripts/postremove.sh

Ahora, si miramos dentro de /src-tauri/scripts veremos:

ls src-tauri/scripts/
postinstall.sh  postremove.sh  preinstall.sh  preremove.sh

3. Añade algo de contenido a los scripts

preinstall.sh

echo "-------------"
echo "This is pre"
echo "Install Value: $1"
echo "Upgrade Value: $1"
echo "Uninstall Value: $1"
echo "-------------"

postinstall.sh

echo "-------------"
echo "This is post"
echo "Install Value: $1"
echo "Upgrade Value: $1"
echo "Uninstall Value: $1"
echo "-------------"

preremove.sh

echo "-------------"
echo "This is preun"
echo "Install Value: $1"
echo "Upgrade Value: $1"
echo "Uninstall Value: $1"
echo "-------------"

postremove.sh

echo "-------------"
echo "This is postun"
echo "Install Value: $1"
echo "Upgrade Value: $1"
echo "Uninstall Value: $1"
echo "-------------"

4. Añade los scripts al archivo tauri.conf.json

tauri.conf.json

{
  "bundle": {
    "linux": {
      "rpm": {
        "epoch": 0,
        "files": {},
        "release": "1",
        // add the script here
        "preInstallScript": "/path/to/your/project/src-tauri/scripts/prescript.sh",
        "postInstallScript": "/path/to/your/project/src-tauri/scripts/postscript.sh",
        "preRemoveScript": "/path/to/your/project/src-tauri/scripts/prescript.sh",
        "postRemoveScript": "/path/to/your/project/src-tauri/scripts/postscript.sh"
      }
    }
  }
}

Configurar Conflict, Provides, Depends, Files, Obsoletes, DesktopTemplate, y Epoch

• conflict: Evita la instalación del paquete si entra en conflicto con otro paquete. Por ejemplo, si actualizas un paquete RPM del que depende tu aplicación y la nueva versión es incompatible con tu aplicación.

• provides: Lista las dependencias RPM que proporciona tu aplicación.

• depends: Lista las dependencias RPM que necesita tu aplicación para ejecutarse.

• files: Especifica qué archivos incluir en el paquete.

• obsoletes: Lista las dependencias RPM que tu aplicación vuelve obsoletas.

Nota

Si este paquete se instala, los paquetes listados como «obsoletes» se eliminarán automáticamente si están presentes.

• desktopTemplate: Añade un archivo desktop personalizado al paquete.

• epoch: Define dependencias ponderadas basadas en números de versión.

Precaución

No se recomienda usar epoch a menos que sea necesario, ya que altera la forma en que el gestor de paquetes compara las versiones de los paquetes. Para obtener más información sobre epoch, por favor consulta: Guía de empaquetado RPM.

Para usar estas opciones, añade lo siguiente a tu tauri.conf.json :

tauri.conf.json

{
  "bundle": {
    "linux": {
      "rpm": {
        "postRemoveScript": "/path/to/your/project/src-tauri/scripts/postscript.sh",
        "conflicts": ["oldLib.rpm"],
        "depends": ["newLib.rpm"],
        "obsoletes": ["veryoldLib.rpm"],
        "provides": ["coolLib.rpm"],
        "desktopTemplate": "/path/to/your/project/src-tauri/desktop-template.desktop"
      }
    }
  }
}

Añadir una licencia al paquete

Para añadir una licencia al paquete, añade lo siguiente al archivo src-tauri/Cargo.toml o en src-tauri/tauri.conf.json:

src-tauri/Cargo.toml

[package]
name = "tauri-app"
version = "0.0.0"
description = "A Tauri App"
authors = ["you"]
edition = "2021"
license = "MIT" # add the license here
# ...  rest of the file

Y para src-tauri/tauri.conf.json

src-tauri/tauri.conf.json

{
  "bundle": {
    "licenseFile": "../LICENSE", // put the path to the license file here
    "license": "MIT" // add the license here
  }
}

Construir el paquete RPM

Para construir el paquete RPM, puedes usar el siguiente comando:

npm

npm run tauri build

yarn

yarn tauri build

pnpm

pnpm tauri build

deno

deno task tauri build

bun

bun tauri build

cargo

cargo tauri build

Este comando construirá el paquete RPM en el directorio src-tauri/target/release/bundle/rpm.

Firmar el paquete RPM

Tauri te permite firmar el paquete con la clave que tienes en tu sistema durante el proceso de construcción. Para hacer esto, necesitarás generar una clave GPG.

Generar una clave GPG

Para generar una clave GPG puedes usar el siguiente comando:

gpg --gen-key

Sigue las instrucciones para generar la clave.

Una vez generada la clave, necesitarás añadirla a tu variable de entorno. Puedes hacer esto añadiendo lo siguiente a tu archivo .bashrc o .zshrc o simplemente exportándola en la terminal:

export TAURI_SIGNING_RPM_KEY=$(cat /home/johndoe/my_super_private.key)

Si tienes una frase de paso (passphrase) para la clave, puedes añadirla a la variable de entorno:

export TAURI_SIGNING_RPM_KEY_PASSPHRASE=password

Ahora puedes construir el paquete con el siguiente comando:

npm

npm run tauri build

yarn

yarn tauri build

pnpm

pnpm tauri build

deno

deno task tauri build

bun

bun tauri build

cargo

cargo tauri build

Verificar la firma

Nota

Esto debe hacerse solo para probar la firma localmente.

Antes de verificar la firma, necesitarás crear e importar la clave pública a la base de datos de RPM:

gpg --export -a 'Tauri-App' > RPM-GPG-KEY-Tauri-App

sudo rpm --import RPM-GPG-KEY-Tauri-App

Ahora que la clave está importada, tenemos que editar el archivo ~/.rpmmacros para utilizar la clave.

~/.rpmmacros

%_signature gpg
%_gpg_path /home/johndoe/.gnupg
%_gpg_name Tauri-App
%_gpgbin /usr/bin/gpg2
%__gpg_sign_cmd %{__gpg} \
    gpg --force-v3-sigs --digest-algo=sha1 --batch --no-verbose --no-armor \
    --passphrase-fd 3 --no-secmem-warning -u "%{_gpg_name}" \
    -sbo %{__signature_filename} %{__plaintext_filename}

Por último, puedes verificar el paquete usando el siguiente comando:

rpm  -v --checksig tauri-app-0.0.0-1.x86_64.rpm

Depurar el paquete RPM

En esta sección, veremos cómo depurar el paquete RPM comprobando el contenido del paquete y obteniendo información sobre el mismo.

Obtener información sobre el paquete

Para obtener información sobre tu paquete, como la versión, el lanzamiento y la arquitectura, usa el siguiente comando:

rpm -qip package_name.rpm

Consultar información específica sobre el paquete

Por ejemplo, si quieres obtener el nombre, versión, lanzamiento, arquitectura y tamaño del paquete, usa el siguiente comando:

rpm  -qp --queryformat '[%{NAME} %{VERSION} %{RELEASE} %{ARCH} %{SIZE}\n]' package_name.rpm

Nota

--queryformat es una cadena de formato que se puede usar para obtener información específica sobre el paquete. La información que se puede recuperar proviene del comando rpm -qip.

Comprobar el contenido del paquete

Para comprobar el contenido del paquete, usa el siguiente comando:

rpm -qlp package_name.rpm

Este comando listará todos los archivos que están incluidos en el paquete.

Depurar scripts

Para depurar scripts de post/pre-instalación/eliminación, usa el siguiente comando:

rpm -qp --scripts package_name.rpm

Este comando imprimirá el contenido de los scripts.

Comprobar dependencias

Para comprobar las dependencias del paquete, usa el siguiente comando:

rpm -qp --requires package_name.rpm

Listar paquetes que dependen de un paquete específico

Para listar los paquetes que dependen de un paquete específico, usa el siguiente comando:

rpm -q --whatrequires package_name.rpm

Depurar problemas de instalación

Si encuentras problemas durante la instalación de un paquete RPM, puedes usar la opción -vv (muy detallado) para obtener un resultado detallado:

rpm -ivvh package_name.rpm

O para un paquete ya instalado:

rpm -Uvvh package_name.rpm

Compilación cruzada para dispositivos basados en ARM

Esta guía cubre la compilación manual. Consulta nuestra guía de GitHub Actions para ver un ejemplo de flujo de trabajo que aprovecha QEMU para compilar la aplicación. Esto será mucho más lento pero también podrá compilar AppImages.

La compilación manual es adecuada cuando no necesitas compilar tu aplicación con frecuencia y prefieres una configuración de una sola vez. Los siguientes pasos asumen que usas una distribución de Linux basada en Debian/Ubuntu.

1. Instalar los targets de Rust para la arquitectura deseada

   • Para ARMv7 (32 bits): rustup target add armv7-unknown-linux-gnueabihf
   • Para ARMv8 (ARM64, 64 bits): rustup target add aarch64-unknown-linux-gnu

2. Instalar el linker correspondiente para la arquitectura elegida

   • Para ARMv7: sudo apt install gcc-arm-linux-gnueabihf
   • Para ARMv8 (ARM64): sudo apt install gcc-aarch64-linux-gnu

3. Abre o crea el archivo <project-root>/.cargo/config.toml y añade las siguientes configuraciones según corresponda

   [target.armv7-unknown-linux-gnueabihf]
   linker = "arm-linux-gnueabihf-gcc"
   
   [target.aarch64-unknown-linux-gnu]
   linker = "aarch64-linux-gnu-gcc"

4. Habilitar la arquitectura respectiva en el gestor de paquetes

   • Para ARMv7: sudo dpkg --add-architecture armhf
   • Para ARMv8 (ARM64): sudo dpkg --add-architecture arm64

5. Ajustar las fuentes de paquetes

   En Debian, este paso no debería ser necesario, pero en otras distribuciones, es posible que necesites editar /etc/apt/sources.list para incluir la variante de arquitectura ARM. Por ejemplo, en Ubuntu 22.04 añade estas líneas al final del archivo (Recuerda reemplazar jammy por el nombre en código de tu versión de Ubuntu):

   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main restricted
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main restricted
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy universe
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates universe
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy multiverse
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates multiverse
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main restricted universe multiverse
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main restricted
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security universe
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security multiverse

   Luego, para evitar problemas con los paquetes principales, debes añadir la arquitectura principal correcta a todas las demás líneas que el archivo contenía previamente. Para sistemas estándar de 64 bits necesitas añadir [arch=amd64], el archivo completo en Ubuntu 22.04 se verá similar a esto:

   Mostrar solución

   # See http://help.ubuntu.com/community/UpgradeNotes for how to upgrade to
   # newer versions of the distribution.
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy main restricted
   # deb-src http://archive.ubuntu.com/ubuntu/ jammy main restricted
   
   ## Major bug fix updates produced after the final release of the
   ## distribution.
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy-updates main restricted
   # deb-src http://archive.ubuntu.com/ubuntu/ jammy-updates main restricted
   
   ## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
   ## team. Also, please note that software in universe WILL NOT receive any
   ## review or updates from the Ubuntu security team.
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy universe
   # deb-src http://archive.ubuntu.com/ubuntu/ jammy universe
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy-updates universe
   # deb-src http://archive.ubuntu.com/ubuntu/ jammy-updates universe
   
   ## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
   ## team, and may not be under a free licence. Please satisfy yourself as to
   ## your rights to use the software. Also, please note that software in
   ## multiverse WILL NOT receive any review or updates from the Ubuntu
   ## security team.
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy multiverse
   # deb-src http://archive.ubuntu.com/ubuntu/ jammy multiverse
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy-updates multiverse
   
   ## N.B. software from this repository may not have been tested as
   ## extensively as that contained in the main release, although it includes
   ## newer versions of some applications which may provide useful features.
   ## Also, please note that software in backports WILL NOT receive any review
   ## or updates from the Ubuntu security team.
   deb [arch=amd64] http://archive.ubuntu.com/ubuntu/ jammy-backports main restricted universe multiverse
   # deb-src http://archive.ubuntu.com/ubuntu/ jammy-backports main restricted universe multiverse
   
   deb [arch=amd64] http://security.ubuntu.com/ubuntu/ jammy-security main restricted
   # deb-src http://security.ubuntu.com/ubuntu/ jammy-security main restricted
   deb [arch=amd64] http://security.ubuntu.com/ubuntu/ jammy-security universe
   # deb-src http://security.ubuntu.com/ubuntu/ jammy-security universe
   deb [arch=amd64] http://security.ubuntu.com/ubuntu/ jammy-security multiverse
   # deb-src http://security.ubuntu.com/ubuntu/ jammy-security multiverse
   
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy main restricted
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates main restricted
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy universe
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates universe
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy multiverse
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-updates multiverse
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-backports main restricted universe multiverse
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security main restricted
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security universe
   deb [arch=armhf,arm64] http://ports.ubuntu.com/ubuntu-ports jammy-security multiverse

6. Actualizar la información de los paquetes: sudo apt-get update && sudo apt-get upgrade -y

7. Instalar la biblioteca webkitgtk requerida para la arquitectura elegida

   • Para ARMv7: sudo apt install libwebkit2gtk-4.1-dev:armhf
   • Para ARMv8 (ARM64): sudo apt install libwebkit2gtk-4.1-dev:arm64

8. Instalar OpenSSL o usar una versión vendored

   Esto no siempre es obligatorio, por lo que puedes continuar primero y verificar si ves errores como Failed to find OpenSSL development headers.

   • Either install the development headers system-wide:
     • Para ARMv7: sudo apt install libssl-dev:armhf
     • Para ARMv8 (ARM64): sudo apt install libssl-dev:arm64
   • O habilita la característica vendor para el crate de OpenSSL en Rust, lo cual afectará a todas las demás dependencias de Rust que usen la misma versión menor. Puedes hacerlo añadiendo esto a la sección de dependencias en tu archivo Cargo.toml:

   openssl-sys = {version = "0.9", features = ["vendored"]}

9. Establece la variable PKG_CONFIG_SYSROOT_DIR en el directorio adecuado según la arquitectura elegida

   • Para ARMv7: export PKG_CONFIG_SYSROOT_DIR=/usr/arm-linux-gnueabihf/
   • Para ARMv8 (ARM64): export PKG_CONFIG_SYSROOT_DIR=/usr/aarch64-linux-gnu/

10. Compilar la aplicación para la versión de ARM deseada

    • Para ARMv7: cargo tauri build –target armv7-unknown-linux-gnueabihf
    • Para ARMv8 (ARM64): cargo tauri build –target aarch64-unknown-linux-gnu

    Elige el conjunto de instrucciones adecuado en función de si quieres realizar una compilación cruzada de tu aplicación Tauri para ARMv7 o ARMv8 (ARM64). Ten en cuenta que los pasos específicos pueden variar según tu distribución de Linux y configuración.