Comment créer un package RPM

RPM est à la fois le gestionnaire de packages et le format de package utilisé par de nombreuses distributions Linux telles que Fedora, Red Hat et CentOS, pour gérer et distribuer des logiciels sous forme binaire. Dans ce tutoriel, nous verrons comment créer et emballer une application simple.

Dans ce tutoriel, vous apprendrez:

• Quels sont les concepts de base derrière le processus de construction du RPM.
• Quel est l'environnement de construction.
• Qu'est-ce qu'un spécifile SpecFile.
• Comment utiliser les macros à l'intérieur d'un specfile.
• Comment installer les dépendances de construction.
• Comment créer un spécifile.
• Comment construire un package RPM.

Exigences et conventions logicielles utilisées

RPM Concepts de base

L'installation, la suppression, la mise à jour, (en un mot, la gestion) est une tâche essentielle sur chaque système d'exploitation. Lorsque les gestionnaires de package n'étaient pas une chose, la seule façon d'installer un programme était de compiler son code source et de placer les fichiers résultants aux endroits appropriés du système de fichiers. Garder une trace des dépendances de chaque morceau de code était vraiment difficile et prenant du temps. Ensuite, les gestionnaires de package ont été introduits, et tout est devenu plus facile.

Chaque distribution Linux moderne a, de nos jours, son gestionnaire de packages: Debian et ses dérivés utilisent dpkg, alors que
RPM est utilisé dans la famille des distributions Red Hat. Le logiciel est fourni pré-compilé sous la forme de paquets, qui sont essentiellement des archives compressées contenant des métadonnées sur la version logicielle, ses dépendances et ses éventuels conflits avec d'autres packages.

Dans ce tutoriel, nous verrons comment créer un package RPM à partir d'un code source d'application. L'application que nous allons emballer est feh, Une vue d'image de ligne de commande simple: elle est assez petite et a peu de dépendances. Avant de commencer à construire notre premier package, il y a cependant quelques concepts essentiels que nous devons comprendre.

L'environnement de construction

La racine d'un arbre d'environnement de construction de RPM est le rpmbuild Répertoire, qui contient 6 sous-répertoires: CONSTRUIRE, Buildroot, RPM, SOURCES, Spécifications et SRPMS. Nous verrons comment est possible de générer cet environnement en lançant une commande simple; Pour l'instant, mentionnons simplement le rôle de ces répertoires. Voici une représentation de l'arbre de travail:

 Rpmbuild | - build | - buildroot | - RPMS | - Sources | - Specs | - SRPMS 

Chacun de ces répertoires a un rôle spécifique dans le processus de construction:

• Le CONSTRUIRE Le répertoire est l'endroit où le code source du programme que nous voulons emballer est construit
• Le Buildroot Le répertoire est où les fichiers résultant de la compilation du logiciel à l'intérieur du répertoire de construction sont copiés, reflétant la structure du système cible dans un sous-répertoire avec le package Mame:
  Dans notre cas, le binaire «feh» qui serait installé dans / usr / bin sera signalé comme buildroot / feh-3.0-1.FC29.x86_64 / usr / bin.
• Le RPM répertoire, c'est l'endroit où RPM Les packages sont générés: chaque régime sera placé dans un sous-répertoire
  nommé d'après son architecture, ou, noarch S'il n'est pas spécifique à l'architecture.
• Le SOURCES Le répertoire héberge le code source compressé du logiciel que nous voulons emballer, souvent sous la forme d'un tarball d'un fichier zip.
• Le Spécifications répertoire, c'est là que nous mettons le .spécifier dossier avec les instructions pour construire notre package: nous analyserons la structure de ce fichier dans un instant.
• Le SRPMS Le répertoire est l'équivalent des RPM, mais pour les RPM de source. Ces packages spéciaux contiennent le code source d'origine de l'application, des correctifs éventuels et le SpecFile utilisé pour créer le package.

Le fichier de spécification

Le fichier où toutes les instructions et informations nécessaires pour créer un package RPM sont définies .spécifier déposer. Un spécifile contient, entre autres choses, le construire des dépendances (le logiciel nécessaire pour compiler le programme que nous voulons emballer), le Dépendances d'exécution (les bibliothèques nécessaires pour que le programme s'exécute correctement) et les Omands qui devraient être exécutés pour compiler le logiciel.

