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:
- ¿Cómo se instala la aplicación?
- ¿Cómo se actualiza y quién lo lanza?
- ¿Se puede volver a una versión anterior?
- ¿Quién lo mantiene: yo, la comunidad o un revisor externo?
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:
- Un
.debo.rpmdescargado de GitHub no se actualiza. El usuario tendría que vigilar él mismo las versiones nuevas. - Para que se actualice necesitas un repositorio apt o dnf propio: clave de firma, alojamiento y mantenimiento de los metadatos. Para un solo autor es una carga desproporcionada.
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:
- Trae sus propias dependencias (git, curl, ruby), así que es más pesado que un simple binario. En un contenedor pequeño puede molestar.
- Si la fórmula no tiene un archivo precompilado, Homebrew compilaría desde el código fuente en el servidor. Por eso es necesario enlazar a binarios ya compilados.
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.
- Repositorio con el código fuente. En el servidor tiene que haber un compilador (en Go, el toolchain) y tras cada
git pullla aplicación debe compilarse de nuevo. La actualización no es solo una descarga, sino también una compilación que puede fallar en el servidor. - Repositorio solo con binarios ya compilados. Esto lo consideré como atajo. No hay que compilar nada, pero git no está hecho para eso: cada versión del binario queda para siempre en el historial, así que tras unos cuantos releases el clon crece hasta cientos de megabytes. Además se clonan todas las plataformas, no solo la tuya. Y nada verifica que el binario descargado sea el que publicaste (no hay sumas de comprobación).
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ía | Instalación | Actualización | Rollback | Quién lo mantiene |
|---|---|---|---|---|
| Descarga manual | descargar y descomprimir | a mano | manual | el usuario |
| Homebrew (macOS, Linux) | brew install | brew upgrade | brew install de una versión concreta (limitado) | yo (tap) |
| winget | winget install | winget upgrade | versión concreta | yo + revisor |
| Scoop | scoop install | scoop update | scoop reset | yo (bucket) |
| Flatpak | flatpak install | flatpak update | flatpak update --commit | yo + Flathub |
| Docker | docker pull | cambio de tag | cambio de tag | yo (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:
- macOS: Homebrew (cask para GUI, fórmula para CLI), con notarización.
- Windows: winget, o Scoop para CLI y aplicaciones portables.
- Linux: Flatpak para GUI, Homebrew para CLI.
- Servidor: Homebrew con
brew services, o Docker con el tag de la versión.
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.