Guix System - OS Reproductible bit-par-bit

Récemment, j'ai testé pas mal de distributions Linux, à la recherche de quelque chose de minimaliste, juste le nécessaire, rien de superflu. Je voulais un système sur-mesure, taillé pour mes besoins.

Je me suis d'abord tourné vers NixOS. J'ai monté ma config, tout fonctionnait correctement, mais quelque chose me gênait. Le langage Nix, bien que puissant, me semblait limité. Je voulais plus qu'un DSL de configuration, je voulais un vrai langage de programmation, un contrôle total sur mon système.

Guix system

C'est là que j'ai découvert Guix System, un système d'exploitation basé sur le gestionnaire de paquets GNU Guix, entièrement programmable en Guile Scheme.

Contrairement à NixOS, Guix s'appuie sur un langage de programmation complet. Ma configuration n'est pas juste déclarative, elle est programmable. Je peux factoriser mon code, créer des abstractions, composer des fonctions. La reproductibilité est garantie : même configuration = même système, bit par bit. Et en cas de problème, je peux revenir instantanément à n'importe quelle génération précédente au boot.

Ce qui me plaît

Tout en Scheme. Ma configuration système est du code Scheme que je peux manipuler comme n'importe quel programme. Pas de YAML rigide, pas de syntaxe limitée, juste un langage complet avec toute sa puissance.

La reproductibilité réelle. Avec les dérivations, chaque package est construit de manière déterministe. Je peux recréer mon système exact sur n'importe quelle machine, ou partager des environnements de dev identiques avec mes collègues.

Les profils

Sous Guix, un profil est une collection isolée de paquets définie en Scheme. Concrètement, c'est un fichier manifest qui liste les paquets que vous voulez dans cet environnement.

L'intérêt ? Vous pouvez avoir plusieurs profils distincts sur la même machine. Un pour le développement Go, un pour Python, un autre pour vos outils système sans qu'ils n'interfèrent entre eux. Chaque profil pointe vers ses propres packages dans le /gnu/store, et vous pouvez activer/désactiver un profil à la demande.

(specifications->manifest
 '("docker"
   "ansible"
   "kubectl"))

Avec ce fichier, on obtient un profil avec docker, ansible et kubectl de façon isolé.

Chaque paquet listé dans le manifest est une dérivation qui produit un output dans /gnu/store/hash-nom-version/. Chaque output contient typiquement un dossier bin/, mais aussi lib/, share/, etc.

Le profil lui-même génère aussi un output dans /gnu/store/. C'est une dérivation qui agrège tous les paquets du manifest. Son dossier bin/ ne contient que des symlinks pointant vers les binaires des paquets individuels.

Résultat : quand vous activez un profil, vous ajoutez simplement /gnu/store/xyz-profile/bin à votre $PATH, et tous les outils deviennent disponibles sans dupliquer les fichiers. Si deux profils utilisent le même package, ils partagent le même store path. Zéro duplication.

Guix Home

Guix Home fonctionne sur le même principe que les profils, mais gère l'environnement utilisateur complet de manière déclarative.

Alors qu'un profil se limite à une liste de paquets, Guix Home va plus loin :

• Installation de paquets pour l'utilisateur
• Gestion des dotfiles (.bashrc, .vimrc, config Emacs...)
• Déploiement de services utilisateur (syncthing, gpg-agent, redshift...)
• Variables d'environnement personnalisées

Comme pour le système, tout est défini en Scheme dans un fichier home-configuration.scm. Guix Home génère des dérivations pour votre configuration, crée les symlinks vers vos dotfiles dans ~/.config/, et gère les services via systemd user ou Shepherd.

(home-environment
  (packages (list vim git htop))
  (services
   (list
    (service home-bash-service-type
             (home-bash-configuration
              (aliases '(("ll" . "ls -lah")
                        ("gs" . "git status"))))))))

Résultat : vos dotfiles et environnement deviennent versionnables, reproductibles, et peuvent être déployés sur n'importe quelle machine avec guix home reconfigure.

Ma configuration en litterate programming

Ma configuration de mon home est entièrement en litterate programming, voici un schéma du fonctionnement de ma config :

Lorsque j'applique le fichier home.scm, voici comment il applique ma configuration :

De façon plus concrète, voici à quoi ressemble mon fichier de configuration pour Emacs.

Cela ressemble beaucoup à Jupyter par exemple, lorsque je sauvegarde, cela tangle automatiquement mes bouts de code dans un fichier de configuration, et ainsi après, guix home va les récupérer.

Cela me garanti d'avoir une configuration super intuitive mais également d'avoir une configuration 100% reproductible puisque je manipule du code scheme qui se transforme en configuration système.