Primeros pasos con Yocto: Compila tu primera imagen Linux

Quieres ejecutar un Linux personalizado en una Raspberry Pi o Jetson. Necesitas una distribución Linux personalizada para un producto IoT que estás construyendo. Pero, ¿por dónde empezar?

Esta guía te lleva paso a paso por Yocto Project desde cero — conceptos fundamentales (Poky, BitBake, capas, recetas), configuración de tu entorno de desarrollo, compilación de tu primera imagen Linux y verificación con QEMU.

Yocto tiene una curva de aprendizaje pronunciada al principio, pero una vez que los conceptos subyacentes hacen clic, se vuelve notablemente flexible y poderoso. Al final de este artículo, tendrás tu primera imagen Linux personalizada funcionando.

¿Qué es Yocto Project?

Yocto Project es un proyecto de código abierto para crear distribuciones Linux personalizadas adaptadas a dispositivos embebidos.

El punto clave: Yocto en sí no es un sistema operativo. Piensa en él como una caja de herramientas para construir sistemas Linux.

Los problemas que Yocto resuelve

El desarrollo de Linux embebido viene con un conjunto único de desafíos:

• Almacenamiento limitado (unos pocos MB a unos pocos GB) — necesitas eliminar paquetes innecesarios
• CPUs de baja potencia (ARM Cortex-A, etc.) — el sistema necesita ser liviano
• Hardware especializado (drivers personalizados) — el kernel necesita personalización
• Ciclos de vida largos del producto (algunos productos funcionan por 10+ años) — las compilaciones reproducibles son esenciales

Yocto es el sistema de compilación estándar de facto que aborda todos estos problemas a la vez.

Yocto vs. Buildroot vs. OpenWRT

Si estás construyendo productos comerciales o dispositivos IoT, aprender Yocto vale la inversión. Casi todos los principales fabricantes de semiconductores distribuyen su SDK basado en Yocto.

¿Quién usa Yocto?

• Intel — Plataformas IoT e industriales
• NXP — BSP oficial para la serie i.MX
• Texas Instruments — Familia de procesadores Sitara
• Sony — Cámaras digitales, equipo de audio
• Automotive Grade Linux (AGL) — El estándar para Linux en vehículos

Los cuatro conceptos fundamentales de Yocto

Para entender Yocto, necesitas familiarizarte con cuatro ideas fundamentales.

Poky (la distribución de referencia)

Poky es la implementación de referencia de Yocto Project — piensa en ella como la plantilla inicial.

Cuando empiezas con Yocto, comienzas descargando Poky. Viene con todo lo que necesitas: BitBake, las capas base y las imágenes de ejemplo.

BitBake (el motor de compilación)

BitBake es el motor que realmente ejecuta tus compilaciones. En lugar de Makefiles, lee "recetas", resuelve dependencias y ejecuta las tareas de compilación en el orden correcto.

# Compilar una imagen Linux mínima
bitbake core-image-minimal

# Compilar solo un paquete
bitbake busybox

# Inspeccionar metadatos del paquete
bitbake -e busybox | grep ^PV=

Capas

Las capas son directorios que agrupan recetas y configuraciones relacionadas. Son lo que hace a Yocto tan modular y mantenible.

• meta — Capa central de OpenEmbedded
• meta-poky — Configuración específica de Poky
• meta-raspberrypi — BSP de Raspberry Pi
• meta-mylayer — Tus propias personalizaciones

Apilando capas, puedes personalizar cualquier aspecto del sistema sin tocar las capas base. Consulta la guía de creación de capas para más detalles.

Recetas

Las recetas son archivos .bb que describen cómo compilar una pieza específica de software.

# hello-world_1.0.bb
SUMMARY = "Hello World sample application"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

SRC_URI = "file://hello.c"

S = "${WORKDIR}"

do_compile() {
    ${CC} ${CFLAGS} ${LDFLAGS} -o hello ${WORKDIR}/hello.c
}

do_install() {
    install -d ${D}${bindir}
    install -m 0755 hello ${D}${bindir}
}

Configuración de tu entorno de desarrollo

Especificaciones del sistema recomendadas

Instalación de paquetes necesarios

