Como criar um pacote de rpm

O RPM é o gerenciador de pacotes e o formato de embalagem usado por muitas distribuições Linux, como Fedora, Red Hat e Centos, para gerenciar e distribuir software em forma binária. Neste tutorial, veremos como construir e empacotar um aplicativo simples.

Neste tutorial, você aprenderá:

• Quais são os conceitos básicos por trás do processo de construção do RPM.
• Qual é o ambiente de construção.
• O que é um especfile de especificação.
• Como usar macros dentro de um especfile.
• Como instalar as dependências de construção.
• Como criar um especfile.
• Como construir um pacote de rpm.

Requisitos de software e convenções usadas

RPM Conceitos básicos

Instalando, removendo, atualizando (em uma palavra, gerenciamento) o software é uma tarefa essencial em todos os sistemas operacionais. Quando os gerentes de pacotes não eram uma coisa, a única maneira de instalar um programa era compilar seu código -fonte e colocar os arquivos resultantes nos locais apropriados no sistema de arquivos. Manter o controle das dependências de cada pedaço de código foi realmente difícil e demorado. Em seguida, os gerentes de pacotes foram introduzidos, e tudo ficou mais fácil.

Atualmente, cada distribuição moderna do Linux tem, hoje em dia, seu gerente de pacotes: Debian e seus derivativos usam dpkg, enquanto
RPM é usado na família Red Hat de Distribuições. O software é fornecido pré-compilado sob a forma de pacotes, que são basicamente arquivos compactados contendo metadados sobre a versão de software, suas dependências e possíveis conflitos com outros pacotes.

Neste tutorial, veremos como criar um pacote de rpm a partir de um código -fonte do aplicativo. O aplicativo que embalaremos é Feh, Um visualizador de imagem simples da linha de comando: é muito pequeno e tem poucas dependências. Antes de começar a construir nosso primeiro pacote, existem, no entanto, alguns conceitos essenciais que devemos entender.

O ambiente de construção

A raiz de uma árvore de ambiental de construção de RPM é a rpMbuild Diretório, que contém 6 subdiretos: CONSTRUIR, BuildRoot, Rpms, FONTES, Especificações e Srpms. Veremos como é possível gerar esse ambiente lançando um comando simples; Por enquanto, vamos mencionar o papel desses diretórios. Aqui está uma representação da árvore de trabalho:

 rpmbuild |- build |- buildroot |- rpms |- fontes |- especificações |- srpms 

Cada um desses diretórios tem um papel específico no processo de construção:

• O CONSTRUIR Diretório é onde o código -fonte do programa que queremos embalar é construído
• O BuildRoot O diretório é onde os arquivos resultantes da compilação do software dentro do diretório de compilação são copiados, refletindo a estrutura do sistema de destino dentro de um subdiretório com o pacote Mame:
  No nosso caso, o binário "Feh" que seria instalado em /usr/bin será relatado como BuildRoot/Feh-3.0-1.FC29.x86_64/usr/bin.
• O Rpms diretório, é onde RPM Os pacotes são gerados: cada RPM será colocado em um subdiretório
  nomeado após sua arquitetura, ou, Noarch Se não for específico da arquitetura.
• O FONTES O diretório hospeda o código -fonte compactado do software que queremos empacotar, geralmente sob a forma de um tarball de um arquivo zip.
• O Especificações diretório, é onde colocamos o .espec Arquive com as instruções para construir nosso pacote: analisaremos a estrutura deste arquivo em um momento.
• O Srpms O diretório é o equivalente a RPMs, mas para RPMs de origem. Esses pacotes especiais contêm o código fonte original do aplicativo, os patches eventuais e o especfile usado para construir o pacote.

O arquivo de especificações

O arquivo em que todas as instruções e informações necessárias para criar um pacote de rpm são definidas é o .espec arquivo. Um specfile contém, entre as outras coisas, o construir dependências (o software necessário para compilar o programa que queremos empacotar), o dependências de tempo de execução (As bibliotecas necessárias para o programa executar corretamente) e os omoms que devem ser executados para compilar o software.

