Empaquetar tu aplicación para Debian y derivadas: primer .deb paso a paso

1. Contexto rápido: dpkg vs apt

Como se detalla en el objetivo 102.4 de LPIC-1, el ecosistema Debian se apoya en dos piezas clave:

• dpkg: la herramienta esencial de bajo nivel (essential utility) que instala, configura, lista y elimina paquetes .deb.
• APT (Advanced Package Tool): el sistema de gestión de paquetes de alto nivel (package management system) que resuelve dependencias automáticamente y trabaja con repositorios remotos, usando dpkg por debajo.

En la práctica:

• dpkg -i algo.deb instala un paquete local. Si faltan dependencias, la instalación falla y dpkg las lista.
• apt-get install algo descarga el paquete desde los repositorios configurados, resuelve dependencias y luego delega la instalación a dpkg.

Nuestro primer .deb será consumido inicialmente con dpkg -i. Más adelante, veremos cómo publicarlo en un repositorio para que apt pueda gestionarlo como cualquier otro paquete.

2. La aplicación de ejemplo

Partiremos de una aplicación CLI mínima:

• Nombre: hola-deb
• Resultado del build: un ejecutable hola-deb

Objetivos para nuestro paquete:

• Instalar hola-deb en /usr/local/bin/hola-deb.
• Registrar el paquete como hola-deb versión 1.0.0.
• Declarar una dependencia (por ejemplo, bash) para ver cómo funciona el campo Depends.

3. Anatomía mínima de un .deb

Un paquete .deb es, internamente, un archivo ar que contiene al menos estos componentes:

• debian-binary: archivo de texto con la versión del formato (por ejemplo, 2.0).
• control.tar.{gz,xz}: metadatos del paquete (archivo control y scripts de mantenimiento).
• data.tar.{gz,xz}: los archivos que se instalarán en el sistema de archivos.

No vamos a manipular estos archivos manualmente. En su lugar, usaremos dpkg-deb para construir el paquete a partir de:

• Un árbol de directorios que replica el sistema de archivos objetivo (por ejemplo, usr/local/bin, usr/share/doc, etc.).
• Un directorio DEBIAN/ con el archivo control y scripts opcionales (como postinst, prerm, etc.).

4. Preparar el entorno de construcción

En una Debian o Ubuntu típica, instalá las herramientas básicas de empaquetado. Como usuario con permisos administrativos:

sudo apt-get update
sudo apt-get install dpkg-dev debhelper lintian

Estas herramientas proporcionan dpkg-deb, utilidades auxiliares y lintian, que te ayudará a validar la calidad del paquete.

5. Montar el árbol de instalación

Comenzamos creando un directorio de trabajo y la estructura de instalación:

mkdir -p ~/paquetes/hola-deb
cd ~/paquetes/hola-deb

mkdir -p paquete/usr/local/bin
mkdir -p paquete/usr/share/doc/hola-deb
mkdir -p paquete/DEBIAN

Luego copiamos el ejecutable y añadimos la documentación básica:

cp /ruta/a/tu/build/hola-deb paquete/usr/local/bin/
chmod 755 paquete/usr/local/bin/hola-deb

cat > paquete/usr/share/doc/hola-deb/README << 'EOF'
hola-deb: ejemplo de paquete Debian minimalista.
EOF

gzip -9 paquete/usr/share/doc/hola-deb/README

Todo lo que coloques dentro de paquete/ se instalará respetando esa misma estructura a partir de la raíz del sistema (/).

6. El corazón del paquete: DEBIAN/control

El archivo DEBIAN/control define los metadatos del paquete. Creémoslo con un contenido mínimo pero correcto:

Package: hola-deb
Version: 1.0.0
Section: utils
Priority: optional
Architecture: amd64
Depends: bash (>= 5.0)
Maintainer: Tu Nombre <tu@correo>
Description: Ejemplo minimalista de paquete Debian
 Empaqueta un binario hola-deb en /usr/local/bin para ilustrar
 el proceso de construcción de un .deb desde cero.

Campos clave que conviene entender bien:

• Package: nombre del paquete, en minúsculas y sin espacios.
• Version: versión del paquete; idealmente, seguí versionado semántico (MAJOR.MINOR.PATCH).
• Section: categoría del paquete (por ejemplo, utils, net, devel).
• Priority: importancia relativa (required, important, optional, etc.). Para software propio, optional suele ser suficiente.
• Architecture: arquitectura objetivo (amd64, arm64 o all para paquetes independiente de arquitectura, como scripts).
• Depends: lista de dependencias que deben estar instaladas para que el paquete funcione. Durante la instalación, dpkg verificará estas dependencias y fallará si no se cumplen.
• Description: primera línea breve; las siguientes deben ir indentadas con un espacio y amplían la descripción.

7. Construir el .deb con dpkg-deb

Con la estructura lista, podemos construir el paquete:

dpkg-deb --build paquete
mv paquete.deb hola-deb_1.0.0_amd64.deb

Antes de instalarlo, es buena práctica inspeccionar su contenido con las utilidades que LPIC-1 exige conocer:

dpkg-deb -I hola-deb_1.0.0_amd64.deb  # Metadatos (control)
dpkg-deb -c hola-deb_1.0.0_amd64.deb  # Lista de archivos contenidos

