Creando Paquetes RPM: Preparativos

por | 23 septiembre, 2008

Hola, voy a escribir unos tres artículos sobre cómo crear paquetes RPM por nuestra cuenta. Llevo tiempo queriendo escribir sobre ello pero no encontré ninguna explicación de cómo crear paquetes RPM de programas que no contienen autotools, hasta que Alejandro de Sin Windows habló de cómo hacerlo.
Trataré de cómo crear dichos paquetes sin poner en riesgo nuestro sistema linuxero, es decir, sin ser superusuario, ya que corremos el riesgo de si lo hacemos como superusuario de instalar el paquete que estamos haciendo el RPM al mismo tiempo que lo creamos, y claro; si nos hemos equivocado gravemente al crearlo y el paquete afecta a configuraciones importantes del sistema podría hacernos un verdadero estropicio.

Pero empecemos por el principio, seguramente muchos os estaréis preguntando qué puñetas es eso del RPM; pues es muy sencillo. Para poder instalar un programa con tan sólo un doble click de ratón sobre un instalador en distribuciones linuxeras basadas en RedHat (como Mandriva, Suse o la propia RedHat, entre otras) necesitaremos empaquetar todo el programa en un paquete que llevará como extensión el sufijo rpm, así, si nuestro programa se llama programita, el paquete se llamará programita.rpm.
Para los de Debian o los ubunteros rpm es el equivalente al deb de Debian, o a los instaladores tipo Setup.exe para los windowseros.
Vale, una vez sabido que nuestro objetivo es empaquetar un programa en formato RPM para que cualquiera pueda instalarlo con un doble click de ratón (y también desinstalarlo), veamos los pasos previos a realizar.
Lo primero será instalar los programas necesarios para poder crearlos, que son:

rpm, rpm-build, spec-helper, libtool, rpmlint

Todos estos programas los podéis instalar fácilmente desde vuestro gestor de instalación. Ahora vamos a crear una serie de directorios en nuestra carpeta personal los cuales nos permitirán poder crear nuestros RPM sin ser superusuarios. Os pongo primero el comando y os explico, así que abrid terminal y escribid

  1. mkdir -p ~/rpm/{BUILD,BUILDROOT,RPMS/i586,RPMS/noarch,RPMS/i686,SOURCES,SRPMS,SPECS,tmp}

Bien, la orden nos va a crear en nuestro home un directorio raíz llamado rpm, del cual se desprenderán unos subdirectorios con la estructura siguiente:

  1. |-- BUILD
  2. |-- RPMS
  3. |   |-- i586
  4. |   `-- noarch
  5. |-- SOURCES
  6. |-- SPECS
  7. |-- SRPMS
  8. `-- tmp

