GitHub

Esta guía te mostrará cómo usar tauri-action en GitHub Actions para compilar y subir fácilmente tu app, y cómo hacer que el actualizador de Tauri consulte el lanzamiento de GitHub recién creado en busca de actualizaciones.

Por último, también mostrará cómo configurar un pipeline de compilación más complicado para AppImages de Linux Arm.

Primeros pasos

Para configurar tauri-action, primero debes configurar un repositorio de GitHub. También puedes usar esta acción en un repositorio que aún no tenga Tauri configurado, ya que puede inicializar Tauri automáticamente por ti; consulta el readme de la acción para conocer las opciones de configuración necesarias.

Ve a la pestaña Actions en la página de tu proyecto en GitHub y selecciona «New workflow», luego elige «Set up a workflow yourself». Reemplaza el archivo con el workflow de abajo o con uno de los ejemplos de la acción.

Configuración

Consulta el readme de tauri-action para conocer todas las opciones de configuración disponibles.

Cuando tu app no esté en la raíz del repositorio, usa la entrada projectPath.

Puedes modificar libremente el nombre del workflow, cambiar sus activadores y agregar más pasos como npm run lint o npm run test. La parte importante es que mantengas la línea de abajo al final del workflow, ya que ejecuta el script de compilación y publica tu app.

Cómo activar

El workflow de lanzamiento que se muestra a continuación y en los ejemplos de tauri-action se activa al hacer push a la rama release. La acción crea automáticamente una etiqueta git y un título para el lanzamiento de GitHub utilizando la versión de la aplicación.

Como otro ejemplo, también puedes cambiar el activador para ejecutar el workflow al hacer push de una etiqueta git de versión como app-v0.7.0:

name: 'publish'

on:
  push:
    tags:
      - 'app-v*'

Para obtener una lista completa de las posibles configuraciones de activadores, consulta la documentación oficial de GitHub.

Ejemplo de Workflow

A continuación se muestra un ejemplo de workflow que se ha configurado para ejecutarse cada vez que haces push a la rama release.

Este workflow compilará y publicará tu app para Windows x64, Linux x64, Linux Arm64, macOS x64 y macOS Arm64 (M1 y superior).

Los pasos que realiza este workflow son:

Obtener el repositorio usando actions/checkout@v7.
Instalar las dependencias del sistema de Linux requeridas para compilar la app.
Configurar Node.js LTS y una caché para los datos globales de paquetes de npm/yarn/pnpm usando actions/setup-node@v6.
Configurar Rust y una caché para los artefactos de compilación de Rust usando dtolnay/rust-toolchain@stable y swatinem/rust-cache@v2.
Instalar las dependencias del frontend y, si no está configurado como beforeBuildCommand, ejecutar el script de compilación de la web app.
Por último, utiliza tauri-apps/tauri-action@v1 para ejecutar tauri build, generar los artefactos y crear un lanzamiento en GitHub.

name: 'publish'

on:
  workflow_dispatch:
  push:
    branches:
      - release

