Aujourd’hui, c’est du gros, on va faire des RPM, enfin on va en faire un simple. Puis, on montera un dépôt pour pouvoir diffuser facilement une tonne de RPM ! Ce dépôt sera utilisé par le gestionnaire de paquet YUM. YUM est apparu avec la Red Hat 5, il a transformé la vie des admins système en leur permettant d’installer une application et ses dépendances en une ligne de commande :D

Introduction

Cet article ne sera pas une introduction à la construction de paquets RPM. Le sujet est un métier à part entière, il serait difficile de couvrir toutes les possibilités. On va se focaliser sur l’aspect diffusion des RPM par l’intermédiaire d’un repository YUM, c’est à dire un dépôt contenant des RPM ainsi que des méta-données exploitables par le gestionnaire de paquets de Red Hat.

On va néanmoins créer un paquet, celui qui nous permettra d’activer le dépôt automatiquement sur un serveur. C’est donc notre point de départ, ensuite on s’attaquera à la configuration du dépôt lui même.

Création du paquet d’activation du repository

Pour pouvoir utiliser un repository supplémentaire, RedHat a besoin d’un fichier de configuration et d’une signature GPG. Notre RPM d’activation embarquera ces deux fichiers.

Premièrement, on va initialiser notre environnement de construction des RPMs. On commence par installer les outils nécessaires :

yum groupinstall "Developement Tools"
yum install rpmdevtools

Il est fortement conseillé de construire les paquets en utilisant un user autre que root. Ouvrez une session avec ce user et allez dans son home :

su - <build_user>
cd

Il y a une arborescence particulière pour la construction de paquets RPM, l’utilitaire rpmdev-setuptree permet de la créer automatiquement :

rpmdev-setuptree
ll rpmbuild/

Description rapide des dossiers :

• BUILD : Dossier temporaire où seront compilées les sources.
• RPMS : Répertoire de sorti où seront stockés les RPM finis, classés par architecture (32, 64 bits ou noarch).
• SOURCES : Répertoire contenant les sources des paquets a construire.
• SPECS : Répertoire contenant les fichiers “SPEC”, sorte de fichier de conf servant à la construction des RPM.
• SRPMS : Répertoire contenant les sources RPM, les paquets src.rpm permettent de reconstruire facilement un paquet sur d’autres systèmes.

On va commencer par peupler le dossier SOURCES avec les deux fichiers nécessaires à l’installation du dépôt. D’abord le fichier de conf du repository :

cd ~/rpmbuild/SOURCES/
vim <my_repo>.repo

Voici la structure du fichier de conf, le chemin est a adapter :

[<my_repo_id>]
name=<my_repo_fullname>
baseurl=http://<cname>.<domaine>/el6/
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/GPG-KEY-<my_repo_id>

Le champs “baseurl” est important, il est à adapter en fonction de l’arborescence de votre dépôt. Il peut contenir les variables suivantes : $basearch, $releasever et sûrement d’autres. Pour ma part, j’ai fais un sous dossier par version, el6 désignant toutes les distribs issues de la famille RH6.

On va ensuite générer la clé GPG qui signera notre dépôt et les paquets qu’il met à disposition :

gpg --gen-key

Il faut répondre à une série de questions puis donner une passphrase. On va ensuite l’exporter sous forme d’un fichier :

gpg  --export  --armor  "<uid_gpg_key>"  >  GPG-KEY-<my_repo_id>

