Cómo instalar dos versiones del mismo paquete en Linux sin conflictos

En el día a día con GNU/Linux es habitual que surja una necesidad muy concreta: ejecutar dos versiones del mismo software a la vez. Por ejemplo, un programa A que depende de una biblioteca o herramienta en su versión 1 y un programa B que exige la versión 2. A priori suena sencillo, pero cuando entran en juego los gestores de paquetes y el sistema de ficheros, aparecen los roces.

La buena noticia es que, con las herramientas adecuadas, sí es posible hacer convivir versiones distintas de binarios, bibliotecas y aplicaciones, ya sea en un mismo sistema, en contenedores o incluso usando formatos de paquetes modernos. En esta guía verás por qué no siempre es trivial y, sobre todo, cómo lograrlo de manera ordenada y segura en Debian, Ubuntu y derivadas.

Por qué no es tan trivial instalar dos versiones del mismo paquete

El primer obstáculo es la gestión de rutas: en los sistemas basados en Debian, cada paquete instala archivos en ubicaciones estandarizadas como /usr/bin, /usr/lib o /usr/include. Si dos paquetes intentan colocar el mismo archivo en la misma ruta, el gestor de paquetes bloqueará la instalación por conflicto.

El segundo punto es la compatibilidad binaria. Las bibliotecas nativas emplean un mecanismo de versionado llamado SONAME, que permite tener al mismo tiempo libX.so.1 y libX.so.2, pero no dos libX.so.1 con el mismo nombre de archivo. Por eso verás que muchas librerías empaquetan versiones mayores en paquetes distintos, como libssl1.1 o libssl3, que pueden coexistir sin tocarse.

Otro factor clave es el empaquetado de cabeceras y enlaces de desarrollo. Los paquetes -dev (por ejemplo, libssl-dev) instalan rutas canónicas en /usr/include y enlaces .so sin versionar para compilar. Normalmente estos -dev no son coinstalables en paralelo, porque pisan los mismos ficheros. Aquí entra en juego el mecanismo de update-alternatives o, si hace falta, compilar con prefijos separados como /opt.

Por último, recuerda que Debian y Ubuntu garantizan que cada ruta del sistema está “gestionada” por un único paquete. Ese contrato de propiedad de ficheros es lo que permite actualizar, desinstalar y auditar sin caos, pero implica que tener dos binarios idénticos en el mismo camino no está permitido salvo que el empaquetado lo contemple.

Métodos prácticos para convivir versiones sin romper el sistema

Alternativas en Debian/Ubuntu para seleccionar binarios

Muchas herramientas exponen varias versiones coinstalables (por ejemplo gcc-4.4 y gcc-8.2) y se selecciona la activa mediante update-alternatives. Este sistema crea enlaces gestionados en /etc/alternatives que apuntan al ejecutable deseado.

Un flujo típico para compilar con dos GCC distintos podría ser: instalar ambas versiones específicas y registrar las alternativas para elegir en cada momento la que te interesa.

sudo apt-get install gcc-4.4 gcc-8.2
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8.2 10
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.4 20
sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc 30
sudo update-alternatives --set cc /usr/bin/gcc
sudo update-alternatives --config gcc

Con ese último comando podrás alternar interactivamente la versión por defecto de gcc. Comprueba en cada caso con gcc –version cuál está activa en el PATH del sistema.

Paquetes coinstalables y nombres versionados

Otra vía es apoyarte en el propio empaquetado. En Debian/Ubuntu es común que las bibliotecas y, a veces, aplicaciones ofrezcan paquetes con nombre que incluye la versión mayor para permitir su coexistencia: libfoo1, libfoo2, libssl1.1, libssl3, etc. Este enfoque es ideal cuando necesitas que dos aplicaciones enlacen con mayorías distintas sin que haya cruces.

Ten presente que los paquetes -dev, al instalar cabeceras y enlaces genéricos, suelen conflict con otras versiones -dev. Si necesitas compilar contra dos mayorías, valora contenedores, chroots o instalar una de las ramas en rutas personalizadas bajo /opt para evitar colisiones.

Instalaciones paralelas con Snap

Snap facilita la vida en estos escenarios gracias a que cada paquete va aislado con sus dependencias. Desde snapd 2.36 existe el soporte para múltiples instancias de un mismo snap, con configuración, servicios e interfaces separadas entre sí.

Para activarlo en sistemas donde aún figura como experimental, habilita la opción y luego instalar instancias con nombres distintos del mismo snap. Verás que puedes tener varias copias de la misma versión o incluso de versiones diferentes si juegas con canales.

