Cómo instalar Gentoo paso a paso sin volverte loco

Instalar Gentoo desde cero impone un poco al principio, pero en realidad es más una cuestión de seguir pasos con calma que de ser un gurú de Linux. A diferencia de otras distros con asistentes gráficos, aquí vas a montar tú mismo el sistema pieza a pieza: particiones, descarga del stage, compilación del núcleo, configuración de red, gestor de arranque… El resultado es un sistema muy ligero y afinado a tu hardware.

Si lo que buscas es una instalación “rápida” para una práctica de clase, también se puede: no hace falta volverse loco con optimizaciones extremas ni configuraciones raras. En esta guía te explico cómo instalar Gentoo paso a paso siguiendo el espíritu del Handbook oficial, pero con un lenguaje más cercano y resumido, y con varios atajos para que puedas tenerlo funcionando, hacer las capturas y entregar la documentación sin sufrir demasiado.

Qué es Gentoo y cómo se organiza su instalación

Gentoo es una meta-distribución basada en código fuente: en lugar de instalar paquetes binarios ya compilados, lo normal es que se compilen en tu equipo a partir de ebuilds gestionados por Portage. Eso permite adaptar el sistema a tu CPU, decidir qué características lleva cada programa (USE flags) y mantener un control fino sobre todo el stack.

Sus principios básicos son tres: franqueza, elección y potencia. Franqueza porque todo está a la vista y en texto plano (scripts bash, Python, ficheros de configuración sencillos). Elección porque casi nada viene “impuesto”: puedes elegir sistema de inicio (OpenRC o systemd), esquema de particiones, sistema de archivos, perfil, USE flags, gestor de red, escritorio, etc. Y potencia porque al compilar tú mismo el sistema, puedes ajustar compilación y características al detalle.

El proceso de instalación estándar se divide en diez grandes pasos, que van desde arrancar el medio live hasta iniciar en tu nuevo Gentoo instalado en disco. La propia documentación oficial los resume así:

• Paso 1-2: Arrancar el medio de instalación y dejar la red funcionando.
• Paso 3-4: Preparar discos y montar el entorno bajo /mnt/gentoo.
• Paso 5-8: Extraer el stage, configurar Portage, compilar e instalar el núcleo y las herramientas base.
• Paso 9-10: Instalar el gestor de arranque y arrancar en el sistema recién creado.

No hace falta ejecutar absolutamente todas las opciones que ofrece el Handbook. Muchas secciones están marcadas como “Opcional” o “Sugerido”, y hay otras que ya están medio obsoletas pero siguen ahí por compatibilidad. Para una instalación funcional básica puedes limitarte al flujo principal y, si te apetece, tocar alguno de los extras (como cifrado, LVM, etc.).

Requisitos, medios de instalación y descarga del stage

A nivel de hardware, con 15-20 GB de disco y 2-4 GB de RAM vas sobrado para un entorno de pruebas. El Manual recomienda unos 40 GB para la raíz si vas a instalar más cosas, pero para una práctica universitaria no es imprescindible. Si piensas compilar núcleos pesados o escritorios completos, cuanta más RAM mejor.

Para instalar Gentoo puedes usar varios tipos de medio:

• La ISO minimal oficial: muy ligera, sin entorno gráfico, pero perfecta para seguir el Handbook.
• La ISO LiveGUI: incluye entorno gráfico, pero exige al menos 2 GB de RAM para arrancar.
• Otra distro ya instalada (Ubuntu, Arch, Manjaro, Debian…): arrancas esa, preparas particiones y haces el chroot a mano. Es muy cómodo porque tienes navegador, copiar/pegar, etc.

Crear el USB de arranque es cuestión de volcar la ISO a un pendrive. En Linux, algo tipo:

dd if=install-amd64-minimal-YYYYMMDD.iso of=/dev/sdX bs=4M status=progress

Ojo con herramientas como Ventoy, porque a veces dan problemas al arrancar las ISOs de Gentoo. Si quieres ir a lo seguro, usa dd o alguna utilidad probada. En Windows puedes tirar de herramientas gráficas tipo Rufus o Win32DiskImager.

Una vez arrancas el medio, ajustas el orden de arranque en la BIOS/UEFI para que coja primero el USB y seleccionas en GRUB la entrada gentoo o gentoo-nofb. Si estás en un sistema UEFI moderno, asegúrate de que la ISO arranca en modo UEFI (no legacy/BIOS), porque eso condicionará luego el tipo de tabla de particiones (GPT vs MBR) y el gestor de arranque.

