Creare una distribuzione Linux minima con Yocto su Ubuntu

TL;DR

Questa guida spiega come costruire una distribuzione Linux minima usando Yocto (Poky, ramo stabile “morty”) su Ubuntu e come avviarla in QEMU. Copre i prerequisiti, la configurazione di build (local.conf), l’esecuzione di bitbake, l’avvio in QEMU e le principali strategie di risoluzione dei problemi.

Introduzione

In questo articolo descriviamo come creare una distribuzione Linux minima per ambienti embedded usando il progetto Yocto su una macchina di sviluppo Ubuntu. Yocto è uno strumento molto usato nel mondo dell’embedded per la sua flessibilità: permette di definire ricette, layer e immagini personalizzate per hardware e simulatori come QEMU. L’obiettivo è ottenere una core-image minimale e avviarla con qemu (emulatore software di base).

Definizione rapida: Yocto è un insieme di strumenti e meta-layer che generano immagini Linux personalizzate per architetture embedded.

Requisiti per la macchina di sviluppo

• RAM: almeno 4–6 GB.
• Sistema operativo: una versione recente di Ubuntu (nell’esempio è 16.04 LTS).
• Spazio disco: almeno 60–80 GB liberi.
• Pacchetti di sviluppo necessari (vedere la lista e i comandi più avanti).
• Scaricare il ramo stabile di Poky (lo sviluppo minimale di Yocto).

Nota importante: Yocto scarica e compila centinaia di pacchetti. Lo spazio disco e la RAM sono i limiti pratici più comuni.

Installare i pacchetti richiesti

Eseguire prima un aggiornamento dei pacchetti:

apt-get update

Installare i pacchetti di supporto necessari (comando unico):

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

Sulla macchina di sviluppo l’installazione dei pacchetti richiederà circa 1 GB di spazio aggiuntivo per i pacchetti binari e le dipendenze visualizzate.

Clonare Poky (Yocto minimal environment)

Nel tutorial usiamo il ramo stabile “morty” di Poky:

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

Entrare nella directory poky e preparare l’ambiente di build:

source oe-init-build-env

Questo script crea e posizionerà la shell nella directory “build”. Da qui si modifica la configurazione e si avvia la compilazione.

Configurazione di base: local.conf

Il file conf/local.conf controlla la maggior parte delle impostazioni della build: macchina target, percorso dei download, cache delle build, formato dei pacchetti, SDK e altro.

Esempio di parametri da verificare o decommentare in conf/local.conf:

DL_DIR ?= "${TOPDIR}/downloads"
SSTATE_DIR ?= "${TOPDIR}/sstate-cache"
TMPDIR ?= "${TOPDIR}/tmp"
PACKAGE_CLASSES ?= "package_rpm"
SDKMACHINE ?= "i686"
EXTRA_IMAGE_FEATURES ?= "debug-tweaks"

Descrizioni rapide:

• DL_DIR: cartella per salvare gli archivi scaricati.
• SSTATE_DIR: cache condivisa per accelerare rebuild.
• TMPDIR: directory temporanea di build.
• PACKAGE_CLASSES: formato pacchetto di output (rpm, deb, ipk).
• SDKMACHINE: architettura del toolchain SDK.
• EXTRA_IMAGE_FEATURES: opzioni aggiuntive per l’immagine, “debug-tweaks” abilita password vuota e altri strumenti utili per sviluppo.

Importante: se non abiliti “debug-tweaks” potresti non poter accedere con password vuota durante i test; per immagini di produzione, rimuovi o modifica le opzioni di default.

Compilazione con Bitbake

Per costruire la immagine minima eseguire come utente normale (non root):

bitbake core-image-minimal

È fondamentale eseguire bitbake come utente non root. Eseguire bitbake come root genererà errori di permessi e controllo delle policy di sicurezza.

Se per errore si è lanciato come root, re-eseguire lo script di ambiente e rilanciare come utente normale:

source oe-init-build-env
bitbake core-image-minimal

La fase di parsing delle ricette precede il download e la compilazione reale. Successivamente Yocto scaricherà e compilerà tutte le dipendenze. Questo processo può richiedere diverse ore (prima il download, poi la compilazione locale).

