Tutoriales

Construyendo un PKGBUILD para construir paquetes para Arch Linux

Los archivos PKGBUILD son la forma en que se construyen y construyen los paquetes para Arch Linux y sus derivados como Manjaro.

Es posible que incluso se haya topado con ellos un poco si alguna vez ha usado AUR, el repositorio de PKGBUILD curado 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

Aquellos que estén familiarizados con Bash u otros shells estarán encantados de saber que un PKGBUILD es prácticamente un script de shell con algunas variables.

Los archivos PKGBUILD se componen de variables y funciones, todas las cuales se utilizan para definir y construir el paquete en sí.

Para construir 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 en el directorio que contiene el PKGBUILD, y listo, ¡tienes un paquete instalable!

En este tutorial, revisará el paquete que acabo de crear y el mensaje «¡Hola, mundo!» mientras corre:

Ejemplo de PKGBUILD

Configurar

Para seguir este tutorial, necesitará crear algunos archivos.

Primero necesitas un archivo llamado. crear PKGBUILD. Si aún no se ha aclarado, esto servirá como una «receta» para construir su paquete.

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

También puede crear estos dos archivos con un solo comando.

touch PKGBUILD hello-world.sh

Puede usar el comando ls para verificar que los archivos fueron creados:

Guía básica de PKGBUILD

¡Y estás listo para empezar!

Configurando su archivo PKGBUILD

En lugar de que copie y pegue todo el archivo, revisaré cada línea con usted para que pueda comprender mejor el propósito de todo lo que sucede. Si no prefieres estudiar así, te lo recomiendo mucho. Artículo de Arch Wiki para crear paquetes para Arch Linux.

Además, este artículo no abarca todas las opciones que puede configurar en un PKGBUILD, sino algunas de las que se usan comúnmente para que pueda comenzar lo antes posible.

Cuando haya terminado, abra su editor de texto y comencemos de inmediato.

Nombre del paquete

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

El formato de esta variable (y algunas otras) es de la forma variable = valor, con el nombre de la variable a la izquierda y 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. Esto está un poco más abajo en el. tratado package() Sección.

pkgver

Como se indica en el nombre de la variable, esto determina la versión de su paquete (por ejemplo, 1.0.0). Esto es útil cuando un usuario está actualizando su sistema, ya que el cambio a una versión superior le pedirá al usuario que actualice.

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

pkgver="1.0.0"

paquete

Esto está relacionado con la variable pkgver y generalmente no es importante. Sin embargo, al igual que la variable pkgver, notifica a los usuarios de las actualizaciones cuando se mueve a un número mayor.

Es 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 está utilizando (y manteniendo la versión igual que la del paquete que desee) y tiene que corregir un error en el PKGBUILD usted mismo.

Para establecer la variable, ingrese lo siguiente en PKGBUILD:

pkgver="1"

Esta variable debe siempre Comience en 1 y luego suba uno a la vez. Si el pkgver incluso movido hacia arriba, esto puede (y debe) restablecerse a 1 ya que el propio pkgver notifica a los usuarios que hay actualizaciones disponibles.

pkgdesc

Esto establece la descripción del paquete, que se utiliza para identificar mejor el paquete.

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

pkgdesc="Hello world in your terminal!"

arco

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

Independientemente, makepkg aún debe configurarse 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 configurar, ingrese lo siguiente en el PKGBUILD:

arch=("x86_64")

Si tuviera que especificar varios valores para esto, separaría cada valor con un espacio y comillas como este: arch = («x86_x64» «brazo»)

depende

Aquí se enumeran todos los paquetes que nuestro paquete necesita para funcionar. Gustar arco, también puede contener varios valores y, por lo tanto, debe utilizar la sintaxis de corchetes.

Dado que nuestro paquete no tiene dependencias, no necesitamos ingresar este campo en el PKGBUILD. Sin embargo, si nuestro paquete tuviera dependencias, usaríamos la misma sintaxis que arco.

opt-dependiente

Aquí se enumeran los paquetes que no son necesarios para la función, 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 se comporte o se comporte de una manera que no queremos.

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

Esto sigue la misma sintaxis que depende además.

Licencia

Esto define la licencia de software bajo la cual se licencia su programa. La wiki de Arch tiene información si necesita ayuda para elegir una licencia. Poniendo en custom funciona cuando no sabe qué configurar.

Esto requiere la misma sintaxis que arco y depende:

license=("custom")

fuente

De esta forma, makepkg sabe qué archivos usar para construir nuestro paquete. Esto puede incluir una variedad de diferentes tipos de fuentes, incluidos archivos locales y URL.

Al agregar archivos locales, ingrese el nombre del archivo relativo al PKGBUILD, es decir, tenga en cuenta el siguiente diseño de directorio:

PKGBUILD
file.txt
src/file.sh

Si quisieras encerrarte File.sh entrarías en nuestro PKGBUILD src / file.sh como su nombre.

Al ingresar 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 ingrese su nombre como valor para. a fuente.

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

source=("hello-world.sh")

sha512sums

Esto se utiliza para comprobar que los archivos están en fuente no modificado o descargado incorrectamente. Para obtener información sobre cómo obtener los valores para estos, consulte el artículo de Arch Wiki sobre PKGBUILD.

Si prefiere no configurar esto (o simplemente no tiene que hacerlo, por ejemplo, para archivos locales), simplemente puede SALTAR para cada archivo en el fuente Variable:

sha512sums=("SKIP")

Paquete()

Esta es la parte final y más importante de la construcción de nuestro paquete. Es importante conocer dos variables al trabajar con él:

  • $ srcdir: Aquí makepkg coloca los archivos en el fuente Variable. Este es el directorio donde puede interactuar con los archivos y realizar cualquier otro cambio necesario 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 / usr / bin / hello-world cuando se instala con pacman.

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

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

package()  tee "$pkgdir/usr/share/motto.txt"

Un par de notas sobre el comando anterior:

  • $ pkgdir contiene No Directorios en él primero. Si omitió el comando mkdir, tee imprime un mensaje de error que indica que el directorio no existe.
  • Al especificar directorios siempre pon eso frente a ellos $ pkgdir o $ srcdir Variable. Ingresar algo como /usr/share/motto.txt sin esto apuntaría al directorio literal /usr/share/motto.txt en su sistema actualmente en ejecución.

Para su PKGBUILD, guarde el archivo hello-world.sh en / usr / bin / hello-world en su sistema de destino. También se asegurarán de que el mensaje Hello You! dice. si se ejecuta.

Para hacer esto, 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 ya está! Cree e instale el paquete con makepkg -siy luego ejecute hello-world en su terminal para ver el resultado.

Imagen 1

Envolver

¡Y has hecho tu primer PKGBUILD! Está bien encaminado para crear paquetes reales para usted, y tal vez incluso el AUR.

¿Tiene alguna pregunta o algo no funciona correctamente? No dudes en publicarlo en la sección de comentarios a continuación.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba