Création d’un PKGBUILD pour créer des packages pour Arch Linux

Les fichiers PKGBUILD sont la façon dont les packages sont construits et créés pour Arch Linux et ses dérivés tels que Manjaro.

Vous les avez peut-être même rencontrés un peu si vous avez déjà utilisé l’AUR, le référentiel de PKGBUILD organisé par les utilisateurs d’Arch Linux.

Mais comment passer exactement d’un PKGBUILD à un package installable ? Que se passe-t-il exactement entre les deux et comment pouvez-vous les créer pour vos propres packages ? Vous les apprendrez dans cet article.

Principes de base de PKGBUILD

Pour ceux qui sont familiers avec Bash ou d’autres shells, vous serez ravi de savoir, si ce n’est déjà fait, qu’un PKGBUILD est à peu près juste un script shell avec quelques variables.

Les fichiers PKGBUILD se composent de variables et de fonctions, qui sont toutes utilisées pour définir le package lui-même et comment le construire.

Pour créer un package à partir d’un PKGBUILD, l’utilitaire de ligne de commande makepkg est utilisé. Après avoir obtenu un PKGBUILD, vous exécutez simplement makepkg dans le répertoire contenant le PKGBUILD, et le tour est joué, vous avez un package installable !

Dans ce didacticiel, vous passerez en revue le package que je viens de créer, qui affiche « Hello World ! » lors de l’exécution :

Se mettre en place

Pour suivre ce didacticiel, vous devez créer quelques fichiers.

Tout d’abord, vous devez créer un fichier appelé PKGBUILD. Si cela n’a pas déjà été précisé, cela servira de “recette” pour construire votre package.

L’autre fichier que vous devrez créer est un fichier appelé bonjour-monde.sh. J’expliquerai son but un peu plus tard.

Vous pouvez également créer ces deux fichiers avec une seule commande.

touch PKGBUILD hello-world.sh

Vous pouvez vérifier que les fichiers ont été créés avec la commande ls :

Et vous êtes prêt à partir !

Configuration de votre fichier PKGBUILD

Au lieu de vous demander de copier-coller tout le fichier, je vais passer en revue chaque ligne avec vous, afin que vous puissiez mieux comprendre le but de tout ce qui se passe. Si vous ne préférez pas apprendre de cette façon, je vous recommande fortement le Article Wiki Arch sur la création de packages pour Arch Linux.

Cet article ne passe pas non plus en revue toutes les options que vous pouvez définir dans un PKGBUILD, mais plutôt certaines d’entre elles couramment utilisées afin que vous puissiez commencer le plus rapidement possible.

Avec cela à l’écart, ouvrez votre éditeur de texte et allons-y directement !

nom_paquet

Tout d’abord, la variable pkgname. C’est ce qui définit le nom de votre package lors de l’installation, et comment le gestionnaire de packages d’Arch Linux pacman assure le suivi du package.

Le format de cette variable (et de quelques autres) prend la forme variable=valeur, avec le nom de la variable à gauche, la valeur de la variable à droite, séparés par un signe égal.

Pour définir le nom du package, saisissez ce qui suit dans PKGBUILD :

pkgname="hello-world"

• Pour définir un nom de package différent, remplacez hello-world avec le nom du paquet.
• Cela ne définit pas la commande utilisée pour exécuter le programme. Cela est traité un peu ci-dessous dans le package() section.

pkgver

Comme indiqué dans le nom de la variable lui-même, cela définit la version de votre package (c’est-à-dire 1.0.0). Ceci est utile lorsqu’un utilisateur met à jour son système, car la définition d’une version supérieure entraînera l’invite de l’utilisateur à effectuer une mise à niveau.

Pour définir, entrez ce qui suit dans le PKGBUILD (après la ligne précédente) :

pkgver="1.0.0"

pkgrel

Ceci est lié à la variable pkgver et n’est normalement pas important à connaître. Comme la variable pkgver, elle informera les utilisateurs des mises à niveau si elle est déplacée vers un nombre plus élevé.

Il sert pour toutes les modifications qui nécessitent que le pkgver reste le même, comme toute modification du PKGBUILD lui-même. Cela serait utile si vous avez créé un PKGBUILD pour un programme que vous utilisez (et que vous souhaitez conserver la même version que celle du paquet), et que vous devez corriger un bogue dans le PKGBUILD lui-même.

Pour définir la variable, saisissez ce qui suit dans PKGBUILD :

pkgver="1"

Cette variable doit toujours commencez à 1, puis montez un à la fois. Quand le pkgver lui-même monte, cela peut (et doit) être réinitialisé à 1, car le pkgver lui-même informera les utilisateurs que des mises à niveau sont disponibles.

pkgdesc

Cela définira la description du package, qui est utilisée pour aider à mieux identifier le package.

Pour le définir, mettez simplement la description entre guillemets :

pkgdesc="Hello world in your terminal!"

cambre

Cette variable définit le architecture le paquet est compatible avec. C’est bien si vous ne comprenez pas ce qu’est une architecture, car c’est à peu près inutile dans la plupart des cas.

Quoi qu’il en soit, makepkg a toujours besoin d’être défini pour qu’il sache que le package est compatible avec notre système.

Cette variable prend en charge la définition de plusieurs valeurs, donc makepkg nécessite une syntaxe différente, comme indiqué ci-dessous.

