Cómo crear un paquete RPM

RPM es tanto el administrador de paquetes como el formato de paquete utilizado por muchas distribuciones de Linux, como Fedora, Red Hat y CentOS, para administrar y distribuir software en forma binaria. En este tutorial veremos cómo construir y empaquetar una aplicación simple.

En este tutorial aprenderás:

• ¿Cuáles son los conceptos básicos detrás del proceso de construcción de RPM?.
• ¿Cuál es el entorno de construcción?.
• ¿Qué es una especie?.
• Cómo usar macros dentro de una specfile.
• Cómo instalar las dependencias de compilación.
• Cómo crear una especificación de especificaciones.
• Cómo construir un paquete RPM.

Requisitos y convenciones de software utilizados

Conceptos básicos de rpm

Instalar, eliminar, actualizar, (en una palabra, administrar) el software es una tarea esencial en cada sistema operativo. Cuando los administradores de paquetes no eran una cosa, la única forma de instalar un programa era compilar su código fuente y colocar los archivos resultantes en los lugares apropiados en el sistema de archivos. Hacer un seguimiento de las dependencias de cada pieza de código fue realmente difícil y lento. Luego se introdujeron los gerentes de paquetes, y todo se hizo más fácil.

Cada distribución moderna de Linux tiene, hoy en día, su administrador de paquetes: Debian y sus derivados usan dpkg, mientras
rpm se usa en la familia Red Hat of Distributions. El software se proporciona precompilado bajo la forma de paquetes, que son básicamente archivos comprimidos que contienen metadatos sobre la versión del software, sus dependencias y posibles conflictos con otros paquetes.

En este tutorial, veremos cómo crear un paquete RPM a partir de un código fuente de la aplicación. La aplicación que el paquete We We es FEH, Un visor de imagen de línea de comando simple: es bastante pequeño y tiene pocas dependencias. Antes de comenzar a construir nuestro primer paquete, hay, sin embargo, algunos conceptos esenciales que deberíamos comprender.

El entorno de construcción

La raíz de un árbol de entorno de construcción de rpm es el rpmbuild Directorio, que contiene 6 subdirectorios: CONSTRUIR, Arrebato, Rpms, FUENTES, ESPECIFICACIONES y SRPMS. Veremos cómo es posible generar este entorno iniciando un comando simple; Por ahora, solo mencionemos el papel de estos directorios. Aquí hay una representación del árbol de trabajo:

 rpmbuild |- build |- buildroot |- rpms |- fuentes |- especificaciones |- srpms 

Cada uno de estos directorios tiene un papel específico en el proceso de construcción:

• El CONSTRUIR El directorio es donde se crea el código fuente del programa que queremos empaquetar
• El Arrebato El directorio es donde se copian los archivos resultantes de la compilación del software dentro del directorio de compilación, lo que refleja la estructura del sistema de destino dentro de un subdirectorio con el paquete mame:
  En nuestro caso, el binario "FEH" que se instalaría en /usr/bin se informará como BuildRoot/Feh-3.0-1.FC29.x86_64/usr/bin.
• El Rpms directorio, es donde rpm Se generan paquetes: cada RPM se colocará en un subdirectorio
  llamado así por su arquitectura, o, noarch Si no es específico de la arquitectura.
• El FUENTES El directorio aloja el código fuente comprimido del software que queremos empaquetar, a menudo bajo la forma de una tarball de un archivo zip.
• El ESPECIFICACIONES directorio, es donde ponemos el .Especificaciones Archivo con las instrucciones para construir nuestro paquete: analizaremos la estructura de este archivo en un momento.
• El SRPMS El directorio es el equivalente de RPMS, pero para las RPM de origen. Estos paquetes especiales contienen el código fuente original de la aplicación, los parches eventuales y la medida de la especificación utilizada para construir el paquete.

El archivo de especificaciones

El archivo donde se definen todas las instrucciones e información necesarias para construir un paquete RPM es el .Especificaciones archivo. Una marca de especificación contiene, entre las otras cosas, la construir dependencias (El software necesario para compilar el programa que queremos empaquetar), el Dependencias de tiempo de ejecución (Las bibliotecas necesarias para que el programa se ejecute correctamente) y los ommands que deben ejecutarse para compilar el software.

