Los archivos PKGBUILD son la forma en que se construyen y crean los paquetes para Arch Linux y sus derivados, como Manjaro.
Es posible que incluso los hayas encontrado un poco si alguna vez has usado AUR, el repositorio de PKGBUILDs curado por el usuario de Arch Linux.
Pero, ¿cómo se pasa exactamente de un PKGBUILD a un paquete instalable? ¿Qué está pasando exactamente entre los dos y cómo puede hacerlos 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, estarán encantados de saber, si aún no lo hicieron, que un PKGBUILD es prácticamente 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 un PKGBUILD, se utiliza la utilidad de línea de comandos makepkg. Después de obtener un PKGBUILD, simplemente ejecute makepkg dentro del directorio que contiene el PKGBUILD, y listo, ¡tienes un paquete instalable!
En este tutorial, repasará el paquete que acabo de crear, que imprime “¡Hola mundo!” cuando se ejecuta:
Preparándose
Para seguir este tutorial, debe crear un par de archivos.
Primero, necesitas 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 verificar que los archivos se crearon con el comando ls:
¡Y estás listo para empezar!
Configurando su archivo PKGBUILD
En lugar de hacer que copie y pegue todo el archivo, voy a ingresar cada línea con usted, para que pueda comprender mejor el propósito de todo lo que está sucediendo. Si no prefiere aprender de esta manera, le recomiendo encarecidamente 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 que se usan comúnmente para que pueda comenzar lo más rápido posible.
Con eso fuera del camino, abra su editor de texto y ¡vayamos directamente a ello!
pkgname
Lo primero es lo primero, la variable pkgname. Esto es lo que define el nombre de su paquete al instalarlo 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-worldcon 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 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 configurar una versión superior hará que se le solicite al usuario una actualización.
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 sobre las actualizaciones si se mueve a un número mayor.
Sirve para cualquier cambio que requiera que 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 misma versión que la del paquete) y necesita corregir un error en el propio PKGBUILD.
Para configurar la variable, ingrese lo siguiente en el PKGBUILD:
pkgver="1"
Esta variable debe siempre comience en 1, y luego suba de uno en uno. Cuando el pkgver si mismo se mueve hacia arriba, esto puede (y debe) restablecerse a 1, ya que el propio pkgver notificará a los usuarios que hay actualizaciones disponibles.
pkgdesc
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 el arquitectura el paquete es compatible con. Está bien si no comprende qué es una arquitectura, ya que es prácticamente inútil en la mayoría de los casos.
Independientemente, makepkg aún necesita ser configurado 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 el PKGBUILD:
arch=("x86_64")
Si tuviera que establecer varios valores para esto, separaría cada valor con un espacio y comillas así: arch = (“x86_x64” “brazo”)
depende
Esto enumera todos los paquetes que nuestro paquete necesita para funcionar. Me gusta arco, también puede contener varios valores y, por tanto, debe utilizar 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 arco.
optar depende
Aquí se enumeran los paquetes que no son necesarios para funcionar, pero que son necesarios 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 quisiéramos.
Cualquier paquete enumerado aquí se desinstalará antes de instalar el nuestro.
Esto sigue la misma sintaxis que depende también.
licencia
Esto define el Licencia de software bajo la cual su programa tiene licencia. El Arch Wiki tiene información si necesita ayuda para elegir una licencia. Estableciendo esto en custom funcionará si no sabe en qué configurarlo.
Esto toma la misma sintaxis que arco 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.
Cuando agregue archivos locales, ingrese el nombre del archivo relativo al PKGBUILD, es decir, considere el siguiente diseño de directorio:
PKGBUILD
file.txt
src/file.sh
Si quisieras incluir file.sh en nuestro PKGBUILD, ingresarías src / file.sh como su nombre.
Al ingresar URL, simplemente ingrese la URL completa, es decir, https://mirrors.GeneratePresscommons.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 arco y depende:
source=("hello-world.sh")
sha512sums
Esto se usa para verificar que los archivos en fuente no se han modificado o descargado incorrectamente. La información sobre cómo obtener los valores para esto se puede encontrar en el Artículo de Arch Wiki sobre PKGBUILDs.
Si prefiere no configurar esto (o simplemente no lo necesita, es decir, para archivos locales), puede ingresar SKIP para cada archivo en el fuente variable:
sha512sums=("SKIP")
paquete()
Esta es la última y más importante parte para hacer nuestro paquete. Es importante conocer dos variables al trabajar 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) necesitara tener un archivo que lea 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 te saltaste el comando mkdir, tee generaría un error diciendo que el directorio no existe.
- Al especificar directorios, siempre anteponerlos con el $ {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!” 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 compile e instale el paquete con el makepkg -si comando, y luego ejecutar hello-world en su terminal para ver su salida.
Terminando
Y así, ¡has creado tu primer PKGBUILD! Está en camino de hacer paquetes reales para usted, y tal vez incluso el AUR.
¿Tiene alguna pregunta o algo no funciona bien? No dudes en publicarlo en la sección de comentarios a continuación.