Vale, de esos directorios empiezo explicando el SOURCES, en este directorio ubicaremos nuestro programa, aquí lo que colocamos es el programa con sus fuentes que nos bajamos para poderlo compilar e instalar con autotools, o aquellos programas que no hacen falta compilarlos para ejecutarlos porque ya vienen los binarios. Ambos tipos deberemos colocarlos ahí de forma comprimida y en formato .tar.bz2. Si tenemos más fuentes las pondremos también ahí. No os preocupéis si estáis algo confusos, en el siguiente artículo lo entenderéis mejor.
En dicho directorio también deberemos colocar los parches si los hubiera, pero esto es un tema demasiado avanzado para lo que yo quiero explicar y entiendo todavía.
El directorio SPECS es un directorio en el cual deberemos ubicar nuestro fichero de extensión .spec de nuestro programa a empaquetar, dicho fichero lo podemos crear con gedit o kate. Contendrá cosas como el nombre del programa, su versión, arquitectura, descripción del programa, dependencias y cómo hay que proceder a su instalación. El fichero spec es como el fichero control de Debian pero al que además le añadimos una serie de instrucciones especificando cómo instalar, vamos que lleva también una especie de órdenes al estilo del fichero rules de DEBIAN. La creación de este fichero es la parte más delicada y compleja de todo el proceso, al principio es bastante tedioso y complejo, pero conforme vas haciendo más paquetes va resultando más claro; ya os explicaré
El directorio BUILD y el directorio tmp son directorios con los que trabajará el ordenador cuando ejecutemos la orden de creación del rpm mediante el comando rpmbuild, y son los que nos permiten no tener que hacerlo como superusuario.
El directorio RPMS es el directorio donde se guardará nuestro paquete creado al final del proceso, según la arquitectura en que lo hayamos creado se nos guardará en su respectivo subdirectorio: i686, 64bits, etc El de noarch es para aquellos paquetes que pueden ser instalados en cualquier arquitectura, equivalen al ALL de Debian.
El directorio SRPMS es el directorio nuestro paquete rpm pero en su estilo de fuentes. Me explico, cuando creamos el rpm tenemos la opción de crear un rpm de fuentes que llevará en su nombre el identificativo src.rpm, así para nuestro programita sería programita-1.0.src.rpm. Estos paquetes lo que llevan son el código fuente del programa y el fichero .spec. Y sirven para poder crear una nueva versión del programa a partir de este rpm de fuentes, es muy útil porque así no tenemos que crear de cero el fichero spec.
Sí quisiera aclarar que aquí cuando me refiero a las fuentes del programa no me refiero sólo al típico fichero comprimido de un programa que viene con las herramientas típicas de compilación e instalación de autotools o scons, sino que también puede ser un comprimido del programa con los ejecutables o binarios. Es decir, que en este contexto igual son fichero fuentes el bajarme el comprimido del navegador Flock el cual para su instalación basta con descomprimirlo; como el comprimido del GIMP que para instalarlo deberíamos compilarlo con lo de configure, make y make install. Espero que esto os quede claro, porque es muy importantge entenderlo.
Bien, ya nos queda poco para terminar los preparativos, tan sólo nos falta crear un archivo oculto en nuestro directorio personal, le llamaremos .rpmmacros ( ¡NO OS OLVIDÉIS DE ANTEPONER EL PUNTO PARA QUE SEA OCULTO!!! ), lo podéis crear con un editor de textos, os pongo uno de ejemplo:

  1. %_topdir %(echo $HOME)/rpm
  2. %_tmppath %(echo $HOME)/rpm/tmp
  3. # Si desea que sus paquetes sean automáticamente firmados con GPG, añada estas
  4. # tres líneas cambiando 'Mandrivalinux' por su nombre GPG. Tambien puede usar
  5. # rpm resign para firmarlos posteriormente.
  6. %_signature gpg
  7. %_gpg_name tobal
  8. %_gpg_path ~/.gnupg
  9. # Agregue su nombre y dirección de correo electrónico en el campo %packager.
  10. # Puede que tambien desee cambiar 'vendor' por usted mismo.
  11. %packager TuNombre Apellido
  12. %distribution Mandriva Linux
  13. %vendor Mandriva
  14. # Si desea que sus paquetes tengan su propio sufijo de distribución en lugar
  15. # de mdv, anótelo aquí
  16. %distsuffix tobal_mdv

Bien, cómo véis es sencillo de hacer, cambiad lo de tobal por vuestro nombre de usuario, y rellenad vuestro e-mail y nombre donde corresponda. Si estáis en Suse pues ya sabéis que debéis cambiar Mandriva por Suse y mdv por lo que toque
En ese texto veréis tres líneas que son:
%_signature gpg
%_gpg_name tobal
%_gpg_path ~/.gnupg

