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

Les fichiers PKGBUILD permettent de construire et de créer des packages pour Arch Linux et ses dérivés tels que Manjaro.

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

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

Les bases de PKGBUILD

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

Les fichiers PKGBUILD sont constitués 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 lancez simplement makepkg dans le répertoire contenant le PKGBUILD, et voilà, vous avez un paquet installable !

Dans ce didacticiel, vous allez passer en revue le package que je viens de créer, qui imprime "Hello World!" lors de l'exécution :

Mise 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é hello-world.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 recommande fortement le Article Arch Wiki 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 de celles 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 du paquet

Tout d'abord, la variable pkgname. C'est ce qui définit le nom de votre paquet lors de l'installation et comment le gestionnaire de paquets d'Arch Linux, pacman, garde une trace du paquet.

Le format de cette variable (et 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, entrez ce qui suit dans le PKGBUILD :

pkgname="hello-world"

Pour définir un nom de package différent, remplacez hello-world avec le nom du package.
Cela ne définit pas la commande utilisée pour exécuter le programme. C'est géré un peu plus bas 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 avertira les utilisateurs des mises à jour si elle est déplacée vers un numéro supérieur.

Il sert pour toutes les modifications qui nécessitent que le pkgver reste le même, telles que les modifications apportées au 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 package), et que vous devez corriger un bogue dans le PKGBUILD lui-même.

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

pkgver="1"

Cette variable doit toujours commencer à 1, puis monter un à la fois. Lorsque le pkgver lui-même monte, cela peut (et devrait) ê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!"

arche

Cette variable définit l'architecture avec laquelle le package est compatible. Ce n'est pas grave si vous ne comprenez pas ce qu'est une architecture, car elle est pratiquement inutile dans la plupart des cas.

Quoi qu'il en soit, makepkg a toujours besoin qu'il soit défini pour qu'il sache que le paquet 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 par un espace et des guillemets comme suit :arch=("x86_x64" "arm")

ça dépend

Ceci répertorie tous les packages dont notre package a besoin pour fonctionner. Comme arche , 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 besoin de saisir ce champ dans le PKGBUILD. Cependant, si notre package avait des dépendances, nous utiliserions simplement la même syntaxe que arch .

opt dépend

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 feraient en sorte que notre paquet agisse ou se comporte d'une manière que nous ne voudrions pas.

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

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

licence

Cela définit la licence logicielle sous laquelle votre programme est concédé sous licence. L'Arch Wiki contient des informations si vous avez besoin d'aide pour choisir une licence. Définir ceci sur custom fonctionnera si vous ne savez pas sur quoi le définir.

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

license=("custom")

source

C'est ainsi que makepkg sait quels fichiers utiliser pour construire notre paquet. Il peut contenir 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 par rapport au PKGBUILD, c'est-à-dire considérez la disposition de répertoire suivante :

PKGBUILD
file.txt
src/file.sh

Si vous vouliez inclure file.sh dans notre PKGBUILD, vous saisiriez src/file.sh comme son nom.

Lors de la saisie des URL, il vous suffit de saisir l'URL complète, c'est-à-dire https://mirrors.creativecommons.org/presskit/logos/cc.logo.large.png.

Votre paquet n'a besoin que du fichier hello-world.sh, et puisqu'il se trouve dans le même répertoire que le PKGBUILD, il vous suffit de taper son nom comme valeur pour source .

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

source=("hello-world.sh")

sha512sums

Ceci est utilisé pour vérifier que les fichiers dans source n'ont pas été modifiés ou téléchargés de manière incorrecte. Des informations sur l'obtention des valeurs pour cela peuvent être trouvées dans l'article Arch Wiki sur les PKGBUILDs.

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

sha512sums=("SKIP")

paquet()

C'est la dernière partie, et la plus importante, de la fabrication de notre package. Il est important de connaître deux variables lorsque vous travaillez avec ceci :

${srcdir} :C'est là que makepkg place les fichiers dans 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 là que nous plaçons les fichiers qui seront installés sur notre système.
La structure de dossiers pour ${pkgdir} est configurée comme si elle se trouvait sur 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 indiquant que 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 d'abord. Si vous ignorez la commande mkdir, tee affichera une erreur indiquant que le répertoire n'existe pas.

Lorsque vous spécifiez des répertoires, toujours faites-les précéder du ${pkgdir} ou ${srcdir} variable. Saisir 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 dire au fichier "Hello to you!" lors de l'exécution.

Pour ce faire, saisissez 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 :

Compilez et installez maintenant le package avec le makepkg -si commande, puis exécutez hello-world dans votre terminal pour voir sa sortie.

Conclusion

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

Vous avez des questions ou quelque chose ne fonctionne pas correctement ? N'hésitez pas à le publier dans la section des commentaires ci-dessous.