Difference between revisions of "Creating packages (Español)"

From ArchWiki
Jump to navigation Jump to search
(Creating_packages add section - Meta packages and groups)
(→‎Metapaquetes y grupos: se añadió el contenido.)
Line 43: Line 43:
  
 
=== Metapaquetes y grupos ===
 
=== Metapaquetes y grupos ===
 +
 +
Un grupo de paquetes es un conjunto de paquetes relacionados, definido por el empaquetador, que se pueden instalar o desinstalar
 +
simultáneamente utilizando el nombre de grupo como un sustituto para cada nombre de paquete individual. Si bien un grupo no es
 +
un paquete, puede instalarse de manera similar a un paquete, vea [[Pacman#Instalando grupos de paquetes]] y [[PKGBUILD#grupos]].
 +
 +
Un metapaquete a menudo (aunque no siempre) titulado con -meta sufijo, proporciona funcionalidad similar a un grupo de paquetes
 +
que permite que se instalen o desinstalen simultáneamente varios paquetes relacionados. Metapaquetes pueden ser instalados como
 +
cualquier otro paquete, vea [[Pacman#Instalando paquetes específicos]]. La única diferencia entre un paquete meta y un paquete regular es que una meta paquete está vacío y existe puramente para vincular paquetes relacionados a través de dependencias.
 +
 +
La ventaja de un paquete meta, en comparación con un grupo, es que cualquier nuevo miembro del paquete se instalará cuando el propio
 +
metapaquete sea actualizado con un nuevo conjunto de dependencias. Esto contrasta con un grupo en el que los nuevos miembros del grupo no se instalarán automáticamente. La desventaja de un metapaquete  es que no es tan flexible como un grupo - puede elegir los miembros del grupo que desea instalar pero no puede elegir qué dependencias del metapaquete desea instalar. Asimismo, puede desinstalar los miembros del grupo sin tener que quitar el grupo entero, sin embargo usted no puede quitar dependencias del metapaquete sin tener que desinstalar el metapaquete en sí mismo.
  
 
== Preparación ==  
 
== Preparación ==  

Revision as of 01:21, 22 July 2017

Tango-preferences-desktop-locale-modified.pngLa traducción de este artículo o sección no refleja el texto original.Tango-preferences-desktop-locale-modified.png

Motivos: desactualizada (Discusión en Talk:Creating packages (Español)#)

Este artículo pretende ayudar al usuario a crear sus propios paquetes usando el sistema de empaquetado “tipo ports” de Arch Linux. Cubre la creación de un archivo PKGBUILD – un archivo de descripción del paquete empaquetado acompañado del archivo makepkg que sirve para crear un archivo binario desde las fuentes. Si ya tiene un PKGBUILD, favor de leer la wiki de makepkg.

Resumen

Los paquetes en Arch Linux se construyen utilizando la utilidad makepkg y la información almacenada en un archivo PKGBUILD. Cuando makepkg se ejecuta, busca un archivo PKGBUILD en el directorio actual y sigue las instrucciones en él para adquirir los archivos requeridos y/o copilarlos para enpaquetarlos en un archivo de paquete(nombredelpaquete.pkg.tar.xz). El paquete resultante contiene archivos binarios e instrucciones de instalación listas para ser instaladas por pacman.

Un paquete de Arch no es más que un archivo tar o 'tarball', comprimido usando xz, que contiene los siguientes archivos generados por makepkg:

  • Archivos binarios a instalar.
  • .PKGINFO: contiene todos los metadatos requeridos por pacman para tratar con paquetes, dependencias, etc.
  • .MTREE: contiene hashes y marcas de tiempo de los archivos que se incluyen en la base de datos local para que pacman pueda verificar la integridad del paquete.
  • .INSTALL: un archivo opcional utilizado para ejecutar comandos después de la fase de instalación/actualización/eliminación. (Este archivo sólo está presente si se especifica en el .PKGBUILD).
  • Changelog: un archivo opcional guardado por el responsable del paquete documentando los cambios del paquete. (No está presente en todos los paquetes.)

Metapaquetes y grupos

Un grupo de paquetes es un conjunto de paquetes relacionados, definido por el empaquetador, que se pueden instalar o desinstalar simultáneamente utilizando el nombre de grupo como un sustituto para cada nombre de paquete individual. Si bien un grupo no es un paquete, puede instalarse de manera similar a un paquete, vea Pacman#Instalando grupos de paquetes y PKGBUILD#grupos.

Un metapaquete a menudo (aunque no siempre) titulado con -meta sufijo, proporciona funcionalidad similar a un grupo de paquetes que permite que se instalen o desinstalen simultáneamente varios paquetes relacionados. Metapaquetes pueden ser instalados como cualquier otro paquete, vea Pacman#Instalando paquetes específicos. La única diferencia entre un paquete meta y un paquete regular es que una meta paquete está vacío y existe puramente para vincular paquetes relacionados a través de dependencias.

La ventaja de un paquete meta, en comparación con un grupo, es que cualquier nuevo miembro del paquete se instalará cuando el propio metapaquete sea actualizado con un nuevo conjunto de dependencias. Esto contrasta con un grupo en el que los nuevos miembros del grupo no se instalarán automáticamente. La desventaja de un metapaquete es que no es tan flexible como un grupo - puede elegir los miembros del grupo que desea instalar pero no puede elegir qué dependencias del metapaquete desea instalar. Asimismo, puede desinstalar los miembros del grupo sin tener que quitar el grupo entero, sin embargo usted no puede quitar dependencias del metapaquete sin tener que desinstalar el metapaquete en sí mismo.

Preparación

Programas necesarios

Asegúrese primero de que las herramientas necesarias estén instaladas. Instalando el grupo de paquetes base-devel debe ser suficiente; incluye make y herramientas adicionales necesarias para compilar desde el codigo fuente.

Una de las herramientas clave para la construcción de paquetes es makepkg (proporcionado por pacman), que hace lo siguiente:

  1. Comprueba que las dependencias del paquete están instaladas.
  2. Descarga el(los) archivo(s) fuente desde el(los) servidor(es) especificado(s).
  3. Desempaque el(los) archivo(s) fuente(s).
  4. Compila el software y lo instala en un entorno fakeroot.
  5. Quita símbolos de los binarios y de las librerías.
  6. Genera el archivo del metapaquete que se incluye con cada paquete.
  7. Comprime el entorno fakeroot en un archivo de paquete.
  8. Almacena el archivo de paquete en el directorio de destino configurado, que es el directorio de trabajo actual de forma predeterminada.

Descargar y probar la instalación

Descargue el tarball con el codigo fuente del software que desea empaquetar, extráigalo, y siga los pasos del autor para instalar el programa. Anote todos los comandos y/o pasos necesarios para compilarlo e instalarlo. Usted repetirá los mismos comandos en el archivo PKGBUILD. La mayoría de los autores de software se adhieren al ciclo de compilación de 3 pasos:

./configure
make
make install

Este es un buen momento para asegurarse de que el programa funciona correctamente.

Creando el PKGBUILD

Cuando ejecuta makepkg buscara el archivo PKGBUILD en el directorio actual. Si este archivo es encontrado descargará el código fuente del software, y lo compilará de acuerdo a las instrucciones guardadas en el archivo PKGBUILD. Estas instrucciones deben ser completamente comprensibles para el Bash Shell. Después de una compilación exitosa los binarios resultantes y la metadata del software (versión del software y dependencias) son empaquetadas en un archivo comprimido paquete.pkg.tar.xz que puede ser instalado con el comando pacman -U [package file]

Definiendo las variables del PKGBUILD

El archivo PKGBUILD contiene metadata referente al software a instalar. Es un archivo de texto plano. El siguiente es un archivo PKGBUILD de ejemplo que se puede localizar en el directorio /usr/share/pacman junto con otras plantillas-.

/usr/share/pacman/PKGBUILD.proto
# This is an example PKGBUILD file. Use this as a start to creating your own,
# and remove these comments. For more information, see 'man PKGBUILD'.
# NOTE: Please fill out the license field for your package! If it is unknown,
# then please put 'unknown'.

# Maintainer: Your Name <youremail@domain.com>
pkgname=NAME
pkgver=VERSION
pkgrel=1
pkgdesc=""
arch=()
url=""
license=('GPL')
groups=()
depends=()
makedepends=()
optdepends=()
provides=()
conflicts=()
replaces=()
backup=()
options=()
install=
changelog=
source=($pkgname-$pkgver.tar.gz)
noextract=()
md5sums=() #generate with 'makepkg -g'

build() {
  cd "$srcdir/$pkgname-$pkgver"

  ./configure --prefix=/usr
  make
}

package() {
  cd "$srcdir/$pkgname-$pkgver"

  make DESTDIR="$pkgdir/" install
}

Una explicación de posibles variables del PKGBUILD se encuentra en la wiki de PKGBUILD.

La función build()

Ahora hay que implementar la función build() en el archivo PKGBUILD. Esta función utiliza sintaxis de comandos comunes de Bash para compilar automáticamente el software y también crear el directorio pkg para instalar el software. Esto permite a makepkg empaquetar los archivos sin envegar entre directorios de su filesystem.

El primer paso de la función build() es entrar al directorio creado al descomprimir el archivo fuente. En la mayoría de los casos ese comando se vera como este:

cd $srcdir/$pkgname-$pkgver

Ahora hay que listar todos los comandos que utilizo al compilar e instalar manualmente el software. Esencialmente la función build() pretende automatizar todo esto y compilar el software en un ambiente de fakeroot. Si el software a instalar utiliza un script configure, es buena practica utilizar --prefix=/usr al crear paquetes para pacman. Hay mucho software que instala archivos en el directorio /usr/local, esto debería ser hecho solamente si usted esta instalando manualmente desde código fuente. Así como se especifica en el archivo /usr/share/pacman/PKGBUILD.proto, las siguientes dos líneas pueden ser parecidas a esto:

./configure --prefix=/usr
make

El paso final en la función build() es poner los archivos compilados donde makepkg los pueda llamar para crear un paquete. Esto por default es el directorio pkg – un simple entorno fakeroot. El directorio pkg replica la jerarquía del sistema de archivos raíz de las rutas de instalación del software, si necesita dejar archivos dentro de su sistema de archivos raíz, deberá instalarlos en el directorio pkg dentro de la misma estructura de directorios. Por ejemplo, si quiere instalar un programa dentro del directorio /usr/bin, debe ser ubicado dentro de $pkgdir/usr/bin. Hay muy pocos procedimientos de instalación que requieran que el usuario copie manualmente estos archivos, pero vale la pena aclararlo. En vez de eso, en la mayoría del software, llamar a make install automatizara esa tarea. La última línea deberá parecer a la siguiente, para instalar el software correctamente en el directorio pkg:

make DESTDIR=$pkgdir install
Nota: se puede dar el caso que el argumento DESTDIR no sea utilizado en el Makefile; en vez de esto habrá que utilizar el argumento prefix, si el paquete es compilado con automake/autoconf, utiliza DESTDIR, esto esta documentado en los manuales. Si DESTDIR no funciona trate de compilarlo con make prefix="$pkgdir/usr/" install. Si es no funciona, tendrá que investigar aun más en los comandos de instalación que son ejecutados por make e install.

En algunos casos raros, el software espera ser ejecutado dentro de algún directorio en específico. En estos casos se recomienda copiar estos a $pkgdir/opt. Muy seguido, el proceso de instalación creara subdirectorios dentro del directorio pkg. Si no es así, makepkg generara muchos errores y usted se vera obligado a crear estos directorios manualmente agregando los comandos mkdir -p dentro de la función build() antes de que inicie el proceso de instalación.

También makepkg define tres variables que deberá tomar en cuenta como parte del proceso de compilación e instalación:

startdir
Contiene la ruta absoluta al directorio donde el PKGBUILD esta localizado. Esta variable se utiliza en combinación con los postfijos /src o /pkg, sin embargo el uso de srcdir y pkgdir son los métodos modernos utilizados.$startdir/src no es garantía de ser igual a $srcdir y muy seguramente para $pkgdir. El uso de esta variable esta depreciado se recomienda ampliamente no utilizarlo.
srcdir
Apunta al directorio donde makepkg´ extrae o copia todos los archivos fuente
pkgdir
Apunta al directorio donde makepkg empaqueta el software instalado, que se convierte el directorio raíz del paquete construido.
Nota: makepkg, y por ende la función build() son pensadas para no ser interactivas. Las rutinas que requieran interacción del usuario que sean llamadas dentro de la función build() podrían destruir el makepkg, particularmente si es invocado con el registro de compilación habilitado (ver Arch Linux Bug #13214)

Guías adicionales.

Por favor lea los estándares de empaquetado de Arch para mejores prácticas y consideraciones adicionales.

Probando el PKGBUILD y el paquete

Mientras escribe la función build() deberá probar los cambios con frecuencia para asegurarse de que no haya fallas. Puede hacerlo utilizando el comando makepkg en el directorio donde se encuentre el archivo PKGBUILD. Con un PKGBUILD correctamente compuesto makepkg será capaz de crear un paquete, con un PKGBUILD incorrecto o roto PKGBUILD mostrara un error.

Si makepkg finaliza correctamente, creara un archivo llamado pkgname-pkgver.pkg.tar.xz en su directorio de trabajo. Este paquete puede ser instalado con el comando pacman -U. Sin embargo solo por que un paquete haya sido correctamente construido esto no implica que sea completamente funcional, es concebible que contenga solo el directorio y ningún archivo si por ejemplo, un prefijo fue especificado incorrectamente. Puede utilizar las herramientas de consulta de pacman para ver la lista de archivos contenidos en el paquete y las dependencias que puede requerir con pacman -Qlp [nombre del paquete] y pacman -Qip [nombre del paquete]

Si el paquete se ve sano, entonces ha terminado!, sin embargo si va a publicar el PKGBUILD, es imperativo que revise y vuelva a revisar el contenido de la variable depends.

También asegúrese de que el software ejecute sin ningún fallo. Es molesto que al publicar un paquete que contenga todos los archivos necesarios deje de funcionar por alguna opción en alguna configuración obsoleta que ya no funciona en relación con el resto del sistema. Si solo va a compilar paquetes solo para su sistema, entonces no tendrá que preocuparse mucho de este procedimiento de seguranza de calidad, al final de cuentas solo usted sufrirá las consecuencias de una mala configuración.

Ldd y namcap

Las dependencias incumplidas son el error más común del empaquetado. Hay dos excelentes herramientas para verificar el cumplimiento de las dependencias. La primera es ldd que mostrara las dependencias compartidas de librerías de ejecutables:

$ ldd gcc
linux-gate.so.1 =>  (0xb7f33000)
libc.so.6 => /lib/libc.so.6 (0xb7de0000)
/lib/ld-linux.so.2 (0xb7f34000)

La otra herramienta es namcap, que solo verifica por las dependencias y no por la sanidad del todo el paquete en si. Por favor lea el artículo sobre namcap para mayores referencias.

Subir paquetes a AUR

Por favor lea Arch User Repository#Submitting packages de la guía de AUR. Para una descripción detallada del proceso.

Resumen

  1. Descargue el código fuente del software que quiera empaquetar.
  2. Trate de compilar e instalar el software en un directorio arbitrario
  3. Copie el prototipo de /usr/share/pacman/PKGBUILD.proto y renómbrelo como PKGBUILD en un directorio de trabajo, preferiblemente ~/abs
  4. Edite el PKGBUILD de acuerdo a las necesidades de su paquete
  5. Ejecute makepkg para verificar si el paquete se construye correctamente
  6. Si no es así, repita los últimos dos pasos

Advertencias

Antes de automatizar el proceso de construcción de paquetes, deberá haberlo hecho por lo menos una vez de manera manual para saber de antemano exactamente lo que esta haciendo. Desafortunadamente muchos autores de paquetes se apegan al proceso de 3 pasos de ./configure, make make install, este no es siempre el caso y puede quedar un paquete en muy malas condiciones si no aplica el cuidado necesario para que todo funcione bien. En algunos pocos casos, los paquetes no son disponibles en código fuente y habrá que recurrir a scripts como sh instalador.run para poder ejecutarlo, habrá de hacer una extensa investigación acerca de otros PKGBUILD, leer los README, buscar información del creador del programa, o buscar EBUILDS de Gentoo para poder ejecutar la instalación, recuerde que makepkg debe ser completamente automático y sin intervención del usuario.