Compilar software desde el código fuente en Linux

Introducción

En esta práctica, aprenderás el proceso fundamental para compilar e instalar software a partir de su código fuente en un sistema Linux. Esta es una habilidad crucial para gestionar aplicaciones que no están disponibles en el gestor de paquetes de tu distribución o cuando necesitas habilitar funciones personalizadas específicas. Trabajarás con un ejemplo real, el servidor Pure-FTPd, para comprender cada etapa del flujo de trabajo de una instalación basada en fuentes.

Comenzarás extrayendo el código fuente de un archivo comprimido, comúnmente conocido como "tarball", utilizando el comando tar. A continuación, prepararás el entorno de compilación ejecutando el script ./configure y luego compilarás el código fuente en programas ejecutables con el comando make. Tras una compilación exitosa, instalarás el software en todo el sistema mediante make install. Finalmente, aprenderás cómo desinstalar correctamente el software y limpiar los archivos de origen, completando así todo el ciclo de vida de una instalación desde el código fuente.

Extraer el código fuente con tar

En este paso, aprenderás a extraer un archivo de código fuente, comúnmente conocido como "tarball", utilizando el comando tar. El código fuente del software suele distribuirse en archivos comprimidos como .tar.gz para agrupar todos los archivos necesarios y reducir el tamaño total del archivo.

Primero, confirmemos que el archivo de código fuente está disponible en nuestro directorio de trabajo actual, ~/project. Usa el comando ls -l para listar los archivos y sus detalles.

ls -l

Deberías ver el archivo pure-ftpd-1.0.53.tar.gz en la salida.

total 748
-rw-r--r-- 1 labex labex 765432 Nov 10 12:00 pure-ftpd-1.0.53.tar.gz

Ahora, utilizaremos el comando tar para extraer el contenido de este archivo. Las opciones que usaremos son:

• -x: para extraer (extract) archivos de un paquete.
• -z: para descomprimir el archivo usando gzip, lo cual se indica por la extensión .gz.
• -v: para una salida detallada (verbose), que enumera todos los archivos a medida que se extraen.
• -f: para especificar el nombre del archivo (filename) que se va a procesar.

Ejecuta el siguiente comando en tu terminal para extraer el archivo:

tar -zxvf pure-ftpd-1.0.53.tar.gz

La opción -v hará que tar imprima el nombre de cada archivo que extrae. La salida será bastante larga, pero debería ser similar al ejemplo de abajo, mostrando la estructura de directorios y los archivos que se están creando.

pure-ftpd-1.0.50/
pure-ftpd-1.0.50/AUTHORS
pure-ftpd-1.0.50/README
pure-ftpd-1.0.50/README.LDAP
pure-ftpd-1.0.50/README.MySQL
pure-ftpd-1.0.50/README.PGSQL
...
pure-ftpd-1.0.50/src/puredb_p.h
pure-ftpd-1.0.50/src/pure-quotacheck.c
pure-ftpd-1.0.50/src/pure-uploadscript.c

Una vez que el comando termine, se habrá creado un nuevo directorio que contiene el código fuente. Usemos ls -l de nuevo para ver este nuevo directorio.

ls -l

Ahora deberías ver el directorio pure-ftpd-1.0.50 junto al tarball original.

total 752
drwxr-xr-x 10 labex labex    4096 Nov 10 12:05 pure-ftpd-1.0.50
-rw-r--r--  1 labex labex  765432 Nov 10 12:00 pure-ftpd-1.0.53.tar.gz

Has extraído con éxito el código fuente del archivo. En el siguiente paso, entraremos en este nuevo directorio y comenzaremos el proceso de configuración y compilación.

Configurar y compilar el software con ./configure y make

En este paso, configurarás el código fuente para tu sistema específico y luego lo compilarás en programas ejecutables. Este es un proceso estándar de dos partes para construir software desde el código fuente en sistemas Linux.

Primero, necesitas cambiar tu ubicación actual al directorio que se creó en el paso anterior. Usa el comando cd para entrar en el directorio pure-ftpd-1.0.50.

cd ~/project/pure-ftpd-1.0.50

Ahora que estás dentro del directorio del código fuente, la primera parte del proceso es ejecutar el script configure. Este script comprueba tu sistema en busca de todas las herramientas, librerías y dependencias necesarias para compilar el software. Luego genera un Makefile, que contiene las instrucciones para el proceso de compilación.

