• Mise en place d’un environnement de compilation personnel
  • Installation des paquets nécessaires
  • Création d’un utilisateur pour le build
  • Ajoute de l’utilisateur au groupe sbuild
  • Création d’une paire de clef GPG
  • Mutualisation du cache apt
  • Récupération des clefs publiques des dépôts
  • Préparation de l’environnement
  • Création d’un volume logique dédié aux builds
  • Création des environnements de build
    • Avant l’installation du chroot: création d’un volume logique
    • Installation du système de base
    • Adaptation post-installation
• Webographie

Mise en place d’un environnement de compilation personnel¶

Sur une machine dédiée au build, nous avons besoin :

• D’un utilisateur pour administrer le système (system) ;

• D’un utilisateur dédié au build (buildd) ;

• D’un groupe de volume logique d’une taille suffisante pour les
  chroot (build) ;

• De suffisamment d’espace libre sur le groupe de volume pour les
  snapshots.

Installation des paquets nécessaires¶

Les deux paquets nécessaire à la création et la gestion des
environnements sont les suivants :

• sbuild: l’utilitaire de gestion des chroot en version 0.63.2-1 ou supérieure disponible sur Wheezy
• debootstrap: l’utilitaire d’installation

system@build:~$ sudo apt-get install sbuild debootstrap

Création d’un utilisateur pour le build¶

Ce dernier recevra les logs dans son répertoire personnel.

Il est cependant possible d’utiliser votre compte utilisateur, mais
sera indispensable lors de la mise en place d’un système de build
automatique.

system@build:~$ sudo adduser buildd

Ajoute de l’utilisateur au groupe sbuild¶

L’accès aux outils de gestion de schroot est restreint aux membres du
groupe sbuild.

Exécuter la commande suivante et copier le fichier comme indiqué :

system@build:~$ sudo sbuild-adduser system
system@build:~$ sudo sbuild-adduser buildd

Création d’une paire de clef GPG¶

L’outil sbuild créé des pseudos paquets pour la gestion des
Build-Depends lors de la construction des paquets.

Cette paire de clef est locale à la machine
(/var/lib/sbuild/apt-keys) et spécifique à la procédure de build, il
n’y a nullement lieu de la publier.

buildd@build:~$ sbuild-update --keygen

Afin de générer de l’entropie, j’exécute dans un autre terminal la
commande suivante :

buildd@build:~$ find / -type f -exec sha512sum {} \; > /dev/null 2>&1

Si vous êtes en SSH sur une machine (virtuelle ou physique), la frappe
de touche au clavier doit consommer autant d’entropie qu’elle n’en
fournie.

Mutualisation du cache apt¶

system@build:~$ sudo /bin/sh -c "echo /var/cache/apt/archives /var/cache/apt/archives none rw,bind 0 0 >>/etc/schroot/sbuild/fstab" 

Récupération des clefs publiques des dépôts¶

La machine de build étant une debian, il faut ajouter les clefs GPG publique du projet ubuntu et de EOLE.

system@build:~$ wget http://eoleng.ac-dijon.fr/eoleng/eole-repository.key
system@build:~$ wget http://fr.archive.ubuntu.com/ubuntu/project/ubuntu-archive-keyring.gpg
system@build:~$ sudo apt-key --keyring /etc/apt/trusted.gpg.d/sbuild.gpg add eole-repository.key
system@build:~$ sudo apt-key --keyring /etc/apt/trusted.gpg.d/sbuild.gpg add ubuntu-archive-keyring.gpg

Préparation de l’environnement¶

Afin d’avoir des commandes réutilisables facilement, nous partirons du principe que :

• la variable d’environnement ${YOUR_VG} contient le nom de votre groupe de volume ;

• La variable d’environnement ${dist} contient le nom de la distribution ;

• La variable d’environnement ${arch} contient le nom de l’architecture ;

system@buildd:~$ export YOUR_VG=build dist=lucid arch=amd64

En partant d'une installation utilisant partman-auto, le groupe de volume est déjà complet. Si la recette est bien faite, un volume logique a été créé avec l'option method{ keep }. Ce volume (nommé par défaut keep_1) peut-être supprimé et l’espace libéré ainsi peut-être réutilisé.

system@build:~$ sudo lvchange -a n /dev/${YOUR_VG}/keep_1
system@build:~$ sudo lvremove /dev/${YOUR_VG}/keep_1

Création d’un volume logique dédié aux builds¶