sudo snap set system experimental.parallel-instances=true
sudo snap install odio_first odio_second

El resultado reflejará instalaciones separadas, algo así como: odio_second 1 from Canonical✓ installed y odio_first 1 from Canonical✓ installed. Lo mismo se aplica a herramientas como GIMP o VLC, lo que abre opciones para pruebas, regresiones o entornos controlados.

Contenedores con adapt, LXC y LXD

Cuando lo que necesitas es ejecutar en tu Ubuntu paquetes procedentes de otra versión de la distribución, puedes recurrir a adapt, una utilidad que descarga y configura un contenedor con la release objetivo y ejecuta dentro las aplicaciones que necesites. Así puedes usar software de Ubuntu 15.10 en Ubuntu 14.04, por ejemplo, sin manchar tu sistema base.

La idea clave de los contenedores es encerrar procesos en un espacio aislado de archivos, red y recursos, mucho más ligero que una máquina virtual completa. En Ubuntu, LXC y LXD son los pilares para este tipo de aislamiento; si te interesa profundizar, tienes buena documentación en LXC, LXD y la wiki de Gentoo.

Lenguajes y runtimes con gestión nativa de versiones

En el mundo de los lenguajes es bastante habitual convivir con varias versiones. Para Python, lo más práctico es usar entornos virtuales (venv) y, si necesitas la propia versión del intérprete, herramientas como pyenv. En Java, el sistema de alternativas te permite conmutar entre distintas JDK/JRE. Y en PHP puedes instalar php7.x y php8.x en paralelo y elegir para el servicio o la línea de comandos con alternativas o configuración del servidor web.

Compiladores como gcc y g++ también suelen publicarse con versiones coinstalables, y ya has visto que update-alternatives es el puente perfecto para cambiarlas sin tocar nada más. La clave en todos estos casos es que cada versión tenga su propio nombre de binario o viva en rutas distintas.

Replicar un equipo con exactamente las mismas versiones

Otra duda recurrente es cómo clonar el estado de un sistema en otro y conservar las mismas versiones, no solo la lista de paquetes. El método clásico con dpkg es útil, pero por sí solo recupera los paquetes y no siempre respeta versiones exactas si el repositorio ya ha avanzado.

Para volcar la lista de paquetes de un host de referencia puedes usar: dpkg –get-selections

dpkg --get-selections > /tmp/dpkglist.txt

Y en la máquina nueva, aplicar esa selección antes de resolver dependencias con apt:

sudo dpkg --set-selections < /tmp/dpkglist.txt
sudo apt-get dselect-upgrade

Si necesitas clonar tal cual, considera completar con técnicas como pinning de versiones y snapshots de repositorios. En Debian existe snapshot.debian.org y en Ubuntu hay mirrors con instantáneas; apuntando sources.list a una fecha concreta evitas que se instalen ediciones distintas a las del origen.

Además, puedes fijar versiones puntuales y bloquearlas con apt-mark, para impedir upgrades no deseados hasta completar el clonado del entorno.

sudo apt-get install paquete=1.2.3-1ubuntu1
sudo apt-mark hold paquete
apt-cache policy paquete

Herramientas como apt-clone también ayudan a exportar e importar estados incluyendo repositorios, lo que sube el nivel de fidelidad. Sea cual sea el camino, la idea es combinar la lista de paquetes, las versiones exactas y las fuentes congeladas para que el destino quede calcado al origen.

Si reinstalas a menudo, automatiza con un pequeño script que compruebe si existe la carpeta en /datos, copie si es necesario y cree el enlace simbólico. De esta forma, pasar de una distro a otra será transparente, ganando tiempo y coherencia.

Varios Linux en un mismo PC sin perder tu contenido

Si desarrollas o pruebas en distintas releases, quizá prefieras tener varias instalaciones en tu máquina. Para evitar duplicar archivos y líos, una práctica muy efectiva es centralizar documentos en una partición común y enlazarlos desde cada sistema con enlaces simbólicos.

La propuesta es simple: crea una partición como /datos, y en ella tus carpetas Escritorio, Documentos, Descargas. Luego, en cada sistema, elimina las carpetas del home y crea un enlace hacia /datos. Así, ~/.config, ~/Escritorio o ~/Documentos apuntan a la misma ubicación compartida.

mkdir -p /datos/Escritorio /datos/Documentos /datos/Descargas
rm -rf ~/Escritorio ~/Documentos ~/Descargas
ln -s /datos/Escritorio ~/Escritorio
ln -s /datos/Documentos ~/Documentos
ln -s /datos/Descargas ~/Descargas

