Programación: empaquetar tus primeros programas

DEB, RPM, tarballs, paquetes universales,… en Linux hay gran cantidad de paquetes. Los binarios precompilados como DEB y RPM aportan comodidad al usuario, ya que simplemente los debe instalar en su sistema si necesidad de hacer uso de un compilador o de la herramienta make. En cambio, aunque los tarballs con código fuente pueden parecer algo más complicados para inexpertos y que tarda más la compilación del código (especialmente en hardware poco potente), aportan universalidad para adaptarse a cualquier distro.

Saber cómo empaquetar en los distintos formatos sería recomendable para poder llegar a la mayor cantidad de distribuciones y usuarios posibles. Aunque ahora los paquetes universales hayan conseguido aportar lo mejor de ambos mundos (código-genérico y binario-específico), aún sigue siendo necesario y recomendable conocer cómo empaquetar en ciertos casos.

Recuerda que puedes transformar entre diferentes tipos de paquetes con la herramienta alien, pero no es lo más óptimo…

Paquetes binarios

Son paquetes binarios, ya precompilados por el desarrollador, por tanto rápidos y fáciles de instalar. Es decir, más próximo a lo que tienes en Windows con los .exe, etc. Para instalarlos, solo necesitas usar un gestor de paquetes. Si usas una herramienta de bajo nivel, como rpm o dpkg, debes resolver tú mismo las dependencias. En cambio, si usas herramientas de alto nivel como zypper, yum, apt, etc., ella se encargará de resolverlas de forma automática o de descargarlo desde los repositorios de software.

Cómo empaquetar DEB

Como curiosidad te diré que los paquetes .deb se crearon para que se pudieran extraer desde cualquier sistema tipo Unix. Es decir, aunque son originarios de la comunidad Debian (de ahí su nombre), y es extraño verlos fuera del mundo Linux, pero se pueden usar en sistemas como Debian GNU/Hurd, Debian GNU/kFreeBSD, Nexenta OS, iOS, macOS, etc. Se pueden portar fácilmente.

Por lo general, tienen un formato de nombre característico:

nombreprograma_V.x.y-arquitectura.deb

Siendo nombreprograma el nombre del paquete, V.x.y la versión y arquitectura la familia de CPUs para las que han sido compilados (i386, AMD64, ia-64, mips, arm, mips, powerpc, sparc, etc.).

Si te preguntas qué contiene un .deb, la respuesta es sencilla: debian-binary, control.targ.gz y data.tar.gz. Puedes ver el contenido usando la herramienta ar:

ar t paquete.deb

Incluso puedes extraer el binario y la parte de control con:

dpkg-deb --extract paquete.deb /home/Isaac/prueba
dpkg-deb --control paquete.deb /home/Isaac/prueba

Para extraer data, puedes usar:

ar vx paquete.deb
tar xzvf data.tar.gz

Así si quieres los podrás analizar…Verás que el debian-binary contiene la versión DEB (2.0 para posteriores a 2011), data contiene los ejecutables y ficheros auxilares necesarios (también la estructura de directorios necesaria), y control la metainformación para las herramientas de gestión de paquetes. Todo esto lo explico de forma bastante detallada en mi curso de Linux, pero no quiero hacer este artículo eterno…

Bien, una vez que conoces el contenido y cómo se ha desempaquetado un DEB, ahora el proceso de empaquetado te resultará más sencillo de entender. Ciertamente hay varias formas de hacerlo, pero una clara y simple sería la siguiente:

  • Primero creas tu fichero de código fuente, como por ejemplo un hola.c como los de ejemplos de artículos anteriores.
  • Instala las herramientas necesarias, es decir:
sudo apt-get install built-essential
  • Compila tu código fuente para obtener el binario hola y prueba el binario para ver que funciona. Por ejemplo con: gcc -o hola hola.c
gcc -o hola hola.c
./hola
  • Crea la jerarquía de directorios que necesitas (hola/DEBIAN/control) y mueve el binario a bin. Para nuestro ejemplo:
mkdir hola
cd hola
mkdir DEBIAN
cd DEBIAN
touch control
mkdir -p hola/usr/bin/
cp /ruta/de/hola hola/usr/bin
  • Ahora vamos a construir el paquete como tal:
dpkg-deb --build hola
  • Ya está, ya tienes tu hola.deb creado. Si quieres hacerlo algo más riguroso, puedes modificarle el nombre a como he comentado anteriormente:
mv hola.deb hola_0.1.0-x86-64.deb

Ahora, para instalar tu paquete usando dpkg o cualquier otra herramienta como Gdebi, etc., e incluso crearte un servidor local para montar tu propio repositorio y así poder usar APT.

Cómo empaquetar RPM