Ce volume sera monté dans chaque snapshot lors d’un build afin de ne
pas surcharger les snapshots de construction.

system@build:~$ sudo lvcreate -L20g -n var+lib+sbuild+build ${YOUR_VG}
system@build:~$ sudo mkfs.ext4 -L /var/lib/sbuild/build -m0 /dev/${YOUR_VG}/var+lib+sbuild+build
system@build:~$ sudo /bin/sh -c "echo /dev/${YOUR_VG}/var+lib+sbuild+build /var/lib/sbuild/build ext4 rw,noatime 0 2 >> /etc/fstab" 
system@build:~$ sudo mount /var/lib/sbuild/build
system@build:~$ sudo chown sbuild:sbuild /var/lib/sbuild/build
system@build:~$ sudo chmod 2770 /var/lib/sbuild/build

Création des environnements de build¶

La gestion des environnements de build est faite par schroot et peut utiliser plusieurs systèmes afin de partager une image de base et ainsi gagner du temps lors des compilation :

• Les volumes logiques ;
• Le système de fichier btrfs.

Avant l’installation du chroot: création d’un volume logique¶

Dans le modèle LVM chaque chroot est installé sur un volume logique
dédié.

La taille de ce volume doit pouvoir contenir :

• Un système minimal ;

• L’intégralité des dépendances pour la compilation d’un paquet.

system@build:~$ sudo lvcreate -L2g -n ${dist}-${arch}-sbuild ${YOUR_VG}
system@build:~$ sudo mkfs.ext4 -m0 -L ${dist}-${arch}-sbuild /dev/${YOUR_VG}/${dist}-${arch}-sbuild
system@build:~$ sudo mkdir -p /srv/chroot/${dist}-${arch}-sbuild
system@build:~$ sudo mount /dev/${YOUR_VG}/${dist}-${arch}-sbuild /srv/chroot/${dist}-${arch}-sbuild

Installation du système de base¶

La création du chroot en lui même est très simple mais nécessitera des
ajustements préalables décris ci-après en fonction du choix fait entre
LVM et btrfs.

En assumant que le chroot doit être créer dans le répertoire
/srv/chroot/${dist}-${arch}-sbuild/, la commande pour installer le
chroot est la suivante :

system@build:~$ sudo sbuild-createchroot --keyring /etc/apt/trusted.gpg.d/sbuild.gpg \
    --arch=${arch} \
    --components=main,restricted,universe,multiverse \
    ${dist} \
    /srv/chroot/${dist}-${arch}-sbuild \
    http://eoleng.ac-dijon.fr/ubuntu

L’utilisation de l’option --components est importante pour la
résolution des dépendances.

Adaptation post-installation¶

Nous devons adapter la configuration de schroot à l’utilisation des
snapshot LVM une fois le système installé :

system@build:~$ sudo sed -i -e "s,type=directory,type=lvm-snapshot," \
    -e "/directory=/d" \
    -e "/type=/ialiases=eole-2.3,eole-2.3-dev,eole-2.3-proposed,eole-2.3-security" \
    /etc/schroot/chroot.d/$dist-$arch-sbuild*
buildd@build:~$ sudo /bin/sh -c "cat >> `expr /etc/schroot/chroot.d/$dist-$arch-sbuild*` <<EOT
lvm-snapshot-options=--size 2G
mount-options=-o noatime
device=/dev/${YOUR_VG}/$dist-$arch-sbuild
source-groups=root,sbuild
source-root-groups=root,sbuild
EOT
" 

Les alias ci-dessus font que l’appel à sbuild -d eole-2.3-dev utilisera l’architecture AMD64 par défaut.

La création d’un schroot i386 devrait ajouter des alias contenant l’architecture afin de ne pas entrer en conflit :

system@build:~$ sudo sed -i \
    -e "/type=/ialiases=eole-2.3-i386,eole-2.3-dev-i386,eole-2.3-proposed-i386,eole-2.3-security-i386" \
    /etc/schroot/chroot.d/$dist-$arch-sbuild*

Ainsi, la commande sbuild -d eole-2.3-dev --arch=i386 utilisera le schroot i386 et non le AMD64.

Webographie¶

• sbuild sur le wiki debian,
• Debian build setup
• Space-efficient reproducible builds using schroot, sbuild and LVM
• Debian wiki on Packaging with git
• Russ Allbery use case
• My use case
• Package Entropy Tracker