Al completamento la directory di deploy contiene le immagini per la macchina target qemux86-64:

build/tmp/deploy/images/qemux86-64

Avviare l’immagine in QEMU

Alcuni terminali remoti come PuTTY possono avere problemi con il forwarding di console. Se riscontri errori, prova a usare un client RDP o un terminale locale su Ubuntu.

Una volta avviato QEMU apparirà una nuova finestra emulata con la schermata di login. Per l’immagine creata in questa guida l’utente di default è root con password vuota (se EXTRA_IMAGE_FEATURES include debug-tweaks).

Dopo il login si possono testare comandi base per verificare kernel, rete e orologio:

date
ifconfig
uname -a

Criteri di accettazione

• L’immagine core-image-minimal si trova in build/tmp/deploy/images/qemux86-64.
• QEMU avvia l’immagine e mostra la prompt di root.
• Comandi base (date, ifconfig, uname) restituiscono output plausibile.

Risoluzione dei problemi comuni

• Errore: bitbake lanciato come root → eseguire come utente normale.
• Spazio insufficiente → pulire TMPDIR o aumentare spazio disco.
• Timeout/slow download → controllare connettività o usare mirror locali per DL_DIR.
• Problemi con PuTTY → usare RDP o terminale nativo.

Alternative e approcci complementari

• Buildroot: alternativa più leggera rispetto a Yocto per immagini semplici.
• Debian debootstrap: utile quando si desidera un userland Debian invece di una build da zero.
• Usare layer aggiuntivi (meta-openembedded, meta-intel) per pacchetti e supporto hardware extra.

Modello mentale e suggerimenti pratici

• Pensa a Yocto come a un sistema di ricette: le ricette definiscono come ottenere, configurare e compilare ogni pacchetto.
• Usa SSTATE per riutilizzare build e risparmiare tempo in rebuild incrementali.
• Mantieni la macchina di build pulita: usa snapshot o container per ricostruire in modo ripetibile.

Checklist rapida per lo sviluppatore

• Verificare RAM e spazio disco.
• Installare pacchetti richiesti.
• Clonare poky sul ramo desiderato.
• Eseguire source oe-init-build-env.
• Configurare conf/local.conf.
• Eseguire bitbake core-image-minimal come utente normale.
• Avviare immagine in QEMU e testare.

Esempio di comando e cheat sheet

• Clonare Poky: git clone -b morty git://git.yoctoproject.org/poky.git
• Preparare ambiente: source oe-init-build-env
• Costruire: bitbake core-image-minimal
• Percorso output: build/tmp/deploy/images/qemux86-64

Sicurezza e consigli per produzione

• Non distribuire immagini con EXTRA_IMAGE_FEATURES=”debug-tweaks” in produzione.
• Verificare e rimuovere account con password vuote.
• Applicare hardening minimo: disabilitare servizi non necessari, aggiornare i pacchetti di sicurezza a livello di ricetta.

Compatibilità e migrazione

• Quando si migra tra rami Yocto (es. morty → newer), aspettati cambiamenti nelle ricette e nella versione del toolchain. Testare su CI prima di aggiornare la produzione.

Mini metodologia per progetti embedded con Yocto

1. Definire requisiti funzionali e hardware.
2. Scegliere ramo Yocto stabile compatibile con gli layer richiesti.
3. Preparare ambiente di build con DL_DIR e SSTATE condivisi.
4. Costruire immagine base, testare in QEMU.
5. Aggiungere pacchetti e layer, iterare con SSTATE per velocizzare.
6. Automatizzare build in CI e produrre SDK se necessario.

Riepilogo

Questa guida mostra come costruire e avviare una distribuzione Linux minima con Yocto su Ubuntu, partendo dall’installazione dei pacchetti, passando per la configurazione di local.conf fino all’uso di bitbake e QEMU. Per lo sviluppo utilizzare un utente non root, abilitare debug-tweaks solo per test e sfruttare SSTATE per velocizzare iterazioni future.

Importante: Yocto è potente ma complesso. Per immagini molto semplici valutare anche Buildroot o debootstrap.