Es un paquete que proviene del entorno de Red Hat, pero que ahora es usado por diferentes distribuciones como Fedora, CentOS, Mandriva, Yellow Dog, SUSE, openSUSE, etc., e incluso en otros sistemas operativos como Novell Netware lo usó e IBM AIX, Solaris, FreeBSD, etc.

Las diferencias con DEB son mínimas. Un paquete .rpm prácticamente hay el mismo contenido, solo que suele incluir un grupo de parches en vez de uno solo como en DEB. El formato de nombre NVR es:

nombreprograma-V.x.y-revision.arquitectura.rpm

En ocasiones, en el campo de la arquitectura aparece src (SRPM), es decir, indica que es un RPM que contiene código fuente y, por tanto, no depende de una arquitectura concreta.

Dentro del paquete encontrarás un lead que identifica al fichero como rpm, una firma usada para verificar la integridad y autenticidad, una cabecera con metadatos y un payload o fichero con el contenido del programa como tal. El contenido estará comprimida en un solo .cpio comprimido con gzip, xz, xar u otro algoritmo de compresión. Puedes analizarlo con:

rpm2cpio paquete.rpm | cpio -idmv

Nuevamente, en mi curso de Linux detallo todo el contenido, formato de cada fichero, etc. Pero ahora lo resumo para no alargarlo demasiado. Para crear un paquete RPM puedes seguir estos pasos sencillos:

  • Lo primero es tener tu código fuente, por ejemplo hola.c y en este caso no lo compiles.
  • Luego instala las herramientas:
yum install rpm-build rpmdevtools
  • Ahora debes crear la siguiente estructura de directorios:
rpmbuild
  |-- BUILD
  |-- BUILDROOT
  |-- RPMS
  |-- SOURCES
  |-- SPECS
  |-- SRPMS

#Otra alternativa es usar una herramienta automática como
rpmdev-setuptree
  • Es probable que quieras crear un README y un configure también. El configure si es un script lo que estás empaquetando no es del todo necesario, pero debes crearlo aunque lo dejes vacío para que no salte algún error…
nano README.txt
touch configure
chmod 0744 configure
cp README.txt hola.c configure /rpmbuild/
  • Escribe el .Spec file, un fichero con la información necesaria para el RPM que debes introducir dentro de SPECS. Un ejemplo básico de su contenido sería (para más información):
Name: hola
Version: 0.1.0
Release: 1%{?dist}
Summary: Un programa hola mundo de prueba

License: ninguna
URL: http://tuweb.es
Source0: http://tuweb.es/hola/%{name}-%{version}.tar.gz

BuildRequires: 
BuildRequires: 

%description
Programa hola mundo de prueba. Escrito en C para hacer una prueba con los paquetes RPM.

%prep
%setup -q -n

%build
%configure
make %{?_smp_mflags}

%check
make check

%install
rm -rf $RPM_BUILD_ROOT
make install DESTDIR=$RPM_BUILD_ROOT

install -m 755 -d $RPM_BUILD_ROOT/%{_sbindir}
ln -s ../bin/eject $RPM_BUILD_ROOT/%{_sbindir}

%find_lang %{name}