Pour le définir, entrez ce qui suit dans le PKGBUILD :

arch=("x86_64")

Si vous deviez définir plusieurs valeurs pour cela, vous sépareriez chaque valeur avec un espace et des guillemets comme ceci : arch=(“x86_x64” “bras”)

dépend

Cela répertorie tous les packages dont notre package a besoin pour fonctionner. Comme cambre, il peut également contenir plusieurs valeurs et doit donc utiliser la syntaxe des parenthèses.

Étant donné que notre package n’aura aucune dépendance, nous n’avons pas à saisir ce champ dans le PKGBUILD. Si notre package avait des dépendances, nous utiliserions simplement la même syntaxe que cambre.

dépend de l’option

Cela répertorie les packages qui ne sont pas nécessaires pour fonctionner, mais qui sont nécessaires pour des fonctionnalités supplémentaires.

Cela suit la même syntaxe que dépend.

conflits

Cela indique à pacman quels paquets provoqueraient l’action ou le comportement de notre paquet d’une manière que nous ne voudrions pas.

Tout paquet répertorié ici serait désinstallé avant que le nôtre ne soit installé.

Cela suit la même syntaxe que dépend également.

Licence

Cela définit le licence de logiciel sous lequel votre programme est sous licence. le Arch Wiki a quelques informations si vous avez besoin d’aide pour choisir une licence. Régler ceci sur custom fonctionnera si vous ne savez pas sur quoi régler cela.

Cela prend la même syntaxe que cambre et dépend:

license=("custom")

la source

C’est ainsi que makepkg sait quels fichiers utiliser pour construire notre package. Cela peut contenir une variété de différents types de sources, y compris des fichiers locaux et des URL.

Lors de l’ajout de fichiers locaux, entrez le nom du fichier relatif au PKGBUILD, c’est-à-dire considérez la disposition de répertoire suivante :

PKGBUILD
file.txt
src/file.sh

Si vous vouliez inclure fichier.sh dans notre PKGBUILD, vous entreriez src/fichier.sh comme son nom.

Lors de la saisie des URL, vous saisissez simplement l’URL complète, c’est-à-dire https://mirrors.GeneratePresscommons.org/presskit/logos/cc.logo.large.png.

Votre package n’a besoin que du fichier hello-world.sh, et comme il se trouve dans le même répertoire que le PKGBUILD, vous saisissez simplement son nom comme valeur pour la source.

Cette variable utilise également la même syntaxe que cambre et dépend:

source=("hello-world.sh")

sha512sommes

Ceci est utilisé pour vérifier que les fichiers dans la source n’ont pas été modifiés ou téléchargés de manière incorrecte. Vous trouverez des informations sur l’obtention des valeurs correspondantes dans le Article Wiki d’Arch sur les PKGBUILD.

Si vous préférez ne pas définir cela (ou si vous n’en avez pas besoin, c’est-à-dire pour les fichiers locaux), vous pouvez simplement entrer SKIP pour chaque fichier dans le la source variable:

sha512sums=("SKIP")

paquet()

C’est la dernière et la plus importante partie de la création de notre package. Il est important de connaître deux variables lorsque vous travaillez avec ceci :

• ${srcdir}: c’est ici que makepkg place les fichiers dans le la source variable. Il s’agit du répertoire dans lequel vous pouvez interagir avec les fichiers et apporter toute autre modification nécessaire aux fichiers.

• ${pkgdir} : c’est ici que nous plaçons les fichiers qui seront installés sur notre système.
  La structure des dossiers pour ${pkgdir} est configurée comme s’il s’agissait d’un système réel (c’est-à-dire que ${pkgdir}/usr/bin/hello-world créerait le fichier /usr/bin/hello-world lors de l’installation avec pacman.

package() contient une liste de commandes utilisées pour créer un package.

Donc, si (hypothétiquement) vous aviez besoin d’un fichier qui lit Linux est supérieur à Windows dans /usr/share/motto.txt, vous exécuteriez quelque chose comme ceci :

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

Quelques notes sur la commande ci-dessus :

• ${pkgdir} contient non répertoires à l’intérieur dans un premier temps. Si vous avez sauté le commande mkdir, tee afficherait une erreur indiquant que le répertoire n’existe pas.

• Lors de la spécification des répertoires, toujours les faire précéder avec le $ {pkgdir} ou ${srcdir} variable. Entrer quelque chose comme /usr/share/motto.txt sans cela pointerait vers le répertoire littéral /usr/share/motto.txt sur votre système en cours d’exécution.

Pour votre PKGBUILD, vous allez placer le fichier hello-world.sh dans /usr/bin/hello-world sur votre système cible. Vous ferez également en sorte que le fichier dise « Bonjour à vous ! » lorsqu’il a couru.

Pour ce faire, entrez ce qui suit dans votre 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"
}

Et tu as fini! Votre fichier résultant devrait maintenant ressembler à ceci :

Maintenant, construisez et installez le paquet avec le makepkg -si commande, puis exécutez hello-world dans votre terminal pour voir sa sortie.

Emballer

Et juste comme ça, vous avez fait votre premier PKGBUILD ! Vous êtes sur le point de créer de véritables packages pour vous-même, et peut-être même pour l’AUR.

Vous avez des questions, ou quelque chose ne fonctionne tout simplement pas ? N’hésitez pas à le poster dans la section commentaire ci-dessous.