El archivo está compuesto por dos macro-secciones: un preámbulo y el cuerpo. En cada una de estas secciones, se pueden especificar diferentes instrucciones. Veamos algunos de ellos. El preámbulo La sección puede contener las siguientes instrucciones:

• • Nombre: El nombre de base del paquete (esto debería coincidir con el nombre del archivo de especificaciones)
  • Versión: La versión aguas arriba del software empaquetado
  • Liberar: El número de lanzamiento del paquete
  • Licencia: La licencia utilizada para el software que queremos empaquetar
  • Url: La URL aguas arriba del software
  • Fuente0: La URL directa o la ruta del código fuente comprimido del software (tarball o archivo con cremallera)
  • Buildarch: La arquitectura del paquete: si no se especifica la arquitectura, se utilizará el sistema de host
  • BuildRequires: Las dependencias necesarias para construir el software
  • Requerimiento: Las dependencias necesarias para ejecutar el software

El cuerpo Sección de la Fila de especificaciones, típicamente contiene las siguientes secciones:

• %descripción: Una descripción opcionalmente de múltiples líneas del software empaquetado
• %deberes: Los comandos necesarios para preparar el código fuente (por ejemplo, los comandos necesarios para extraer un tarball)
• %construir: Los comandos necesarios para construir el software
• %instalar: Los comandos necesarios para copiar el archivo resultante del proceso de compilación al Arrebato directorio
• %de archivos: La lista de los archivos proporcionados por el paquete, que se instalará en el sistema

Macros

Para aliviar nuestro trabajo, dentro de una marca de especificación, podemos usar algunas macros que nos permiten hacer referencia a muchas cosas útiles y realizar automáticamente ciertas tareas. En primer lugar, tenemos el Macros de directorio RPM que permiten referencia a los directorios de nuestro entorno de construcción; Siempre debemos usarlos en lugar de rutas directas:

• %_ topdir: Esta macro hace referencia al rpmbuild directorio
• %_ builddir: Referencias el CONSTRUIR Directorio dentro de nuestro árbol de construcción
• %_ rpmdir: Hace referencia al camino del Rpms directorio
• %_ Sourcedir: Esta macro se evalúa en la ruta del FUENTES directorio
• %_ Specdir: Una macro que representa el camino del ESPECIFICACIONES directorio
• %_ srcrpmdir: Hace referencia al camino de SRPMS directorio
• %_ BuildRootDir: Hace referencia al camino del Arrebato directorio

Otras Macros permitamos hacer referencia a los directorios más importantes en el sistema de archivos Our Machine, por ejemplo:

• %_ sysconfigdir: El /etc directorio
• %_prefijo: El /USR directorio
• %_ bindir: El /usr/bin directorio
• %_ mandir: El camino hacia el /usr/share/hombre directorio

El anterior, no es una lista completa, pero te da una idea. Además, también podemos usar un conjunto de macros que realizan tareas específicas. Para expandir la definición de una macro, y así para ver su contenido, podemos usar el RPM --Eval comando, que toma la macro como argumento. Aquí hay algunos ejemplos de macros de uso frecuente:

• El %configuración macro, se usa en el %config Sección de la File Spec, y básicamente realiza las siguientes acciones:
  1. Extrae el código fuente del programa que queremos empaquetar en el Builddir directorio
  2. Cambia al directorio extraído
  3. Establece los permisos de archivo apropiados dentro de él
• El %make_build La macro se usa en el %construir Sección de la File de especificación, y básicamente ejecuta el hacer Comando con un conjunto de opciones predefinidos, para compilar el código fuente del software. Si lo expandimos, podemos verificar el comando que ejecuta:

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

• El %make_install La macro, en cambio, se usa en el %instalar sección del archivo y se ejecuta hacer instalar con el Destdir Parámetro, utilizado para instruir al comando para instalar los archivos compilados relativamente a un directorio determinado en lugar del sistema real /:

  $ rpm --eval "%make_install"/usr/bin/make install Destdir =/home/egdoc/rpmbuild/buildroot/%name-%versión-%versión.x86_64 install = "/usr/bin/install -p" 