O arquivo é composto por duas macro-seções: A preâmbulo e a corpo. Em cada uma dessas seções, diferentes instruções podem ser especificadas. Vamos ver alguns deles. O preâmbulo A seção pode conter as seguintes instruções:

• • Nome: O nome da base do pacote (isso deve corresponder ao nome do arquivo de especificações)
  • Versão: A versão upstream do software embalado
  • Liberar: O número de liberação do pacote
  • Licença: A licença usada para o software que queremos empacotar
  • Url: O URL a montante do software
  • Fonte0: O URL direto ou o caminho do código -fonte compactado do software (Tarball ou Arquivo Zippeado)
  • BuildArch: A arquitetura do pacote: se nenhuma arquitetura for especificada, o do sistema host será usado
  • BuildRequires: As dependências necessárias para construir o software
  • Requer: As dependências necessárias para executar o software

O corpo A seção do specFile, normalmente contém as seguintes seções:

• %descrição: Uma descrição opcionalmente multi-line do software embalado
• %preparação: Os comando (s) necessários para preparar o código -fonte (por exemplo, os comandos necessários para extrair um tarball)
• %construir: Os comando (s) necessário para construir o software
• %instalar: Os comando (s) precisavam copiar o arquivo resultante do processo de construção para o BuildRoot diretório
• %arquivos: A lista dos arquivos fornecidos pelo pacote, que serão instalados no sistema

Macros

Para facilitar nosso trabalho, dentro de um specFile, podemos usar algumas macros que vamos referenciar muitas coisas úteis e executar automaticamente determinadas tarefas. Primeiro de tudo, temos o Macros do diretório RPM que permitem que o uso de referência nos diretórios de nosso ambiente de construção; Devemos sempre usá -los em vez de caminhos diretos:

• %_ topdir: Esta macro referencia o rpMbuild diretório
• %_ BuildDir: Referências o CONSTRUIR diretório dentro de nossa árvore de construção
• %_ rpmdir: Referências o caminho do Rpms diretório
• %_ Sourcedir: Esta macro é avaliada no caminho do FONTES diretório
• %_ specdir: Uma macro que representa o caminho do Especificações diretório
• %_ srcrpmdir: Referências o caminho de Srpms diretório
• %_ Buildrootdir: Referências o caminho do BuildRoot diretório

Outras macros vamos referenciar os diretórios mais importantes no sistema de arquivos de nossa máquina, por exemplo:

• %_ sysconfigdir: O /etc diretório
• %_prefixo: O /usr diretório
• %_ bindir: O /usr/bin diretório
• %_ mandir: O caminho para o /usr/share/homem diretório

O acima, não é uma lista completa, mas lhe dá uma ideia. Além disso, também podemos usar um conjunto de macros que executam tarefas específicas. Para expandir a definição de uma macro e, para ver seu conteúdo, podemos usar o RPM --eval comando, que toma a macro como seu argumento. Aqui estão alguns exemplos de macros usadas com frequência:

• O %configurar macro, é usado no %config A seção do especfile e basicamente executa as seguintes ações:
  1. Extrai o código -fonte do programa que queremos empacotar para o BuildDir diretório
  2. Muda para o diretório extraído
  3. Define as permissões de arquivo apropriadas dentro dele
• O %make_build Macro é usado no %construir seção do especfile e basicamente executa o fazer comando com um conjunto de opções predefinidas, para compilar o código -fonte do software. Se expandirmos, podemos verificar o comando que ele é executado:

  $ rpm --eval "%make_build"/usr/bin/make -o -j4 

• O %make_install Macro, em vez disso, é usado no %instalar seção do arquivo e executa faça instalar com o Destdir Parâmetro, usado para instruir o comando para instalar os arquivos compilados relativamente a um determinado diretório em vez do sistema real /:

  $ rpm --eval "%make_install"/usr/bin/faça instalar destdir =/home/egdoc/rpmbuild/buildroot/%name-%versão-%release.x86_64 install = "/usr/bin/install -p" 