Le fichier est composé par deux macro-sections: un préambule et le corps. Dans chacune de ces sections, différentes instructions peuvent être spécifiées. Voyons certains d'entre eux. Le préambule La section peut contenir les instructions suivantes:

• • Nom: Le nom de base du package (cela devrait correspondre au nom du fichier de spécification)
  • Version: La version en amont du logiciel emballé
  • Libérer: Le numéro de version du package
  • Licence: La licence utilisée pour le logiciel que nous voulons emballer
  • URL: L'URL en amont du logiciel
  • Source0: L'URL directe ou le chemin du Code source compressé du logiciel (Tarball ou fichier zippé)
  • Buildarch: L'architecture du package: si aucune architecture n'est spécifiée, celle du système hôte sera utilisée
  • BuildRequires: Les dépendances nécessaires pour créer le logiciel
  • A besoin: Les dépendances nécessaires pour exécuter le logiciel

Le corps Section du SpecFile, contient généralement les sections suivantes:

• %description: Une description éventuellement multi-ligne du logiciel emballé
• %préparation: La ou les commandes nécessaires pour préparer le code source (par exemple, les commandes nécessaires pour extraire un tarball)
• %construire: La ou les commandes nécessaires pour construire le logiciel
• %installer: La ou les commandes devaient copier le fichier résultant du processus de construction au Buildroot annuaire
• %des dossiers: La liste des fichiers fournis par le package, qui sera installé sur le système

Macros

Pour faciliter notre travail, à l'intérieur d'un spécifile, nous pouvons utiliser certaines macros qui nous faisaient référence à de nombreuses choses utiles et effectuer automatiquement certaines tâches. Tout d'abord, nous avons le RPM Directory Macros qui permettent de référence aux répertoires de notre environnement de construction; Nous devons toujours les utiliser au lieu de chemins directs:

• % _ topdir: Cette macro fait référence au rpmbuild annuaire
• % _ builddir: Référence le CONSTRUIRE Répertoire à l'intérieur de notre arbre de construction
• % _ rpmdir: Référence le chemin du RPM annuaire
• % _ Sourcedir: Cette macro est évaluée sur le chemin de la SOURCES annuaire
• % _ Specdir: Une macro qui représente le chemin du Spécifications annuaire
• % _ srcrpmdir: Référence à la voie de SRPMS annuaire
• % _ buildrootdir: Référence le chemin du Buildroot annuaire

D'autres macros nous faisons référence aux répertoires les plus importants du système de fichiers de notre machine, par exemple:

• % _ sysconfigdir: Le /etc annuaire
• %_préfixe: Le / usr annuaire
• % _ bindir: Le / usr / bin annuaire
• % _ mandir: Le chemin vers le / usr / share / man annuaire

Celui ci-dessus, n'est pas une liste complète, mais cela vous donne une idée. De plus, nous pouvons également utiliser un ensemble de macros qui effectuent des tâches spécifiques. Pour étendre la définition d'une macro, et donc pour voir son contenu, nous pouvons utiliser le RPM - Eval commande, qui prend la macro comme argument. Voici quelques exemples de macros fréquemment utilisées:

• Le %installation macro, est utilisé dans le % de configuration Section du SpecFile, et effectue essentiellement les actions suivantes:
  1. Extrait le code source du programme que nous voulons emballer dans le Builddir annuaire
  2. Passe dans le répertoire extrait
  3. Définit les autorisations de fichiers appropriées à l'intérieur
• Le % make_build la macro est utilisée dans le %construire Section du SpecFile, et exécute essentiellement le faire Commande avec un ensemble d'options prédéfini, pour compiler le code source du logiciel. Si nous l'élargissons, nous pouvons vérifier la commande qu'il s'exécute:

  $ rpm --eval "% make_build" / usr / bin / make -o -j4 