Cómo crear un paquete RPM instrucciones paso a paso

Ahora que aprendimos el concepto básico del proceso de construcción de paquetes, podemos ver cómo crear nuestro entorno de compilación y nuestro primer paquete de RPM. Creemos nuestro paquete.

Instale las dependencias de compilación

Como lo primero, necesitamos instalar rpmdevtools, Además de las dependencias necesarias para construir FEH:

$ sudo dnf instalación rpmdevtools gcc make imlib2-devel libjpeg-devel libpng-devel libxt-devel libxinerama-devel libexif-devel \ perl-test-command perl-test-harness libcurl-devel 

Una vez que se instalan los paquetes, podemos generar nuestro entorno de compilación. Todo lo que tenemos que hacer es iniciar el siguiente comando:

$ rpmdev-setuptree

En este punto el rpmbuild El directorio, y todos los subdirectorios que vimos antes, deben crearse. El siguiente paso es escribir nuestra especificación.

Crea la File de especificaciones

Creamos lafile de especificaciones con nuestro editor de texto favorito y la guardamos en el ESPECIFICACIONES directorio con el mismo nombre del paquete. Así es como debería verse una especie mínima:

Nombre: Feh Versión: 3.0 Versión: 1%?Dist Resumen: Visor de imagen de línea de comando rápido usando la licencia IMLIB2: URL MIT: http: // Feh.Finalwind.Org Source0: http: // feh.Finalwind.org/feh-%versión.alquitrán.BZ2 BuildRequires: GCC BuildRequires: IMLIB2-Devel BuildRequires: LibCurl-Devel BuildRequires: LibJpeg-Devel BuildRequires: Libpng-Devel BuildRequires: LibXT-Devel BuildRequires: Libxinerama-Devel BuildRequires: Libexif-COMECHIRES: PERL-CONDECO: PERL-TUST-COLECHIRES: PERL-CONDICIO: PERL-COLECHIRES: PERL-CONDIVO: LIBEX-COBLES: PERL-COBLE-COBLE-CON. Test -Harness %Descripción Visor de imágenes de línea de comando rápida Uso de IMLIB2 %Prep %setup -q %build %make_build %instalación %make_install prefix = %_ prefijo %archivos/usr/bin/feh/usr/lib/debug/debug /usr/bin/Feh-3.0-1.FC29.x86_64.debug/usr/share/aplicaciones/FEH.Desktop/usr/share/doc/feh/authors/usr/share/doc/feh/changelog/usr/share/doc/feh/readme.MD/USR/Share/Doc/Feh/TODO/USR/Share/Doc/Feh/Ejemplos/Buttons/USR/Share/Doc/Feh/Ejemplos/Find-Lowres/USR/Share/Doc/Feh/Ejemplos/Keys/ USR/Share/Doc/Feh/Ejemplos/Themes/USR/Share/Feh/Fonts/Black.estilo/usr/share/feh/fuentes/menú.estilo/usr/share/feh/fuentes/yudit.TTF/USR/Share/Feh/Images/Feh.PNG/USR/Share/Feh/Images/Feh.svg/usr/share/feh/imágenes/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 

Analicémoslo. Primero, especificamos información básica sobre el software que queremos empaquetar: su nombre y versión ascendente, su licencia, la ubicación de la página principal del proyecto y el enlace directo al código fuente de tarball, luego declaramos la construir dependencias usando BuildRequires. La lista de dependencias puede representarse como una lista en línea separada de espacio o coma, pero en aras de la legibilidad declaramos una dependencia por línea, repitiendo la BuildRequires instrucción.

Después de declarar las dependencias necesarias para construir el software, proporcionamos una breve descripción en el %descripción sección, y que se procedieron a la parte más importante de lafila de especificaciones: las instrucciones para preparar, construir e instalar el software, respectivamente en el %deberes, %construir y %instalar secciones.

En el %deberes sección, proporcionando el %configuración -q Macro ha sido suficiente: como se dijo antes, esta macro ejecutará los comandos necesarios para desempacar el Tarball de origen y colocar el directorio extraído en el CONSTRUIR carpeta.