8. Probar el paquete: instalar, listar y eliminar

8.1 Instalación con dpkg -i

Instalamos el paquete directamente:

sudo dpkg -i hola-deb_1.0.0_amd64.deb

Si faltan dependencias, dpkg fallará y mostrará cuáles son. Podés resolverlas con:

sudo apt-get -f install

El parámetro -f (fix-broken) hará que APT instale las dependencias faltantes y complete la configuración de los paquetes pendientes.

8.2 Verificar la instalación

Para listar todos los archivos instalados por el paquete (comando clave para auditoría según LPIC-1), usá:

dpkg -L hola-deb

Para ver la información del paquete ya instalado (estado, versión, descripción, etc.), dpkg -s:

dpkg -s hola-deb

8.3 Desinstalación y purga

El material de LPIC-1 enfatiza la diferencia entre eliminar y purgar un paquete. En Debian:

• dpkg -r (remove): elimina los archivos del paquete, pero deja los ficheros de configuración.
• dpkg -P (purge): elimina también los archivos de configuración.

Aplicado a nuestro ejemplo:

sudo dpkg -r hola-deb    # Elimina el paquete, deja configuración (si la hubiera)
sudo dpkg -P hola-deb    # Purga todo rastro del paquete

9. Añadir scripts de mantenimiento (opcional)

Los scripts de mantenimiento en DEBIAN/ se ejecutan en diferentes fases del ciclo de vida del paquete:

• preinst: antes de desempaquetar/instalar.
• postinst: después de la instalación y configuración.
• prerm: antes de la desinstalación.
• postrm: después de la desinstalación o purga.

Ejemplo sencillo de postinst para nuestro paquete:

cat > paquete/DEBIAN/postinst << 'EOF'
#!/bin/sh
set -e

echo "Gracias por instalar hola-deb."
echo "Ejecuta 'hola-deb' para saludar al sistema."

exit 0
EOF

chmod 755 paquete/DEBIAN/postinst

Volvé a construir el paquete e instalalo de nuevo para ver el mensaje durante la fase de configuración. En proyectos reales, estos scripts se usan para tareas como regenerar cachés, crear usuarios de sistema o migrar archivos de configuración entre versiones.

10. Opcional: servir el paquete vía APT

Instalar con dpkg -i sirve para pruebas o despliegues puntuales, pero en entornos más grandes es mucho más cómodo exponer el paquete en un repositorio APT (aunque sea local).

Crea un directorio para el repositorio e incorpora el paquete:

sudo mkdir -p /srv/debian-repo/pool/main/h/hola-deb
sudo cp hola-deb_1.0.0_amd64.deb /srv/debian-repo/pool/main/h/hola-deb/

Genera el índice de paquetes:

cd /srv/debian-repo
sudo mkdir -p dists/stable/main/binary-amd64
dpkg-scanpackages pool /dev/null | gzip -9c > dists/stable/main/binary-amd64/Packages.gz

Añadí el repositorio a /etc/apt/sources.list:

deb [trusted=yes] file:/srv/debian-repo stable main

Actualizá el índice e instalá el paquete como harías con cualquier otro:

sudo apt-get update
sudo apt-get install hola-deb

A partir de aquí, APT se encargará de resolver dependencias, actualizar y eliminar tu paquete igual que los provenientes de repositorios oficiales.

11. Buenas prácticas para ir más allá

• Adoptar la infraestructura Debian completa
  Crear un directorio debian/ con dh_make y construir con dpkg-buildpackage o debuild. Esto aporta:
  • Declaración clara de dependencias de compilación.
  • Changelogs en formato Debian.
  • Integración con herramientas como pbuilder o sbuild para builds reproducibles.
• Integrar con CI/CD
  Automatizá la construcción de paquetes en cada tag de tu repositorio (GitHub Actions, GitLab CI, etc.) y publicá los artefactos en un repositorio APT interno.
• Usar lintian
  Ejecutá:

  lintian hola-deb_1.0.0_amd64.deb
  

  para detectar errores, advertencias y mejoras recomendadas según las políticas Debian.
• Multi-arquitectura
  Usá Architecture: all para paquetes de solo scripts y generá paquetes específicos por arquitectura (amd64, arm64, etc.) cuando distribuyas binarios.

12. Conclusión

Empaquetar tu aplicación para Debian no es solo generar un .deb que “más o menos instala”. Es hablar el idioma nativo de dpkg y apt: dependencias correctamente declaradas, una estructura coherente en el sistema de archivos y scripts de mantenimiento que respetan el ciclo de vida del paquete.

Con el flujo que vimos:

1. Crear el árbol de instalación.
2. Escribir el archivo DEBIAN/control.
3. Construir con dpkg-deb --build.
4. Instalar y probar con dpkg -i, dpkg -L, dpkg -s, dpkg -r y dpkg -P.
5. Opcionalmente, añadir scripts y publicar en un repositorio APT.

Ya tenés un .deb completamente funcional y alineado con los conceptos de gestión de paquetes que se evalúan en la certificación LPIC-1. El siguiente paso natural es migrar al flujo “oficial” con debian/ y dpkg-buildpackage, para tratar tus paquetes como ciudadanos de primera clase en cualquier Debian o derivada. https://wiki.debian.org/es/Packaging