Guix

Science Reproductible

Je me présente …

pierre.gambarotto AT math.univ-toulouse.fr

• ASR dans un labo de math, l'IMT
• quelques «serveurs de calcul»
• environnement partagé: difficile à faire évoluer

=> à la recherche d'une solution !

• côté dev: 😍 programmation fonctionnelle
• côté ops: 😍 debian, puppet, automatisation

Reproductible Science

Reproductibilité ?

• arriver à le dire …
• arriver à le définir !

Contexte de la recherche

Pour démontrer la validité d'un résultat scientifique:

• publier le résultat
• donner les moyens à d'autres de reproduire le résultat de manière indépendante

Démarche

1. je monte un environnement
2. j'utilise cet environnement pour décrire/bâtir une expérience/validation
3. je veux donner les instructions pour que quelqu'un d'autre reproduise mon environnement

Science reproductible => Environnement reproductible

Traduction informatique

• environnement = environnement logiciel + architecture matérielle
• environnement = du code !

Du code …

• répétable : le même code a tourné (plusieurs fois?) avec les mêmes données sur la même machine et les résultats sont similaires ;
• reproductible : le même code a tourné avec les mêmes données sur une autre machine et les résultats sont similaires ;
• réplicable : un autre code a tourné avec les mêmes données sur une autre machine et les résultats sont similaires.

Environnement au sens unix

FHS

Gérer des paquetages logiciels

• apt-get/dpkg, yum/rpm, pkgadd …
• gestionnaire de paquetages

exemple de guile, empaqueté par debian:

https://packages.debian.org/source/stretch/guile-2.0

Source d'un paquetage

• où le trouver ? upstream
• dépendances de construction/d'exécution
• comment générer les versions binaires ?

• 1 paquetage source => n paquetages binaires
• peut gérer plusieurs architectures matérielles
• archive + metainformation : dépendances !
• installation dans un lieu commun : /usr/bin, /usr/lib, /var
• téléchargement automatique de binaires préconstruits, à partir d'archives signées

apt-get install guile

Le dur travail de mainteneur de paquetages

• langage de description du paquetage:
  • spécifier les métadonnées
  • spécifier comment bâtir à partir des sources
• langage de construction: bash, make, …

description => spécifique au gestionnaire de paquetage

construction => spécifique au logiciel

Avantages

• facilite la vie de l'admin
• gère de manière unifiée les endroits commun /usr/bin, /usr/lib …
• environnement utilisateur fixe
• gestion centralisée : sécurité, mises à jour
• mise en commun des dépendances
• optimisation mémoire (bibliothèque dynamique)

Inconvénients

• pas délégable à un utilisateur non-root
• plusieurs version d'un même produit (guile-1.8 et guile-2.0), environnement utilisateur à gérer
• fabriquer un paquetage est assez ardu
• état instable possible, notamment pendant les mises à jour
• pour des versions récentes, nécessite que toute la distribution soit mise à jour

«non délégable» à un simple utilisateur

À cause de la gestion du FHS ! /usr/bin, /usr/lib …

La gestion de cet espace commun est complexe

L'état général du système dépend

• des paquetages installés
• de l'ordre d'installation
• des sources de paquetages, de leur priorité
• des évolutions upstream

Solutions possibles

• arborescence privée: npm (js), rvm (ruby), virtualenv (python), maven(java), cargo (rust), stack(haskell), stow
• container : docker, lxc : gros problèmes de mises à jour, mais indépendance de la distribution de base
• archive contenant toutes les dépendances non basiques du produit : snaps/flatpak/appimage

=> idée globale: isoler une installation du reste de la distribution

Gestionnaire de paquetage fonctionnel

thèse d'Eelco Dolstra

• nix, 2003 langage de description spécifique, shell comme langage de construction
• guix, 2012, idem mais utilise scheme comme langage universel

Principe

À partir du graphe des dépendances

bash = f(readline, ncurses)
readline = g(ncurses)
ncurses = h(pkg-config)

f,g,h =~ wget puis ./configure; make; make install

• dérivation = résultat de la construction d'un paquet
• environnement isolé pour construire un paquetage
• chaque dérivation dans un répertoire séparé
• les répertoires sont non modifiables

Store guix

• tout est dans /gnu/store
• nom du répertoire: hash -nom_logiciel-version

$ ls -ald /gnu/store
drwxrwxr-t 757 root guixbuild 598016 juin  20 05:13 /gnu/store

Exemple

guix build bash # build from source
guix package --install=bash
# try to download, build if not found

guix build/package -i bash
# => /gnu/store/34vqyy26q...-bash-4.4.12
# 34vqyy26q... : hash de toutes les dépendances

Conséquence:

• reproductibilité de la construction d'un paquetage
• 2 versions différentes peuvent cohabiter

Liberté de l'utilisateur

guix permet à un utilisateur:

• de rajouter un logiciel dans le store
• de se composer un profil à partir des éléments du store
• de bâtir une version personnalisée d'un logiciel

Démo

$ guix install bash
substitute: mise à jour des substituts depuis « https://ci.guix.info »... 100.0%
Le paquet suivant sera installé :
   bash 4.4.23  /gnu/store/qn1ax1fkj16x280m1rv7mcimfmn9l2pf-bash-4.4.23