Con la configuración conviene ser selectivo. Los archivos de preferencias del escritorio cambian de una versión a otra y podrían causar problemas. Sin embargo, para apps estables como GIMP o Inkscape, puedes enlazar sus carpetas de configuración y mantener la misma experiencia en todas tus instalaciones.

mkdir -p /datos/.config/GIMP
rm -rf ~/.config/GIMP
ln -s /datos/.config/GIMP ~/.config/GIMP

Si reinstalas a menudo, automatiza con un pequeño script que compruebe si existe la carpeta en /datos, copie si es necesario y cree el enlace simbólico. De esta forma, pasar de una distro a otra será transparente, ganando tiempo y coherencia.

Recordatorio útil de APT, dpkg y compañía para gestionar versiones

En Debian y derivadas, APT es la herramienta moderna que engloba funciones de apt-get y apt-cache, mientras que dpkg instala paquetes .deb manualmente. Conocer los básicos te ayuda a encontrar y fijar versiones con precisión.

Actualiza el índice de paquetes antes de nada. Si trabajas en contenedores o imágenes mínimas, este paso suele faltar y por eso no aparece nada al buscar o instalar.

sudo apt update

Para localizar paquetes, usa la apt search de texto completo. Te permitirá descubrir nombres exactos y alternativas relacionadas sin tener que abrir el navegador.

apt search nombre

Si quieres ver detalles finos (versión disponible, origen, dependencias, tamaño), consulta la ficha con apt show, que es muy práctica cuando te preocupa el número de versión concreto a instalar.

apt show paquete

Listar lo que hay instalado y lo que es actualizable también te servirá para auditar estados, depurar conflictos o confirmar que el pinning ha surtido efecto en un sistema.

apt list --installed
apt list --upgradable

Instalar paquetes es tan simple como apt install paquete, y puedes encadenar varios nombres en la misma línea. Si no quieres confirmaciones interactivas durante scripts, añade -y al comando para aceptar por defecto.

sudo apt install paquete1 paquete2 -y

Desinstalar sin borrar configuración se hace con apt remove, y si necesitas limpiar también los ficheros de ajuste locales, usa apt purge. Tras grandes cambios, libera dependencias huérfanas con autoremove.

sudo apt remove paquete
sudo apt purge paquete
sudo apt autoremove

Para mantener el sistema al día, tienes dos vías: apt upgrade para actualizar paquetes ya instalados y apt full-upgrade para permitir además la eliminación o sustitución de paquetes cuando sea imprescindible.

sudo apt upgrade
sudo apt full-upgrade

Editar los orígenes de paquetes determina qué versiones ve tu sistema. El comando apt edit-sources ayuda a abrir el listado y ajustar repositorios y mirrors, vital cuando trabajas con snapshots o canales específicos.

sudo apt edit-sources

Si necesitas instalar manualmente un .deb concreto que no está en los repos o quieres forzar una versión, dpkg es el gestor de bajo nivel que hace el trabajo directamente sobre el archivo.

sudo dpkg -i paquete.deb

En cuanto a equivalencias, apt simplifica acciones clásicas de apt-get y apt-cache. A modo de referencia rápida: apt update equivale a apt-get update; apt install a apt-get install; apt search a apt-cache search; apt list –installed a dpkg -l; apt full-upgrade a apt-get dist-upgrade.

Y sí, APT tiene sentido del humor. Si tecleas apt moo verás un pequeño huevo de pascua que recuerda los viejos tiempos. No sirve para gestionar versiones, pero alegra la terminal de vez en cuando.

Cuando juntamos todo lo anterior, se dibuja un mapa claro: los conflictos al instalar dos versiones se deben al control estricto de rutas y dependencias, pero hay vías maduras para sortearlos. Alternatives permite conmutar binarios coinstalables, los nombres versionados y las librerías con SONAME facilitan la convivencia, Snap aporta instancias paralelas y aislamiento, y los contenedores con LXC/LXD o herramientas como adapt resuelven la ejecución de paquetes de otras releases. Para clonar entornos al detalle, pinning, snapshots y utilidades como apt-clone ponen la guinda, mientras que en escenarios multiboot los enlaces simbólicos mantienen tus datos y preferencias a salvo. Con un poco de método, tener dos versiones del mismo paquete en Linux deja de ser un dolor de cabeza y pasa a ser parte de tu caja de herramientas.