Pour connaître l’uid de votre clé (habituellement “Prénom Nom (quelque chose) "), vous pouvez utiliser la commande suivante :

gpg --list-keys

C’est bon pour les sources, passons maintenant au “spec-file”, fichier de conf décrivant ce que fera le RPM finit. L’utilitaire rpmdev-newspec va créer l’ossature du fichier :

cd ~/rpmbuild/SPECS/
rpmdev-newspec repo-<my_repo_id>.spec
vim repo-<my_repo_id>.spec

Voila la gueule du fichier finit, c’est un peu brutal comme introduction mais il serait trop long de décrire les millions de possibilités du fichier spec :

Name:           repo-<my_repo_id>
Version:         1.0
Release:         1%{?dist}
Summary:     <my_repo_fullname>
Group:          System Environment/Base
License:        <licence>
URL:             https://<my_repo_url>
Packager:      <Prénom> <Nom> <<email>>
Vendor:         <entreprise_name>

Source0:       <my_repo>.repo
Source1:       GPG-KEY-<my_repo_id>

BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
BuildArch:      noarch

%description
<bla_bla_a_propos_du_repo>

%prep

%build

%install
rm -rf $RPM_BUILD_ROOT

# Creation de l'arborescence
mkdir -p $RPM_BUILD_ROOT%{_sysconfdir}/yum.repos.d/
mkdir -p $RPM_BUILD_ROOT%{_sysconfdir}/pki/rpm-gpg/

# Copie des fichiers du depot <my_repo_id>
install -m644 %{SOURCE0} $RPM_BUILD_ROOT%{_sysconfdir}/yum.repos.d/
install -m644 %{SOURCE1} $RPM_BUILD_ROOT%{_sysconfdir}/pki/rpm-gpg/

# Import de la clé
rpm --import %{_sysconfdir}/pki/rpm-gpg/GPG-KEY-<my_repo_id>

%clean
rm -rf $RPM_BUILD_ROOT

%files
%defattr(-,root,root,-)
%doc
%{_sysconfdir}/yum.repos.d/*
%{_sysconfdir}/pki/rpm-gpg/*

%changelog
* <DOW> <MMM> <DD> <YYYY> <Prénom> <Nom> <<email>> - 1.0-1
- Initial RPM Release

Il nous reste plus qu’à builder le paquet :

rpmbuild -ba repo-<my_repo_id>.spec

Deux fichiers sont finalement créés :

~/rpmbuild/SRPMS/repo-<my_repo>-1.0-1.el6.src.rpm : Le RPM source contenant le fichier spec ainsi qu'une archive des sources.
~/rpmbuild/RPMS/noarch/repo-<my_repo>-1.0-1.el6.noarch.rpm : Le RPM d'installation de notre dépôt.

Enfin, on signe nos deux paquets :

rpm --addsign ~/rpmbuild/SRPMS/repo-<my_repo>-1.0-1.el6.src.rpm
rpm --addsign ~/rpmbuild/RPMS/noarch/repo-<my_repo>-1.0-1.el6.noarch.rpm

On peut vérifier les infos du paquet avec la commande suivante :

rpm -qp --info ~/rpmbuild/RPMS/noarch/repo-<my_repo>-1.0-1.noarch.rpm

Création du repository RPM

Deuxième partie de l’article, on s’occupe cette fois ci du dépôt. Le dépôt est en fait un serveur http tout simple avec une arborescence particulière.

On installe les paquets nécessaires, vérifiez bien que votre distrib propose le paquet “createrepo” :

yum install createrepo httpd mod_ssl

On déclare un vhost Apache sur le port 80. Vous pouvez consulter cet article pour la configuration du serveur Apache.

On crée l’arborescence de notre dépôt, là vous êtes libre de faire comme vous le voulez. Il n’y a pas, à priori, de règle à suivre. Sur les dépôts les plus connus, ils utilisent une arborescence qui ressemble à :

<racine>/<distribution>/<version_majeur>/<arch>

Dans cette exemple, et comme dit au moment de créer le RPM d’install du dépôt, j’ai un sous-dossier par version de RedHat. Donc, créons l’arborescence :

cd /var/www/<cname>
mkdir el6/i386 el6/x86_64 el6/noarch el6/SRPMS
chown apache:apache /var/www/<cname> -R

On retrouve le classement par architectures comme dans le dossier rpmbuild/RPMS, on y ajoute le sous-dossier SRPMS. Il est important de diffuser les sources RPM pour permettre à d’autre de builder sur des architectures différentes.

Reste à générer les méta-données pour que notre dépôt soit utilisable. L’utilitaire “createrepo” s’occupe de ce travail, il est indispensable qu’il crée un dossier “repodata” dans chaque que vous avez déclaré. Pour rappel, le “baseurl” est déclaré dans le fichier <my_repo>.repo inclut dans le RPM d’installation du dépôt :

createrepo /var/www/<cname>/el6/

Si vous avez plusieurs baseurl, pour d’autres version de RH par exemple, alors il faut lancer createrepo pour chacun des “baseurl”.

Utilisation de repoview

Repoview est un utilitaire qui génère des pages html statiques à partir des paquets présents dans votre dépôt et des méta-données présentes dans les paquets. En pré-requis, repoview a besoin de la librairie python-kid qui n’est pas dispo dans les dépôts de base de RedHat 6, il faut utiliser des dépôts supplémentaires, DAG (http://dag.wieers.com/rpm/) ou EPEL (http://fedoraproject.org/wiki/EPEL).

Une fois les problèmes de dépendance résolus, on installe repoview :

yum install repoview

Il faut ensuite lancer repoview dans le baseurl, comme createrepo. Mais avant, il est nécessaire de relancer createrepo avec l’option -d qui va créer des fichiers sqlite en plus des fichiers xml.

createrepo -d /var/www/<cname>/el6/
repoview /var/www/<cname>/el6/

Vous pouvez maintenant consulter les pages générées : http://./el6/repoview/

Enfin, pour finir l’install du repository, on va copier le RPM repo-<my_repo>-1.0-1.noarch.rpm dans notre arborescence. Pour ma part, comme c’est un paquet un peu spécial, je l’ai mis à la racine du dépôt el6/ et j’ai mis le source RPM par contre à l’endroit habituel el6/SRPMS/.

Tester son repository tout neuf

En l’état, il n’y a pas grand chose a tester, notre dépôt est plutôt vide ! On va quand même tester l’installation du repository et lister le contenu.

Premièrement, installons le RPM qui va activer notre repository :

yum install http://<cname>.<domaine>/el6/repo-<my_repo>-1.0-1.noarch.rpm

Ça va être dur de pousser les tests plus loin car notre dépôt est vide :-/ On peut quand même demander à YUM de lister les dépôts installés :

yum repolist

Automatiser la génération des méta-données

Pour finir, ça peut être pas mal de mettre en place des crons pour rafraîchir les méta-données. Car à chaque fois qu’on modifie le contenu du repo, il est nécessaire de relancer la commande createrepo et la commande repoview. Éditez la crontab :

crontab -e

Ajoutez et adaptez avec vos chemins ces lignes :

# Mise à jour des méta-données
0 0 * * *       createrepo -d /var/www/<cname>/el6/ > /dev/null

# Mise à jour des pages statiques repoview
30 0 * * *      repoview /var/www/<cname>/el6/ > /dev/null

Et voilà qui conclu un premier article sur le métier peu connu de packager :D

Références

• wImage Tux-RedHat : http://tux.crystalxp.net/fr.id.15184-alexandrafranco-tux-redhat.html