Créer une distribution Linux minimale avec Yocto sur Ubuntu

Introduction

Yocto est un ensemble d’outils pour construire des distributions Linux embarquées. Définition rapide : Yocto permet d’automatiser la récupération des sources, la compilation et l’assemblage d’images pour des architectures cibles.

Cet article montre la création d’une distribution minimale (core-image-minimal) pour la machine cible qemux86-64 et son exécution dans QEMU. Les commandes et captures proviennent d’un environnement Ubuntu (ex. 16.04 utilisé ici), mais la procédure s’adapte à d’autres versions récentes.

TL;DR technique

• Préparez Ubuntu avec les paquets requis et assez d’espace disque. 4–6 Go RAM et 60–80 Go libres recommandés.
• Clonez poky (branche morty), sourcez l’environnement OE et modifiez conf/local.conf.
• Lancez bitbake core-image-minimal (en utilisateur non-root).
• Exécutez l’image générée avec QEMU.

Important : exécutez bitbake en tant qu’utilisateur normal, pas en root. L’image générée par défaut a l’utilisateur root et un mot de passe vide — sécurisez-le avant tout déploiement.

Prérequis pour la machine de développement

• 4–6 Go de RAM minimum recommandé.
• Ubuntu récent (l’exemple a utilisé 16.04 LTS).
• 60–80 Go d’espace disque libre (dépend du nombre de recettes/paquets).
• Paquets requis installés avant de commencer (liste ci‑dessous).
• Cloner la branche stable de Poky (morty dans cet exemple).

Installez d’abord les paquets système :

apt-get update

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

Note : l’installation des paquets de développement peut demander presque 1 Go selon la configuration.

Cloner Poky (Yocto)

Dans cet exemple on clone la branche morty :

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

Entrez dans le répertoire poky et initialisez l’environnement de build :

source oe-init-build-env

Cela crée et vous place dans le répertoire build où se trouve la configuration.

Le fichier de configuration principal est build/conf/local.conf. Il définit notamment la machine cible, les répertoires de téléchargement et de cache, et d’autres options du SDK.

Configurer local.conf

Exemples de paramètres à vérifier/modifier dans build/conf/local.conf :

• Définir la machine cible :

MACHINE ??= "qemux86-64"

• Décommenter ou ajouter les chemins partagés pour les téléchargements et le cache :

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

• Choix du format de paquet et machine pour le SDK :

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

• Pour pouvoir se connecter sans mot de passe (utile en développement), autoriser les tweaks de debug :

EXTRA_IMAGE_FEATURES ?= "debug-tweaks"

Cela active par exemple un compte root avec mot de passe vide. À utiliser uniquement en environnement de test.

Note : nous n’utilisons pas d’interface graphique de build (toaster) dans ce tutoriel.

Compilation et génération (bitbake)

Lancez la génération de l’image minimale :

bitbake core-image-minimal

Important : exécutez bitbake en tant qu’utilisateur normal, pas en root. Si vous lancez bitbake en root, vous obtiendrez une erreur :

Si besoin, restaurez l’environnement :

source oe-init-build-env

Puis relancez bitbake. La première étape du build est l’analyse des recettes. Ensuite bitbake télécharge les sources, puis compile les paquets.

La phase de compilation peut durer plusieurs heures (2–3 heures typiques sur une machine modeste), car les sources sont d’abord téléchargées puis compilées.

Lorsque la liste de tâches est terminée, vous trouverez les images compilées dans :

build/tmp/deploy/images/qemux86-64

Exécution dans QEMU

Sur certaines connexions (par ex. via PuTTY), l’exécution de la commande de lancement peut poser problème. Préférez un terminal local ou une session graphique (RDP) si nécessaire.

Lancer QEMU depuis un terminal fonctionnel ouvrira une fenêtre émulateur QEMU :

L’écran de connexion apparaît. Par défaut : utilisateur root et mot de passe vide (si debug-tweaks est set). Connectez-vous et testez quelques commandes de base (date, ifconfig, uname) pour valider l’image.

Fichier de sortie et artefacts

Les images et artefacts (images disque, fichiers rootfs, manifests) se trouvent dans build/tmp/deploy/images/qemux86-64. Vous pouvez réutiliser ces artefacts pour tests supplémentaires ou pour créer un SDK.

Dépannage courant

• Erreur : « ne pas exécuter bitbake en root » — relancer en utilisateur normal.
• Manque d’espace disque — augmentez l’espace disponible ou nettoyez DL_DIR/sstate-cache/tmp.
• Lancement QEMU échoue via SSH/PuTTY — utilisez un terminal local ou RDP/X11.
• Mot de passe root vide — changez-le immédiatement pour un usage non-test.

Alternatives et approches complémentaires

• Utiliser une branche Yocto plus récente (p.ex. zeus, dunfell) selon contraintes projet.
• Embarquer des paquets supplémentaires via IMAGE_INSTALL dans local.conf ou créer une recette personnalisée.
• Pour interface graphique de build, étudier les outils externes ou intégrations CI (par exemple Jenkins avec conteneur de build Yocto).

Modèle mental rapide (heuristique)

• Préparer → Configurer → Builder → Tester.
• Si le build échoue, inspecter logs dans tmp/work, relancer avec -c cleansstate sur la recette fautive.

Checklist par rôle

• Développeur firmware

  • Vérifier MACHINE et IMAGE_FEATURES
  • Ajouter recettes nécessaires
  • Tester l’image dans QEMU

• Intégrateur système

  • Valider DL_DIR, SSTATE_DIR et TMPDIR partagés pour accélérer builds
  • Générer SDK si besoin

• QA

  • Valider l’ID de version et la présence des outils essentiels (busybox, busybox applets)
  • Exécuter tests fonctionnels de démarrage et réseau

Mini-méthodologie (étapes rapides)

1. Installer paquets système.
2. Cloner poky (branche choisie).
3. source oe-init-build-env.
4. Modifier build/conf/local.conf (MACHINE, DL_DIR, SSTATE_DIR, TMPDIR, EXTRA_IMAGE_FEATURES).
5. bitbake core-image-minimal (en utilisateur non-root).
6. Exécuter l’image avec QEMU et valider.

Flux de décision (succès/échec) — diagramme Mermaid

flowchart TD
  A[Démarrer build] --> B{bitbake lancé}
  B -->|root| C[Erreur: relancer en utilisateur non-root]
  B -->|utilisateur| D[Téléchargement des sources]
  D --> E[Compilation]
  E --> F{Build OK?}
  F -->|oui| G[Déployer dans QEMU]
  F -->|non| H[Consulter tmp/work et logs]
  H --> I[Corriger recette/configuration]
  I --> A

Sécurité et bonnes pratiques

• Ne laissez jamais un mot de passe root vide en production.
• Utilisez des répertoires DL_DIR et SSTATE_DIR partagés pour les builds réplicables.
• Pour production, considérez la signature des paquets et durcissement du rootfs.

Résumé final

Ce tutoriel vous a guidé pour créer une distribution minimale Yocto (poky/morty) sur Ubuntu et la lancer dans QEMU. Vous savez maintenant préparer l’environnement, éditer local.conf, lancer bitbake et dépanner les problèmes courants. Pour aller plus loin, créez des recettes personnalisées, générez un SDK et testez sur la cible matérielle réelle.

Notes :

• Temps de compilation estimé : 2–3 heures sur une machine modeste.
• Espace disque recommandé : 60–80 Go.
• RAM recommandée : 4–6 Go.

Bonnes pratiques : partagez le sstate-cache entre développeurs pour accélérer les builds et versionnez vos modifications de local.conf.