Eu só quero criar um arquivo RPM para distribuir meu "foobar" binário no Linux, com apenas algumas dependências. Ele tem um arquivo de configuração, /etc/foobar.conf, e deve ser instalado em / usr / bin / foobar.

Infelizmente, a documentação para o RPM tem 27 capítulos e eu realmente não tenho um dia para sentar e ler isso, porque também estou ocupado criando instaladores .deb e EXE para outras plataformas.

Qual é o mínimo absoluto que preciso fazer para criar um RPM? Suponha que o foobar binary e foobar.conf estejam no diretório de trabalho atual.

Costumo fazer rpm binário por aplicativos proprietários de embalagens - também moster como websphere - no linux. Portanto, minha experiência pode ser útil também para você, além disso, seria melhor fazer um RPM VERDADEIRO, se puder. Mas eu discordo.

Portanto, a etapa básica para empacotar seu programa (binário) é a seguinte - na qual suponho que o programa seja toybinprog com a versão 1.0, tenha um conf para ser instalado no /etc/toybinprog/toybinprog.conf e tenha um bin para ser instalado em / usr / bin chamado tobinprog:

1. crie seu ambiente de compilação do 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. crie o tarball do seu projeto

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 para o diretório de fontes

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. construa a fonte e o rpm binário

rpmbuild -ba SPECS/toybinprog.spec

E isso é tudo.

Espero que esta ajuda

Como distribuidor de aplicativos, o fpm soa perfeito para suas necessidades . Há um exemplo aqui que mostra como empacotar um aplicativo da fonte. O FPM pode produzir arquivos deb e arquivos RPM.

Para uma rápida criação de RPM, confira o Togo:

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

O projeto tem um guia de início rápido e consegui criar um RPM básico em menos de 3 minutos.

Exemplo usando os dados fornecidos na pergunta original:

1) Crie o diretório do projeto usando o script:

$ togo project create foobar; cd foobar

2) Crie a estrutura de diretórios desejada em ./root e copie seus arquivos para ele:

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

3) Exclua os diretórios de propriedade do sistema da propriedade do seu RPM:

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

4) (OPCIONAL) Modifique a especificação gerada para alterar a descrição do seu pacote / dependências / versão / qualquer que seja, etc .:

$ vi spec/header

5) Crie o RPM:

$ togo build package

e seu RPM é cuspido no diretório ./rpms.

Da mesma forma, eu precisava criar um rpm com apenas alguns arquivos. Como esses arquivos eram controlados pela fonte e, por parecer bobo, eu não queria tará-los apenas para que o rpm os desviasse. Eu vim com o seguinte:

1. Configure seu ambiente:

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

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

2. Crie seu arquivo de especificação, foobar.spec, com o seguinte conteúdo:

   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. Crie seu rpm: rpmbuild -bb foobar.spec

Existe um pequeno truque especificando o 'source' como seu diretório atual, mas parecia muito mais elegante que a alternativa, que era, no meu caso, escrever um script separado para criar um tarball, etc., etc.

Nota: Na minha situação específica, meus arquivos foram organizados em pastas de acordo com o local em que precisavam ir, assim:

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

e assim a seção de preparação se tornou:

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

O que é um pouco mais limpo.

Além disso, eu estou no RHEL5.6 com rpm versões 4.4.2.3, portanto sua milhagem pode variar.

Se make configfuncionar para o seu programa ou se você tiver um script de shell que copie seus dois arquivos para o local apropriado, poderá usar o checkinstall . Vá para o diretório em que seu makefile está e chame-o com o parâmetro -R(para RPM ) e, opcionalmente, com o script de instalação.

Maneira fácil de compilar o pacote rpm a partir do binário (estas etapas foram testadas com o Fedora 18):

1) Primeiro você precisa instalar o rpmdevtools, portanto, execute estes comandos (atenção: execute como usuário normal)

$ sudo yum install rpmdevtools rpmlint
$ rpmdev-setuptree

2) Na pasta ~ / rpmbuild / SPECS, crie um novo arquivo: package_name.spec

3) Abra-o com um editor (como gedit) e escreva:

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) Crie ~ / rpmbuild / BUILDROOT / package_name-version-release.i386 e reproduza os caminhos em que os arquivos serão colocados. Nesse caso, por exemplo, crie:

• ~ / 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) Coloque nessas pastas os arquivos que você deseja inserir no pacote:

• ~ / 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 é o ícone binário usr / share / applications / package_name.desktop são as regras para inserir o programa nas entradas do menu

6) package_name.desktop deve ser assim:

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

As categorias são: standards.freedesktop.org/menu-spec/latest/apa.html

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

8) Seu pacote foi incorporado na pasta ~ / rpmbuild / RPMS

Se você instalar este pacote, instale:

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

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

Para mais detalhes sobre a criação de rpm, dê uma olhada neste link .

Software java da GUI para criar o rpm: https://sourceforge.net/projects/javarpmbuilder/

Se você também conhece o Maven, o rpm-maven-pluginque simplifica a criação de RPMs: você precisa escrever apenas o pom.xmlque será usado para criar o RPM. O ambiente de construção do RPM é criado implicitamente pelo plug-in.

Processo de geração de RPM a partir do arquivo de origem:

1. baixe o arquivo fonte com extensão.gz.
2. instale o rpm-build e o rpmdevtools a partir da instalação do yum. (a pasta rpmbuild será gerada ... as pastas SPECS, SOURCES, RPMS .. deverão ser geradas dentro da pasta rpmbuild).
3. copie o código-fonte.gz para a pasta SOURCES. (rpmbuild / SOURCES)
4. Descompacte a bola de alcatrão usando o seguinte comando. vá para a pasta SOURCES: rpmbuild / SOURCES onde o arquivo tar está presente. comando: por exemplo, a pasta tar -xvzf httpd-2.22.tar.gz httpd-2.22 será gerada no mesmo caminho.
5. vá para a pasta extraída e digite o comando abaixo: ./configure --prefix = / usr / local / apache2 --with-included-apr --enable-proxy --enable-proxy-balancer --with-mpm = worker - -enable-mods-static = all (.configure pode variar de acordo com a fonte para a qual o RPM precisa ser construído-- eu fiz para o apache HTTPD que precisa do pacote de dependência apr e apr-util).
6. execute o comando abaixo assim que o configure for bem-sucedido: make
7. após a execução bem sucedida do comando, execute: checkinstall na mesma pasta. (se você não possui o software checkinstall, baixe a versão mais recente do site) Também o software checkinstall possui um bug que pode ser resolvido da seguinte maneira ::::: localize checkinstallrc e substitua TRANSLATE = 1 por TRANSLATE = 0 usando o comando vim. Verifique também o pacote de exclusão: EXCLUDE = "/ selinux"
8. checkinstall solicitará a opção (digite R se desejar tp build rpm para o arquivo de origem)
9. O arquivo .rpm pronto será criado na pasta RPMS dentro do arquivo rpmbuild / RPMS ... TODOS OS MELHORES ....

Os RPMs geralmente são criados a partir da fonte, não dos binários.

Você precisa escrever o arquivo de especificações que cobre como configurar e compilar seu aplicativo; Além disso, quais arquivos incluir no seu RPM.

Uma rápida olhada no manual mostra que a maior parte do que você precisa é abordada no Capítulo 8 - também, como a maioria das distribuições baseadas em RPM tem fontes disponíveis, há literalmente um zilhão de exemplos de diferentes abordagens que você poderia observar.