El %construir La sección es donde especificamos los comandos que deben ejecutarse para construir el código fuente. Incluso aquí, todo lo que tuvimos que usar era solo el %make_build macro, que ejecuta el hacer comando con las opciones que vimos antes, en el directorio que aloja el código fuente desempaquetado de la aplicación que queremos empaquetar.

En el %instalar Sección, usamos otra macro, %make_install, proporcionando también el PREFIJO parámetro, configurándolo en %_prefijo, que se ampliará a /USR. El comando resultante hará que los archivos producidos por la compilación del código fuente, se coloquen en la "raíz falsa", establecida con el Destdir parámetro contenido en la macro. Desde que en el %make_install Macro, "Destdir" está configurado en /home/egdoc/rpmbuild/buildroot/%name-%versión-%rotes.x86_64, Los archivos se instalarán en: /home/egdoc/rpmbuild/buildroot/%name-%versión-%rotes.x86_64/usr.

Finalmente, proporcionamos, en el %de archivos Sección, una lista de los archivos que serán instalados por nuestro paquete. Esta lista podría inspeccionarse más tarde ejecutando el rpm -qlp/rath/to/the/rpm comando o, si el paquete ya está instalado, simplemente ejecutando rpm -ql packagename.

Obtenga las fuentes y cree el paquete RPM

Ahora que nuestro archivo de especificaciones finalmente está listo, podemos construir nuestro rpm. Puede notar que no descargamos el Tarball de origen de "Feh" todavía: no hay necesidad de hacer esto manualmente, ya que podemos usar el espejool dominio:

$ SPECTOOL -G -R ~/RPMBUILD/SPECS/FEH.especificaciones obteniendo http: // feh.Finalwind.org/FEH-3.0.alquitrán.bz2 a/home/egdoc/rpmbuild/fuentes/FEH-3.0.alquitrán.BZ2 % Total % recibido % XFERD Tiempo de velocidad promedio Tiempo de tiempo Corriente de carga Total Total Gasto Velocidad Izquierda 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 descargará las fuentes a las que hicimos referencia con una URL dentro de la Fila de Especificaciones, en el directorio apropiado de nuestro árbol de trabajo: ~/rpmbuild/fuentes. Con las fuentes en su lugar, podemos construir nuestras RPM: todo lo que tenemos que hacer es lanzar el rpmbuild comandar y proporcionar la ruta a lafile de especificaciones. Cuando se lanzó con el -cama y desayuno opción, rpmbuild construirá solo un paquete binario: Si queremos generar también un RPM de origen, debemos usar -licenciado en Letras en su lugar (consulte la manzana RPMBuild para obtener una descripción general de las opciones de posibilidad).

Una cosa muy importante para recordar es que el comando rpmbuild nunca debe lanzarse con permisos raíz: al hacerlo, incluso un error simple en lafilia podría producir efectos no deseados en nuestro sistema. Ejecutemos rpmbuild:

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

La salida de las operaciones realizadas se imprimirá en la pantalla y, si todo va como se esperaba, el paquete RPM se generará dentro del Rpms directorio.

Conclusiones

En este tutorial aprendimos los conceptos fundamentales involucrados en la creación de un paquete RPM. Aprendimos algunas macros y cómo construir un .Especificaciones archivo, que contiene todas las instrucciones necesarias para el proceso de construcción. También proporcionamos un ejemplo real, construcción y embalaje FEH, Un visor de imagen de línea de comando simple. Le sugiero que consulte a la Guía oficial de empaque de Red Hat para expandir aún más los conceptos mencionados en este tutorial.

Tutoriales de Linux relacionados:

• Una introducción a la automatización, herramientas y técnicas de Linux
• Cosas para instalar en Ubuntu 20.04
• Mastering Bash Script Loops
• Mint 20: Mejor que Ubuntu y Microsoft Windows?
• Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
• Cómo actualizar CentOS
• Descarga de Linux
• Ubuntu 20.04 Guía
• Cómo migrar de Centos a Almalinux
• Archivos de configuración de Linux: los 30 principales más importantes