- 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
- Un volume logique pour tous les chroots
- Création d’un sous volume par chroot
- Installation du système de base
- Adaptation post-installation
- Création du répertoires contenant les points de montages temporaires
- Changement du type de schroot
- Paramétrage spécifique Btrfs
- Gestion des alias
- Configuration des outils Debian
- Gestion des alias
- Autoriser l’utilisateur system à installer des paquets dans les schroots
- Accélération de la création de paquet
- Mettre à jour et nettoyer le schroot
- 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
.
Un volume logique pour tous les chroots¶
Ce volume contiendra les chroots des différents systèmes pour lesquels
vous ferez des compilation.
Un snapshot sera créé avant chaque build et détruit après, cela permet
de gagner le temps du debootstrap.
system@build:~$ sudo apt-get install btrfs-tools system@build:~$ sudo lvcreate -L20g -n schroot ${YOUR_VG} system@build:~$ sudo mkfs.btrfs -L schroot /dev/${YOUR_VG}/schroot system@build:~$ sudo mkdir -p /srv/chroot system@build:~$ sudo /bin/sh -c "echo /dev/${YOUR_VG}/schroot /srv/chroot btrfs rw,noatime 0 3 >> /etc/fstab" system@build:~$ sudo mount /srv/chroot
Création d’un sous volume par chroot¶
Il est nécessaire de mettre en place un sous volume par distribution/architecture
system@buildd:~$ sudo btrfs subvolume create /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 entreLVM
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 ensuite adapter la configuration de schroot
à
l’utilisation des snapshot btrfs
.
Création du répertoires contenant les points de montages temporaires¶
system@build:~$ sudo mkdir -p /srv/chroot/snapshots
Changement du type de schroot¶
system@build:~$ sudo sed -i -e "s,type=directory,type=btrfs-snapshot,; /directory=/ d" \ /etc/schroot/chroot.d/$dist-$arch-sbuild*
Paramétrage spécifique Btrfs¶
buildd@build:~$ sudo /bin/sh -c "cat >> `expr /etc/schroot/chroot.d/$dist-$arch-sbuild*` <<EOT btrfs-source-subvolume=/srv/chroot/$dist-$arch-sbuild btrfs-snapshot-directory=/srv/chroot/snapshots EOT "
Gestion des alias¶
Configuration des outils Debian¶
Des optimisations de configuration permettent aux outils Debian debconf et Apt de fonctionner de façon optimale dans les schroots de compilation.
Mode non interactif lors de l’installation des paquets¶
system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c 'echo "debconf debconf/priority select critical" | debconf-set-selections echo "debconf debconf/frontend string noninteractive" | debconf-set-selections'
Ne pas installer les paquets recommandés et suggérés¶
system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c 'cat > /etc/apt/apt.conf.d/90no-install-recommends <<EOF APT::Install-Recommends "False"; APT::Install-Suggests "False"; EOF'
Ne pas utiliser les diff des indexes de paquets¶
Ces fichiers permettent de diminuer la quantité de données téléchargées lors des apt-get update
mais peuvent faire planter l’outil apt-get
de temps en temps :
system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c 'cat > /etc/apt/apt.conf.d/80no-pdiff <<EOF Acquire::PDiffs "False"; EOF'
Forcer la mise à jour des fichiers de configuration¶
system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c 'echo "force-confnew" > /etc/dpkg/dpkg.cfg.d/force-confnew'
Configurer debfoster¶
L’outil debfoster permet de garder un système propre.
system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c 'cat > /var/lib/debfoster/keepers <<EOF build-essential debfoster eatmydata EOF'
Gestion des alias¶
Nous venons de créer des schroots Ubuntu Lucid Lynx dans lesquels les builds seront effectués.
Il nous reste à déclarer que ces schroots seront utilisés pour compiler des paquets pour notre distribution, nos distributions en prenant en compte les variantes -security
, -updates
, -proposed
et -dev
.
Cette étape est importante afin que les paquets compilés pour une distribution soient répartis dans la bonne distribution sur le dépôt de paquets deb.
La commande suivante créé un fichier .changes
contenant la distribution eole-2.3-dev
, ce fichier étant utilisé pour le triage :
buildd@build:~$ sbuild -d eole-2.3-dev $package_$version.dsc
Nous configurons les alias en ajoutant une ligne:
system@build:~$ sudo sed -i \ -e "/type=/ialiases=eole-2.3-${arch}-sbuild,eole-2.3-dev-${arch}-sbuild,eole-2.3-proposed-${arch}-sbuild,eole-2.3-security-${arch}-sbuild" \ /etc/schroot/chroot.d/$dist-$arch-sbuild*
Autoriser l’utilisateur system à installer des paquets dans les schroots¶
Il faut en premier lieu configurer sudo
:
system@build:~$ sudo /bin/sh -c "cat >> `expr /etc/sudoers.d/apt` <<EOT Cmnd_Alias APT_INSTALL = /usr/bin/apt-get install *, /usr/bin/dpkg -i *.deb Cmnd_Alias APT_REMOVE = /usr/bin/apt-get remove *, /usr/bin/apt-get purge * Cmnd_Alias APT_CLEAN = /usr/bin/apt-get clean, /usr/bin/apt-get --purge autoremove, /usr/bin/orphaner --purge Cmnd_Alias APT_UPGRADE = /usr/bin/apt-get update, /usr/bin/apt-get upgrade, /usr/bin/apt-get dist-upgrade system ALL=NOPASSWD : APT_INSTALL, APT_REMOVE, APT_CLEAN, APT_UPGRADE EOT "
Il faut ensuite ajouter ce fichier à la liste des fichiers à copier dans les schroot
:
system@build:~$ sudo /bin/sh -c "cat >> `expr /etc/schroot/sbuild/copyfile` <<EOT /etc/sudoers.d/apt EOT "
Accélération de la création de paquet¶
Le système de packaging dpkg
utilise intensément l’appel systeme fsync afin d’assurer au maximum la cohérence des systèmes de fichiers.
Cette frénésie de fsync
ralenti considérablement les accès disques et n’est pas primordiale lors de la compilation d’un paquet.
On peut donc installer le paquet eatmydata à l’intérieur des schroot
et les configurer pour inhiber les appels à fsync
:
Pour Lucid Lynx, le paquet est disponible et supporté dans les backports
qui ne sont pas activé par défaut, on peut télécharger et installer le paquet manuellement.
system@build:~$ EAT_URL=$([ "$arch" = "amd64" ] && echo 'http://launchpadlibrarian.net/68861934/eatmydata_26-2~lucid1_amd64.deb' || echo 'http://launchpadlibrarian.net/68861936/eatmydata_26-2~lucid1_i386.deb') system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c \ "apt-get install wget \ && wget ${EAT_URL} \ && dpkg -i eatmydata_26-2~lucid1_$arch.deb"
Pour Precise Pangolin le paquet est disponible dans les composants universe
qui a été activé lors de la création du schroot
.
system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- \ /bin/bash -c \ "apt-get install eatmydata"
Il faut ensuite ajouter une configuration au schroot
:
system@build:~$ sudo /bin/sh -c "cat >> `expr /etc/schroot/chroot.d/$dist-$arch-sbuild*` <<EOT command-prefix=eatmydata EOT "
Mettre à jour et nettoyer le schroot¶
Nous pouvons maintenant mettre à jour le schroot et supprimer les paquets inutiles :
system@build:~$ sbuild-update -udcar source:$dist-$arch-sbuild system@build:~$ schroot -u root -c source:$dist-$arch-sbuild -d /tmp -- debfoster -f