• Le % make_install La macro, à la place, est utilisée dans le %installer Section du fichier et s'exécute faire l'installation avec le Destdir Paramètre, utilisé pour instruire la commande d'installer les fichiers compilés relativement à un répertoire donné au lieu du système réel / /:

  $ rpm --eval "% make_install" / usr / bin / make install destdir = / home / egdoc / rpmbuild / buildroot /% name -% version -% release.x86_64 install = "/ usr / bin / install -p" 

Comment créer un package RPM Instructions étape par étape

Maintenant que nous avons appris le concept de base du processus de construction de packages, nous pouvons voir comment créer notre environnement de construction et notre premier package RPM. Créons notre package.

Installez les dépendances de construction

En première chose, nous devons installer rpmdevtools, plus les dépendances nécessaires pour construire feh:

$ sudo dnf installer rpmdevtools gcc make imlib2-devel libjpeg-devel libpng-devel libxt-devel libxinerama-devel libexif-devel \ perl-test-command perl-test-harness libcurl-devel 

Une fois les packages installés, nous pouvons générer notre environnement de construction. Tout ce que nous avons à faire est de lancer la commande suivante:

$ rpmdev-setuptree

À ce stade rpmbuild Le répertoire, et toutes les sous-répertoires que nous avons vues auparavant, devraient être créées. L'étape suivante consiste à écrire notre spécifile.

Créer le SpecFile

Nous créons le SpecFile avec notre éditeur de texte préféré et l'enregistrons dans le Spécifications Répertoire avec le même nom du package. Voici à quoi devrait ressembler un SpecFile minimal:

Nom: Feh Version: 3.0 Libération: 1% ?DIST Résumé: Visionneuse d'image de ligne de commande rapide Utilisation de la licence IMLIB2: URL MIT: http: // feh.finalwind.org source0: http: // feh.finalwind.org / feh -% version.le goudron.BZ2 BuildRequires: GCC BuildRequires: IMLIB2-Devel BuildRequires: Libcurl-Devel BuildRequires: libjpeg-devel BuildRequires: libpng buildRequires Test-Harness% Description Visionneuse d'image de ligne de commande rapide Utilisation d'IMLIB2% Prep% Configuration -Q% build% make_build% install% make_install prefix =% _ prefix% fichiers / usr / bin / feh / usr / lib / debug / usr / bin / feh-3.0-1.FC29.x86_64.débogage / usr / share / applications / feh.Desktop / usr / share / doc / feh / auteurs / usr / share / doc / feh / changelog / usr / share / doc / feh / readme.md / usr / share / doc / feh / todo / usr / share / doc / feh / exemples / boutons / usr / share / doc / feh / exemples / find-lowres / usr / share / doc / feh / exemples / keys / usr / share / doc / feh / exemples / thèmes / usr / share / feh / polis / noir.style / usr / share / feh / polices / menu.style / usr / share / feh / polices / yudit.ttf / usr / share / feh / images / feh.png / usr / share / feh / images / feh.svg / usr / share / feh / images / menubg_default.png / usr / share / icons / hicolor / 48x48 / apps / feh.png / usr / share / icons / hicolor / scalable / apps / feh.svg / usr / share / man / man1 / feh.1.gz 

Analysons-le. Tout d'abord, nous avons spécifié quelques informations de base sur le logiciel que nous souhaitons emballer: son nom et sa version en amont, sa licence, l'emplacement de la page principale du projet et le lien direct vers le code source Tarball, puis nous avons déclaré le construire des dépendances en utilisant Raccourcissement. La liste des dépendances peut être représentée comme une liste en ligne séparée dans l'espace ou les virgules, mais par souci de lisibilité, nous avons déclaré une dépendance par ligne, répétant le Raccourcissement instruction.

Après avoir déclaré les dépendances nécessaires pour construire le logiciel, nous avons fourni une brève description dans le %description Section, et a été remise à la partie la plus importante du SpecFile: les instructions pour préparer, construire et installer le logiciel, respectivement dans le %préparation, %construire et %installer sections.

Dans le %préparation Section, fournissant le % Configuration -Q La macro a été suffisante: comme dit précédemment, cette macro exécutera les commandes nécessaires pour déballer la source tarball et placer le répertoire extrait dans le CONSTRUIRE dossier.

