Un release, cinco gestores de paquetes: cómo facilitar a los usuarios la instalación y la actualización

Instalar es fácil; lo que de verdad importa es actualizar. Cómo entregar una aplicación desde un único tag a través de Homebrew, winget, Scoop, Flatpak y Docker.

Publicar una nueva versión de una aplicación es fácil. En GitHub aparece un release, adjuntas los archivos y listo. Pero el usuario que se descargó la aplicación hace medio año no sabe que existe una versión nueva. Y si no llega a ella, la culpa no es suya, sino de la forma en que le entregaste la aplicación.

Instalar es algo que se hace una sola vez. La diferencia real entre «descárgalo de la web» y un software bien distribuido es la actualización: quién la lanza, con qué facilidad y si se puede volver atrás. Esto es lo que he resuelto en mis herramientas (OmniDB, PgArachne, pg_procrustes, pg_dbml y otras) y he llegado a un reparto que no tiene una única respuesta válida para todas las plataformas.

Qué criterios uso

Para cada plataforma me hice cuatro preguntas:

macOS: Homebrew

En macOS, Homebrew tiene sentido para todo. Las fórmulas (formula) sirven para la línea de comandos y los casks para aplicaciones con interfaz gráfica.

brew install --cask heptau/tap/omnidb   # GUI (cask)
brew install heptau/tap/pg-procrustes   # CLI (fórmula)
brew install heptau/tap/pg-dbml         # CLI (fórmula)
brew upgrade                            # actualiza todo

La decisión que merece reflexión es tap propio frente a repositorio oficial. Un tap propio (heptau/tap) funciona al instante: basta con un repositorio en GitHub y unos pocos archivos. Al homebrew-cask oficial solo llegas cuando el proyecto es suficientemente conocido y, sobre todo, con una aplicación firmada y notarizada por Apple (lo que implica una cuenta de Apple Developer de pago).

Homebrew, por cierto, no esquiva Gatekeeper. Marca la aplicación descargada con cuarentena igual que un navegador, de modo que macOS la comprueba en el primer arranque. Antes existía el interruptor --no-quarantine, con el que el usuario desactivaba la cuarentena, pero desde Homebrew 5.0.0 está obsoleto, porque Homebrew no quiere facilitar que se eludan las funciones de seguridad de macOS. Los casks sin firma están marcados como obsoletos y, según el plan, el repositorio oficial debía retirar desde septiembre de 2026 todos los que Gatekeeper no deje pasar (esto lo comprobé en el anuncio de Homebrew 5.0.0, no en la práctica).

Para ti la conclusión es sencilla: la firma y la notarización son trabajo tuyo, no de Homebrew. Sin ellas, Gatekeeper bloqueará la aplicación en el primer arranque, la haya instalado el usuario como la haya instalado, y no entrarás en el repositorio oficial. En un tap propio nadie retira el cask, pero Gatekeeper actúa igual en el equipo del usuario.

Algo que les viene bien a los usuarios, sin importar cómo instalaron la aplicación: si ya la tienes instalada a mano (descargando el .dmg o el zip) y quieres que a partir de ahora la gestione Homebrew, no hace falta borrarla y descargarla de nuevo. Basta con:

brew install --cask --adopt heptau/tap/omnidb

El interruptor --adopt toma la aplicación existente en /Applications, si es idéntica a la que instalaría el cask, y a partir de ahí la gestiona Homebrew, de modo que brew upgrade la actualizará. Según la documentación, los archivos existentes deben ser idénticos a los instalados, así que resulta útil sobre todo cuando tienes la misma versión que el cask. No se puede combinar con --force. Para el autor es una buena noticia: los usuarios que descargaron la aplicación de la web pueden pasarse a Homebrew sin reinstalar.

Windows: winget y Scoop

winget es el gestor de paquetes incluido en Windows 11 y en Windows 10 (desde la versión 1809, como parte del componente App Installer). El usuario escribe winget install y winget upgrade y no necesita nada más. Para ti significa enviar un manifiesto como pull request al repositorio microsoft/winget-pkgs. Las condiciones son una URL estable del instalador y una instalación silenciosa. La aprobación es más lenta que en un tap propio, pero tras el primer paquete las versiones siguientes se pueden enviar automáticamente.

Tengo un ejemplo con la aplicación gráfica OmniDB. El usuario escribe:

winget install heptau.OmniDB
winget upgrade heptau.OmniDB

