Guía de empaquetamiento/Completa

Uno o más colaboradores están trabajando actualmente en extender esta página. Es posible que, a causa de ello, haya lagunas de contenido, deficiencias de formato o texto en otros idiomas. Por favor, antes de realizar correcciones mayores o reescrituras, contacta con ellos en su página de usuario o en la página de discusión del artículo para poder coordinar la redacción.

Contenido 1 Introducción 1.1 Por dónde empezar 1.2 Requisitos 2 Empezando 2.1 Paquetes binarios y paquetes fuente 2.2 Herramientas de empaquetado 2.3 Empaquetador personal: pbuilder 3 Empaquetado básico 3.1 Empaquetando desde el código fuente 4 Fuentes

Introducción

¡Bienvenido a la Guía de Empaquetamiento para Ubuntu! Esta guía pretende ser un de las principales referencias para aquellos que deseen construir y mantener paquetes Deb para Ubuntu. Asimismo muchos de los conceptos de esta guía podrían ser usados para hacer paquetes binarios para uso personal, está diseñada para aquellos que quieran distribuir sus paquetes. Aunque está orientada a la distribución GNU/Linux Ubuntu, debería ser al menos útil para cualquier distribución basada en Debian.

Hay varias razones por las que querrías aprender a empaquetar para Ubuntu. La primera, crear y arreglar paquetes *buntu es una gran forma de contribuir a la comunidad Ubuntu. También un buen camino para aprender cómo funciona Ubuntu y las aplicaciones que tienes instaladas. Quiźas quieras instalar un programa que no esté en los repositorios de Ubuntu. Ojalá después de que completes está guía tengas los suficientes conocimientos y herramientas para realizar todas estas cosas.

Por dónde empezar

Si eres completamente nuevo en la creación de paquetes deb entonces deberías leerte esta guía de principio a fin, prestando especial atención a las secciones Requisitos y Empaquetado básico. Gente con cierta experiencia en el tema encontrará cosas más útiles en la secciones Empaquetado y Errores comunes.

Requisitos

Esta guía asume que el lector tiene un conocimiento razonable a cerca de la construcción y la instalación de software desde su código fuente en distribuciones GNU/Linux. Además usaremos la Interfaz de Línea de Comandos (CLI en inglés) así que deberías defenderte bastante bien usando una terminal. Deberías ser capaz de usar al menos las siguientes herramientas:

• make: GNU Make es una herramienta de construcción de software muy importante. Se usa para transformar una tarea de compilación compleja en algo trivial. Es muy importante que sepas usarlo, ya que desviaremos mucha de la información del proceso de empaquetamiento en un Makefile. La documentación está disponible en la web de GNU.

• ./configure: Este script se incluye en casi todos los códigos fuente de programas para GNU/Linux, especialmente en programas escritos en lenguajes de programación compilados tales como C y C++. Se usa para generar un Makefile (archivo usado por make) adaptado a su sistema. Las herramientas estándar de empaquetamiento de Debian lo usan, así que es importante que sepas qué hace el script configure. Información sobre ./configure puede consultarse en la documentación del make.

• apt/dpkg: Más allá del uso básico de instalar programas, apt y dpkg tienen muchas características que los hacen muy útiles para empaquetar.

• apt-cache dump - lista cada paquete en el cache. Este comando es especialmente util en combinación con grep. Un ejemplo apt-cache dump |grep foo buscará aquelos paqetes cuyos nombres o dependencias incluyan la palabra foo.

• apt-cache policy - lista el repositorio (main/restricted/universe/multiverse) en cual existe el paquete.

• apt-cache show - mostrar información acerca de un paquete binario

• apt-cache showsrc - mostrar información acerca de un código fuente

• apt-cache rdepends - muestra las dependencias invertidas para un paquete

• dpkg -S - lista el/los paquete/s binario/s al cual/es pertenece un archivo en particular

• dpkg -l - lista los paquetes que tengas instalados en el sistema