Le %construire La section est l'endroit où nous spécifions les commandes qui devraient être exécutées pour construire le code source. Même ici, tout ce que nous devions utiliser était juste le % make_build macro, qui exécute le faire Commande avec les options que nous avons vues auparavant, dans le répertoire hébergeant le code source déballé de l'application que nous souhaitons emballer.

Dans le %installer Section, nous avons utilisé une autre macro, % make_install, fournir également le PRÉFIXE paramètre, en le réglant sur %_préfixe, qui sera étendu à / usr. La commande résultante provoquera la mise en place des fichiers produits par la compilation du code source dans la «fausse racine», définie avec le Destdir paramètre contenu dans la macro. Depuis dans le % make_install macro, «destdir» est réglé sur / home / egdoc / rpmbuild / buildroot /% name -% version -% release.x86_64, Les fichiers seront installés sous: / home / egdoc / rpmbuild / buildroot /% name -% version -% release.x86_64 / usr.

Enfin, nous avons fourni, dans le %des dossiers Section, une liste des fichiers qui seront installés par notre package. Cette liste pourrait être inspectée plus tard en exécutant le rpm -qlp / path / to / the / rpm commande ou, si le package est déjà installé, en exécutant simplement RPM -QL PackageName.

Obtenez les sources et créez le package RPM

Maintenant que notre fichier de spécifications est enfin prêt, nous pouvons construire notre RPM. Vous remarquerez peut-être que nous n'avons pas encore téléchargé la source Tarball de «FEH»: il n'est pas nécessaire de le faire manuellement, car nous pouvons utiliser le spectaculaire commande:

$ Spectool -g -r ~ / rpmbuild / specs / feh.spec obtenant http: // feh.finalwind.org / feh-3.0.le goudron.bz2 à / home / egdoc / rpmbuild / sources / feh-3.0.le goudron.bz2% total% reçu% xferd vitesse moyenne temps temps temps courant dload téléchargement total dépensé à gauche 100 185 100 185 0 0 898 0 -: -: - -:: - - -: -: - - 898 100 2057K 100 2057K 0 0 1988K 0 0:00:01 0:00:01 -: -: - 4191k 

Cette commande téléchargera les sources que nous avons référencées avec une URL à l'intérieur du SpecFile, dans le répertoire approprié de notre arbre de travail: ~ / rpmbuild / sources. Avec les sources en place, nous pouvons construire notre régime: tout ce que nous avons à faire est de lancer le rpmbuild commander et fournir le chemin du SpecFile. Lorsqu'il est lancé avec le -bb Option, RPMBuild ne construira qu'un seul colis binaire: si nous voulons générer aussi un RPM de source, Nous devons utiliser -ba Au lieu de cela (consultez la page mande RPMBuild pour un aperçu des options de possibile).

Une chose très importante à retenir est que la commande rpmbuild ne doit jamais être lancée avec des autorisations racines: ce faisant, même une simple erreur dans le SpecFile pourrait produire des effets indésirables sur notre système. Exécutons RPMBuild:

$ rpmbuild -bb ~ / rpmbuild / specs / feh.spécifier

La sortie des opérations effectuées sera imprimée à l'écran et, si tout se passe comme prévu, le package RPM sera généré à l'intérieur du RPM annuaire.

Conclusions

Dans ce tutoriel, nous avons appris les concepts fondamentaux impliqués dans la création d'un régime RPM. Nous avons appris des macros et comment construire un .spécifier fichier, qui contient toutes les instructions nécessaires pour le processus de construction. Nous avons également fourni un exemple réel, construire et emballage feh, une visualise d'image de ligne de commande simple. Je vous suggère de consulter le Guide officiel d'emballage Red Hat pour étendre davantage les concepts mentionnés dans ce tutoriel.

Tutoriels Linux connexes:

• Une introduction à l'automatisation Linux, des outils et des techniques
• Choses à installer sur Ubuntu 20.04
• Masterring Bash Script Loops
• Mint 20: Mieux que Ubuntu et Microsoft Windows?
• Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
• Comment mettre à jour Centos
• Téléchargement Linux
• Ubuntu 20.04 Guide
• Comment migrer de Centos à Almaliux
• Fichiers de configuration Linux: 30 premiers