El paso siguiente es descargar el stage3, que es un tarball con un sistema base ya compilado para tu arquitectura (aquí asumimos amd64). Desde el live envuelves así:

• Montas la partición raíz futura en /mnt/gentoo.
• Te colocas ahí: cd /mnt/gentoo.
• Descargas el stage3 apropiado desde un mirror (por ejemplo con wget o usando links para navegar). Más información sobre tarballs: crear un paquete tarball de código fuente.
• Descomprimes con tar xpvf stage3-amd64-*.tar.xz --xattrs-include='*.*' --numeric-owner.

Si quieres ser fino, puedes verificar la integridad y autenticidad del stage comparando las sumas SHA256 o SHA512 con los archivos .DIGESTS y validando la firma .asc con gpg y las claves públicas de Gentoo. Para una práctica de clase puede que no te lo exijan, pero es bueno saber hacerlo.

Particionado de discos y sistemas de archivos

Gentoo no trae un instalador gráfico de particiones, así que aquí toca tirar de fdisk, cfdisk, parted o GParted si estás instalando desde otra distro. La idea general es:

• Crear una partición de arranque: ESP en FAT32 si usas UEFI (/dev/sda1, 512 MB-1 GB) o /boot en xfs/ext4 si usas BIOS (también ~1 GB).
• Crear una partición de swap, típicamente igual o algo mayor que la RAM si quieres hibernación.
• Crear una partición raíz que ocupe el resto del disco (/), normalmente en XFS o ext4.

Para sistemas UEFI se recomienda GPT. Con fdisk /dev/sda puedes:

• Pulsar g para crear una tabla GPT nueva.
• n → partición 1, +1G → luego cambiar tipo a “EFI System” (código 1).
• n → partición 2 para swap, por ejemplo +4G, tipo “Linux swap”.
• n → partición 3 para la raíz, usando el resto del espacio, tipo “Linux filesystem” o “Linux root (x86-64)”.
• w para escribir cambios en disco.

Si estás en BIOS clásico puedes usar MBR (o en fdisk) y crear hasta cuatro particiones primarias. La idea es la misma: /boot, swap y /, marcando la de /boot como booteable con a. GPT + BIOS también es posible, pero añade la pequeña partición BIOS boot (1-2 MB) para GRUB.

Una vez tengas las particiones, toca formatear:

• ESP UEFI: mkfs.fat -F32 /dev/sda1.
• /boot BIOS: mkfs.xfs /dev/sda1 o mkfs.ext4 /dev/sda1.
• swap: mkswap /dev/sda2 y swapon /dev/sda2.
• raíz: mkfs.xfs /dev/sda3 o mkfs.ext4 /dev/sda3. En ext4 pequeña (< 8 GiB) conviene añadir -T small para tener más inodos.

Si quieres algo más avanzado (LVM, cifrado LUKS, Btrfs, etc.), el Handbook también lo cubre y las guías personales que circulan por ahí suelen usar esquemas tipo “/boot sin cifrar + LUKS/LVM para / y swap”. Para una instalación básica de prácticas, GPT simple con /boot, swap y / suele ser más que suficiente.

Con los sistemas de archivos creados, monta todo bajo /mnt/gentoo:

• mount /dev/sda3 /mnt/gentoo
• mkdir /mnt/gentoo/boot y mount /dev/sda1 /mnt/gentoo/boot (o /mnt/gentoo/efi si es ESP).

Entrar en el entorno chroot y preparar Portage

Después de extraer el stage3 y montar las particiones, hay que “meterse” en ese sistema como si ya fuese el nuestro. Antes copiamos la configuración DNS:

cp --dereference /etc/resolv.conf /mnt/gentoo/etc/resolv.conf

Montamos los pseudo-sistemas de archivos del kernel dentro de /mnt/gentoo para que luego todo funcione bien desde el chroot:

• mount -t proc /proc /mnt/gentoo/proc
• mount --rbind /sys /mnt/gentoo/sys y mount --make-rslave /mnt/gentoo/sys
• mount --rbind /dev /mnt/gentoo/dev y mount --make-rslave /mnt/gentoo/dev
• Opcionalmente, mount --bind /run /mnt/gentoo/run.

Entramos al chroot y cargamos el entorno:

chroot /mnt/gentoo /bin/bash
source /etc/profile
export PS1="(chroot) $PS1"