sudo apt update
sudo apt install -y gawk wget git diffstat unzip texinfo gcc build-essential \
    chrpath socat cpio python3 python3-pip python3-pexpect xz-utils debianutils \
    iputils-ping python3-git python3-jinja2 python3-subunit zstd liblz4-tool \
    file locales libacl1

# Configurar locale (en_US.UTF-8 es necesario)
sudo locale-gen en_US.UTF-8

Descarga de Poky

# Crear un directorio de trabajo
mkdir -p ~/yocto && cd ~/yocto

# Clonar Poky (scarthgap = rama LTS, soportada hasta el 30 de abril de 2028)
git clone -b scarthgap git://git.yoctoproject.org/poky

# Verificar la descarga
ls poky/
bitbake  documentation  meta  meta-poky  meta-yocto-bsp  oe-init-build-env  scripts

Ejecutando tu primera compilación

Inicialización del entorno de compilación

cd ~/yocto/poky
source oe-init-build-env build

# Después de ejecutar esto, serás movido automáticamente al directorio build/
# Verás un mensaje como:
You had no conf/local.conf file. This configuration file has therefore been
created for you...

Importante: siempre usa source, no bash ni ./. El script establece variables de entorno que necesitan persistir en tu sesión de shell actual.

Configuración de local.conf

Edita conf/local.conf para ajustar el paralelismo de compilación.

# Añade estas líneas, ajustando a la cantidad de núcleos de tu CPU
BB_NUMBER_THREADS = "8"
PARALLEL_MAKE = "-j 8"

# Máquina objetivo (por defecto es qemux86-64 para pruebas con QEMU)
MACHINE ?= "qemux86-64"

BB_NUMBER_THREADS controla cuántas tareas de BitBake se ejecutan en paralelo. PARALLEL_MAKE controla la bandera -j pasada a make. Establecer ambos a la cantidad de núcleos de tu CPU es un buen punto de partida.

Ejecución de la compilación

# Compilar la imagen Linux mínima
bitbake core-image-minimal

# Las primeras compilaciones toman 1-3 horas dependiendo de tu hardware
# Si una compilación falla a mitad de camino, simplemente ejecuta el mismo comando de nuevo

En la primera ejecución, BitBake descarga todo el código fuente y compila todo desde cero. Las compilaciones posteriores son mucho más rápidas gracias a la caché de estado compartido.

Referencia de tiempo de compilación

Probando tu compilación con QEMU

Usando runqemu

Una vez que la compilación termine, puedes lanzar tu imagen Linux en un emulador — sin necesidad de hardware físico.

# Lanzar la imagen en QEMU
runqemu qemux86-64

# Lanzar sin ventana gráfica (solo consola serial)
runqemu qemux86-64 nographic

# Después del arranque, inicia sesión como root (sin contraseña)
qemux86-64 login: root
root@qemux86-64:~#

Verificación del sistema

# Verificar la versión del kernel
root@qemux86-64:~# uname -a
Linux qemux86-64 6.6.x-yocto-standard #1 SMP ...

# Verificar uso de disco — nota lo pequeño que es el sistema de archivos raíz
root@qemux86-64:~# df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/root        48M   32M   14M  70% /

# Apagar
root@qemux86-64:~# poweroff

Conclusión

Esto es lo que cubrimos en este artículo:

• Yocto es una caja de herramientas para construir sistemas Linux embebidos personalizados — no es un SO en sí
• Los cuatro componentes fundamentales son Poky, BitBake, capas y recetas
• En Ubuntu, bitbake core-image-minimal compila una imagen Linux funcional
• runqemu te permite probar tu imagen sin ningún hardware

Yocto tiene una curva de aprendizaje pronunciada, pero una vez que lo dominas, puedes compilar Linux para prácticamente cualquier dispositivo embebido. Ahora que tienes lo básico, aquí están los siguientes pasos:

• Crear y gestionar capas — estructura tus compilaciones con capas personalizadas
• Escribir recetas — empaqueta tus propias aplicaciones en imágenes
• Compilar Linux para Raspberry Pi — despliega en hardware real
• Si encuentras errores de compilación, consulta la guía de depuración

Para profundizar en Linux embebido, estos libros son excelentes referencias.