Comment créer un package RPM Linux

Cet article vous montre comment empaqueter un script dans un fichier RPM pour faciliter l'installation, la mise à jour et la suppression de vos systèmes Linux. Avant d'entrer dans les détails, je vais vous expliquer ce qu'est un package RPM et comment vous pouvez l'installer, l'interroger, le supprimer et, surtout, en créer un vous-même.

Cet article couvre :

Qu'est-ce qu'un package RPM ?
Comment créer un package RPM.
Comment installer, interroger et supprimer un package RPM.

Qu'est-ce qu'un package RPM ?

RPM signifie Red Hat Package Manager . Il a été développé par Red Hat et est principalement utilisé sur les systèmes d'exploitation Linux basés sur Red Hat (Fedora, CentOS, RHEL, etc.).

Un package RPM utilise le .rpm extension et est un ensemble (une collection) de différents fichiers. Il peut contenir les éléments suivants :

Fichiers binaires, également appelés exécutables (nmap , stat , xattr , ssh , sshd , et ainsi de suite).
Fichiers de configuration (sshd.conf , updatedb.conf , logrotate.conf , etc.).
Fichiers de documentation (README , TODO , AUTHOR , etc.).

Le nom d'un package RPM suit ce format :

<name>-<version>-<release>.<arch>.rpm

Un exemple :

bdsync-0.11.1-1.x86_64.rpm

Certains packages incluent également une version abrégée de la distribution pour laquelle ils ont été créés, par exemple :

bdsync-0.11.1-1.el8.x86_64.rpm

[ Vous pourriez également apprécier : la gestion des packages Linux avec YUM et RPM ]

Comment créer un package RPM

Vous aurez besoin des composants suivants pour créer un package RPM :

Un poste de travail ou une machine virtuelle exécutant une distribution basée sur RPM, telle que RHEL ou Fedora.
Logiciel pour créer le package.
Code source à empaqueter.
Fichier SPEC pour construire le RPM.

Installation du logiciel requis

Les packages suivants doivent être installés pour créer le package RPM :

$ sudo dnf install -y rpmdevtools rpmlint

Après avoir installé rpmdevtools , créez l'arborescence de fichiers dont vous avez besoin pour créer des packages RPM :

$ rpmdev-setuptree

Vous construisez des packages RPM en tant qu'utilisateur normal (pas root), donc votre environnement de construction est placé dans votre répertoire personnel. Il contient cette structure de répertoire :

rpmbuild/
├── BUILD
├── RPMS
├── SOURCES
├── SPECS
└── SRPMS

La CONSTRUCTION est utilisé pendant le processus de construction du package RPM. C'est là que les fichiers temporaires sont stockés, déplacés, etc.
Le RPMS répertoire contient les packages RPM construits pour différentes architectures et noarch si spécifié dans .spec fichier ou pendant la construction.
Les SOURCES Le répertoire, comme son nom l'indique, contient les sources. Cela peut être un simple script, un projet C complexe qui doit être compilé, un programme pré-compilé, etc. Habituellement, les sources sont compressées en .tar.gz ou .tgz fichiers.
La SPEC répertoire contient le .spec des dossiers. Le .spec Le fichier définit comment un package est construit. Plus d'informations à ce sujet plus tard.
Le SRPMS répertoire contient le .src.rpm paquets. Un package Source RPM n'appartient pas à une architecture ou à une distribution. Le .rpm réel la construction du paquet est basée sur le .src.rpm paquet.

Un .src.rpm est très flexible, car il peut être construit et reconstruit sur toutes les autres distributions et architectures basées sur RPM.

Vous savez maintenant ce que contient chaque répertoire, alors créez maintenant un script simple à distribuer :

$ cat << EOF >> hello.sh
#!/bin/sh
echo "Hello world"
EOF

Cela crée un script shell appelé hello.sh , qui imprime "Hello world" sur le terminal. C'est simple, mais c'est suffisant pour démontrer l'emballage.

Placez le script dans le répertoire désigné