substitute: mise à jour des substituts depuis « https://ci.guix.info »... 100.0%
La dérivation suivante sera compilée :
   /gnu/store/iz3jjpmm7z849142lybmjqy97d9y50lg-profile.drv
Les crochets suivants seront compilés :
   /gnu/store/fgrj408cq39s48pmhvin9am1ngf25nfy-manual-database.drv
   /gnu/store/3lvvsja4ijg8jv9716hrwgbmj2pdgkqb-gtk-icon-themes.drv
   /gnu/store/5b0x42hrcmcglkdsc2cqa72j13ky3xin-fonts-dir.drv
   /gnu/store/72mc0jkp4xm0f23rc55aakdf47if1k6z-gtk-im-modules.drv
   /gnu/store/9132wsyg7s89jw6j6djr304r4r6gpq7m-xdg-mime-database.drv
   /gnu/store/98knvgqcbl46wn64nflza1787a9l9mcz-glib-schemas.drv
   /gnu/store/ixvviv4v7a0950k25ani16f0n1bv76nf-ca-certificate-bundle.drv
   /gnu/store/jga3lq39vw3w4w9zaq90xzvcp6xsd332-xdg-desktop-database.drv
   /gnu/store/vx2bwap1bfy22iifaz3l5wmfnvq5dak5-info-dir.drv

Gestion des profils utilisateurs

• une hiérarchie complète pour chaque utilisateur

Gestion du profil

• guix package gère automatiquement !
• guix package --list-generations
• guix package --roll-back
• guix package --switch-generations=24-

$ which bash # => /home/gamba/.guix-profile/bin/bash
$ guix package -l
Génération 25   20 juin 2019 05:13:26   (actuelle)
 + bash 4.4.23  out     /gnu/store/qn1ax1fkj16x280m1rv7mcimfmn9l2pf-bash-4.4.23
$ guix package --roll-back
passé de la génération 25 à 24
$ which bash # => /bin/bash
$ guix package -S 25

Guix en environnement partagé

• s'installe au-dessus de n'importe quel distro linux
• chaque utilisateur peut installer des softs
• chaque utilisateur peut gérer ses profils /var/guix/profile/per-user/
• HPC: /var/guix/ et /gnu/store gérés sur une machine, exportés en NFS sur le reste de la grappe
• boulôt de l'admin: guix gc de temps à autre: cron :-)

Scheme

guile, l'implémentation gnu de scheme est utilisée:

(define-public hello
  (package
    (name "hello")
    (version "2.10")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
    (build-system gnu-build-system)
    (synopsis "Hello, GNU world: An example GNU package")
    (description
     "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))

Adapter

modifier la conf normale d'un paquetage:

$ guix build hwloc \
--with-source=./hwloc-2.0rc1.tar.gz
...
$ guix package -i mumps --with-input=scotch=pt-scotch
...
$ guix package -i julia --with-input=fftw=fftw-avx
...

Reproductible Science !

Spécifier un environnement complet:

;; manifest.scm
(use-package-modules guile emacs)

(packages->manifest
 (list emacs
       guile-2.0
       ;; Use a specific package output.
       (list guile-2.0 "debug")))

guix package --manifest=manifest.scm

Guix pack

Pour reproduire un environnement crée dans guix sans guix

guix pack

$ guix pack -m manfifest.scm
# => tgz with /gnu/store
$ guix pack -m manifest.scm -S /opt/gnu/bin=bin
# idem, plus symlink created in /opt/gnu/bin !

Sur une autre machine:

# must be root :-(
$ cd /
$ tar zxf /path/to/pack.tgz
$ /opt/gnu/bin/… # to launch command 

Avec un linux récent (>3.19), on peut utiliser les user namespaces et se passer de root

$ mkdir /tmp/pack
$ cd /tmp/pack
$ tar xf /path/to/pack.tar.gz
$ unshare -mrf chroot . /opt/gnu/bin/guile --version
guile (GNU Guile) 2.2.0

Docker

$ guix pack -m manfifest.scm -S /opt/gnu=/ -f docker   

génère une image docker !

Cross-compiler

$ guix pack --target=arm-linux-gnueabihf -m manifest.scm

Conclusion

• 1.0 mai 2019, 9000 paquetages, communauté
• modèle nix/guix: révolutionnaire ! On casse le FHS en appliquuant des principes issues de la programmation fonctionnelle
• guix vs nix
• guix : faut aimer les gnous
• guixSD : distribution GNU/Linux basée sur guix
• apprendre scheme ~ 1/2 journée
• faire un premier paquetage guix ~ 1 journée

Reproductile builds

Reproducible builds

independently-verifiable path from source to binary code

Debian Reproductible Builds

Reproductible Science

• Software Heritage : pour reproduire dans le futur, il faut garder les sources
• Guix : pour reproduire les environnements à partir des sources
• ReScience : implémentation open-source répliquant des résultats de recherche déjà publiés, pour assurer que la recherche original est reproductible

Crédits documentaires

• présentations guix officielles : https://git.savannah.gnu.org/git/guix/maintenance.git

tous les jolis schémas ont été repris dans des présentations officielles de guix

• xkcd: https://imgs.xkcd.com