Quel est le minimum que je dois faire pour créer un fichier RPM?

StackOverflow https://stackoverflow.com/questions/880227

  •  22-08-2019
  •  | 
  •  

Question

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

Malheureusement, la RPM est de 27 longs chapitres et je vraiment don « t ont un jour pour asseoir et lire ceci, parce que je suis occupé à faire 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 sont dans le répertoire courant.

Était-ce utile?

La solution

Je fais souvent binaire RPM par emballage des applications propriétaires - aussi moster que websphere - sur linux. Donc, mon expérience pourrait être utile aussi vous, outre qu'il serait mieux de faire un RPM TRUE si vous le pouvez. Mais je digresse.

Donc une étape de base pour l'emballage de votre programme (binaire) est comme suit - dans lequel je suppose que la programme est toybinprog avec la version 1.0, un être installé conf dans /etc/toybinprog/toybinprog.conf et ont un bac à installer dans / usr / bin appelé tobinprog:

1. créer votre rpm pour construire env 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éer le tarball 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 les sources dir 

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 régime binaire 

rpmbuild -ba SPECS/toybinprog.spec

Et voilà tout.

Hope this help

Autres conseils

En tant que distributeur d'application, FPM sons parfait pour vos besoins . Il est un exemple qui montre comment emballer un application de la source. FPM peut produire à la fois des fichiers deb et les fichiers RPM.

Pour la construction rapide RPM, consultez Togo:

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

Le projet a un guide de démarrage rapide et je suis en mesure de créer un régime de base en moins de 3 minutes.

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

1) Créez le répertoire de projet en utilisant le script: 

$ togo project create foobar; cd foobar

2) Faites votre structure de répertoire désiré sous ./root et copiez vos fichiers dans ce: 

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

3) Exclure des répertoires appartenant par le système de la propriété de votre RPM: 

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

4) (EN OPTION) Modifier la spécification générée pour changer votre description du paquet / dépendances / version / whatever, etc. 

$ vi spec/header

5) Construire le RPM: 

$ togo build package

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

De même, je devais créer un régime avec seulement quelques fichiers. Étant donné que ces fichiers ont été contrôlés source et parce qu'il semblait stupide, je ne voulais pas passer par les tarer juste pour avoir rpm untar. Je suis venu avec ce qui suit:

  1. Configurer votre environnement:

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

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

  2. Créez votre fichier de spécification, 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. Construire votre régime: rpmbuild -bb foobar.spec

Il y a un petit hack, il spécifiant la « source » comme répertoire courant, mais il semblait beaucoup plus élégante alors l'alternative, qui devait, dans mon cas, écrire un script séparé pour créer un paquet, etc, etc.

Note: Dans ma situation, mes dossiers ont été disposés dans des dossiers selon l'endroit où ils avaient besoin pour aller, comme ceci: 

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

et ainsi la section de préparation est devenu: 

%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.

En outre, je suis d'être sur un RHEL5.6 avec les versions rpm 4.4.2.3, de sorte que votre kilométrage peut varier.

Si make config fonctionne pour votre programme ou si vous avez un script shell qui copie vos deux fichiers à l'endroit approprié, vous pouvez utiliser checkinstall . Il suffit d'aller dans le répertoire où votre makefile est et l'appeler avec le paramètre -R (pour RPM ) et éventuellement avec le script d'installation.

Un moyen facile de construire des paquets rpm binaires de (ces étapes ont été testées avec Fedora 18):

1) D'abord, vous devez installer rpmdevtools, donc exécuter ces commandes (attention: exécuter en tant qu'utilisateur normal) 

$ sudo yum install rpmdevtools rpmlint
$ rpmdev-setuptree

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

3) Ouvrez-le avec un éditeur (comme gedit) et écrire 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) Faire ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 et reproduire les chemins où les fichiers seront placés Donc, dans ce cas, par exemple créer:

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

5) Mettre dans ces dossiers les fichiers que vous souhaitez insérer dans le paquet:

  • ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 / usr / bin / binary_file.bin
  • ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 / usr / share / applications / package_name.desktop
  • ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 / usr / share / pixmaps / package_name.png

usr / share / pixmaps / package_name.png est l'icône 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) Exécutez $ rpmbuild -bb ~/rpmbuild/SPECS/package_name.spec

8) Votre colis a été construit dans ~ / rpmbuild / dossier RPMS

si vous installez ce package, il est l'installation:

  • /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 pour construire rpm jeter un oeil à cette de .

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

Si vous connaissez Maven là aussi rpm-maven-plugin qui simplifie grandement les RPM: vous devez écrire seulement pom.xml qui sera ensuite utilisé pour construire RPM. environnement de construction RPM est créé implicitement par le plug-in.

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

  1. fichier source de téléchargement with.gz extention.
  2. install rpm-build et rpmdevtools de yum installer. (Dossier rpmbuild sera généré ... SPECS, SOURCES, RPMS .. dossiers sera doit être généré dans le dossier rpmbuild).
  3. copier le code.gz source dans le dossier SOURCES. (Rpmbuild / SOURCES)
  4. Untar la boule de goudron en utilisant la commande suivante. Aller au dossier SOURCES: rpmbuild / SOURCES où fichier tar est présent. commande: par exemple le goudron -xvzf httpd-2.22.tar.gz dossier httpd-2.22 sera généré dans le même chemin.
  5. Aller au dossier extrait ci-dessous, puis tapez la commande suivante: ./configure prefix = / usr / local / apache2 --with-included-avr. --enable-proxy --enable-proxy-Balancer --with-mpm = travailleur --enable-mods-statique = all (.Configure peut varier selon la source pour laquelle RPM doit built-- i ai fait pour Apache qui a besoin avril et le paquet de dépendance apr-util).
  6. Exécuter ci-dessous commande une fois que la configuration est réussie: faire
  7. après l'exécution Successfull od faire courir de commande: checkinstall dans tha même dossier. (Si vous n'avez pas le logiciel checkinstall s'il vous plaît télécharger la dernière version à partir du site) En outre le logiciel checkinstall a bug qui peut être résolu par la suite ::::: localiser checkinstallrc puis remplacer TRANSLATE = 1 à TRANSLATE = 0 en utilisant la commande vim. Vérifiez également exclure package: EXCLURE = "/ SELinux"
  8. checkinstall demandera l'option (type R si vous voulez construire tp rpm pour le fichier source)
  9. fichier .rpm Fait sera construit dans le dossier RPMS dans le fichier rpmbuild / RPMS ... Tous les meilleurs ....

RPM sont généralement construits à partir des sources, pas les binaires.

Vous devez écrire le fichier de spécification qui couvre comment configurer et compiler votre application; En outre, les fichiers à inclure dans votre RPM.

Un rapide coup d'œil au manuel montre que la plupart de ce que vous avez besoin est couvert dans le chapitre 8 -. En outre, comme la plupart des distributions à base de RPM ont des sources disponibles, il y a littéralement un tas d'exemples de différentes approches que vous pouvez regarder

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top