Pour créer un package pour votre script, vous devez placer votre script dans le répertoire dans lequel le système de génération RPM s'attend à ce qu'il se trouve. Créez un répertoire pour celui-ci, en utilisant la gestion sémantique des versions comme le font la plupart des projets, puis déplacez hello.sh dedans :

$ mkdir hello-0.0.1
$ mv hello.sh hello-0.0.1

La plupart du code source est distribué sous forme d'archive, utilisez donc la commande tar pour créer un fichier d'archive :

$ tar --create --file hello-0.0.1.tar.gz hello-0.0.1

Déplacez ensuite l'archive que vous venez de créer dans les SOURCES répertoire :

$ mv hello-0.0.1.tar.gz SOURCES

Créer un fichier .spec

Un package RPM est défini par un .spec dossier. La syntaxe d'un .spec file est strict, mais rpmdev peut générer un fichier passe-partout pour vous :

$ rpmdev-newspec hello

Cela génère un fichier appelé hello.spec , que vous devez déplacer dans le SPECS annuaire. Exécutez tree ~/rpmbuild pour voir à quoi ressemble la structure du répertoire :

/home/tux/rpmbuild/
├── BUILD
├── BUILDROOT
├── RPMS
├── SOURCES
│   └── hello-0.0.1.tar.gz
├── SPECS
│   └── hello.spec
└── SRPMS

Le hello.spec généré Le fichier fournit un bon point de départ, mais il ne contient aucune information spécifique sur ce que vous construisez. Le .spec généré suppose que je vais compiler et construire un logiciel.

Vous empaquetez un script Bash, il y a donc une simplification que vous pouvez faire. Par exemple, il n'y a pas de Build processus car il n'y a pas de code à compiler. J'ai ajouté BuildArch :noarch car ce package est valide pour 32 bits, 64 bits, Arm et toute autre architecture de processeur exécutant Bash.

J'ai également ajouté Nécessite :bash afin que le package s'assure que Bash est installé. Ce simple script "hello world" s'exécute sur n'importe quel shell, bien sûr, mais ce n'est pas vrai pour tous les scripts, c'est donc un bon moyen de démontrer les dépendances.

Name:           hello
Version:        0.0.1
Release:        1%{?dist}
Summary:        A simple hello world script
BuildArch:      noarch

License:        GPL
Source0:        %{name}-%{version}.tar.gz

Requires:       bash

%description
A demo RPM build

%prep
%setup -q

%install
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/%{_bindir}
cp %{name}.sh $RPM_BUILD_ROOT/%{_bindir}

%clean
rm -rf $RPM_BUILD_ROOT

%files
%{_bindir}/%{name}.sh

%changelog
* Sun Nov  18 2020 Valentin Bajrami <[email protected]> - 0.0.1
- First version being packaged

Comme vous pouvez le constater, il existe de nombreux raccourcis dans .spec des dossiers. On les appelle des macros, et il existe une excellente liste de ce qui est disponible dans la documentation de l'empaquetage de Fedora. Il est important d'utiliser des macros dans votre .spec des dossiers. Ils aident à assurer la cohérence entre tous les systèmes RPM, ils vous aident à éviter les erreurs dans les noms de fichiers et la numérotation des versions, et ils facilitent la mise à jour du .spec fichier lorsque vous publiez une nouvelle version de votre script.

Par exemple, il est nécessaire que vous spécifiiez exactement quels fichiers sont installés sous %files section. Ici, j'ai explicitement mis la ligne suivante :

%files
%{_bindir}/%{name}.sh

Cela fonctionne parce que je veux que le script aille à %{_bindir} (qui est une macro qui se traduit par /usr/bin par défaut, mais est configurable lorsque les utilisateurs souhaitent installer à un emplacement différent, tel que /usr/local/bin ). Vous pouvez vérifier les valeurs des macros en exécutant :

$ rpm --eval '%{_bindir}'
/usr/bin

Autres macros utiles :

%{name} nom du package (tel que défini dans le Nom : champ)
%{version} version du package (telle que définie dans la section Version : champ)
%{_datadir} données partagées (/usr/sbin par défaut)
%{_sysconfdir} répertoire de configuration (/etc par défaut)