• dpkg -c -lista el contenido de un paquete binario. Es util para asegurarse de que los archivos se instalan en los lugares correctos.

• dpkg -f muestra el archivo control de un paquete binario. Es útil para asegurarse de que las dependencias son correctas.

• grep-dctrl - busca información especializada en los paquetes. Es un uso específico de la herramienta grep (pero no instalado por defecto)

• diff y patch:

• El programa diff se puede usar para comparar 2 archivos y de este modo crear parches. Un ejemplo típico podría ser:

diff -ruN archivo.antiguo archivo.nuevo > archivo.diff

Este comando creará un archivo .diff que mostrará los cambios entre 2 archivos.

• El programa patch es usado para aplicar un parche (normalmente creado por diff o otro programa similar). Para aplicar el parche utiliza el comando:

patch -p0 < archivo.diff

El parámetro -p le dice a patch cómo debe formatear los nombres de archivo en el parche. La opción -p0 significa que deja el parche intacto.

Empezando

Paquetes binarios y paquetes fuente

La mayoría de los usuarios de una distribución basada en Debian como Ubuntu nunca van a tener que tratar con el código fuente que se usa para crear todos los programas que usen en sus ordenadores. En vez de eso, el código fuente se compila en paquetes binarios a partir de un paquete fuente que contiene ambos: el código fuente en sí mismo y las instrucciones para crear el paquete binario. Los mantenedores de paquetes suben el código fuente con los cambios a sistemas de empaquetado que compilan los paquetes binarios para cada arquitectura. Un sistema independiente distribuye los archivos binarios .deb generados y el código fuente con las instrucciones a cada repositorios espejo.

Herramientas de empaquetado

Hay muchas herramientas escritas específicamente para empaquetar en sistemas basados en Debian. Muchas de ellas no fueron creadas con la intención de empaquetar programas pero son realmente útiles y suelen automatizar tareas repetitivas. Sus páginas man e info son buenas fuentes de información. Sin embargo, la lista de paquetes son extremadamente necesarios para comenzar a empaquetar.

• build-essential es un metapaquete que depende de libc6-dev, gcc, g++, make y dpkg-dev. Uno de los paquetes con los que podrías no estar familiarizado es dpkg-dev. Este contiene herramientas de la talla de dpkg-buildpackage y dpkg-source que se usan para crear, desempaquetar y construir paquetes binarios o fuentes.

• devscripts contiene muchos scripts que facilitan considerablemente la tareas de un mantenedor de paquetes. Algunos de los más usados son debdiff, dch, debuild y debsing.

• ubuntu-dev-tools también contiene una colección de scripts (al igual que devscripts), pero específicos para Ubuntu. Contiene herramientas como update-maintainer, dgetlp, what-patch, pbuilder-dist, etc.

• debhelper son un conjunto de scripts que realizan tareas comunes de empaquetado.

• dh-make se usa para crear una plantilla para tu futuro paquete.

• diff y patch se usan para crear y aplicar parches, respectivamente. Su uso está muy extendido ya que son faciles de usar, limpios y más eficientes que modificar el código fuente a lo bruto.

• quilt administra los parches.

• gnupg es un completo y libre reemplazo para PGP usado para firmar digitalmente archivos (incluyendo paquetes).

• fakeroot simula ejecutar comandos con privilegios de root. Es útil para crear paquetes binarios para uso personal.

• lintian y linda diseccionan paquetes Debian y avisan de errores y violaciones de la normativa. Contienen autómatas que revisan muchos aspectos de la Normativa Debian así como otros errores comunes. linda no está disponible desde los repositorios de Ubuntu 8.04, pero aún está disponible en repositorios de lanzamientos anteriores.

• pbuilder crea un sistema chroot y construye un paquete en el mismo. Es un sistema ideal para comprobar si un paquete se realiza correctamente, revisar sus dependencias y construir paquetes para probar y distribuir.

Empaquetador personal: pbuilder

