Je veux juste créer un fichier RPM pour distribuer mon binaire Linux "foobar", avec seulement quelques dépendances. Il a un fichier de configuration, /etc/foobar.conf et doit être installé dans / usr / bin / foobar.

Malheureusement, la documentation de RPM est longue de 27 chapitres et je n'ai vraiment pas un jour pour m'asseoir et lire ceci, car je suis également occupé à créer des installateurs .deb et EXE pour d'autres plates-formes.

Quel est le minimum absolu que je dois faire pour créer un RPM? Supposons que le binaire foobar et foobar.conf se trouvent dans le répertoire de travail actuel.

Je fais souvent des rpm binaires par empaquetage d'applications propriétaires - également sous forme de websphere - sur Linux. Mon expérience pourrait donc être utile à vous aussi, en plus, il serait préférable de faire un VRAI RPM si vous le pouvez. Mais je m'éloigne du sujet.

Donc, l'étape de base pour l'empaquetage de votre programme (binaire) est la suivante - dans laquelle je suppose que le programme est toybinprog avec la version 1.0, ayez un conf à installer dans /etc/toybinprog/toybinprog.conf et ayez un bin à installer dans / usr / bin appelé tobinprog:

1. créez votre environnement de build rpm pour RPM <4.6,4.7

mkdir -p ~/rpmbuild/{RPMS,SRPMS,BUILD,SOURCES,SPECS,tmp}

cat <<EOF >~/.rpmmacros
%_topdir   %(echo $HOME)/rpmbuild
%_tmppath  %{_topdir}/tmp
EOF

cd ~/rpmbuild

2. créez l'archive tar de votre projet

mkdir toybinprog-1.0
mkdir -p toybinprog-1.0/usr/bin
mkdir -p toybinprog-1.0/etc/toybinprog
install -m 755 toybinprog toybinprog-1.0/usr/bin
install -m 644 toybinprog.conf toybinprog-1.0/etc/toybinprog/

tar -zcvf toybinprog-1.0.tar.gz toybinprog-1.0/

3. Copier dans le répertoire sources

cp toybinprog-1.0.tar.gz SOURCES/

cat <<EOF > SPECS/toybinprog.spec
# Don't try fancy stuff like debuginfo, which is useless on binary-only
# packages. Don't strip binary too
# Be sure buildpolicy set to do nothing
%define        __spec_install_post %{nil}
%define          debug_package %{nil}
%define        __os_install_post %{_dbpath}/brp-compress

Summary: A very simple toy bin rpm package
Name: toybinprog
Version: 1.0
Release: 1
License: GPL+
Group: Development/Tools
SOURCE0 : %{name}-%{version}.tar.gz
URL: http://toybinprog.company.com/

BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root

%description
%{summary}

%prep
%setup -q

%build
# Empty section.

%install
rm -rf %{buildroot}
mkdir -p  %{buildroot}

# in builddir
cp -a * %{buildroot}


%clean
rm -rf %{buildroot}


