Crear un PKGBUILD para hacer paquetes para Arch Linux

Los archivos PKGBUILD son cómo se compilan y crean los paquetes para Arch Linux y sus derivados, como Manjaro.

Es posible que incluso te hayas topado con ellos un poco si alguna vez has usado AUR, el repositorio de PKGBUILDs seleccionado por el usuario de Arch Linux.

Pero, ¿cómo se pasa exactamente de un PKGBUILD a un paquete instalable? ¿Qué sucede exactamente entre los dos y cómo puede crearlos para sus propios paquetes? Los aprenderá en este artículo.

Conceptos básicos de PKGBUILD

Para aquellos que están familiarizados con Bash u otros shells, les encantará saber, si aún no lo saben, que PKGBUILD es prácticamente solo un script de shell con algunas variables.

Los archivos PKGBUILD constan de variables y funciones, todas las cuales se utilizan para definir el paquete en sí y cómo construirlo.

Para crear un paquete a partir de PKGBUILD, se utiliza la utilidad de línea de comandos makepkg. Después de obtener un PKGBUILD, simplemente ejecuta makepkg dentro del directorio que contiene el PKGBUILD, y listo, ¡tienes un paquete instalable!

En este tutorial, revisará el paquete que acabo de crear, que imprime "¡Hola mundo!" cuando se ejecuta:

Configuración

Para seguir este tutorial, debe crear un par de archivos.

Primero, debe crear un archivo llamado PKGBUILD . Si aún no quedó claro, esto servirá como la "receta" para crear su paquete.

El otro archivo que deberá crear es un archivo llamado hello-world.sh . Explicaré su propósito un poco más tarde.

También puede crear ambos archivos con un solo comando.

touch PKGBUILD hello-world.sh

Puede comprobar que los archivos se crearon con el comando ls:

¡Y estás listo para empezar!

Configurando su archivo PKGBUILD

En lugar de pedirle que copie y pegue todo el archivo, revisaré el ingreso de cada línea con usted, para que pueda comprender mejor el propósito de todo lo que sucede. Si no prefiere aprender de esta manera, recomiendo encarecidamente el Artículo de Arch Wiki sobre la creación de paquetes para Arch Linux.

Este artículo tampoco repasa todas las opciones que puede configurar en un PKGBUILD, sino algunas de las más utilizadas para que pueda comenzar lo más rápido posible.

Con eso fuera del camino, abra su editor de texto, ¡y entremos directamente!

nombre del paquete

Lo primero es lo primero, la variable pkgname. Esto es lo que define el nombre de su paquete durante la instalación y cómo el administrador de paquetes de Arch Linux, pacman, realiza un seguimiento del paquete.

El formato de esta variable (y algunas otras) toma la forma de variable=valor, con el nombre de la variable a la izquierda, el valor de la variable a la derecha, separados por un signo igual.

Para establecer el nombre del paquete, ingrese lo siguiente en PKGBUILD:

pkgname="hello-world"

• Para establecer un nombre de paquete diferente, reemplace hello-world con el nombre del paquete.
• Esto no establece el comando utilizado para ejecutar el programa. Eso se maneja un poco más abajo en el package() sección.

pkgver

Como se indica en el propio nombre de la variable, esto establece la versión de su paquete (es decir, 1.0.0). Esto es útil cuando un usuario actualiza su sistema, ya que al configurar una versión superior, se le solicitará al usuario que actualice.

Para configurar, ingrese lo siguiente en PKGBUILD (después de la línea anterior):

pkgver="1.0.0"

paquete

Esto está relacionado con la variable pkgver y normalmente no es importante conocerlo. Sin embargo, al igual que la variable pkgver, notificará a los usuarios para actualizaciones si se mueve a un número más alto.

Sirve para cualquier cambio que requiera que el pkgver permanezca igual, como cualquier cambio en el propio PKGBUILD. Esto sería útil si ha creado un PKGBUILD para un programa que usa (y desea mantener la versión igual a la del paquete) y necesita corregir un error en el propio PKGBUILD.

Para configurar la variable, ingrese lo siguiente en PKGBUILD:

pkgver="1"

Esta variable debe siempre comience en 1 y luego suba uno a la vez. Cuando el pkgver se mueve hacia arriba, esto puede (y debe) restablecerse a 1, ya que el propio pkgver notificará a los usuarios que hay actualizaciones disponibles.

paquetedesc

Esto establecerá la descripción del paquete, que se utiliza para ayudar a identificar mejor el paquete.

Para configurarlo, simplemente coloque la descripción entre comillas:

pkgdesc="Hello world in your terminal!"

arco

Esta variable establece la arquitectura con la que el paquete es compatible. Está bien si no entiendes qué es una arquitectura, ya que es bastante inútil en la mayoría de los casos.

Independientemente, makepkg aún necesita que se configure para que sepa que el paquete es compatible con nuestro sistema.

Esta variable admite la configuración de varios valores, por lo que makepkg requiere una sintaxis diferente, como se muestra a continuación.

Para configurarlo, ingrese lo siguiente en PKGBUILD:

arch=("x86_64")