Como criar um pacote de rpm passo a passo instruções

Agora que aprendemos o conceito básico do processo de criação de pacotes, podemos ver como criar nosso ambiente de construção e nosso primeiro pacote de RPM. Vamos criar nosso pacote.

Instale as dependências de construção

Como primeira coisa, precisamos instalar rpmdevTools, Além das dependências necessárias para construir Feh:

$ sudo dnf install rpmdevTools gcc faça imlib2-devel libjpeg-devel libpng-devel libxt-devel libxinerama-devel libexif-devel \ perl-teste-command perl-harness harness libcurl-desvelo 

Depois que os pacotes forem instalados, podemos gerar nosso ambiente de construção. Tudo o que precisamos fazer é lançar o seguinte comando:

$ rpmdev-setuptree

Neste ponto rpMbuild diretório, e todos os subdiretos que vimos antes, devem ser criados. O próximo passo é escrever nosso specFile.

Crie o especfile

Criamos o especfile com nosso editor de texto favorito e salvamos no Especificações diretório com o mesmo nome do pacote. Aqui está como um specFile mínimo deve parecer:

Nome: FEH Versão: 3.0 liberação: 1%?Dist Resumo: Visualizador de imagem da linha de comando rápido usando o IMLIB2 Licença: MIT URL: http: // feh.finalrewind.Org Source0: http: // feh.finalrewind.org/feh-%versão.alcatrão.Bz2 BuildRequis: GCC BuildRequiss: IMLIB2-DEVEL BuildRequises: Libcurl-Devel BuildRequis: Libjpeg-devel BuildRequis: Libpng-Devel BuildRequieres: Libxt-DevelRequires: LibxineReMerReSirReSirReRequires: Libxt-DevelRequires: LibxineReMerReSirReSirReSirSirSiresIres: Teste -Harness %Descrição Visualizador de imagem da linha de comando rápido usando imlib2 %prepare /usr/bin/feh-3.0-1.FC29.x86_64.Debug/usr/share/aplicações/feh.Desktop/usr/share/doc/feh/autores/usr/share/doc/feh/changelog/usr/share/doc/feh/readme.md/usr/share/doc/feh/todo/usr/share/doc/feh/exemplos/botões/usr/share/doc/feh/exemplos/find-lowres/usr/share/doc/feh/exemplos/keys/ usr/share/doc/feh/exemplos/temas/usr/share/feh/fonts/preto.estilo/usr/share/feh/fontes/menu.estilo/usr/share/feh/fontes/yudit.ttf/usr/share/feh/imagens/feh.png/usr/share/feh/imagens/feh.svg/usr/share/feh/imagens/menubg_default.png/usr/share/icons/hicolor/48x48/apps/feh.png/usr/share/icons/hicolor/scalable/apps/feh.svg/usr/share/man/man1/feh.1.gz 

Vamos analisar. Primeiro, especificamos algumas informações básicas sobre o software que queremos empacotar: seu nome e versão upstream, sua licença, a localização da página principal do projeto e o link direto para o código -fonte Tarball, depois declaramos o construir dependências usando BuildRequires. A lista de dependências pode ser representada como um espaço ou vírgula em linha em linha, mas, por uma questão de legibilidade, declaramos uma dependência por linha, repetindo o BuildRequires instrução.

Depois de declarar as dependências necessárias para construir o software, fornecemos uma breve descrição no %descrição seção, e depois prosseguiu para a parte mais importante do especfile: as instruções para preparar, construir e instalar o software, respectivamente no %preparação, %construir e %instalar Seções.

No %preparação seção, fornecendo o %Configuração -q Macro já foi suficiente: como dito antes, essa macro executará os comandos necessários para descompactar o tarball de origem e colocar o diretório extraído no CONSTRUIR pasta.