Para ejecutar el script, debes escribir ./ antes de su nombre. Esto le indica a la shell que busque el script configure en el directorio actual.

./configure

El script ejecutará una serie de comprobaciones y verás mucha información pasando por la pantalla. Esto es normal. Una ejecución exitosa terminará con un resumen similar al siguiente.

checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /usr/bin/mkdir -p
...
checking for OpenSSL... no
...
configure: creating ./config.status
config.status: creating Makefile
config.status: creating src/Makefile
config.status: creating man/Makefile
...
config.status: executing depfiles commands

Pure-FTPd has been configured.

Fíjate en las líneas config.status: creating Makefile. Esto confirma que el Makefile se ha creado correctamente.

La segunda parte del proceso es compilar el código. El comando make lee el Makefile y ejecuta el compilador (como gcc) con las opciones correctas para convertir el código fuente legible por humanos (archivos .c) en archivos binarios ejecutables por la máquina.

Ahora, ejecuta el comando make.

make

Este proceso puede tardar unos momentos. Verás muchas líneas de salida a medida que make invoca al compilador para cada archivo de origen. Esta es la compilación real ocurriendo.

(CDPATH="${ZSH_VERSION+.}:" && cd . && /bin/bash /home/labex/project/pure-ftpd-1.0.50/config/missing automake-1.15 --gnu src/Makefile)
...
gcc -g -O2 -Wall -W -Wshadow -Wcast-align -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline -c pure-ftpd.c
...
gcc -g -O2 -Wall -W -Wshadow -Wcast-align -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline   -o pure-ftpd pure_ftpd-pure-ftpd.o pure_ftpd-log.o ...
...
make[1]: Leaving directory '/home/labex/project/pure-ftpd-1.0.50/src'

Una vez que el comando make finaliza sin errores, el software se ha compilado con éxito. Los archivos binarios ya están listos para ser instalados en el sistema, lo cual harás en el siguiente paso.

Instalar el software con make install

En este paso, instalarás el software compilado en tu sistema. Después de compilar el código fuente con make, los archivos binarios resultantes y otros componentes necesarios (como documentación y archivos de configuración) todavía se encuentran dentro del directorio del código fuente. El comando make install copia estos archivos a las ubicaciones estándar del sistema para que el software pueda ejecutarse desde cualquier lugar.

Asegúrate de seguir en el directorio ~/project/pure-ftpd-1.0.50.

El proceso de instalación normalmente requiere escribir archivos en directorios como /usr/local/bin y /usr/local/sbin, que son propiedad del usuario root. Por lo tanto, debes usar el comando sudo para ejecutar make install con privilegios administrativos.

Ejecuta el siguiente comando para instalar Pure-FTPd:

sudo make install

El comando make install leerá el Makefile y ejecutará las instrucciones de instalación. Verás una salida que muestra los archivos que se están creando y copiando en los directorios del sistema.

make[1]: Entering directory '/home/labex/project/pure-ftpd-1.0.50/src'
/usr/bin/mkdir -p '/usr/local/sbin'
/usr/bin/install -c pure-ftpd pure-pw pure-pwconvert pure-authd pure-certd pure-uploadscript pure-quotacheck '/usr/local/sbin'
/usr/bin/mkdir -p '/usr/local/share/man/man8'
/usr/bin/install -c -m 644 ../man/pure-ftpd.8 ../man/pure-pw.8 ../man/pure-pwconvert.8 ../man/pure-authd.8 ../man/pure-certd.8 '/usr/local/share/man/man8'
make[1]: Leaving directory '/home/labex/project/pure-ftpd-1.0.50/src'
make[1]: Entering directory '/home/labex/project/pure-ftpd-1.0.50'
/usr/bin/mkdir -p '/usr/local/etc'
/usr/bin/install -c -m 644 pure-ftpd.conf '/usr/local/etc'
make[1]: Nothing to be done for 'install-data-am'.
make[1]: Leaving directory '/home/labex/project/pure-ftpd-1.0.50'

El software ya está instalado. Una forma sencilla de verificarlo es usar el comando which, que busca en la variable PATH del sistema un ejecutable e imprime su ruta completa.

which pure-ftpd

Si la instalación fue exitosa, deberías ver la siguiente salida, indicando que el ejecutable pure-ftpd se encuentra ahora en un directorio estándar del sistema.

