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

  • FrançaisFrançais



  • 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 vous-même 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 connaissent Bash ou d’autres shells, vous serez ravi 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 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 à l’intérieur du répertoire contenant le PKGBUILD, et le tour est joué, vous avez un package installable !

    PKGBUILD

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

    Exemple PKGBUILD

    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 :

    Guide de base de PKGBUILD

    Et vous êtes prêt à partir !

    Configuration de votre fichier PKGBUILD

    Au lieu de vous demander de copier-coller tout le fichier, je vais entrer 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 pacman d’Arch Linux 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 à toutes les modifications qui nécessitent que le pkgver reste le même, comme toutes 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 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 ainsi que.

    Licence

    Cela définit le licence de logiciel sous lequel votre programme est sous licence. le Wiki Arch 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.creativecommons.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 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 réalisation 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 de ${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 alors ${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 ! » quand 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! Construisez et installez le paquet avec makepkg -si, puis exécutez hello-world dans votre terminal pour voir sa sortie.

    image 1

    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.

    Source

    N'oubliez pas de voter pour cet article !
    1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
    Loading...

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.