O %construir Seção é onde especificamos os comandos que devem ser executados para construir o código -fonte. Mesmo aqui, tudo o que tínhamos que usar era apenas o %make_build macro, que executa o fazer Comando com as opções que vimos antes, no diretório que hospeda o código -fonte descompactado do aplicativo que queremos empacotar.

No %instalar Seção, usamos outra macro, %make_install, fornecendo também o PREFIXO parâmetro, configurando -o para %_prefixo, que será expandido para /usr. O comando resultante causará os arquivos produzidos pela compilação do código -fonte, a serem colocados na "raiz falsa", definida com o Destdir parâmetro contido na macro. Desde que no %make_install Macro, "Destdir" está definido como /home/egdoc/rpmbuild/buildroot/%name-%versão-%release.x86_64, Os arquivos serão instalados em: /home/egdoc/rpmbuild/buildroot/%name-%versão-%release.x86_64/usr.

Finalmente, fornecemos, no %arquivos Seção, uma lista dos arquivos que serão instalados pelo nosso pacote. Esta lista pode ser posteriormente inspecionada executando o RPM -QLP/PATH/TO/O/RPM comando ou, se o pacote já estiver instalado, simplesmente executando RPM -QL Packagename.

Obtenha as fontes e construa o pacote RPM

Agora que nosso arquivo de especificações está finalmente pronto, podemos construir nosso RPM. Você pode notar que ainda não baixamos o tarball de origem de "feh": não há necessidade de fazer isso manualmente, pois podemos usar o SpectCool comando:

$ SPECTOOL -G -R ~/RPMBUILD/Specs/Feh.especificando http: // feh.finalrewind.org/feh-3.0.alcatrão.bz2 para/home/egdoc/rpmbuild/fontes/feh-3.0.alcatrão.Bz2 % % % % recebeu % xferd de velocidade média tempo tempo de upload de upload dargas de d Total Speed ​​esquerda 100 185 100 185 0 0 898 0-:-:-:-:--:-:- -898 100 2057K 100 2057K 0 0 1988K 0 0:00:01 0:00:01-:-:-4191k 

Este comando baixará as fontes que referenciamos com um URL dentro do especfile, no diretório apropriado de nossa árvore de trabalho: ~/rpmbuild/fontes. Com as fontes em vigor, podemos construir nosso RPM: tudo o que precisamos fazer é lançar o rpMbuild comando e forneça o caminho para o especfile. Quando lançado com o -bb opção, o rpmbuild construirá apenas um pacote binário: se queremos gerar também um RPM de origem, devemos usar -BA em vez.

Uma coisa muito importante a lembrar é que o comando rpMbuild nunca deve ser lançado com permissões raiz: ao fazê -lo, mesmo um simples erro no especfile pode produzir efeitos indesejados em nosso sistema. Vamos executar rpmbuild:

$ rpmbuild -bb ~/rpmbuild/specs/feh.espec

A saída das operações executadas será impressa na tela e, se tudo correr como o esperado, o pacote RPM será gerado dentro do Rpms diretório.

Conclusões

Neste tutorial, aprendemos os conceitos fundamentais envolvidos na criação de um pacote de RPM. Aprendemos algumas macros e como construir um .espec arquivo, que contém todas as instruções necessárias para o processo de construção. Também fornecemos um exemplo real, construção e embalagem Feh, um visualizador de imagem de linha de comando simples. Sugiro que você consulte o guia oficial de embalagem Red Hat para expandir ainda mais os conceitos mencionados neste tutorial.

Tutoriais do Linux relacionados:

• Uma introdução à automação, ferramentas e técnicas do Linux
• Coisas para instalar no Ubuntu 20.04
• Mastering Bash Script Loops
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Como atualizar o CentOS
• Download do Linux
• Ubuntu 20.04 Guia
• Como migrar de CentOS para Almalinux
• Arquivos de configuração do Linux: os 30 primeiros mais importantes