/usr/local/sbin/pure-ftpd

Con el software instalado, técnicamente está listo para su configuración y uso. Sin embargo, para este ejercicio, el siguiente paso te guiará a través del proceso de desinstalación.

Desinstalar el software y limpiar con make uninstall y rm

En este paso final, aprenderás cómo desinstalar correctamente el software que instalaste desde el código fuente y cómo limpiar los archivos de compilación, devolviendo tu sistema a su estado original. Esta es una parte importante de la gestión manual de software.

La mayoría de los paquetes de fuentes bien escritos que utilizan un Makefile proporcionan un objetivo de desinstalación (uninstall). Este objetivo está diseñado para revertir las acciones de make install, eliminando todos los archivos que se copiaron a los directorios del sistema.

Primero, asegúrate de seguir en el directorio ~/project/pure-ftpd-1.0.50. Al igual que el proceso de instalación requería privilegios administrativos, la desinstalación también los requiere. Usa sudo con el comando make uninstall.

sudo make uninstall

Verás una salida indicando que los archivos se están eliminando de los directorios del sistema donde fueron instalados.

make[1]: Entering directory '/home/labex/project/pure-ftpd-1.0.50/src'
rm -f /usr/local/sbin/pure-ftpd /usr/local/sbin/pure-pw /usr/local/sbin/pure-pwconvert /usr/local/sbin/pure-authd /usr/local/sbin/pure-certd /usr/local/sbin/pure-uploadscript /usr/local/sbin/pure-quotacheck
rm -f /usr/local/share/man/man8/pure-ftpd.8 /usr/local/share/man/man8/pure-pw.8 /usr/local/share/man/man8/pure-pwconvert.8 /usr/local/share/man/man8/pure-authd.8 /usr/local/share/man/man8/pure-certd.8
make[1]: Leaving directory '/home/labex/project/pure-ftpd-1.0.50/src'
make[1]: Entering directory '/home/labex/project/pure-ftpd-1.0.50'
rm -f /usr/local/etc/pure-ftpd.conf
make[1]: Leaving directory '/home/labex/project/pure-ftpd-1.0.50'

Para confirmar que el software ha sido eliminado, puedes usar el comando which de nuevo.

which pure-ftpd

Esta vez, el comando no debería producir ninguna salida, porque el ejecutable pure-ftpd ha sido borrado de /usr/local/sbin y ya no se puede encontrar en el PATH del sistema.

Ahora que el software está desinstalado, el último paso es eliminar el propio directorio del código fuente. No puedes eliminar un directorio mientras estás dentro de él, así que primero navega de vuelta al directorio raíz de tu proyecto.

cd ~/project

Ahora, usa el comando rm con la opción -r (recursiva) para borrar el directorio pure-ftpd-1.0.50 y todo su contenido.

rm -r pure-ftpd-1.0.50

Este comando no producirá ninguna salida si tiene éxito. Puedes verificar su eliminación listando el contenido del directorio ~/project.

ls -l

El directorio pure-ftpd-1.0.50 ha desaparecido y solo queda el tarball original.

total 748
-rw-r--r-- 1 labex labex 765432 Nov 10 12:00 pure-ftpd-1.0.53.tar.gz

¡Felicidades! Has completado con éxito todo el proceso de compilación de software desde el código fuente: extracción, configuración, compilación, instalación y, finalmente, desinstalación y limpieza.

Resumen

En esta práctica, aprendiste el procedimiento estándar para compilar e instalar software a partir de su código fuente en un sistema Linux. Comenzaste extrayendo un archivo de código fuente comprimido, también conocido como tarball (.tar.gz), utilizando el comando tar. Tras la extracción, navegaste al directorio de fuentes para ejecutar el script ./configure, que prepara el software para la compilación comprobando las dependencias del sistema y creando un Makefile. Finalmente, utilizaste el comando make para compilar el código fuente en binarios ejecutables y make install para copiar el software a los directorios apropiados del sistema.

Además, practicaste el método adecuado para eliminar el software y limpiar el entorno de compilación. Aprendiste a usar el comando make uninstall para eliminar los archivos instalados del sistema. Para completar el proceso de limpieza, eliminaste el directorio original del código fuente con el comando rm, asegurando que el sistema volviera a su estado anterior.