Créer un OS Live sur CD et clé USB

Date: 28/02/2008 | Catégories: Open-source,Systeme | Tags: clés usb,linux,live,ubuntu,usbkey

Avoir un système d'exploitation live sur CD ou clé USB peut s'avérer extrêmement utile lorsque, par exemple, Windows plante au démarrage (ah bon?) et que l'on veut récupérer des fichiers importants sur le disque, ou tout simplement pour transporter sa propre boite a outils de geek dans sa poche.

photo credit: Locator

Pour cela, on peut :

télécharger un OS Live existant comme celui d'Ubuntu, DSL (Damn Small Linux) ou autre
créer son propre OS from scratch
partir d'un OS Live existant et le customizer

La première solution est évidemment la plus simple et la plus rapide, mais ne permet pas de pré-configurer le système.

La seconde solution est la plus complète de toutes, mais nécessite de longues heures de compilation.

La troisième est un excellent compromis entre les 2 autres solutions et est celle que nous allons détailler dans ce sujet...

1. Pré-requis

Ce tutoriel a été réalisé sur une distribution Ubuntu 7.10, et nécessite les packages suivants: mkisofs, squashfs-tools, fakeroot, gfxboot, syslinux

~/# sudo apt-get install mkisofs squashfs-tools fakeroot gfxboot syslinux

Il nous faudra aussi télécharger une distribution Ubuntu, par exemple la 6.06 ou la 7.10. Ce tutoriel se base sur la Ubuntu Desktop 6.06, mais marche très bien avec les versions supérieures.

On se créera aussi un répertoire de travail sur le système, par exemple ~/SANDBOX

~/# mkdir ~/SANDBOX

2. Préparation de l'environnement

Tout d'abord, il va falloir monter le fichier ISO de la distribution choisie dans un répertoire sur le disque, par exemple /mnt/ubuntu

~/# sudo mkdir /mnt/ubuntu
~/# sudo mount -t iso9660 -o loop /chemin/vers/ubuntu-6.06-desktop-i386.iso /mnt/ubuntu

puis copier intégralement le contenu du CD dans le repertoire de travail ~/SANDBOX/livecd et récupérer les droits d'écriture sur toute l'arborescence

~/# cd ~/SANDBOX
~/SANDBOX/# mkdir livecd
~/SANDBOX/# sudo cp -a /mnt/ubuntu/* livecd
~/SANDBOX/# sudo chmod -R u+w livecd
~/SANDBOX/# sudo umount /mnt/ubuntu

La majorité des fichiers visibles du disque sert pour la phase de boot du systeme. Seul le fichier livecd/casper/filesystem.squashfs contient la racine système chargé en mémoire par le live CD. Nous allons donc le monter dans notre repertoire ~/SANDBOX/old-filesystem en lecture seule

~/SANDBOX/# mkdir old-filesystem
~/SANDBOX/# sudo mount -t squashfs -o loop,ro livecd/casper/filesystem.squashfs old-filesystem

Désormais, le répertoire ~/SANDBOX/old-filesystem contient la racine du systeme de fichiers de la distribution live. Un petit coup de "du -cs old-filesystem" nous montre que ce systeme occupe presque 2Go sur le disque ! Il nous faut donc réserver 2Go d'espace supplémentaire pour le nouveau systeme de fichiers...

~/SANDBOX/# dd if=/dev/zero of=myfs.ext2 bs=1M count=2147

