Qual é o mínimo que preciso fazer para criar um arquivo RPM?

148

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.

Steve Hanov
fonte
1
" Como criar um pacote RPM " é um bom write-up on (docs Fedora) da RPM
webwesen
6
Chamar isso de 'write-up' é um eufemismo
kernelK

Respostas:

177

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 <[email protected]> 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

devzero2000
fonte
6
Caso você encontre "rpmbuild: command not found", consulte wiki.centos.org/HowTos/SetupRpmBuildEnvironment . Mas este guia é um bom começo para mim em aprender o funcionamento interno do rpm
icasimpan
4
No seu exemplo, o que define o _bindir? Estou tentando seguir sua solução, mas gostaria de colocar meus binários em / opt. Eu criei o arquivo targz de acordo com isso. E o rpmbuild está falhando no "arquivo não encontrado" no buildroot / usr / bin.
Kiss Viktoria
sudo dnf install rpm-build- Comando Fedora 23 para instalar o rpmbuild v4.13 +
Ray Foss
1
@ devzero2000 O que você quer dizer com TRUE RPM?
RubenLaguna
@ devzero2000 a pasta rpmbuild deve estar no diretório / root ou eu poderia colocá-lo em outro lugar?
Diogo Calazans
20

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.

timmow
fonte
2
O FPM é uma ferramenta incrível.
Takashi
Usamos essa ferramenta o tempo todo no trabalho. De longe, a ferramenta mais prática para atender à necessidade.
djhaskin987
2
O FPM possui o melhor princípio fundamental que se pode obter no software: se não está ajudando, há um erro. É o tipo de compromisso que eu aprecio.
Ribamar #
16

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.

dadealeus
fonte
Atualizado o exemplo para corresponder ao cenário fornecido na pergunta original.
dadealeus
15

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.

glickbot
fonte
Eu tive que virar tudo $RPM_BUILD_ROOTpara %{buildroot}fazê-lo funcionar no meu "Red Hat Enterprise Linux Server versão 6.9". Além disso, os dois arquivos que estavam instalados precisavam estar no diretório atual quando executei o rpmbuild. Instalei-o na minha outra máquina com: sudo rpm -Uvh --nodeps foobar-0.1a-1.x86_64.rpm
user1683793
4

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.

js.
fonte
4

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/

RobotMan
fonte
-1

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.

scrutari
fonte
-3

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 ....
user3248738
fonte
-4

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.

andri
fonte