Usar pbuilder como un constructor de paquetes te permitirá crear paquetes sin necesidad de un entorno chroot. Puedes construir paquetes sin usar pbuilder, pero tendrás todas las dependencias instaladas en tu sistema muchas de las cuales no necesitarías (librerías de desarrollo y similares). Sin embargo, pbuilder permite al empaqeutador comprobar las dependencias de constucción ya que el paquete se construye con una instalación mínima de Ubuntu, y las dependencias de construcción serán descargadas de acuerdo con el archivo debian/control.

Un manual de uso rápido:

• Para crear un entorno pbuilder, ejecuta:

sudo pbuilder create --distribution <versión de ubuntu> \
--othermirror "deb http://archive.ubuntu.com/ubuntu <versión de ubuntu> main restricted ubiverse multiverse"

• Para construir un paquete usando pbuidler, ejecuta:

sudo pbuilder build *.dsc

• Para actualizar un entorno pbuilder, ejecuta:

sudo pbuilder update

• Usa pbuidler-dist (del paquete ubuntu-dev-tools) para tener distintas instalaciones de pbuidler para las diferentes lanzamientos de Ubuntu.

Empaquetado básico

Dos de los problemas a los que se enfrentan la mayoría de los nuevos empaquetadores son las múltiples formas de crear paquetes deb y el hecho de que existan diversas herramientas para hacer lo mismo.

El desarrollo de un paquete suele necesitar de la instalación de muchos otros paquetes (especialmente paquetes -dev que contiene las cabeceras (headers) y otros archivos comunes de desarrollo) que no forman parte de una instalación normal de escritorio de Ubuntu. Si quieres evitar la instalación de paquetes extra o deseas desarrollar para una versión de Ubuntu distinta a la que usas (la versión en desarrollo por ejemplo) el uso de un entorno chroot es altamente recomendable.

Vamos a exponer dos ejemplos de sistemas de construcción comunes. Usaremos debhelper, el sistema de construcción más popular en Debian. Este ayuda al empaquetador automatizando tareas repetitivas. Luego vamos a cubrir brevemente el Sistema de Construcción Común para Debian (Common Debian Build System, CDBS) un sistema más automatizado que utiliza debhelper.

Empaquetando desde el código fuente

Requerimientos: build-essential, automake, gnupg, lintian, fakeroot, pbuilder, debhelper y dh-make.

Usaremos el programa GNU hello como ejemplo. Puedes descargarte el tarball del código fuente desde ftp.gnu.org. Para el propósito de este ejemplo, usaremos el directorio ~/hello/.

mkdir ~/hello/
cd ~/hello/
wget http://ftp.gnu.org/gnu/helllo/helll-2.1.1.tar.gz

Si estás empaquetando tu propio código fuente o el programa no está disponible en un archivo .tar.gz, puedes crear el archivo .tar.gz necesario desde el directorio que lo contenga con el siguiente comando:

tar czf hello-2.1.1.tar.gz hello-2.1.1

Para el propósito de este ejemplo, también compararemos nuestro paquete (hello) con uno que ya está empaquetado en el repositorio de ubuntu (bajo el nombre hello-debhelper). Por ahora nos centraremos en el directorio hello así que podremos mirar el paquete de los repositorios despues. Para conseguir el código fuente, asegúrate de tener una línea «deb-src» del repositorio principal en tu /etc/apt/sources.list. Entonces simplemente ejecuta:

mkdir ubuntu/
cd ubuntu/
apt-get source hello-debhelper
cd ..

A diferencia de la mayoría de los comandos apt-get, no necesitaras privilegios de administrador (root) para conseguir el paquete fuente, ya que se descarga en el directorio actual. De echo, es recomendable que sólo uses apt-get source como usuario normal, ya que de esta forma puedes editar archivos en el paquete fuente sin necesidad de privilegios de administrador. El comando apt-get source:

• Descarga el paquete fuente. Un paquete fuente normalmente contiene un archivo .dsc que describe el paquete y proporciona el md5sums para el paquete fuente, un archivo .orig.tar.gz que contiene el código fuente del autor/es del programa, un archivo .diff.gz que contiene las instrucciones de empaquetado (en el directorio debian/) y los parches que se aplicarán en el código fuente.

• Descomprime el archivo .orig.tar.gz en el directorio actual.

• Aplica el .diff.gz al directorio del código fuente.

Si te has descargado manualmente el paquete fuente (los archivos .dsc, .orig.tar.gz y .diff.gz) puedes desempaquetarlos de la misma manera que el apt-get source con el comando:

dpkg-source -x *.dsc

Nosotros queremos recrear lo anterior desde el código fuente. Lo primero que necesitaras es hacer una copia (algunas veces llamado «upstream») del tarball de forma que quede con el siguiente formato: <paquete>_<versión>.orig.tar.gz. Con esto conseguir crear una copia del código fuente por si accidentalmente cambias o eliminas algo en el que estas trabajando. También debemos tener en cuenta que se considera una forma de actuar no muy aceptada modificar el código fuente original a menos que sea absolutamente necesario.

cp hello-2.1.1.tar.gz hello_2.1.1.orig.tar.gz
tar -xzvf hello_2.1.1.orig.tar.gz

La línea baja «_». entre el nombre del paquete (hello) y la versión (2.1.1), como opuesto de la línea alta «-», es muy importante. Las herramientas de empaquetado buscarán un archivo con ese nombre exacto. Si Si te equivocas, las herramientas asumirán incorrectamente que no hay código fuente original y el código fuente será construido como un paquete nativo de Debian.

Ahora tenemos un directorio hello que contiene los archivos del código fuente. Ahora necesitamos crear un directorio debian donde almacenaremos toda la información para construir el paquete, permitiendo serpara los archivos del paquete de los archivos del código fuente del programa. Usaremos dh_make para que cree el directorio debian con todos los archivos:

cd hello-2.1.1
dh_make -e tu.dirección.de.correo.electrónico.como@mantenedor

Una vez ejecutado dh_make este te preguntará varios aspectos sobre tu futuro paquete:

Type of packager single binary, multiple binary, libreary, kernel module or cdbs? [s/m/l/b] s

Maintainer name : Tu nombre
Email-Address : tu.dirección.de.correo.electrónico.como@mantenedor
Date: Thu, 6 Aprt 2008 10:07:19 -0700
Package Name : hello
Version : 2.1.1
License : blank
Type of Package : Single
Hit <enter> to confirm: Enter

El comando dh_make sólo se debe ejecutar una única vez. Si lo ejecutas más de una vez en el mismo directorio no funcionará correctamente. Si quieres cambiar o cometiste un error, elimina el directorio fuente y descomprime el tarball original de nuevo. Luego repite el proceso en el nuevo directorio.

Al ejecutar dh_make este crear los archivos básicos en el directorio debian/ y algunos archivos plantilla (.ex) que quizas puedan ser necesarios o no. El programa Hello no es muy complicado, y una vez vista la sección "Empaquetar desde la fuente", sus requerimientos no pasan de los archivos básicos. Por ello, procederemos a eliminar los archivos .ex:

cd debian
rm *.ex *.EX

Para hello, tampoco necesitaras algunos archivos del directorio debian:

• README.Deban: El archivo README concreta aspectos del paquete Debian, NO es el archivo README del programa.
• dirs : Usado por dh_installdirs para crear los directorios necesarios.
• docs : Usado por dh_installdocs para instalar la documentación del programa.
• info : Usado por dh_installinfo para instalar el archivo info.

Ten en cuenta que para la mayor parte de los paquetes estos archivos son necesarios. Para más información sobre ellos consulta la sección llamada "archivos de ejemplo dh_make"

Llegados a este pinto deberías tener en el directorio debian/ sólo los archivos changelog, compat, copyright y rules.

Fuentes

• https://wiki.ubuntu.com/PackagingGuide/Complete.