... on va ensuite formater ce nouveau systeme de fichiers en EXT2 (mke2fs va afficher un message d'avertissement, le valider)...

~/SANDBOX/# mke2fs myfs.ext2

... puis on va monter ce tout nouveau systeme de fichiers en lecture/ecriture dans le repertoire ~/SANDBOX/new-filesystem

~/SANDBOX/# mkdir new-filesystem
~/SANDBOX/# sudo mount -o loop myfs.ext2 new-filesystem

Maintenant on peut copier le systeme de fichiers originel dans l'espace réservé au nouveau afin de pouvoir lui appliquer toutes les modifications souhaitées

~/SANDBOX/# sudo cp -a old-filesystem/* new-filesystem/

Avant de procéder aux modifications réelles du nouveau systeme, on va tout d'abord récupérer la configuration DNS de notre machine ainsi que "binder" le répertoire /proc sur le nouveau systeme

~/SANDBOX/# sudo cp /etc/resolv.conf new-filesystem/etc
~/SANDBOX/# sudo mount -t proc -o bind /proc new-filesystem/proc
~/SANDBOX/# sudo mount -t sys -o bind /proc new-filesystem/sys
~/SANDBOX/# sudo mount -t devpts -o bind /proc new-filesystem/dev/pts

3. Go-go-gadget au chroot & installation de nouveaux logiciels

Maintenant que tout est prêt, c'est parti pour le CHROOT : on va lancer un shell (bash par exemple) en spécifiant le répertoire "~/SANDBOX/new-filesystem" comme la racine du systeme.

~/SANDBOX/# sudo chroot new-filesystem /bin/bash

Désormais, "ls -l /" listera les fichiers contenus dans la nouvelle racine (et non la vraie racine de votre systeme), et un "ps aux" sur ce shell listera les processus du nouveau systeme ainsi que ceux du système englobant. Tout se passe donc a peu près comme si on avait booté sur le nouveau système, avec quelques processus en plus !

Avant de continuer, on va changer la variable d'environnement $HOME pour qu'elle pointe vers /root

# export HOME=/root # export LC_ALL=C

Maintenant on peut y aller ! On va commencer par mettre a jour la liste des paquets aptitude...

# aptitude update

...puis lister les packages installés...

# dpkg-query -W --showformat='${Package}\n' | sort | less

...et supprimer les packages non utilisés avec une recherche : copier et executer le resultat de la commande

# dpkg-query -W "gnome-*" | awk 'BEGIN {printf "apt-get remove --purge ";} // { printf $1" "; } END { print "\n"}'

ou taper les commandes à la main

# apt-get remove --purge gnome-~n compiz-~n language-pack-gnome-~n
# apt-get remove --purge "gimp*"
# apt-get remove --purge java-common
# apt-get remove --purge "mysql*"
# apt-get remove --purge "openoffice*"

Ensuite, on va installer de nouveaux logiciels

# apt-get install xfce4-panel xfce4-utils xfce4-quicklauncher-plugin xfce4-terminal xfce4-xkb-plugin
# apt-get install xfwm4 xfwm4-themes xfce4-mcs-manager
# apt-get install gdm
# .......

Avant de terminer, on va supprimer tous les fichiers temporaires téléchargés par apt et vider le répertoire /tmp

# apt-get clean
# rm -rf /tmp/*

Sortir du système avec la commande:

# exit

4. Finalisation du nouveau systeme

Commencer par dé-monter le repertoire new-filesystem/proc

~/SANDBOX/# sudo umount new-filesystem/proc
~/SANDBOX/# sudo umount new-filesystem/sys
~/SANDBOX/# sudo umount new-filesystem/dev/pts

Supprimer la configuration DNS du nouveau systeme

~/SANDBOX/# sudo rm new-filesystem/etc/resolv.conf

Mettre a jour le fichier MANIFEST qui reflete la liste des packages installés

~/SANDBOX/# sudo chroot new-filesystem dpkg-query -W --showformat='${Package} ${Version}\n' > ~/SANDBOX/livecd/casper/filesystem.manifest

Maintenant, on va nettoyer l'image du systeme de fichiers en remplissant de zeros tout l'espace non occupé afin d'optimiser la compression de l'image

~/SANDBOX/# dd if=/dev/zero of=new-filesystem/dummy

On peut maintenant supprimer le fichier dummy

~/SANDBOX/# rm new-filesystem/dummy

On va ensuite construire un fichier correspondant à notre systeme de fichiers compressé

~/SANDBOX/# rm livecd/casper/filesystem.squashfs
~/SANDBOX/# cd new-filesystem
~/SANDBOX/# sudo mksquashfs . ~/SANDBOX/livecd/casper/filesystem.squashfs

prendre un café...Démonter les systèmes de fichiers précédemment montés

~/SANDBOX/# sudo umount new-filesystem
~/SANDBOX/# sudo umount old-filesystem

5. Creation du live CD

Généralement, il y a quelques fichiers et répertoires inutiles sur les distributions live, donc on va supprimer tout ce qui n'est pas nécessaire

~/SANDBOX/# cd livecd
~/SANDBOX/livecd/# rm -rf bin
~/SANDBOX/livecd/# rm -rf programs
~/SANDBOX/livecd/# rm start.exe autorun.inf start.ini start.bmp

Maintenant on peut modifier le script de démarrage afin de personnaliser l'écran d'accueil

~/SANDBOX/livecd# cd isolinux
~/SANDBOX/livecd/isolinux# vim isolinux.cfg

Pour changer la couleur de l'écran de boot (notamment la couleur de la jauge et du texte), changer la valeur hexadécimale de la ligne appropriée, exemple (pour une couleur blanche):

GFXBOOT-BACKGROUND 0XFFFFFF

et on ajouter ou modifier les labels présents, et modifier les options de boot, exemple:

LABEL livemenu
label ^Start MY GREAT OS
kernel /casper/vmlinuz
append boot=casper initrd=/casper/initrd.gz ramdisk_size=1048576 root=/dev/ram rw quiet splash vga=791 --

Pour modifier le logo de l'écran de démarrage, il faut éditer (avec The Gimp ou Paint.net) l'image ~/SANDBOX/livecd/isolinux/splash.pcx

Pour modifier l'image de splash, affichée lors du chargement du système il va falloir éditer l'image ~/SANDBOX/livecd/isolinux/splash.rle' : c'est une image de type LSS16 qui a une résolution de 640x480 pixels avec 16 couleurs indexées. Pour la modifier, il faut la convertir en un format lisible par The Gimp ou Paint.net avec la commande ppmtolss16 :

~/SANDBOX/livecd/isolinux# lss16toppm < splash.rle > splash.ppm

Apres l'avoir modifiée, la reconvertir en format LSS16 avec la commande ppmtolss16 :

~/SANDBOX/livecd/isolinux# ppmtolss16 < splash.ppm > splash.rle

Maintenant on va regénérer l'empreinte MD5 du CD (obligatoire)

~/SANDBOX/livecd/# sudo find . -type f -print0 | xargs -0 md5sum | sudo tee md5sum.txt

Et pour terminer, on va créer l'ISO de notre LiveCD !

~/SANDBOX/livecd/# cd ..
~/SANDBOX/# sudo mkisofs -o MyLiveCD.iso -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -r -V "Custom Ubuntu Live CD" -cache-inodes -J -l livecd

Il ne reste plus qu'a graver cette image ISO sur un CD et rebooter pour tester tout ca (pour éviter de rebooter, on peut installer VirtualBox aussi...) !

6. Creation du live USB

Un CD c'est bien, mais une clé USB c'est mieux (encore faut-il pouvoir booter dessus) !. Pour cela il faut créer 2 partitions sur la clé :

une pour l'os
et une autre qui sera utilisée pour la persistence des données (c'est l'avantage par rapport au CD...)

Tout d'abord brancher la clé usb, puis regarder le nom de device que lui a attribué le kernel

~/SANDBOX/# fdisk -l

Supposons que ce soit /dev/sdb, alors les partitions de ce devices auront alors pour nom /dev/sdb1, /dev/sdb2, etc.

# fdisk /dev/sdb

puis entrer les commandes suivantes:

p (pour afficher la liste des partitions)
d (pour supprimer la ou les partitions)
p (pour lister les partitions restantes : appuyer sur d pour les supprimer alors)
n (pour créer une nouvelle partition)
p (pour créer une partition primaire)
1 (pour faire en sorte que ce soit la premiere partition)
1 ou entrée (pour choisir le premier cylindre)
+1024M (pour choisir la taille de la partition principale, à adapter selon la taille de votre liveCD et de votre clé USB)
a (pour activer la partition)
1 (pour choisir d'activer la partition que l'on vient de créer)
t (pour choisir le système de fichiers de la partition)
6 (pour choisir FAT16)
n (pour créer la deuxième partition)
p (partition primaire)
2 (numéro de la partition)
entrée (choix par défaut pour le premier cylindre)
entrée (choix par défaut pour le dernier cylindre)
w (pour ecrire les changements sur la partition)

Démonter ensuite les partitions montées de la clé

~/SANDBOX/# sudo umount /dev/sdb1

Puis il faut formatter les deux partitions:

~/SANDBOX/# mkfs.vfat -F 16 -n MyUSBOS /dev/sdb1
~/SANDBOX/# mkfs.ext2 -b 4096 -L casper-rw /dev/sdb2

Maintenant, on peut recopier le contenu du livecd sur la premiere partition de la clé

~/SANDBOX/# sudo mkdir -p /mnt/liveusb{1,2}
~/SANDBOX/# mount /dev/sdb1 /mnt/liveusb1
~/SANDBOX/# sudo cp -r ~/SANDBOX/livecd/* /mnt/liveusb1

Copier les images splash .rle et .pcx du répertoire isolinux a la racine...

~/SANDBOX/# sudo cp /mnt/liveusb1/isolinux/splash.{rle,pcx} /mnt/liveusb1

Copier le fichier isolinux/isolinux.txt a la racine et le renommer en syslinux.txt

~/SANDBOX/# sudo cp /mnt/liveusb1/isolinux/isolinux.txt /mnt/liveusb1/syslinux.txt

Créer un fichier nommé syslinux.cfg (qui permet de configurer syslinux) a la racine...

~/SANDBOX/# touch /mnt/liveusb1/syslinux.cfg

... et le remplir avec la configuration de base suivante:

DEFAULT /casper/vmlinuz
GFXBOOT /casper/bootlogo
GFXBOOT-BACKGROUND 0x678db2
APPEND boot=casper initrd=/casper/initrd.gz quiet splash --
LABEL persistent
kernel /casper/vmlinuz
append boot=casper persistent initrd=/casper/initrd.gz quiet splash --
LABEL live
kernel /casper/vmlinuz
append boot=casper initrd=/casper/initrd.gz quiet splash --
LABEL memtest
kernel /install/mt86plus
append -
LABEL hd
localboot 0x80
append -
DISPLAY syslinux.txt
TIMEOUT 300
PROMPT 1

A noter que le label "persistent" ajoute un parametre du meme nom au kernel qui permettra de monter la deuxième partition en lecture/ecriture.

Ne pas oublier ensuite de regénérer l'empreinte MD5 :

~/SANDBOX/# cd /mnt/liveusb1
/mnt/liveusb1# sudo find . -type f -print0 | xargs -0 md5sum | sudo tee md5sum.txt
/mnt/liveusb1# cd -

Et finalement rendre la clé bootable avec syslinux

~/SANDBOX/# syslinux -sf /dev/sdb1

Et voila, vous pouvez maintenant conquérir le monde avec votre clé USB et votre CD bootables !

Voici les articles dont je me suis largement inspiré pour écrire ce post, merci à eux:

NDNicolargo: un grand merci à Nicolas Richasse pour cet article !