Si tuviera que establecer varios valores para esto, separaría cada valor con un espacio y comillas de la siguiente manera:arch=(“x86_x64” “arm”)

depende

Esto enumera todos los paquetes que nuestro paquete necesita para funcionar. Me gusta arco , también puede contener varios valores y, por lo tanto, debe usar la sintaxis de paréntesis.

Dado que nuestro paquete no tendrá dependencias, no tenemos que ingresar este campo en PKGBUILD. Sin embargo, si nuestro paquete tuviera dependencias, usaríamos la misma sintaxis que arch .

optardepende

Aquí se enumeran los paquetes que no se requieren para funcionar, pero que se necesitan para una funcionalidad adicional.

Esto sigue la misma sintaxis que depende .

conflictos

Esto le dice a pacman qué paquetes harían que nuestro paquete actúe o se comporte de una manera que no nos gustaría.

Cualquier paquete enumerado aquí se desinstalará antes de que se instale el nuestro.

Esto sigue la misma sintaxis que depende también.

licencia

Esto define la licencia de software bajo la cual se otorga la licencia de su programa. Arch Wiki tiene información si necesita ayuda para elegir una licencia. Estableciendo esto en custom funcionará si no sabe cómo configurarlo.

Esto toma la misma sintaxis que arch y depende :

license=("custom")

fuente

Así es como makepkg sabe qué archivos usar para construir nuestro paquete. Esto puede contener una variedad de diferentes tipos de fuentes, incluidos archivos locales y URL.

Al agregar archivos locales, ingrese el nombre del archivo relativo a PKGBUILD, es decir, considere el siguiente diseño de directorio:

PKGBUILD
file.txt
src/file.sh

Si desea incluir file.sh en nuestro PKGBUILD, ingresaría src/file.sh como su nombre.

Al ingresar las URL, simplemente ingrese la URL completa, es decir, https://mirrors.creativecommons.org/presskit/logos/cc.logo.large.png.

Su paquete solo necesita el archivo hello-world.sh, y dado que está en el mismo directorio que PKGBUILD, simplemente escriba su nombre como valor para fuente .

Esta variable también usa la misma sintaxis que arch y depende :

source=("hello-world.sh")

sha512sumas

Esto se usa para verificar que los archivos en fuente no han sido modificados o descargados incorrectamente. Puede encontrar información sobre cómo obtener los valores para esto en el artículo de Arch Wiki sobre PKGBUILD.

Si prefiere no configurar esto (o simplemente no necesita hacerlo, es decir, para archivos locales), puede ingresar SKIP para cada archivo en la fuente variables:

sha512sums=("SKIP")

paquete()

Esta es la última y más importante parte para hacer nuestro paquete. Es importante conocer dos variables cuando se trabaja con esto:

• ${srcdir} :Aquí es donde makepkg coloca los archivos en el fuente variable. Este es el directorio donde puede interactuar con los archivos y realizar cualquier otra modificación necesaria en los archivos.

• ${pkgdir}:aquí es donde colocamos los archivos que se instalarán en nuestro sistema.
  La estructura de carpetas para ${pkgdir} está configurada como si estuviera en un sistema real (es decir, ${pkgdir}/usr/bin/hello-world crearía el archivo /usr/bin/hello-world al instalar con pacman.

package() contiene una lista de comandos utilizados para crear un paquete.

Entonces, si (hipotéticamente) necesita tener un archivo que diga que Linux es superior a Windows en /usr/share/motto.txt, ejecutaría algo como esto:

package() {
  mkdir -p "${pkgdir}/usr/share"
  echo "Linux is superior to Windows" | tee "${pkgdir}/usr/share/motto.txt"
}

Algunas notas sobre el comando anterior:

• ${pkgdir} contiene no directorios dentro de él al principio. Si omitió el comando mkdir, tee generaría un error que indica que el directorio no existe.

• Al especificar directorios, siempre prepárelos con ${pkgdir} o ${srcdir} variable. Ingresar algo como /usr/share/motto.txt sin eso apuntaría al directorio literal /usr/share/motto.txt en su sistema actualmente en ejecución.

Para su PKGBUILD, colocará el archivo hello-world.sh en /usr/bin/hello-world en su sistema de destino. También hará que el archivo diga "¡Hola a ti!" cuando corrió.

Para hacerlo, ingrese lo siguiente en su PKGBUILD:

package() {
  echo 'Hello to you!' > "${srcdir}/hello-world.sh"
  mkdir -p "${pkgdir}/usr/bin"
  cp "${srcdir}/hello-world.sh" "${pkgdir}/usr/bin/hello-world"
  chmod +x "${pkgdir}/usr/bin/hello-world"
}

¡Y tu estas listo! Su archivo resultante ahora debería verse similar a esto:

Ahora compila e instala el paquete con makepkg -si y luego ejecute hello-world en su terminal para ver su salida.

Conclusión

¡Y así, has hecho tu primer PKGBUILD! Está en camino de hacer paquetes reales para usted mismo, y tal vez incluso el AUR.

¿Tienes alguna pregunta o algo simplemente no funciona bien? Siéntase libre de publicarlo en la sección de comentarios a continuación.