Descargar, configurar, compilar e instalar el kernel Linux paso a paso

Compilar el núcleo de Linux es una de esas tareas que separan al usuario curioso del que quiere meter las manos hasta el fondo en el sistema operativo. No es obligatorio para usar GNU/Linux en el día a día, pero sí es una forma estupenda de entender mejor cómo funciona tu máquina, exprimir el hardware y dejar el sistema ajustado a tu gusto.

En esta guía vas a ver, paso a paso, cómo descargar, configurar, compilar e instalar un kernel Linux desde cero en distribuciones basadas en Debian (Debian, Ubuntu, Mint y derivadas), además de las ideas generales que puedes aplicar a otras familias como Fedora o CentOS. También veremos por qué podrías querer hacerlo, qué herramientas necesitas, cómo reutilizar la configuración del kernel actual, cómo ajustar opciones para Docker o para hardware específico y cómo volver atrás si algo sale mal.

Por qué puede interesarte compilar tu propio kernel

Antes de tocar nada, conviene tener claro qué ganas: no siempre compilar el kernel es necesario, pero hay varios motivos de peso para hacerlo.

• Rendimiento y eficiencia: quitar controladores y funcionalidades que nunca usas puede hacer que el sistema arranque más rápido, consuma menos RAM y reduzca la latencia en ciertas cargas.
• Seguridad: desactivar características o módulos que no necesitas reduce la superficie de ataque. Un kernel más minimalista es, en muchos contextos, un kernel más seguro.
• Soporte para hardware específico: a veces tu distribución todavía no incluye el driver que necesitas o lo lleva desactivado; compilando tu propio kernel puedes activar exactamente el soporte para tu hardware (tarjetas de red, RAID, dispositivos de almacenamiento poco comunes, etc.).
• Funciones especiales: puede que quieras probar un planificador de tareas nuevo, características concretas para virtualización, Docker, contenedores, BPF, io_uring o cualquier otra función avanzada que no venga activada de serie.
• Aprendizaje y experimentación: compilar el kernel es una forma muy directa de aprender cómo se organiza un sistema GNU/Linux por dentro, cómo se inicializa el hardware y cómo se integran los módulos.

Eso sí: para un usuario doméstico que solo quiere encender el ordenador, navegar y poco más, compilar el kernel a mano es matar moscas a cañonazos. Es un proceso largo, delicado, y es normal comerse algún kernel panic antes de dejarlo fino. Si te gusta trastear, adelante; si no, mejor quédate con los paquetes oficiales de tu distro.

Qué es exactamente el kernel de Linux

El núcleo de Linux es el componente central del sistema: el software que se coloca entre el hardware y el resto de programas. Se encarga de gestionar memoria, procesos, sistemas de archivos, dispositivos de entrada/salida, red, seguridad y mucho más.

Linux arrancó en 1991 como un proyecto personal de Linus Torvalds para crear un núcleo libre. Desde entonces ha crecido una barbaridad: hoy en día hablamos de decenas de millones de líneas de código, mantenidas por miles de desarrolladores bajo la licencia GPLv2. El sistema que solemos llamar «Linux» en realidad es una combinación de kernel Linux + herramientas GNU y otros componentes que montan la distribución.

Cuando compilas un núcleo personalizado, lo que haces es generar un binario (normalmente /boot/vmlinuz-versión) más un conjunto de módulos en /lib/modules/versión, acompañado de ficheros como System.map, el config con la configuración usada y la imagen de arranque inicial (initrd o initramfs).

Herramientas básicas necesarias para compilar el kernel

Para poder compilar un kernel Linux desde las fuentes necesitas un entorno de desarrollo completo. En sistemas Debian, Ubuntu y Mint lo normal es instalar build-essential y una serie de bibliotecas y utilidades adicionales.

En muchas de las guías clásicas se recomiendan conjuntos como los siguientes (puedes adaptarlos según tu distribución):

• Conjunto mínimo en Debian/Ubuntu para un kernel relativamente moderno:sudo apt-get install build-essential libncurses-dev bison flex libssl-dev libelf-dev libudev-dev libpci-dev libiberty-dev dkms openssl bc autoconf
• Entorno de empaquetado Debian para construir paquetes .deb del kernel:sudo apt install autoconf automake autotools-dev bison build-essential dh-make debhelper debmake devscripts dpkg fakeroot file gfortran git gnupg fp-compiler lintian patch pbuilder perl quilt xutils-dev

En Fedora, CentOS y derivadas, el enfoque cambia un poco, pero la idea es la misma: instalar un grupo de herramientas de desarrollo y bibliotecas para interfaces de configuración (texto y gráficas). Por ejemplo, se suelen usar comandos del estilo:

su -c 'yum groupinstall "Development Tools"'
su -c 'yum install ncurses-devel qt-devel unifdef'

Sin estas dependencias, la compilación fallará bastante pronto, así que es fundamental dejar el entorno listo antes de descargar el código fuente.

Dónde descargar el código fuente del kernel Linux

La fuente oficial para obtener el código del kernel es kernel.org. Desde ahí puedes elegir entre versiones mainline, estables y de soporte prolongado (LTS). Cada una tiene su carpeta y un enlace a un tarball comprimido.

Algunos ejemplos de descargas que se ven a menudo en tutoriales son:

• Kernel estable 6.6 para pruebas recientes:
  wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.tar.xz
• Kernel 6.0.11 (rama v6.x):
  wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-6.0.11.tar.xz
• Kernel 5.10.13 (rama v5.x):
  wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.10.13.tar.xz

También puedes descargar las fuentes desde los repositorios de tu distribución. En Debian/Ubuntu existe, por ejemplo, el paquete linux-source:

sudo apt-get install linux-source

Esto deja un archivo tipo linux-source-x.x.x.tar.bz2 en /usr/src, que puedes descomprimir de forma parecida al tarball de kernel.org.

Preparar el árbol de fuentes y el espacio en disco

Una vez descargado el tarball del kernel, hay que descomprimirlo en alguna ruta donde tengas espacio suficiente y permisos de escritura. No estás obligado a usar /usr/src, aunque es un clásico. Puedes crear, por ejemplo, un directorio como ~/Descargas/mis-kernels.

Ten en cuenta que, descomprimido, el árbol de fuentes puede rondar 1,5 GB, y durante la compilación la cosa se dispara fácilmente por encima de los 7 GB, así que reserva margen de sobra.

Algunos ejemplos típicos de descompresión son:

• Con tar.xz:
  tar avxf linux-6.6.tar.xz
• Con tar.bz2:
  tar jxvf linux-2.6.36.tar.bz2 -C /usr/src
• Con tar.gz:
  tar zxvf linux-x.x.x.x.tar.gz -C /usr/src

Tras descomprimir, tendrás un directorio tipo linux-6.6 o linux-5.10.13. Puedes crear un enlace simbólico genérico llamado linux para no volverte loco con las rutas:

cd /usr/src
sudo ln -s linux-6.0.11 linux

No es obligatorio ubicar las fuentes en /usr/src, aunque muchas guías lo hacen por tradición. La compilación e instalación funcionarán igual si lo haces en tu carpeta de usuario, siempre que tengas espacio y permisos adecuados.

Reutilizar la configuración del kernel actual

Configurar un kernel desde cero, opción por opción, es una tarea interminable incluso para gente con mucha experiencia. La práctica habitual es reutilizar la configuración del kernel que ya estás usando como punto de partida.

Para ello, primero conviene saber qué kernel tienes cargado en este momento:

uname -r

El resultado será algo como 6.1.0-13-amd64 o 4.19.0-6-amd64. Con ese dato puedes copiar la configuración actual desde /boot al directorio de las fuentes recién descomprimidas:

cd linux-6.6
cp /boot/config-$(uname -r) .config

Ese fichero .config será el que el sistema de construcción del kernel use como base. En versiones nuevas, al ejecutar las herramientas de configuración, se te preguntará solo por opciones que no existían en tu kernel anterior, lo cual ahorra una barbaridad de tiempo.

Cómo ajustar la configuración al hardware real

Además de reutilizar el .config actual, puedes afinar aún más usando las herramientas que trae el propio árbol del kernel. Una especialmente útil es make localmodconfig, que intenta generar una configuración adaptada a los módulos que tienes cargados en ese momento.

Dentro del directorio de las fuentes, bastaría con ejecutar:

make localmodconfig

Este comando inspecciona los módulos activos y desactiva muchas cosas que tu sistema no está usando. Es ideal si estás configurando un kernel para esa máquina concreta. Si lo que pretendes es compilar un núcleo genérico para otros equipos o servidores distintos, tendrás que revisar después con calma para no dejar fuera hardware que no está presente en el sistema donde compilas.

Modos de configurar el kernel: texto y entornos gráficos

La configuración del kernel se puede hacer de varias formas. Todas acaban generando o modificando el fichero .config, pero la experiencia es muy distinta según el modo:

• make config: cuestionario puramente en modo texto, pregunta a pregunta. Hoy se considera práctico solo para casos muy específicos; es lento, tedioso y fácil de equivocarse.
• make menuconfig: interfaz de menús en texto (ncurses), muy habitual en servidores o cuando no tienes entorno gráfico. Navegas con flechas, tabulador y barra espaciadora.
• make xconfig: interfaz gráfica basada en Qt, cómoda para usar ratón. Ideal cuando trabajas desde un escritorio completo.
• make gconfig: interfaz gráfica basada en GTK, pensada para entornos tipo GNOME.

En la práctica, make menuconfig es la estrella en casi todas las guías, porque funciona en casi cualquier contexto. Partiendo de tu .config copiado, bastaría con:

make menuconfig

Verás un menú principal con categorías del estilo «Processor type and features», «Device Drivers», «File systems», «Networking support», «Virtualization», etc. Dentro de cada una podrás activar, desactivar o marcar como módulo las diferentes opciones. Normalmente:

• [*] significa «integrado en el kernel» (built-in).
• [M] indica «se compila como módulo cargable».
• [ ] es «desactivado».

La idea es dejar integrado en el núcleo aquello que es necesario para arrancar el sistema (por ejemplo el soporte del disco raíz), y usar módulos para funcionalidades menos críticas o que no se usan siempre, de forma que el kernel principal sea más ligero.

Cada entrada del menú suele tener una opción de Help donde se explica qué hace exactamente y, a veces, se da una recomendación por defecto. Si dudas con algo muy específico, es más prudente respetar el valor recomendado o el que ya venía activado en la configuración anterior.

Ajustes útiles: sistemas de ficheros, virtualización y Docker

Una parte importante de la personalización del kernel está en elegir bien qué sistemas de ficheros, mecanismos de contenedores y opciones de red vas a necesitar. Por ejemplo, si piensas usar particiones NTFS con escritura, deberás activar el soporte correspondiente (suele estar en «File systems → DOS/FAT/EXFAT/NT Filesystems»).

Si piensas trabajar con virtualización o contenedores, hay bloques de opciones que es vital revisar. Para Docker y Docker Swarm, por ejemplo, hay una serie de funciones de namespaces, cgroups y red que deben estar activas:

• Jerarquía de cgroups (cgroup hierarchy).
• CONFIG_NAMESPACES, CONFIG_NET_NS, CONFIG_PID_NS, CONFIG_IPC_NS, CONFIG_UTS_NS.
• CONFIG_CGROUPS y subopciones como CONFIG_CGROUP_CPUACCT, CONFIG_CGROUP_DEVICE, CONFIG_CGROUP_FREEZER, CONFIG_CGROUP_SCHED, CONFIG_CPUSETS, CONFIG_MEMCG.
• Soporte de claves (CONFIG_KEYS).
• Opciones de red como CONFIG_VETH, CONFIG_BRIDGE, CONFIG_BRIDGE_NETFILTER, CONFIG_NF_NAT_IPV4, CONFIG_IP_NF_FILTER, CONFIG_IP_NF_TARGET_MASQUERADE, CONFIG_NETFILTER_XT_MATCH_ADDRTYPE, CONFIG_NETFILTER_XT_MATCH_CONNTRACK, CONFIG_NETFILTER_XT_MATCH_IPVS, CONFIG_IP_NF_NAT, CONFIG_NF_NAT, CONFIG_NF_NAT_NEEDED.
• Soporte de colas POSIX (CONFIG_POSIX_MQUEUE).
• Opciones como CONFIG_IPVLAN para ciertas configuraciones de red usadas por Docker.

Mucha de esta funcionalidad se puede compilar como módulo sin problema, pero conviene revisar la documentación de Docker o usar scripts de comprobación. Existen utilidades como check-config.sh que analizan el .config del kernel y te indican qué falta para tener compatibilidad completa con contenedores.

La mecánica básica sería:

chmod +x check-config.sh
./check-config.sh .config

En la salida verás qué opciones están OK, cuáles faltan o están mal configuradas. Si detectas algo crítico desactivado, puedes volver a ejecutar make menuconfig o make xconfig, corregirlo, guardar y repetir la verificación.

Mejoras interesantes en versiones recientes del kernel

Además de la personalización, muchas personas compilan versiones nuevas del kernel para aprovechar mejoras de rendimiento y nuevas características que todavía tardarán en llegar a los paquetes de su distribución.

Por ejemplo, en la rama 6.6 se han comentado mejoras como:

• Aumento notable de rendimiento en EXT4, con incrementos de hasta un 34 % en ciertas cargas de escritura concurrente.
• Mejoras en el soporte de GPUs NVIDIA mediante el driver libre Nouveau, preparando el terreno para el driver NVK (Vulkan).
• Opciones para configurar aspectos de la BIOS de equipos HP directamente desde Linux.
• Ajustes de planificación en clústeres para procesadores híbridos de Intel (Alder Lake, Raptor Lake y posteriores).
• Optimización de la E/S asíncrona directa con io_uring, con subidas de rendimiento en torno al 37 % en ciertas pruebas.
• Un nuevo planificador de tareas, EEVDF (Earliest Eligible Virtual Deadline First), que mejora la distribución de CPU entre procesos.

Todo esto viene «de fábrica» en las versiones modernas, pero tu distribución puede tardar en empaquetarlo o habilitarlo, de ahí que mucha gente recurra a compilar manualmente un kernel más reciente.

Compilar el kernel: make, módulos e hilos de compilación

Una vez tienes la configuración como quieres, llega el momento de darle trabajo a la CPU. Aquí es donde entran los comandos make clásicos del kernel. La compilación puede durar desde varios minutos hasta más de una hora, dependiendo del hardware y de cuántos módulos vayas a generar.

En esencia, el flujo básico en Debian/Ubuntu (u otras distros) suele ser:

• Compilar el núcleo (imagen principal):
  make -j$(nproc)
  o, si quieres que use solo un núcleo:
  make
• Compilar e instalar los módulos:
  sudo make modules_install

La opción -j$(nproc) le dice a make que use tantos procesos en paralelo como núcleos tenga tu CPU, lo que en máquinas modernas ahorra muchísimo tiempo. Si ves errores durante la compilación, habrá que revisarlos en el punto donde fallan; pueden deberse a dependencias que faltan, configuraciones contradictorias o bugs puntuales en esa versión del kernel.

En algunas recetas más avanzadas se usa la herramienta de Debian make-kpkg y el paquete kernel-package para empaquetar el kernel en ficheros .deb. Esto permite luego instalar y desinstalar el núcleo personalizado como si fuera un paquete más, con algo como:

fakeroot make-kpkg --initrd --append-to-version=-custom kernel_image kernel_headers
cd /usr/src
sudo dpkg -i *.deb

En ese escenario, también resulta común encontrarse con errores relacionados con certificados del kernel. Muchas guías solucionan problemas puntuales deshabilitando claves de confianza en el .config con una línea del tipo:

sed -i '/CONFIG_SYSTEM_TRUSTED_KEYS/s/^/#/g' .config

Instalar el kernel recién compilado y actualizar el arranque

Si no estás utilizando empaquetado .deb y vas «a pelo» con las herramientas estándar del árbol del kernel, la instalación se hace directamente desde el directorio de las fuentes. La secuencia más habitual tras compilar es:

• Instalar los módulos (si no lo hiciste ya):
  sudo make modules_install
• Instalar el kernel:
  sudo make install

El propio sistema de scripts del kernel copiará el binario bzImage generado a /boot, junto con System.map y el fichero de configuración. En Debian/Ubuntu, normalmente se disparan scripts en /etc/kernel/postinst.d que generan el initramfs y actualizan el gestor de arranque (GRUB) automáticamente.

Aun así, nunca está de más ejecutar de forma explícita:

sudo update-initramfs -u
sudo update-grub
sudo update-grub2

Con esto te aseguras de que la imagen de arranque inicial se ha regenerado correctamente para la nueva versión del kernel, y de que GRUB la tiene en cuenta en su menú. En otras distribuciones, como algunas basadas en Red Hat, puede usarse mkinitrd o dracut en lugar de update-initramfs, pero el objetivo es el mismo: crear una imagen initrd/initramfs adecuada para el nuevo núcleo.

El papel de initrd/initramfs y posibles problemas

El initrd o initramfs es una imagen de sistema de archivos que se carga en memoria muy temprano en el arranque. Contiene los controladores mínimos necesarios para poder montar el sistema de archivos raíz real (por ejemplo, el soporte del controlador SATA o NVMe donde está tu partición /).

Si tu initrd está mal generado o no contiene los módulos necesarios, el kernel arrancará pero no podrá montar / y terminarás con un kernel panic quejándose de que no puede encontrar el root filesystem. Este es un error típico cuando se desactivan opciones críticas del kernel o se olvida regenerar el initramfs tras cambiar de versión.

En Debian/Ubuntu la orden de referencia hoy día es update-initramfs:

sudo update-initramfs -c -k x.x.x

El parámetro -c crea una imagen nueva, y -k indica la versión exacta del kernel. En distribuciones más antiguas (o con herramientas distintas) se utilizaba mkinitrd con una sintaxis similar:

cd /boot
mkinitrd -o initrd.img-2.6.36 2.6.36

En cualquier caso, si después de instalar tu kernel personalizado ves errores relacionados con /lib/modules o con el montaje del root, revisa primero initramfs/initrd y la configuración de GRUB antes de tocar nada más.

Comprobar que el nuevo kernel funciona correctamente

Con todo instalado y el gestor de arranque actualizado, toca reiniciar para probar el invento. Durante el arranque, vigila los mensajes de GRUB y de inicio del kernel por si asoman errores de módulos, sistemas de ficheros o dispositivos que no se reconocen.

Una vez dentro del sistema, puedes comprobar qué versión de kernel estás usando con:

uname -a

La salida debe reflejar la versión recién compilada. A partir de ahí, es cuestión de probar tus servicios habituales: servidor web, bases de datos, Docker, máquinas virtuales, programas de escritorio, etc. Si todo va fino, puedes dejar ese kernel como principal y conservar versiones antiguas como respaldo.

Cómo volver a un kernel anterior y desinstalar el nuevo

Si algo sale torcido (que puede pasar, sobre todo las primeras veces), lo importante es que no cunda el pánico. Mientras tu GRUB tenga listados otros núcleos funcionales, puedes recuperar el sistema sin demasiados dramas.

El proceso típico sería:

1. Reiniciar el equipo.
2. En la pantalla de GRUB, moverte con las flechas y entrar en la sección tipo «Advanced options for…».
3. Elegir una versión de kernel anterior que sepas que funcionaba bien.
4. Arrancar con ese núcleo y, una vez dentro, proceder a borrar el kernel problemático.

Si instalaste el kernel a mano, sin paquetes .deb, la eliminación suele implicar borrar los ficheros correspondientes en /boot y /lib/modules. Por ejemplo, para quitar un 6.6.0 podrías hacer:

cd /boot
sudo rm config-6.6.0 initrd.img-6.6.0 System.map-6.6.0 vmlinuz-6.6.0

Y después, borrar sus módulos:

cd /lib/modules
sudo rm -rf 6.6.0

Al terminar, actualiza GRUB para que ya no ofrezca ese kernel en el menú y reinicia:

sudo update-grub
sudo update-grub2
sudo reboot

Si habías instalado el kernel empaquetado como .deb, es más limpio usarlo como cualquier otro paquete con apt o dpkg para desinstalarlo, manteniendo mejor controlado el estado del sistema.

Notas para otras distribuciones: Fedora, CentOS y compañía

Aunque esta guía se centra mucho en Debian/Ubuntu/Mint, la lógica general es similar en distribuciones basadas en Red Hat, como Fedora o CentOS. Lo que cambia son las herramientas de gestión de paquetes, algunos nombres de dependencias y la forma de tocar el gestor de arranque.

En Fedora/CentOS, por ejemplo, un flujo básico para compilar un kernel desde kernel.org podría ser:

• Instalar las herramientas de desarrollo:
  su -c 'yum groupinstall "Development Tools"'
su -c 'yum install ncurses-devel qt-devel unifdef'
• Descargar una versión estable (como 2.6.36 en los ejemplos clásicos):
  cd /tmp
wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.36.tar.bz2
• Descomprimir y preparar el árbol de fuentes:
  mkdir /usr/src/linux
tar -xjvf linux-2.6.36.tar.bz2 -C /usr/src/linux
cd /usr/src/linux
• Configurar el kernel con menuconfig, xconfig o gconfig.
• Compilar e instalar:
  make
make modules
make modules_install
make install

Después tendrás que revisar y editar /boot/grub/grub.conf (o el fichero equivalente, según si usas GRUB Legacy, GRUB2, etc.) para añadir una entrada para el nuevo kernel con su initrd correspondiente, cuidando mucho las rutas de root= y las referencias a los volúmenes lógicos si usas LVM.

Compilar, configurar e instalar un kernel Linux a medida es un proceso largo, pero tremendamente instructivo: te obliga a entender qué módulos necesitas para arrancar, qué opciones son esenciales para tus servicios (como Docker o la virtualización), cómo se integran initramfs y GRUB en el arranque y cómo mantener siempre una salida de emergencia para volver a un núcleo anterior si algo se tuerce; si te tomas tu tiempo para revisar cada apartado, reutilizas de forma inteligente la configuración de tu kernel actual y te acostumbras a probar los cambios poco a poco, podrás acabar disfrutando de un sistema más optimizado, ajustado a tu hardware y alineado con tus necesidades reales que el que proporcionan los kernels genéricos de la mayoría de distribuciones.