Para una aplicación gráfica lo más natural es un instalador de verdad (.exe o .msi), porque tiene que crear accesos directos, registrar la desinstalación y cosas así. Por eso OmniDB genera en cada release un instalador NSIS, y un script crea a partir de él y de las sumas de comprobación el manifiesto. Este consta de tres archivos YAML (versión, instalador y descripción). El más importante es el del instalador:

PackageIdentifier: heptau.OmniDB
PackageVersion: 5.5.0
InstallerType: nullsoft
Scope: machine
InstallModes:
  - interactive
  - silent
  - silentWithProgress
UpgradeBehavior: install
Installers:
  - Architecture: x64
    InstallerUrl: https://github.com/heptau/omnidb/releases/download/v5.5.0/OmniDB-win-x64-setup.exe
    InstallerSha256: …
ManifestType: installer

Esa parte de silent es la «instalación silenciosa», sin la cual winget upgrade no podría ejecutarse sin intervención del usuario. El identificador heptau.OmniDB tiene la forma Publicador.Nombre, que es la convención de winget.

winget tiene una característica que no he visto en otros gestores de paquetes: es capaz de actualizar incluso una aplicación que el usuario instaló a mano, descargando el instalador de la web. Funciona porque cada instalador clásico de Windows escribe en el registro una entrada para la lista «Aplicaciones y características» (ARP, Agregar o quitar programas): nombre, publicador y versión. winget lee esas entradas e intenta emparejarlas con los paquetes del repositorio. Si lo consigue, winget list muestra la aplicación instalada a mano junto a las demás y winget upgrade puede actualizarla como si la hubiera instalado él desde el principio.

De ahí se deduce un consejo práctico para el autor: procura que el nombre y el publicador del instalador coincidan con el manifiesto, o enuméralos en el manifiesto en el campo AppsAndFeaturesEntries. El emparejamiento se apoya en nombres y versiones y, si falla, la aplicación no aparece en winget upgrade o aparece con la versión «Unknown». No es, por tanto, una garantía, sino un extra que hay que vigilar. Homebrew tiene algo parecido, pero distinto: no encuentra la aplicación por sí mismo, el usuario tiene que «adoptarla» a mano (véase el comando --adopt en la sección de macOS).

La publicación termina entonces de forma automática: el script crea una rama en el fork heptau/winget-pkgs y abre un pull request con la nueva versión. El primer paquete hubo que enviarlo a mano a winget-pkgs, porque un paquete nuevo pasa por una aprobación distinta de la de una subida de versión. El script lo sabe y se niega a enviar automáticamente un paquete que todavía no existe en upstream.

Para las herramientas de línea de comandos no necesitas instalador. winget conoce el tipo portable (un .exe independiente) y, desde la versión 1.4, también zip, del que toma el archivo portable anidado. Basta, pues, con el archivo comprimido que de todos modos ya publicas, y en el manifiesto solo cambia el tipo. Así sería para el archivo que ya publica pg_procrustes (todavía no lo he enviado a winget-pkgs, es un ejemplo):

InstallerType: zip
NestedInstallerType: portable
NestedInstallerFiles:
  - RelativeFilePath: pg_procrustes.exe
Installers:
  - Architecture: x64
    InstallerUrl: https://github.com/heptau/pg_procrustes/releases/download/v0.6.1/pg_procrustes-0.6.1-windows-amd64.zip
    InstallerSha256: 6d361058befc5176516b52017428abd271d41a2b2d5192968b73097de3b549bc

winget descomprime esa herramienta en el directorio del usuario y la deja accesible en el PATH, sin permisos de administrador y sin instalador. Este camino solo lo he probado a nivel de documentación, no en un pull request real a winget-pkgs, así que antes de enviarlo comprueba los nombres exactos de los campos en el esquema del manifiesto.

Scoop es una buena alternativa para la línea de comandos y las aplicaciones portables. Se instala sin permisos de administrador en el directorio del usuario y un bucket propio (el equivalente de un tap) se crea en unos minutos.

scoop bucket add heptau https://github.com/heptau/scoop-bucket
scoop install pgarachne
scoop update pgarachne

Conviene mencionar también Chocolatey: es un gestor de paquetes más antiguo, que se usa sobre todo en entornos corporativos. Para proyectos nuevos, sin embargo, winget y Scoop resultan más cómodos.

Linux

Aquí los caminos para GUI y CLI son distintos.

Aplicaciones gráficas: Flatpak