%files
%defattr(-,root,root,-)
%config(noreplace) %{_sysconfdir}/%{name}/%{name}.conf
%{_bindir}/*

%changelog
* Thu Apr 24 2009  Elia Pinto <devzero2000@rpm5.org> 1.0-1
- First Build

EOF

4. construire la source et le rpm binaire

rpmbuild -ba SPECS/toybinprog.spec

Et c'est tout.

J'espère que cette aide

En tant que distributeur d'applications, fpm répond parfaitement à vos besoins . Il y a un exemple ici qui montre comment empaqueter une application à partir de la source. FPM peut produire à la fois des fichiers deb et des fichiers RPM.

Pour la construction rapide de RPM, consultez le Togo:

https://github.com/genereese/togo-rpm

Le projet a un guide de démarrage rapide et j'ai pu créer un RPM de base en moins de 3 minutes.

Exemple utilisant les données fournies dans la question initiale:

1) Créez le répertoire du projet à l'aide du script:

$ togo project create foobar; cd foobar

2) Créez la structure de répertoires souhaitée sous ./root et copiez-y vos fichiers:

$ mkdir -p root/etc; cp /path/to/foobar.conf root/etc/
$ mkdir -p root/usr/bin; cp /path/to/foobar root/usr/bin/

3) Excluez les répertoires appartenant au système de la propriété de votre RPM:

$ togo file exclude root/etc root/usr/bin

4) (FACULTATIF) Modifiez la spécification générée pour changer la description de votre package / dépendances / version / peu importe, etc.:

$ vi spec/header

5) Construisez le RPM:

$ togo build package

-et votre RPM est craché dans le répertoire ./rpms.

De même, j'avais besoin de créer un rpm avec seulement quelques fichiers. Puisque ces fichiers étaient contrôlés par la source, et parce que cela semblait idiot, je ne voulais pas les tarer juste pour que rpm les décompose. J'ai trouvé ce qui suit:

1. Configurez votre environnement:

   mkdir -p ~/rpm/{BUILD,RPMS}

   echo '%_topdir %(echo "$HOME")/rpm' > ~/.rpmmacros

2. Créez votre fichier de spécifications, foobar.spec, avec le contenu suivant:

   Summary: Foo to the Bar
   Name: foobar
   Version: 0.1
   Release: 1
   Group: Foo/Bar
   License: FooBarPL
   Source: %{expand:%%(pwd)}
   BuildRoot: %{_topdir}/BUILD/%{name}-%{version}-%{release}
   
   %description
   %{summary}
   
   %prep
   rm -rf $RPM_BUILD_ROOT
   mkdir -p $RPM_BUILD_ROOT/usr/bin
   mkdir -p $RPM_BUILD_ROOT/etc
   cd $RPM_BUILD_ROOT
   cp %{SOURCEURL0}/foobar ./usr/bin/
   cp %{SOURCEURL0}/foobar.conf ./etc/
   
   %clean
   rm -r -f "$RPM_BUILD_ROOT"
   
   %files
   %defattr(644,root,root)
   %config(noreplace) %{_sysconfdir}/foobar.conf
   %defattr(755,root,root)
   %{_bindir}/foobar
   

3. Construisez votre rpm: rpmbuild -bb foobar.spec

Il y a un petit hack spécifiant la `` source '' comme votre répertoire actuel, mais cela semblait beaucoup plus élégant que l'alternative, qui consistait, dans mon cas, à écrire un script séparé pour créer une archive tar, etc., etc.

Remarque: dans ma situation particulière, mes fichiers étaient organisés dans des dossiers en fonction de leur destination, comme ceci:

./etc/foobar.conf
./usr/bin/foobar

et ainsi la section de préparation est devenue:

%prep
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT
cd $RPM_BUILD_ROOT
tar -cC %{SOURCEURL0} --exclude 'foobar.spec' -f - ./ | tar xf -

Ce qui est un peu plus propre.

De plus, il se trouve que je suis sur un RHEL5.6 avec les versions de régime 4.4.2.3, donc votre kilométrage peut varier.

Si cela make configfonctionne pour votre programme ou si vous avez un script shell qui copie vos deux fichiers à l'emplacement approprié, vous pouvez utiliser checkinstall . Allez simplement dans le répertoire où se trouve votre makefile et appelez-le avec le paramètre -R(pour RPM ) et éventuellement avec le script d'installation.

Un moyen facile de créer un package rpm à partir de binaire (ces étapes ont été testées avec Fedora 18):

1) Vous devez d'abord installer rpmdevtools, alors exécutez ces commandes (attention: exécutez en tant qu'utilisateur normal)

$ sudo yum install rpmdevtools rpmlint
$ rpmdev-setuptree

2) Dans le dossier ~ / rpmbuild / SPECS, créez un nouveau fichier: package_name.spec

3) Ouvrez-le avec un éditeur (comme gedit) et écrivez ceci:

Name:           package_name
Version:        1.0
Release:        1
Summary:        Short description (first char has to be uppercase)

License:        GPL
URL:            www. your_website/

BuildRequires:  package_required >= (or ==, or <=) 1.0.3 (for example)

%description
Description with almost 79 characters (first char has to be uppercase)

#This is a comment (just as example)

%files
/usr/bin/binary_file.bin
/usr/share/applications/package_name.desktop
/usr/share/pixmaps/package_name.png

%changelog
* date Packager's Name <packager's_email> version-revision
- Summary of changes

#For more details see: docs.fedoraproject.org/en-US/Fedora_Draft_Documentation/0.1/html/Packagers_Guide/sect-Packagers_Guide-Creating_a_Basic_Spec_File.html

4) Créez ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 et reproduisez les chemins où les fichiers seront placés Donc dans ce cas par exemple créez:

• ~ / rpmbuild / BUILDROOT / nom_package-version-version.i386 / usr / bin /
• ~ / rpmbuild / BUILDROOT / nom_du_package-version-version.i386 / usr / share / applications /
• ~ / rpmbuild / BUILDROOT / nom_package-version-release.i386 / usr / share / pixmaps /

5) Mettez dans ces dossiers les fichiers que vous souhaitez insérer dans le package:

• ~ / rpmbuild / BUILDROOT / nom_package-version-version.i386 / usr / bin / fichier_binaire.bin
• ~ / rpmbuild / BUILDROOT / nom_du_package-version-version.i386 / usr / share / applications / nom_package.desktop
• ~ / rpmbuild / BUILDROOT / nom_du_package-version-release.i386 / usr / share / pixmaps / nom_package.png

usr / share / pixmaps / package_name.png est l'icône du binaire usr / share / applications / package_name.desktop sont les règles pour insérer le programme dans les entrées de menu

6) package_name.desktop doit être comme ceci:

[Desktop Entry]
Encoding=UTF-8
Type=Application
Name=example
GenericName=Short description
Comment=Comment of the application
Exec=package_name
Icon=package_name
Terminal=false
Categories=System;

Les catégories sont les suivantes: standards.freedesktop.org/menu-spec/latest/apa.html

7) Courir $ rpmbuild -bb ~/rpmbuild/SPECS/package_name.spec

8) Votre package a été intégré dans le dossier ~ / rpmbuild / RPMS

si vous installez ce package, il est installé:

• /usr/bin/binary_file.bin
• /usr/share/applications/package_name.desktop
• /usr/share/pixmaps/package_name.png

Merci à: losurs.org/docs/tips/redhat/binary-rpms

Pour plus de détails sur la création de rpm, consultez ce lien .

Logiciel java GUI pour construire rpm: https://sourceforge.net/projects/javarpmbuilder/

Si vous êtes familier avec Maven là aussi rpm-maven-plugince qui simplifie la création de RPM: vous devez écrire uniquement pom.xmlce qui sera ensuite utilisé pour construire des RPM. L'environnement de construction RPM est créé implicitement par le plugin.

Processus de génération de RPM à partir du fichier source:

1. télécharger le fichier source avec l'extension.gz.
2. installez rpm-build et rpmdevtools depuis yum install. (le dossier rpmbuild sera généré ... SPECS, SOURCES, RPMS .. les dossiers devront être générés dans le dossier rpmbuild).
3. copiez le code source.gz dans le dossier SOURCES. (rpmbuild / SOURCES)
4. Décompressez la boule tar à l'aide de la commande suivante. allez dans le dossier SOURCES: rpmbuild / SOURCES où le fichier tar est présent. commande: par exemple, le dossier tar -xvzf httpd-2.22.tar.gz httpd-2.22 sera généré dans le même chemin.
5. allez dans le dossier extrait et tapez la commande ci-dessous: ./configure --prefix = / usr / local / apache2 --with-included-apr --enable-proxy --enable-proxy-balancer --with-mpm = worker - -enable-mods-static = all (.configure peut varier en fonction de la source pour laquelle RPM doit être construit - je l'ai fait pour apache HTTPD qui a besoin des packages de dépendances apr et apr-util).
6. exécutez la commande ci-dessous une fois la configuration réussie: make
7. après une exécution réussie de la commande make run: checkinstall dans le même dossier. (si vous ne disposez pas du logiciel checkinstall, veuillez télécharger la dernière version du site). Le logiciel checkinstall a également un bogue qui peut être résolu de la manière suivante ::::: localisez checkinstallrc puis remplacez TRANSLATE = 1 par TRANSLATE = 0 en utilisant la commande vim. Vérifiez également le package d'exclusion: EXCLUDE = "/ selinux"
8. checkinstall demandera une option (tapez R si vous voulez tp build rpm pour le fichier source)
9. Le fichier .rpm terminé sera construit dans le dossier RPMS à l'intérieur du fichier rpmbuild / RPMS ... TOUT LE MEILLEUR ....

Les RPM sont généralement construits à partir de la source, pas des binaires.

Vous devez écrire le fichier de spécification qui explique comment configurer et compiler votre application; également, quels fichiers inclure dans votre RPM.

Un rapide coup d'œil au manuel montre que la plupart de ce dont vous avez besoin est couvert dans le chapitre 8. De plus, comme la plupart des distributions basées sur RPM ont des sources disponibles, il y a littéralement un zillion d'exemples d'approches différentes que vous pourriez examiner.