CentOS - Fedora : Créer des RPM

Introduction



Dans cet article, on va voir comment créer ses RPMS sous Fedora et CentOS.
Cet article est une adaptation pour Fedora / CentOS de l'atelier que j'avais fait en 2014 chez COAGUL avec Mageia ( https://www.linuxtricks.fr/wiki/conference-coagul-initiation-a-la-mise-en-paquet-rpm )

On verra comment créer des RPMS par l'exemple, plus simple que de la théorie :-)

Prérequis



Être à l'aise avec la ligne de commande.
Avoir accès à Internet.
Une machine virtuelle CentOS ou Fedora (dédiée aux RPMs)

Installer les outils nécessaires :
Code BASH :
dnf install dnf-utils rpmdevtools rpmlint



Quelques rappels



Rappels sur les commandes RPM et DNF



RPM : Système de gestion de paquets, utilisés par certaines distributions GNU/Linux : CentOS, Fedora, OpenSuse, Mageia
A noter que RPM ne gère pas les dépendances.

rpm -i : installer
rpm -e : supprimer
rpm -U : mettre à jour
-vh : En mode verbeux, et avec une barre de progression.
rpm -E %{macro} : donne la valeur de la macro ( rpm -E %{_lib} )

DNF : Système de gestion de paquets gérant les dépendances.

dnf install : Installer
dnf upgrade : Mettre à jour
dnf autoremove / remove : Supprimer (avec les dépendances orphelines / ou pas)
dnf builddep : Installe les dépendances nécessaire pour la compilation (dnf-utils nécessaires)

Concept de build : RPM, SRPM



Un RPM, c'est un paquet binaire ou métapaquet.
Le métapaquet : Le plus simple, suite de dépendances.
Un paquet binaire est un fichier qui contient tous les fichiers appartenant à une certaine application (ou bibliothèque). Un peu à la manière d'une archive TAR (ou ZIP). Mais le paquetage n'est pas seulement une archive (compressée), il contient aussi des scripts de contrôle. Ces scripts sont lus, exécutés et stockés lors de l'installation locale du RPM. Ils gèrent l'installation, la désinstallation, les contrôles d'état, les dépendances etc.

Un SRPM, c'est un paquet source.
Un paquet source contient le code source de l'application, les éventuels patchs, et le fichier SPEC.

Ce qu'il faut comprendre :
La création d'un paquet binaire consiste à compiler le programme sur une machine, à partir du code source. Nécessite bien souvent de connaître le langage de programmation. Google est notre ami sinon.
On y applique parfois des patchs.
On en produit un fichier RPM.
La compilation c'est parfois long (+ chercher les dépendances etc...)

Attention : Si compile sur machine 64bits, c'est un RPM 64bits généré. (Idem arm). Impossible de faire des RPM ARM sur PC 64bits. Sauf paquets noarch, indépendants de l'architecture

L'avantage du RPM, il apporte à l'utilisateur un paquet tout fait, qui s'installe rapidement.


Commandes qu'on va utiliser



On va devoir utiliser plusieurs commandes :
rpm et dnf : Logique pour faire des paquets mais déjà installé par défaut.
rpmbuild : Contient les scripts et exécutables pour compiler des paquets RPM.
rpmlint Vérificateur de paquets RPM
rpmdevtools : Outils de développement RPM

Il est conseillé de ne pas utiliser l'utilisateur root pour fabriquer ses paquets. Créer un utilisateur simple sur la machine.


Créer son arborescence de construction



On va avoir d'une hiérarchie spécifique.
On va utiliser la commande
Code BASH :
rpmdev-setuptree


L'arborescence est dans rpmbuild :

Code BASH :
rpmbuild 
|-- BUILD 
|-- RPMS 
|-- SOURCES 
|-- SPECS 
|-- SRPMS


Explications :

~/rpmbuild/BUILD : dossier (temporaire) où se fait la compilation des sources.
~/rpmbuild/RPMS : contient les paquets binaires RPM générés.
~/rpmbuild/SOURCES : contient les fichiers sources (par exemple paquet-source.tar.bz2, nos patchs ).
~/rpmbuild/SPECS : contient les fichiers .spec que nous devons écrire (fichiers recette).
~/rpmbuild/SRPMS : RPM sources après la construction. (pas d'architecture SRPM)


Nous avons aussi à la racine de notre home, le fichier .rpmmacros (généré de base comme ceci) :

Code BASH :
%_topdir %(echo $HOME)/rpmbuild
 
%__arch_install_post \
    [ "%{buildarch}" = "noarch" ] || QA_CHECK_RPATHS=1 ; \
    case "${QA_CHECK_RPATHS:-}" in [1yY]*) /usr/lib/rpm/check-rpaths ;; esac \
    /usr/lib/rpm/check-buildroot
 


On va pouvoir y définir des macros plus tard (la macro _topdir ici indique le chemin de l'arborescence précédemment créée)

On peut y ajouter des infos comme :
Code BASH :
%vendor         AdrienD
%packager       AdrienD <adriend@linuxtricks.fr>
%distsuffix     .ltfr



Quelques macros utiles


Macro Correspondance
%{buildroot} /home/adrien/rpmbuild/BUILDROOT/%{NAME}-%{VERSION}-%{RELEASE}.x86_64
%{_bindir} /usr/bin
%{_datadir} /usr/share
%{_prefix} / %{_usr} /usr
%{_lib} lib64
%{_libdir} /usr/lib64
%{_mandir} /usr/share/man
%{_sbindir} /usr/sbin
%{_sysconfdir} /etc
%{_usrsrc} /usr/src
%{_var} /var


Le fichier SPEC



Explications



On va décortiquer les sections d'un fichier SPEC :

En vert, les valeurs minimum requises pour effectuer la compilation d'un RPM



Compiler avec rpmbuild



On va utiliser dans nos exemples la commande rpmbuild, on pourra utiliser plusieurs options :

rpmbuild -ba fichier.spec : Pour compiler un RPM + SRPM à partir d'un fichier SPEC
On peut utiliser d'autres options pour y aller étapes par étape :
rpmbuild -bp fichier.spec : On ne fait que l'étape %prep
rpmbuild -bc fichier.spec : On fait %prep et %build
rpmbuild -bi fichier.spec : On fait %prep et %build et %install

Créer la structure d'un SPEC rapidement




Exemple 1 : Paquet vide



Exemple 2 : Méta paquet



Exemple 3 : 2 RPM dans un seul SPEC



Exemple 4 : Créer un paquet simple : lbzip2



Exemple 5 : Mettre à jour un paquet existant : A définir








Signer ses RPM



Générer une signature GPG



Signer un RPM généré



Créer son dépôt



Création du dépôt



Génération des métadonnées