Para aplicaciones con ventana, Flatpak es una elección razonable. La aplicación se instala desde Flathub, se actualiza con flatpak update y se ejecuta en un sandbox. Precisamente el sandbox es importante para un cliente de PostgreSQL. La aplicación, por sí sola, no verá ~/.pgpass ni los sockets Unix, y por eso los permisos hay que enumerarlos expresamente en el manifiesto (hablo de ello con más detalle en el artículo Aplicaciones en sandbox: cuando el aislamiento deja la base de datos sin .pgpass).

De Snap y AppImage solo diré una frase: Snap está ligado a Canonical y AppImage no tiene, por sí mismo, ningún mecanismo de actualización.

Línea de comandos: Homebrew

En este punto pensé al principio en paquetes .deb y .rpm. Me topé con dos cosas:

Por eso, para mí, la opción pragmática en Linux es Homebrew. Es el mismo comando que en macOS, se instala en /home/linuxbrew/.linuxbrew, no necesita root y no choca con el gestor de paquetes del sistema. Y la fórmula puede ser exactamente la misma. Mi fórmula de PgArachne solo tiene bloques on_macos y on_linux con enlaces a archivos precompilados del release de GitHub:

on_linux do
  if Hardware::CPU.arm?
    url "https://github.com/heptau/pgarachne/releases/download/v#{version}/pgarachne-linux-arm64.tar.gz"
    sha256 "…"
  else
    url "https://github.com/heptau/pgarachne/releases/download/v#{version}/pgarachne-linux-amd64.tar.gz"
    sha256 "…"
  end
end

Nada de compilar: solo descargar el binario ya hecho y comprobarlo contra la suma de comprobación.

Homebrew en Linux tiene también inconvenientes, y es justo mencionarlos:

Servidor: el ejemplo de PgArachne

Un servidor se actualiza de forma distinta a un escritorio. La actualización de la pasarela a la que se conectan las aplicaciones tiene que ser controlada, no silenciosa. No quiero que un viernes por la tarde se cambie sola a la versión nueva.

Homebrew lo permite bien:

brew install heptau/tap/pgarachne
brew services start pgarachne      # crea el servicio
brew upgrade pgarachne             # nueva versión
brew services restart pgarachne    # reinicio tras la actualización

En Linux, brew services crea un servicio systemd de usuario. Para que siga funcionando sin un usuario con sesión iniciada, hay que activar una vez loginctl enable-linger. Si quieres automatizar las actualizaciones, basta con llamar a brew upgrade desde cron o desde un temporizador de systemd, pero de forma consciente y en el momento que tú elijas.

¿Y git pull?

También se me ocurrió la solución más sencilla: tener en el servidor un clon del repositorio y actualizarlo con git pull. Hay dos variantes y ambas tienen un inconveniente.

Lo curioso es que Homebrew en realidad también hace esto: un tap es un repositorio git y brew update es, en esencia, un git pull. La diferencia es que en el repositorio solo hay pequeñas descripciones de texto (fórmulas), no binarios. Los binarios se descargan de los releases, se verifican con la suma de comprobación y la versión se elige según la plataforma. Es, por tanto, un git pull para los metadatos y una descarga para los datos, y precisamente esa separación es lo que lo convierte en una solución utilizable.

Para desarrollo basta con git pull. Para producción lo usaría solo a través de un tap, no directamente.

Docker: el camino corto para el servidor

En aplicaciones de servidor, la actualización menos dolorosa suele ser mediante una imagen Docker con el tag de la versión:

services:
  app:
    image: ghcr.io/tu-cuenta/tu-app:2.0.2

Actualizar es cambiar el número de versión y ejecutar docker compose pull && docker compose up -d. El rollback es lo mismo con el número anterior. Es el camino más directo para gestionar versiones, pero presupone que ya tienes Docker en el servidor y lo usas.

Confieso que todavía no publico una imagen de PgArachne. Es otro canal que GoReleaser sabría atender desde el mismo tag y, si lo añado, será solo un bloque más en la configuración.

¿Y las aplicaciones web (PWA)?

Con las PWA la situación es la opuesta a todo lo anterior: no hace falta actualizarlas, porque la actualización ocurre en la siguiente carga de la página. Un gestor de paquetes no mejora nada aquí. Solo queda la instalación, y esa ya son dos clics en el navegador.