Vérification du fichier .spec en cas d'erreur (rpmlint)

Le rpmlint la commande peut trouver des erreurs dans .spec fichiers :

$ rpmlint ~/rpmbuild/SPECS/hello.spec
SPECS/hello.spec: W: no-%build-section
SPECS/hello.spec: W: invalid-url Source0: hello-0.0.1.tar.gz
0 packages and 1 specfiles checked; 0 errors, 2 warnings.

Il y a 2 erreurs signalées, mais elles sont toutes les deux acceptables. Il n'y a pas de code à construire, donc il n'y a pas besoin d'un %build section, et l'archive source est un fichier local et n'a pas d'URL réseau.

Tout a l'air bien.

Construire le paquet (rpmbuild)

Pour construire le package RPM, utilisez le rpmbuild commande. Plus tôt dans ce tutoriel, j'ai mentionné la différence entre le .src.rpm (paquet source RPM) et le .rpm paquet.

Pour créer le .src package rpm :

$ rpmbuild -bs ~/rpmbuild/SPECS/hello.spec

Les drapeaux -bs ont les significations suivantes :

-b :construire
-s :source

Pour créer le package binaire .rpm :

$ rpmbuild -bb ~/rpmbuild/SPECS/rm-ssh-offendingkey.spec

Les drapeaux -bb ont les significations suivantes :

-b :construire
-b :binaire

Utilisez -ba pour construire les deux.

Une fois le processus de construction terminé, vous avez la structure de répertoires suivante :

$ tree ~/rpmbuild/
/home/tux/rpmbuild/
├── BUILD
│   └── hello-0.0.1
│       ├── hello.sh
├── BUILDROOT
├── RPMS
│   └── noarch
│       └── hello-0.0.1-1.el8.noarch.rpm
├── SOURCES
│   └── hello-0.0.1.tar.gz
├── SPECS
│   └── hello.spec
└── SRPMS

Installation du package RPM

Après une construction réussie du paquet, vous pouvez installer le paquet RPM en utilisant le dnf commande :

$ sudo dnf install ~/rpmbuild/RPMS/noarch/hello-0.0.1-1.el8.noarch.rpm

Il peut alternativement être installé avec le rpm commande directement :

$ sudo rpm -ivh ~/rpmbuild/RPMS/noarch/hello-0.0.1-1.el8.noarch.rpm

Vérifiez que le package a été installé

Pour vérifier que le package a été correctement installé, exécutez la commande suivante :

$ rpm -qi hello
Name        : hello
Version     : 0.0.1
Release     : 1
Architecture: noarch
Install Date: Mon 09 Nov 2020 01:29:51 AM CET
Group       : Unspecified
Size        : 294
License     : GPL
Signature   : (none)
Source RPM  : hello-0.0.1-1.el8.src.rpm
Build Date  : Mon 09 Nov 2020 01:08:14 AM CET
Build Host  : slimmerAI
Summary     : A simple hello world script
Description : A demo RPM build

Le %changelog l'entrée d'un package peut également être visualisée :

$ rpm -q hello --changelog
* Sun Nov 08 2020 Valentin Bajrami <[email protected]> - 0.1
- First version being packaged

Découvrez ce qu'il y a dans le package RPM

Il est facile de voir quels fichiers contient un package RPM :

$ rpm -ql hello
/usr/bin/hello.sh

Suppression du package RPM

La suppression du package du système est aussi simple que son installation. Vous pouvez utiliser le dnf commande :

$ sudo dnf remove hello

Ou le rpm commande directement :

$ sudo rpm --verbose --erase hello

Réflexions finales

Dans ce document, j'ai couvert les bases de l'empaquetage, y compris comment construire, installer et supprimer un paquet RPM de votre système. Le .spec peut devenir très compliqué à mesure que vous créez des logiciels plus avancés, mais vous pouvez lire des exemples concrets sur des référentiels de logiciels publics, tels que src.fedoraproject.org, pour en savoir plus.

[ Cours en ligne gratuit :Présentation technique de Red Hat Enterprise Linux. ]