Solo quiero crear un archivo RPM para distribuir mi "foobar" binario de Linux, con solo un par de dependencias. Tiene un archivo de configuración, /etc/foobar.conf y debe instalarse en / usr / bin / foobar.

Desafortunadamente, la documentación para RPM tiene 27 capítulos y realmente no tengo un día para sentarme y leer esto, porque también estoy ocupado haciendo instaladores .deb y EXE para otras plataformas.

¿Cuál es el mínimo absoluto que tengo que hacer para crear un RPM? Suponga que el binario foobar y foobar.conf están en el directorio de trabajo actual.

A menudo hago rpm binarias por empaquetado de aplicaciones propietarias, también moster como websphere, en Linux. Por lo tanto, mi experiencia podría ser útil también para usted, además de que sería mejor hacer un RPM VERDADERO si puede. Pero yo divago.

Entonces, el paso básico para empaquetar su programa (binario) es el siguiente: en el que supongo que el programa es toybinprog con la versión 1.0, tengo que instalar una conf en /etc/toybinprog/toybinprog.conf y tengo un contenedor para instalar en / usr / bin llamado tobinprog:

1. cree su entorno de compilación de rpm para 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. crea el tarball de tu proyecto

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. Copie al directorio de fuentes

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 <[email protected]> 1.0-1
- First Build

EOF

4. construir la fuente y las rpm binarias

rpmbuild -ba SPECS/toybinprog.spec

Y eso es todo.

Espero que esto ayude

Como distribuidor de aplicaciones, fpm suena perfecto para sus necesidades . Aquí hay un ejemplo que muestra cómo empaquetar una aplicación desde el origen. FPM puede producir archivos deb y archivos RPM.

Para una construcción rápida de RPM, consulte Togo:

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

El proyecto tiene una guía de inicio rápido y pude crear un RPM básico en menos de 3 minutos.

Ejemplo usando los datos provistos en la pregunta original:

1) Cree el directorio del proyecto usando el script:

$ togo project create foobar; cd foobar

2) Realice la estructura de directorios deseada en ./root y copie sus archivos en ella:

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

3) Excluya los directorios propiedad del sistema de la propiedad de su RPM:

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

4) (OPCIONAL) Modifique la especificación generada para cambiar la descripción / dependencias / versión / lo que sea del paquete, etc.

$ vi spec/header

5) Construir el RPM:

$ togo build package

-y su RPM se escupe en el directorio ./rpms.

Del mismo modo, necesitaba crear un rpm con solo unos pocos archivos. Dado que estos archivos estaban controlados por la fuente, y porque parecía una tontería, no quería pasar a tararlos solo para que rpm los desarmara. Se me ocurrió lo siguiente:

1. Configura tu entorno:

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

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

2. Cree su archivo de especificaciones, foobar.spec, con los siguientes contenidos:

   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. Construye tus rpm: rpmbuild -bb foobar.spec

Hay un pequeño hacker que especifica la 'fuente' como su directorio actual, pero parecía mucho más elegante que la alternativa, que era, en mi caso, escribir un script separado para crear un tarball, etc., etc.

Nota: En mi situación particular, mis archivos se organizaron en carpetas de acuerdo a dónde tenían que ir, de esta manera:

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

y entonces la sección de preparación se convirtió en:

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

Que es un poco más limpio.

Además, estoy en un RHEL5.6 con rpm rpm 4.4.2.3, por lo que su kilometraje puede variar.

Si make configfunciona para su programa o tiene un script de shell que copia sus dos archivos en el lugar apropiado, puede usar checkinstall . Simplemente vaya al directorio donde está su archivo MAKE y llámelo con el parámetro -R(para RPM ) y opcionalmente con el script de instalación.

Manera fácil de construir un paquete rpm desde binario (estos pasos fueron probados con Fedora 18):

1) Primero debe instalar rpmdevtools, así que ejecute estos comandos (atención: ejecutar como usuario normal)

$ sudo yum install rpmdevtools rpmlint
$ rpmdev-setuptree

2) En la carpeta ~ / rpmbuild / SPECS, cree un nuevo archivo: package_name.spec

3) Ábrelo con un editor (como gedit) y escribe esto:

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) Realice ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 y reproduzca las rutas donde se colocarán los archivos. En este caso, por ejemplo, cree:

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

5) Coloque en estas carpetas los archivos que desea insertar en el paquete:

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

usr / share / pixmaps / package_name.png es el icono de binario usr / share / aplicaciones / package_name.desktop son las reglas para insertar el programa en las entradas del menú

6) package_name.desktop debe ser así:

[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;

Las categorías son las siguientes: standards.freedesktop.org/menu-spec/latest/apa.html

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

8) Su paquete fue integrado en la carpeta ~ / rpmbuild / RPMS

si instala este paquete, instale:

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

Gracias a: losurs.org/docs/tips/redhat/binary-rpms

Para más detalles sobre cómo construir rpm, eche un vistazo a este enlace .

Software Java GUI para construir rpm: https://sourceforge.net/projects/javarpmbuilder/

Si también está familiarizado con Maven, lo rpm-maven-pluginque simplifica la creación de RPM: solo tiene que escribir pom.xmllo que luego se utilizará para construir RPM. El plugin crea implícitamente el entorno de compilación de RPM.

Proceso de generar RPM desde el archivo fuente:

1. descargue el archivo fuente con extensión.gz.
2. instale rpm-build y rpmdevtools desde yum install. (se generará la carpeta rpmbuild ... las carpetas SPECS, SOURCES, RPMS ... se generarán dentro de la carpeta rpmbuild).
3. copie el código fuente.gz a la carpeta FUENTES. (rpmbuild / SOURCES)
4. Untar la bola de alquitrán usando el siguiente comando. vaya a la carpeta FUENTES: rpmbuild / SOURCES donde está presente el archivo tar. comando: por ejemplo, tar -xvzf httpd-2.22.tar.gz La carpeta httpd-2.22 se generará en la misma ruta.
5. vaya a la carpeta extraída y luego escriba el siguiente comando: ./configure --prefix = / usr / local / apache2 --with-included-apr --enable-proxy --enable-proxy-balancer --with-mpm = worker - -enable-mods-static = all (.configure puede variar de acuerdo con la fuente para la cual RPM tiene que construirse; lo he hecho para apache HTTPD que necesita un paquete de dependencia apr y apr-util).
6. ejecutar debajo del comando una vez que la configuración sea exitosa: make
7. después de la ejecución exitosa de ejecutar el comando: verifique la instalación en la misma carpeta. (si no tiene el software checkinstall, descargue la última versión del sitio). Además, el software checkinstall tiene un error que se puede resolver de la siguiente manera ::::: busque checkinstallrc y luego reemplace TRANSLATE = 1 a TRANSLATE = 0 usando el comando vim. Compruebe también el paquete de exclusión: EXCLUDE = "/ selinux"
8. checkinstall le pedirá la opción (escriba R si desea tp build rpm para el archivo fuente)
9. El archivo .rpm listo se creará en la carpeta RPMS dentro del archivo rpmbuild / RPMS ... TODO LO MEJOR ...

Los RPM generalmente se crean a partir de la fuente, no los binarios.

Debe escribir el archivo de especificaciones que cubre cómo configurar y compilar su aplicación; también, qué archivos incluir en su RPM.

Un vistazo rápido al manual muestra que la mayor parte de lo que necesita está cubierto en el Capítulo 8; además, como la mayoría de las distribuciones basadas en RPM tienen fuentes disponibles, hay literalmente una infinidad de ejemplos de diferentes enfoques que puede observar.