Aun así, me pregunté si no se podría instalar el icono de la aplicación mediante Homebrew, para tenerla junto a las demás aplicaciones y en el Brewfile. En macOS resulta sorprendentemente sencillo. Cuando añades una PWA al escritorio desde Safari, se crea un .app que contiene solo el Info.plist (con todo el manifiesto de la aplicación web), el icono y la firma. Ningún código ejecutable: ese lo aporta el sistema. Una aplicación así basta con empaquetarla en un zip y publicarla como cask. Por ahora es solo un ejemplo (no publico todavía un release de Lumifex con este archivo, así que la dirección y la suma son marcadores de posición):

cask "lumifex" do
  version "1.0"
  sha256 "…"

  url "https://github.com/heptau/lumifex/releases/download/v#{version}/Lumifex.app.zip"
  name "Lumifex"
  homepage "https://lumifex.80.cz/"

  depends_on macos: ">= :sonoma"

  app "Lumifex.app"
end

Comprobé que una copia con el indicador de cuarentena (como tras una descarga de internet) se abre sin un solo error, aunque esté firmada solo ad hoc. Pero lo probé únicamente en el mismo Mac donde se creó el bundle, así que es una verificación con reservas.

Hay que admitir qué se gana con esto y qué no. Las actualizaciones siguen ocurriendo dentro de la PWA y brew upgrade no cambia nada en ellas. Lo que se obtiene es un comando de instalación unificado, el icono en Launchpad y la posibilidad de tener la aplicación en el Brewfile. En Windows y Linux no esperaría algo igual de sencillo. Un acceso directo que abra el navegador en modo aplicación se podría crear con Scoop o con un pequeño instalador, pero todavía no lo he probado, y en Linux Flatpak sería una envoltura con su propio núcleo, no un enlace.

Comparación

VíaInstalaciónActualizaciónRollbackQuién lo mantiene
Descarga manualdescargar y descomprimira manomanualel usuario
Homebrew (macOS, Linux)brew installbrew upgradebrew install de una versión concreta (limitado)yo (tap)
wingetwinget installwinget upgradeversión concretayo + revisor
Scoopscoop installscoop updatescoop resetyo (bucket)
Flatpakflatpak installflatpak updateflatpak update --commityo + Flathub
Dockerdocker pullcambio de tagcambio de tagyo (registry)

Cómo hacerlo para que no sea trabajo extra

Cinco canales suenan a cinco tareas en cada release. La solución es la automatización: de un único tag deben generarse solos todos los artefactos. Para ello uso GoReleaser, que a partir de un único código fuente compila los binarios para todas las plataformas, los empaqueta en archivos y calcula las sumas de comprobación.

La base de la configuración de PgArachne es así:

version: 2

project_name: pgarachne

builds:
  - id: cli
    main: ./cmd/pgarachne
    binary: pgarachne
    env:
      - CGO_ENABLED=0
    goos: [darwin, linux, windows]
    goarch: [amd64, arm64]
    ldflags:
      - -s -w
      - -X github.com/heptau/pgarachne/internal/version.Version={{ .Version }}

archives:
  - id: cli-archive
    ids: [cli]
    name_template: "{{ .ProjectName }}-{{ .Os }}-{{ .Arch }}"
    formats: [tar.gz]
    format_overrides:
      - goos: darwin
        formats: [zip]
      - goos: windows
        formats: [zip]

checksum:
  name_template: checksums.txt

Esta es la configuración real. La fórmula para el tap la genera después mi script a partir de las sumas de comprobación que produce GoReleaser. Pero GoReleaser puede más y puede crear por sí mismo la fórmula, el manifiesto de Scoop y el manifiesto de winget, y enviarlos al repositorio correspondiente:

brews:
  - repository:
      owner: heptau
      name: homebrew-tap
    homepage: "https://www.pgarachne.com/"
    description: "PostgreSQL JSON-RPC gateway"

scoops:
  - repository:
      owner: heptau
      name: scoop-bucket
    homepage: "https://www.pgarachne.com/"
    description: "PostgreSQL JSON-RPC gateway"

(Esta segunda parte la incluyo como muestra de posibilidades; en PgArachne todavía no la uso.)

Lo que no se puede automatizar, o solo con dificultad: la notarización de Apple, la aprobación en Flathub y el pull request a winget-pkgs, donde al final siempre hay una persona o un bot que verifica el paquete.

Conclusión

Mi recomendación, la que uso ahora:

El núcleo común es uno: la actualización es una función del producto, no un añadido. El usuario debería recibirla con la misma facilidad que la instalación, y tú deberías tenerla a partir de un único tag, sin clics manuales.