Crear una distribución Linux mínima con Yocto en Ubuntu

Introducción

En este artículo explico cómo crear una distribución Linux mínima usando el proyecto Yocto sobre una máquina de desarrollo con Ubuntu. Yocto es muy conocido en el mundo del Linux embebido por su flexibilidad y modularidad. Su objetivo principal es permitir a fabricantes y desarrolladores crear distribuciones Linux personalizadas para hardware embebido.

Generaremos una nueva distribución mínima para qemu (qemu es un emulador de software) como máquina destino y la ejecutaremos en qemu para comprobar el resultado.

Qué vas a aprender

• Preparar la máquina de desarrollo en Ubuntu.
• Clonar Poky (Yocto) ramal morty.
• Configurar local.conf para qemux86-64.
• Compilar core-image-minimal con bitbake.
• Ejecutar la imagen en qemu y probar comandos básicos.

Requisitos para la máquina de desarrollo

• Memoria: 4–6 GB RAM como mínimo (más recomendable para builds grandes).
• Sistema operativo: Ubuntu moderno (en el ejemplo se usa 16.04 LTS).
• Espacio en disco: 60–80 GB libre (las descargas y cachés ocupan espacio).
• Paquetes necesarios instalados antes de crear la distro.
• Descargar la versión estable de Yocto (Poky) correspondiente.

Actualiza la lista de paquetes:

apt-get update

Instala los paquetes requeridos:

apt-get install wget git-core unzip make gcc g++ build-essential subversion sed autoconf automake texi2html texinfo coreutils diffstat python-pysqlite2 docbook-utils libsdl1.2-dev libxml-parser-perl libgl1-mesa-dev libglu1-mesa-dev xsltproc desktop-file-utils chrpath groff libtool xterm gawk fop

Nota: la instalación de estos paquetes puede requerir casi 1 GB.

Clonar Poky (ramal morty)

En este tutorial se usa el ramal estable “morty” de Poky. Clona el repositorio:

git clone -b morty git://git.yoctoproject.org/poky.git

Entra en el directorio poky y prepara el entorno de compilación:

source oe-init-build-env

Ese script crea un subdirectorio build y configura variables de entorno para Yocto.

Configuración de local.conf

El archivo local.conf dentro de conf define la arquitectura, la máquina objetivo y otras rutas importantes. Abre build/conf/local.conf y ajusta o comprueba los parámetros siguientes.

Establece la máquina objetivo a qemux86-64:

MACHINE = "qemux86-64"

Descomenta y ajusta las rutas de descarga y caché para centralizar las descargas:

DL_DIR ?= "${TOPDIR}/downloads"
SSTATE_DIR ?= "${TOPDIR}/sstate-cache"
TMPDIR ?= "${TOPDIR}/tmp"

Define el formato de paquetes y la máquina del SDK:

PACKAGE_CLASSES ?= "package_rpm"
SDKMACHINE ?= "i686"

Si quieres poder iniciar sesión como root sin contraseña en la imagen mínima, añade la característica debug-tweaks:

EXTRA_IMAGE_FEATURES ?= "debug-tweaks"

Nota: usar una contraseña en blanco solo para pruebas y entornos controlados.

Important: no se usa ninguna interfaz gráfica como Toaster (hob ya no se mantiene) en este flujo.

Compilación con Yocto (bitbake)

Lanza la compilación del artefacto mínimo con bitbake. Ejecuta como usuario normal (no root):

bitbake core-image-minimal

Si intentas ejecutar bitbake como root verás un error. Vuelve a exportar el entorno si hace falta:

source oe-init-build-env

El proceso de build primero analiza las recetas y muestra información del sistema. Luego descarga SDKs y dependencias y compila paquetes. Este paso puede tardar varias horas (en mi ejemplo 2–3 horas), porque primero descarga y luego compila todo para la nueva distribución.

Al terminar, verás la lista de tareas completadas.

Las imágenes resultantes para qemux86-64 se encuentran en build/tmp/deploy/images/qemux86-64:

Ejecutar la imagen en qemu

Advertencia: ejecutar ciertas órdenes desde clientes SSH (por ejemplo PuTTY) puede fallar por cuestiones de terminal; si ves errores, prueba desde un cliente RDP o una terminal local de Ubuntu.