A partir de aquí ya estás “dentro” de tu Gentoo nuevo. Todo lo que hagas afectará al sistema del disco, no al live. El siguiente paso es configurar Portage a nivel básico editando /etc/portage/make.conf.

Las variables clave son:

• COMMON_FLAGS / CFLAGS / CXXFLAGS: algo razonable es -march=native -O2 -pipe. Para detalles sobre cómo afinar opciones de compilación, consulta optimizar binarios en C/C++. No te líes con -O3 o flags raros para una práctica, puedes romper cosas.
• MAKEOPTS: número de trabajos en paralelo para make; normalmente -jN donde N suele ser número de hilos de CPU (o algo menos si tienes poca RAM).
• USE: valores globales que activan o desactivan características. Por ejemplo USE="X alsa pulseaudio dbus" si luego vas a poner un escritorio, o algo minimal si solo quieres consola.
• GENTOO_MIRRORS: lista de mirrors cercanos para descargar código fuente.
• GRUB_PLATFORMS: muy útil poner "efi-64" si estás en UEFI, o "pc" en BIOS.

Configura también la zona horaria y las locales antes de seguir:

• echo "Europe/Madrid" > /etc/timezone y luego emerge --config sys-libs/timezone-data.
• Edita /etc/locale.gen y añade, por ejemplo:
  es_ES.UTF-8 UTF-8
en_US.UTF-8 UTF-8, luego locale-gen.
• Selecciona la localización por defecto con eselect locale set y recarga entorno.

Actualiza el repositorio de ebuilds con:

• emerge-webrsync para bajar una instantánea reciente vía HTTP/FTP.
• Opcionalmente, emerge --sync para ponerlo completamente al día vía rsync.

Elige un perfil con eselect profile list y eselect profile set N. Para ir rápido, un perfil tipo default/linux/amd64/17.1 (o el que marque el Handbook como recomendado) es suficiente. Si quieres OpenRC, elige uno sin “systemd” en el nombre; si te apetece systemd, escoge un perfil que lo incluya para que USE y dependencias encajen.

Compilación e instalación del núcleo Linux

Aquí tienes dos caminos: usar un “distribution kernel” o compilarlo tú a mano. Para una práctica donde prima la rapidez, el núcleo distribuido de Gentoo (preconfigurado) es una bendición.

Para núcleo de distribución basta con instalar el paquete:

emerge --ask sys-kernel/gentoo-kernel-bin

Portage se encargará de instalar el kernel en /boot, los módulos y, si tienes installkernel configurado, el initramfs. Con el USE dist-kernel activado globalmente, cada actualización de núcleo disparará automáticamente la recompilación de módulos externos (NVIDIA, ZFS…) y la regeneración del initramfs.

Si quieres compilar el núcleo a mano (por aprender, que para eso es un curso de SO), el flujo es:

• emerge --ask sys-kernel/gentoo-sources
• Crear/ajustar el enlace /usr/src/linux con eselect kernel set.
• Entrar en /usr/src/linux y arrancar un configurador tipo make menuconfig.
• Activar mínimo: soporte para tu CPU, disco (SATA/NVMe, SCSI), sistema de archivos raíz, devtmpfs, red, etc. Gentoo recomienda además activar las “Gentoo Linux support” options.
• Compilar con make -jN && make modules_install.
• Instalar el kernel en /boot con make install (o dejando que installkernel haga su magia).

Para cifrado, LVM, Secure Boot y demás filigranas hay que marcar algunas opciones extra en el kernel (device-mapper, crypt target, soporte EFI stub, firma de módulos…). Muchas guías personales de Gentoo que circulan por ahí enseñan a hacerlo a base de ir menú por menú.

Sea cual sea el método, asegúrate de que /boot está montado antes de instalar el kernel. Y si estás usando initramfs generado con Dracut o similares, indica la raíz con root= (por UUID o PARTUUID) en la línea de comando del kernel para que pueda encontrar el sistema de archivos raíz.

Configurar fstab, red básica y usuarios

Con el núcleo en su sitio, hay que decirle al sistema qué montar en cada arranque. Eso se hace en /etc/fstab. Un ejemplo simple para UEFI con GPT podría ser:

/dev/sda1 /efi vfat defaults,noatime 0 2
/dev/sda2 none swap sw 0 0
/dev/sda3 / xfs noatime 0 1