Bien, estas tres líneas sirven para que podáis firmar vuestros paquetes, me explico, si es el caso que queréis crearos un repositorio de Mandriva será conveniente que vuestro repositorio tenga una firma de clave, para poder autenticar vuestro repositorio. De esas tres líneas sólo hace faltga que cambiéis donde pone tobal por el nombre que le hayáis dado a vuestra clave. Para crear la clave se hace mediante terminal con la orden gpg, os pongo mi salida por terminal:

  1. $ gpg --gen-key
  2. gpg (GnuPG) 1.4.9; Copyright (C) 2008 Free Software Foundation, Inc.
  3. This is free software: you are free to change and redistribute it.
  4. There is NO WARRANTY, to the extent permitted by law.
  5.  
  6. gpg: directorio `/home/tobal/.gnupg' creado
  7. gpg: creado un nuevo fichero de configuración `/home/tobal/.gnupg/gpg.conf'
  8. gpg: AVISO: las opciones en `/home/tobal/.gnupg/gpg.conf' no están aún activas en esta ejecución
  9. gpg: anillo `/home/tobal/.gnupg/secring.gpg' creado
  10. gpg: anillo `/home/tobal/.gnupg/pubring.gpg' creado
  11. Por favor seleccione tipo de clave deseado:
  12.    (1) DSA y ElGamal (por defecto)
  13.    (2) DSA (sólo firmar)
  14.    (5) RSA (sólo firmar)
  15. Su elección: 1
  16. El par de claves DSA tendrá 1024 bits.
  17. las claves ELG-E pueden tener entre 1024 y 4096 bits de longitud.
  18. ¿De qué tamaño quiere la clave? (2048)
  19. El tamaño requerido es de 2048 bits
  20. Por favor, especifique el período de validez de la clave.
  21.          0 = la clave nunca caduca
  22.         = la clave caduca en n días
  23.       w = la clave caduca en n semanas
  24.       m = la clave caduca en n meses
  25.       y = la clave caduca en n años
  26. ¿Validez de la clave (0)?
  27. La clave nunca caduca
  28. ¿Es correcto? (s/n) s
  29.  
  30. Necesita un identificador de usuario para identificar su clave. El programa
  31. construye el identificador a partir del Nombre Real, Comentario y Dirección
  32. de Correo Electrónico de esta forma:
  33.     "Heinrich Heine (Der Dichter) "
  34.  
  35. Nombre y apellidos: tobal
  36. Dirección de correo electrónico: lopeztobal@gmail.com
  37. Comentario:
  38. Ha seleccionado este ID de usuario:
  39.     "tobal "
  40.  
  41. ¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? v
  42. Necesita una frase contraseña para proteger su clave secreta.
  43. $ gpg --list-keys
  44. /home/tobal/.gnupg/pubring.gpg
  45. ------------------------------
  46. pub   1024D/F47BFB7C 2008-09-23
  47. uid                  tobal
  48. sub   2048g/8C3E538B 2008-09-23

Como podéis apreciar es bastante sencillo crear una clave pública para un repositorio, acordaos de apuntaros vuestra frase secreta en un papel porque cuando construyáis el paquete os la preguntará. En lo de la clave falta un pequeño detalle, es exportarla a un fichero de extensión .gpg para que todo el mundo tenga acceso a ella, tan sencillo como abrir terminal y escribir:

  1. $ gpg --export -a 'tobal' > RPM-GPG-tobal.gpg

Ahora si váis a vuestro directorio personal encontraréis el fichero gpg, en mi caso es RPM-GPG-tobal.gpg; ya listo para subirlo al repositorio Fijaros que en el fichero .rpmmacros en el nombre de gpg he puesto el mismo que en la generación de la clave, en mi caso es tobal.
Deciros, que esta forma de crear la clave es independiente de la distribución en la que estéis, esta forma de hacerla también sirve para distribuciones DEBIAN, así que para un repositorio propio basado en DEBIAN podemos crear así la clave. En lo único que cambia es en la forma de introducir el comando para construir el paquete con la firma de la clave pública. Cuando vayamos a crear el paquete rpm lo crearemos con la orden rpmbuild y la opción sign. Para que os aclaréis y como pequeño adelanto, supongamos que nuestro programa se llama programita, entonces la orden de construcción será:

  1. rpmbuild -ba --sign programita.spec

No os preocupéis que ya os explicaré todo esto con un ejemplo concreto en el próximo artículo.
Sólo falta aclarar que el gpg y el md5sums no son la misma cosa, así que un mismo paquete puede llevar ambos, uno de ellos o ninguno; pero ambos sirven para autenticar paquetes. Obviamente lo del gpg no hace falta hacerlo si el rpm no lo vais a subir a un repositorio firmado.
Naturalmente todo lo que he explicado en el artículo, o el 99% de lo que he escrito, sólo hay que hacerlo una vez
Y bueno hasta aquí esta primera parte sobre las tres que tengo programadas sobre cómo crear paquetes RPM, uuff cuesta montón escribirlo todo #:-S Bueno qué, ¿nos vemos en las siguientes entregas o ya os habéis acojonado?
Saludos :-h
Fuente 1 -> Sin Windows
Fuente 2 -> Artículo en BlogDrake
Fuente 3 -> Artículo en la Wiki De Mandriva

Un pensamiento en “Creando Paquetes RPM: Preparativos

  1. Pingback: Creando Paquetes RPM: Sin Fuentes Y Sin Autotools

Los comentarios están cerrados.