%files -f %{name}.lang
%doc README TODO COPYING ChangeLog
%{_bindir}/*
%{_sbindir}/*
%{_mandir}/man1/*

%changelog
* Wed Aug 02 19 Isaac  <tu@email.com> 0.1.0 Beta
- Corrección de bug
  • Después de haber escrito el Spec, que es lo más complicado si no conoces el formato adecuadamente, el proceso puede ser dificente según el caso. Deberías usar el comando rpmlint sobre tu fichero Spec para que detecte si hay errores sintácticos. Luego, introduce tu código fuente en OURCES.
  • Para crear el paquete, puedes usar, por ejemplo:
rpmbuild -ba --sign --clean hola-0.1.0.src.spec
  • Si quieres crear el binario a partir del .rpm fuente anterior, puedes hacer esto:
rpmbuild --rebuild  hola-0.1.0.src.rpm

Ahora ya podrías instalarlo, etc. Recuerda que se encontrará en RPMS/arch/*.rpm

Paquetes fuente

Son tarballs, es decir, paquetes que han sido empaquetados con la herramienta tar y a los que se les ha dado algún tipo de compresión (tar.gz, tar.bz2, tar.xz, etc.). La ventaja es que puedes compilarlos desde cualquier distribución y desde las fuentes originales, no dependen de un gestor de paquetes concreto o de una jerarquía de directorios particular. Lo malo es que los tienes que compilar tú, y si no tienes un hardware decente, puede tardar.

Cómo empaquetar un tarball

Para crear un tarball es cuestión de introducir tu código fuente tal cual y los directorios, con los ficheros auxiliares que se necesiten en un directorio. Luego lo puedes empaquetar y comprimir con tar. Simplemente así, de esa forma, conservarán los permisos cuando los desempaqueten…

Para más información (véase Make / makefile)

Paquetes universales

Los paquetes universales han venido para unificar las instalaciones en Linux. La fragmentación de las distribuciones es elevada, y hay varios tipos de paquetes como ya sabes. Eso dificulta mucho el trabajo de los desarrolladores, que deben empaquetar en varios formatos cuando en Windows o macOS solo necesitan hacerlo de una forma. Para resolver todo eso y aportar algunas cualidades extra, puedes empaquetar en estos formatos…

Cómo empaquetar en Snap

Diseñado por Canonical, este paquete universal para Snappy, no solo viene a resolver los problemas de fragmentación, también resuelven algunos problemas de seguridad, etc. Pero actualmente parece que, a pesar de ser universal, es algo de Ubuntu…

Para crear el Snap, puedes seguir estos pasos. Por ejemplo, imagina que quieres crear un snap a partir de un paquete fuente remoto:

  • Por supuesto necesitas tener las herramientas necesarias instaladas en tu distro…
  • Crea la estructura de directorios necesaria. Por ejemplo, un directorio con el nombre hola.
  • Entra y ejecuta el siguiente comando para crear el fichero snapcraft.yaml
  • Ahora, debes editar dicho fichero con lo que necesitas. Por ejemplo:
name: hola
version: "0.1.0"
summary: Prueba con Hola mundo
description: Programa que muestra un hola mundo
grade: stable
confinement: strict

apps:
  hola:
    command: hola

parts:
  hola:
    plugin: autotools
    source: http://mipaginaweb.es/descargas/hola/hola-0.1.0.tar.gz
  • Ahora, para construir tu snap, solo ejecuta la siguiente orden desde el mismo directorio donde está el yaml:
snapcraft

Ahora tendrás el hola-0.1.0_amd64.snap que podrás instalar con snap install nombre.snap… y ejecutarlo invocando hola en el terminal.

Cómo empaquetar en Flatpak

Otro paquete universal que ha llegado al escritorio de Linux que se presente como el paquete del futuro. Tiene algunas similitudes con Snap, aprotando también aislamiento de procesos, fácil gestión, etc. Al no tener una empresa como Canonical detrás, aún no hay gran cantidad de programas empaquetados así…

Para construir un Flatpak, los pasos genéricos serían:

  • Instala las herramientas y luego el SDK necesario:
flatpak install flathub org.freedesktop.Platform//18.08 org.freedesktop.Sdk//18.08
  • Crea tu código fuente, por ejemplo tu hola binario o tu script.sh o lo que quieras empaquetar. Compilalo y llamalo hola.
  • Ahora crea un manifiesto y guardalo junto a tu código fuente. El fichero de manifiesto debe tener el nombre org.flatpak.hola.json y su contenido:
{
    "app-id": "org.flatpak.Hola",
    "runtime": "org.freedesktop.Platform",
    "runtime-version": "18.08",
    "sdk": "org.freedesktop.Sdk",
    "command": "hola",
    "modules": [
        {
            "name": "hola",
            "buildsystem": "simple",
            "build-commands": [
                "install -D hello.sh /app/bin/hola"
            ],
            "sources": [
                {
                    "type": "file",
                    "path": "hola"
                }
            ]
        }
    ]
}
  • Ahora construye tu flatpak:
flatpak-builder build-dir org.flatpak.Hola.json

Listo, ahora puedes instalarlo, ponerlo en un repositorio, etc.

Cómo empaquetar en AppImage

AppImage es un formato portable y universal para Linux, aportando independencia de la distribución con la que trabajes. A diferencia de otros paquetes, en este no se hace una instalación del programa como tal, sino que simplemente lo situa en el lugar correcto para que se pueda ejecutar. Desgraciadamente, igual que ocurre con otros formatos, aún hay muy pocas paquetes de este tipo…

Quizás la forma más sencilla de crearlo sea mediante electron-builder:, además, con ella no solo podrás crear un AppImage, sino otros paquetes de una vez de una forma automática. Los pasos son bastante sencillos, puedes ver un ejemplo aquí.

Más información – AppImage / Otras formas de crearlo

Aunque hay más tipos de paquetes para Linux, como .run, .bin, Ebuild, etc., para diferentes distros y gestores de paquetes, éstos que te he mostrado son los más comunes…

Isaac

Apasionado de la computación y la tecnología en general. Siempre intentando desaprender para apreHender.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

A %d blogueros les gusta esto:

Si continuas utilizando este sitio aceptas el uso de cookies. más información

Los ajustes de cookies de esta web están configurados para "permitir cookies" y así ofrecerte la mejor experiencia de navegación posible. Si sigues utilizando esta web sin cambiar tus ajustes de cookies o haces clic en "Aceptar" estarás dando tu consentimiento a esto.

Cerrar