Puedes usar /dev/sdXN, LABEL, UUID o PARTUUID. Lo más robusto son las UUID/ PARTUUID, que puedes obtener con blkid. Evita montar discos por nombre de dispositivo si cambias a menudo el orden de los discos o añades externos, porque /dev/sda puede dejar de ser el que era.

Configura también el nombre de máquina y el teclado de consola:

• En OpenRC, /etc/conf.d/hostname con algo tipo hostname="tux-gentoo".
• El keymap de las TTY en /etc/conf.d/keymaps, por ejemplo keymap="es" o la-latin1 según tu distribución de teclado.
• Si usas systemd, más cómodo tirar de systemd-firstboot y hostnamectl.

La red en el entorno live suele estar gestionada por NetworkManager o dhcpcd. Dentro del sistema instalado puedes hacerlo muy sencillo instalando net-misc/dhcpcd y añadiéndolo al arranque (OpenRC) o activando el servicio (systemd) para que obtenga IP por DHCP en tu interfaz principal.

Por ejemplo, en OpenRC sería:

emerge --ask net-misc/dhcpcd
rc-update add dhcpcd default

Finalmente, establece la contraseña de root y crea un usuario normal para tu día a día:

• passwd para root.
• useradd -m -G users,wheel,audio,video -s /bin/bash nombre seguido de passwd nombre.
• Instala sudo o doas y dale permisos al grupo wheel para elevar privilegios cuando haga falta.

Instalar y configurar el gestor de arranque (GRUB y alternativas)

La opción más habitual y versátil en Gentoo es GRUB2, que funciona tanto en BIOS como en UEFI, admite mil escenarios (LUKS, LVM, RAID, Btrfs…) y es fácil de configurar. Para instalarlo:

emerge --ask sys-boot/grub:2

Si estás en BIOS con MBR, basta con:

grub-install /dev/sda

En UEFI con ESP en /efi, por ejemplo:

grub-install --target=x86_64-efi --efi-directory=/efi

Si tu firmware UEFI es tiquismiquis y solo mira en /EFI/BOOT/BOOTX64.EFI, puedes añadir --removable para que GRUB coloque ahí el ejecutable EFI. Para Secure Boot hay una capa adicional (shim, firma con sbsigntools, claves enroladas en MOK), pero para una práctica suele sobrar con Secure Boot desactivado.

Genera el archivo de configuración de GRUB escaneando automáticamente núcleos e initramfs:

grub-mkconfig -o /boot/grub/grub.cfg

En la mayoría de casos GRUB detectará el kernel de Gentoo y el initramfs sin que tengas que tocar nada más. Si tienes requisitos especiales (cifrado, raíz en LVM, parámetros extras del kernel…), puedes editar /etc/default/grub y jugar con GRUB_CMDLINE_LINUX antes de volver a regenerar grub.cfg.

Como alternativas tienes systemd-boot y el arranque directo EFI stub. Ambos funcionan bien en UEFI y tienen su gracia si quieres algo minimalista:

• systemd-boot: se instala con bootctl install, lee entradas desde /boot/loader/entries/ y se integra bien con systemd-UKI (imágenes unificadas de kernel+initramfs+cmdline).
• EFI stub: el propio kernel se compila como binario EFI y lo registras como entrada con efibootmgr (ver ejemplos prácticos del comando efibootmgr). Es muy simple pero menos flexible cuando quieras cambiar parámetros.

En cualquier caso, lo importante para tu práctica es que el gestor de arranque lance tu kernel de Gentoo con la raíz correcta y, si procede, cargando el initramfs. Con GRUB esto se reduce a un par de comandos y poco más.

Cuando tengas todo listo, solo queda salir del chroot, desmontar y reiniciar:

• exit para salir del chroot.
• umount -l /mnt/gentoo/dev{/shm,/pts,}, umount -R /mnt/gentoo.
• reboot y retirar el USB para que arranque desde el disco.

Si todo ha ido bien, verás GRUB, seleccionarás Gentoo y terminarás en tu nuevo sistema, listo para hacer capturas, instalar un Xfce o un i3 si te apetece, y documentar los pasos que has seguido.

Desde el punto de vista de un curso de Sistemas Operativos, esta instalación tiene bastante sentido pedagógico: te obliga a entender la relación entre kernel, initramfs, gestor de arranque, tablas de particiones, sistemas de archivos, demonios de red, gestión de servicios (OpenRC/systemd), compilación de software y configuración de un PM como Portage. No es simplemente “siguiente, siguiente, finalizar”, sino un recorrido práctico por las tripas de un sistema Linux real.