jobs:
  publish-tauri:
    permissions:
      contents: write
    strategy:
      fail-fast: false
      matrix:
        include:
          - platform: 'macos-latest' # for Arm based macs (M1 and above).
            args: '--target aarch64-apple-darwin'
          - platform: 'macos-latest' # for Intel based macs.
            args: '--target x86_64-apple-darwin'
          - platform: 'ubuntu-22.04'
            args: ''
          - platform: 'ubuntu-22.04-arm' # Only available in public repos.
            args: ''
          - platform: 'windows-latest'
            args: ''

    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v7

      - name: install dependencies (ubuntu only)
        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm' # This must match the platform value defined above.
        run: |
          sudo apt-get update
          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf xdg-utils

      - name: setup node
        uses: actions/setup-node@v6
        with:
          node-version: lts/*
          cache: 'npm' # Set this to npm, yarn or pnpm.

      - name: install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
          # Those targets are only used on macos runners so it's in an `if` to slightly speed up windows and linux builds.
          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}

      - name: Rust cache
        uses: swatinem/rust-cache@v2
        with:
          # This matches tauri's default project layout. Change this if you have a different layout.
          workspaces: './src-tauri -> target'

      - name: install frontend dependencies
        # If you don't have `beforeBuildCommand` configured you may want to build your frontend here too.
        run: npm install # change this to npm, yarn or pnpm depending on which one you use.

      - uses: tauri-apps/tauri-action@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tagName: app-v__VERSION__ # the action automatically replaces __VERSION__ with the app version.
          releaseName: 'App v__VERSION__'
          releaseBody: 'See the assets to download this version and install.'
          releaseDraft: true
          prerelease: false
          args: ${{ matrix.args }}

Para conocer más opciones de configuración, consulta el repositorio de tauri-action y sus ejemplos.

Compilación en Runner Arm

Este workflow utiliza pguyot/arm-runner-action para compilar directamente en un runner Arm emulado. Esto soluciona la falta de soporte para compilaciones entre distintas arquitecturas en las herramientas de AppImage.

name: 'Publish Linux Arm builds'

on:
  workflow_dispatch:
  push:
    branches:
      - release

jobs:
  build:
    runs-on: ubuntu-22.04

    strategy:
      matrix:
        arch: [aarch64, armv7l]
        include:
          - arch: aarch64
            cpu: cortex-a72
            base_image: https://dietpi.com/downloads/images/DietPi_RPi5-ARMv8-Bookworm.img.xz
            deb: arm64
            rpm: aarch64
            appimage: aarch64
          - arch: armv7l
            cpu: cortex-a53
            deb: armhfp
            rpm: arm
            appimage: armhf
            base_image: https://dietpi.com/downloads/images/DietPi_RPi-ARMv7-Bookworm.img.xz

    steps:
      - uses: actions/checkout@v3

      - name: Cache rust build artifacts
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: src-tauri
          cache-on-failure: true

      - name: Build app
        uses: pguyot/arm-runner-action@v2.6.5
        with:
          base_image: ${{ matrix.base_image }}
          cpu: ${{ matrix.cpu }}
          bind_mount_repository: true
          image_additional_mb: 10240
          optimize_image: no
          #exit_on_fail: no
          commands: |
            # Prevent Rust from complaining about $HOME not matching eid home
            export HOME=/root

            # Workaround to CI worker being stuck on Updating crates.io index
            export CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse

            # Install setup prerequisites
            apt-get update -y --allow-releaseinfo-change
            apt-get autoremove -y
            apt-get install -y --no-install-recommends --no-install-suggests curl libwebkit2gtk-4.1-dev build-essential libssl-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev patchelf libfuse2 file
            curl https://sh.rustup.rs -sSf | sh -s -- -y
            . "$HOME/.cargo/env"
            curl -fsSL https://deb.nodesource.com/setup_lts.x | bash
            apt-get install -y nodejs

            # Install frontend dependencies
            npm install

            # Build the application
            npm run tauri build -- --verbose

      - name: Get app version
        run: echo "APP_VERSION=$(jq -r .version src-tauri/tauri.conf.json)" >> $GITHUB_ENV

      # TODO: Combine this with the basic workflow and upload the files to the Release.
      - name: Upload deb bundle
        uses: actions/upload-artifact@v3
        with:
          name: Debian Bundle
          path: ${{ github.workspace }}/src-tauri/target/release/bundle/deb/appname_${{ env.APP_VERSION }}_${{ matrix.deb }}.deb

      - name: Upload rpm bundle
        uses: actions/upload-artifact@v3
        with:
          name: RPM Bundle
          path: ${{ github.workspace }}/src-tauri/target/release/bundle/rpm/appname-${{ env.APP_VERSION }}-1.${{ matrix.rpm }}.rpm

      - name: Upload appimage bundle
        uses: actions/upload-artifact@v3
        with:
          name: AppImage Bundle
          path: ${{ github.workspace }}/src-tauri/target/release/bundle/appimage/appname_${{ env.APP_VERSION }}_${{ matrix.appimage }}.AppImage

Solución de problemas

Token de entorno de GitHub

El token de GitHub se emite automáticamente por GitHub para cada ejecución de workflow sin necesidad de configuración adicional, lo que significa que no hay riesgo de filtración de secretos. Sin embargo, este token solo tiene permisos de lectura por defecto y es posible que recibas un error «Resource not accessible by integration» al ejecutar el workflow. Si esto sucede, es posible que debas agregar permisos de escritura a este token. Para hacer esto, ve a la configuración de tu proyecto en GitHub, selecciona Actions, desplázate hacia abajo hasta Workflow permissions y marca «Read and write permissions».

Puedes ver cómo el Token de GitHub se pasa al workflow mediante esta línea en el workflow:

env:
  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Apoya en Open Collective Patrocina en GitHub