Al ejecutar la imagen en qemu se abrirá una ventana del emulador y verás la pantalla de arranque de la nueva distribución.

La pantalla de login muestra la versión de Yocto. En la imagen mínima el usuario por defecto es root y la contraseña está vacía (si añadiste debug-tweaks):

Después de iniciar sesión, prueba comandos básicos:

date
ifconfig
uname -a

Mini-metodología: pasos rápidos

1. Preparar Ubuntu y paquetes necesarios.
2. Clonar poky (morty) y ejecutar oe-init-build-env.
3. Editar build/conf/local.conf: MACHINE, DL_DIR, SSTATE_DIR, TMPDIR.
4. Añadir EXTRA_IMAGE_FEATURES si necesitas login sin contraseña para pruebas.
5. Ejecutar bitbake core-image-minimal como usuario normal.
6. Localizar imágenes en tmp/deploy/images/qemux86-64.
7. Ejecutar con qemu y validar funcionalidades.

Listas de verificación por rol

• Desarrollador embebido:

  • Comprobar versiones de gcc y make.
  • Verificar espacio libre en disco y memoria.
  • Confirmar MACHINE en local.conf.

• Integrador de sistemas:

  • Validar paquetes incluidos en la imagen.
  • Ejecutar pruebas de arranque en qemu.
  • Preparar herramienta de despliegue para hardware real.

• Administrador de CI/CD:

  • Cachear DL_DIR y SSTATE_DIR en servidor compartido.
  • Asegurar permisos de usuario para bitbake.
  • Automatizar builds incrementales.

Heurísticas y modelos mentales

• «Caché primero»: usar sstate-cache reduce compilaciones repetidas.
• «Divide y vencerás»: empezar con core-image-minimal y añadir paquetes gradualmente.
• «Entorno reproducible»: fijar ramas y revisiones de recetas para builds constantes.

Cuándo falla este enfoque (contraejemplos)

• Si tu hardware objetivo no es x86, MACHINE debe cambiar: qemux86-64 solo emula x86_64.
• Si trabajas con BSPs propietarios, necesitarás capas adicionales y recetas del proveedor.
• En equipos con poca RAM o espacio en disco, el build puede fallar o ser extremadamente lento.

Caja de datos clave

• Requisitos mínimos: 4–6 GB RAM, 60–80 GB disco.
• Tiempo aproximado de compilación inicial: 2–6 horas (según CPU, red y cachés).
• Ramal usado: morty (ejemplo). Ajusta según necesidad.

Seguridad y privacidad

• No dejes imágenes con root sin contraseña en producción.
• El uso de EXTRA_IMAGE_FEATURES = “debug-tweaks” permite root sin contraseña y debe limitarse a entornos de desarrollo.
• Si vas a recopilar datos de usuarios, añade revisiones de privacidad según GDPR y evita incluir servicios por defecto.

Solución de problemas comunes

• Error de bitbake como root: ejecuta bitbake con un usuario normal y reexporta el entorno.
• Falta de espacio en disco: limpia TMPDIR o mueve DL_DIR/SSTATE_DIR a disco con más espacio.
• Errores de red al bajar paquetes: verifica proxies y acceso al servidor git.yoctoproject.org.
• Problemas con terminales remotas (Putty): usa una terminal local o RDP si ves errores GUI.

Mantenimiento y mejoras posteriores

• Añadir capas meta para incluir software adicional.
• Usar una rama de Yocto más reciente si tu BSP la soporta.
• Implementar CI que comparta sstate-cache y DL_DIR para acelerar builds.

Glosario 1 línea

• Bitbake: herramienta de compilación que procesa recetas y genera paquetes e imágenes.
• Poky: conjunto de metadatos y herramientas mínimas para Yocto.
• Sstate-cache: caché de estado compartido para acelerar recompilaciones.

Resumen

La creación de una distribución Linux mínima con Yocto implica preparar el entorno en Ubuntu, clonar Poky, configurar local.conf, compilar con bitbake y ejecutar la imagen en qemu. Este flujo es reproducible y modulable: empieza con una imagen mínima y añade capas o paquetes según tus requisitos. Para producción, ajusta la seguridad y adapta la máquina objetivo al hardware real.

Important: guarda copias de DL_DIR y sstate-cache si vas a compartir la infraestructura de builds entre varios desarrolladores.

Fin del tutorial.