Gestion de paquets évoluée avec Nix : cachix, overlays et home‑manager

Posté par (page perso) . Édité par MmeQuignon, Davy Defaud, ZeroHeure, Guillaum et palm123. Modéré par patrick_g. Licence CC by-sa.
Tags :
39
25
nov.
2019
Administration système

Nix est un gestionnaire de paquets dont les débuts remontent à 2003. Il a pour but de rendre la gestion de paquets fiable, reproductible et personnalisable. Il permet notamment de faire des mises à jour atomiques, d’annuler des mises à jour, d’installer des multiples versions d’un même paquet, de définir précisémment des environnements logiciels… Il peut être installé sur n’importe quelle distribution GNU/Linux et sur macOS. Enfin, Nix a également inspiré un projet assez similaire : GNU Guix.

De nombreux outils ont été développés sur la base de Nix : la logithèque Nixpkgs, la distribution GNU/Linux NixOS, l’outil de déploiement de machines Nixops, le système de construction et de cache de paquets binaires Hydra, l’outil de construction d’images Docker Docker Tools, etc.

Cette dépêche présente trois outils très pratiques pour gérer son environnement utilisateur : un service de cache de paquets binaires (Cachix), un outil de personnalisation de la logithèque (Overlays) et un outil de configuration de l’environnement utilisateur (home‑manager).

Sommaire

Cachix

Cachix permet de gérer facilement un cache personnel de paquets binaires. Concrètement, il s'agit d'un service de cloud et d'un logiciel client, le tout basé sur le gestionnaire de paquets Nix. Cachix propose différentes offres, dont une offre gratuite de 10 Go de stockage en accès public.

Quand on utilise la logithèque officielle de Nix, on télécharge des paquets binaires déjà compilés. Nix permet très facilement d'empaqueter des programmes/bibliothèques personnels ou de modifier les paquets officiels. Mais dans ce cas, les paquets binaires correspondants ne sont pas dans le cache officiel et doivent donc être compilés sur la machine locale. Cachix permet d'envoyer les paquets binaires ainsi compilés sur un serveur. On peut alors récupérer ces paquets sur d'autres machines sans avoir à recompiler.

Exemple de cas d’utilisation

Imaginons qu'on a développé une bibliothèque personnelle tuto38lib, potentiellement longue à compiler, et qu'on l'utilise désormais pour développer un projet tuto38appli. Ces deux projets sont empaquetés via Nix, si bien qu'on peut intégrer tuto38lib dans tuto38appli avec le fichier tuto38appli/default.nix suivant :

{ pkgs ? import <nixpkgs> {} }:

let 

  tuto38lib-src = pkgs.fetchzip {
    url = "https://gitlab.com/nokomprendo/tuto38lib/-/archive/v1.0/tuto38lib-v1.0.tar.gz";
    sha256 = "1di8ms0g1j9kih9qg1s42p9wi5xxbm7h3n9as6fbxqfbfa75w9nf";
  };

  tuto38lib = pkgs.callPackage tuto38lib-src {};

in pkgs.stdenv.mkDerivation {
  name = "tuto38appli";
  src = ./.;
  buildInputs = with pkgs; [ cmake tuto38lib ];
}

Pour travailler sur le projet tuto38appli, il suffit de récupérer le code et de lancer un nix-shell. Toutes les dépendances sont récupérées et on peut alors travailler sur le projet. Ici il s'agit d'un projet C++/Cmake :

$ nix-shell 
these derivations will be built:
  /nix/store/zasgjbqnp89nnzb3fyrvi0daq2bwnacq-tuto38lib.drv
building '/nix/store/zasgjbqnp89nnzb3fyrvi0daq2bwnacq-tuto38lib.drv'...
unpacking sources
...

[nix-shell]$ mkdir build

[nix-shell]$ cd build/

[nix-shell]$ cmake ..
...

[nix-shell]$ make
...

[nix-shell]$ ./tuto38appli 
42

[nix-shell]$ exit

On constate que pour tuto38lib, le code source est récupéré, compilé et installé sur la machine locale, dans le /nix/store. Ainsi, si on lance de nouveau un nix-shell utilisant tuto38lib, cette bibliothèque est déjà sur le système local et n'est donc pas recompilée.

$ find /nix/store -maxdepth 1 -name "*tuto38lib*"
/nix/store/zasgjbqnp89nnzb3fyrvi0daq2bwnacq-tuto38lib.drv
/nix/store/js0gbdilqjg3y9yhpjfc7slja902kfxy-tuto38lib

$ nix-shell 

[nix-shell]$

Si on nettoie les paquets de tuto38lib dans le /nix/store ou qu'on passe une autre machine, tuto38lib n'est plus disponible. Si on lance un nix-shell dans le projet tuto38appli, la bibliothèque tuto38lib est donc de nouveau téléchargée, compilée et installée.

$ find /nix/store -maxdepth 1 -name "*tuto38lib*" -exec nix-store --delete {} 
finding garbage collector roots...
deleting '/nix/store/js0gbdilqjg3y9yhpjfc7slja902kfxy-tuto38lib'
deleting '/nix/store/h85xxfmc0lf5g8srhv7jqr8kbjdijia1-tuto38appli.drv'
deleting '/nix/store/ss39dl3l4y0kbccpkjzr4dbypr0fz5c2-tuto38appli.drv'
deleting '/nix/store/zasgjbqnp89nnzb3fyrvi0daq2bwnacq-tuto38lib.drv'
deleting '/nix/store/trash'
deleting unused links...
note: currently hard linking saves -0.00 MiB
4 store paths deleted, 0.02 MiB freed

$ nix-shell 
these derivations will be built:
  /nix/store/zasgjbqnp89nnzb3fyrvi0daq2bwnacq-tuto38lib.drv
building '/nix/store/zasgjbqnp89nnzb3fyrvi0daq2bwnacq-tuto38lib.drv'...
unpacking sources
...

[nix-shell]$

Cachix permet de mettre les paquets binaires produits par la première compilation sur un serveur et de récupérer ensuite ces paquets sans avoir à les recompiler.

Installation du client cachix

Sur NixOS, ceci est assez simple. Il suffit d'éditer le fichier /etc/nixos/configuration.nix pour ajouter le paquet cachix et spécifier l'utilisateur (ici nokomprendo) dans les trustedUsers :

  environment.systemPackages = with pkgs; [
    cachix
    ...
  ];

  nix.trustedUsers = [ "nokomprendo" "root" ];

Il faut ensuite mettre à jour la configuration du système :

$ sudo nixos-rebuild switch

Et, éventuellement, nettoyer le cache du root :

$ sudo rm -rf /root/.cache/nix

Création d’un dépôt de cache

Tout est expliqué sur le site de cachix. Il faut d'abord se connecter (via un compte github) puis créer un dépôt de cache (par exemple, tuto38).

On génère ensuite une clé d'authentification du dépôt :

cachix authtoken ...
...

Et une clé de signature :

$ cachix generate-keypair tuto38
...

Mettre en cache des paquets

La commande cachix push permet d'envoyer dans un cache, un paquet local et ses dépendances :

$ cachix push tuto38 /nix/store/js0gbdilqjg3y9yhpjfc7slja902kfxy-tuto38lib
pushing /nix/store/4l35nqpaiwzhfafrpby1xf7kfik7ai7c-gcc-8.3.0-lib
...

Utilisation du cache

La commande cachix use indique à Nix qu'il faut regarder dans un dépôt de cache si un paquet binaire n'est pas déjà disponible.

$ cachix use tuto38

Par exemple, avec le projet tuto38appli précédent, si on nettoie l'installation locale de tuto38lib et qu'on lance de nouveau un nix-shell, c'est désormais le paquet binaire qui est directement téléchargé du cache et installé sur la machine.

$ find /nix/store -maxdepth 1 -name "*tuto38lib*" -exec nix-store --delete {} 
...

$ nix-shell 
these paths will be fetched (0.00 MiB download, 0.02 MiB unpacked):
  /nix/store/js0gbdilqjg3y9yhpjfc7slja902kfxy-tuto38lib
copying path '/nix/store/js0gbdilqjg3y9yhpjfc7slja902kfxy-tuto38lib' from 'https://tuto38.cachix.org'...

[nix-shell]$

Overlays

Le gestionnaire de paquets Nix est hautement personnalisable. Pour cela, il reprend le principe de la composition de fonctions : un paquet est en fait une fonction qui indique comment ajouter ou modifier un logiciel à partir d'un environnement logiciel d'entrée.

Ainsi, la logithèque Nix n'est qu'un ensemble de paquets qui peuvent être appliqués pour construire l'environnement logiciel final. Les overlays permettent de modifier les paquets de cet ensemble ou d'en ajouter de nouveaux.

Principe des overlays Nixpkgs

Pour ajouter un paquet personnel ou pour modifier un paquet déjà existant, Nix permet d'ajouter des overlays. Concrètement, il s'agit de fichiers Nix que l'on place dans le dossier ~/.config/nixpkgs/overlays/. Ces overlays sont alors appliqués automatiquement sur la logithèque.

Par exemple, si on ajoute le fichier ~/.config/nixpkgs/overlays/monOverlay1.nix suivant, on modifie le paquet boost de la logithèque et on y ajoute un paquet monAppli :

self: super: {

  boost = super.boost.override {
    python = self.python3;
  };

  monAppli = super.callPackage ./pkgs/monAppli.nix {};

}

Dans cet overlay, self et super sont les paramètres de la fonction à appliquer sur la logithèque d’entrée ; super est la version initiale de la logithèque et self la version modifiée.

Ces modifications seront alors automatiquement appliquées, par exemple si on installe un de ces paquets ou si on lance un nix-shell qui les utilisent.

Les overlays sont détaillés dans le manuel de nixpkgs et dans le wiki nixos.

Exemple avec GNU Nano

Prenons le paquet GNU Nano et modifions-le grâce aux overlays Nixpkgs.

Le paquet de base

Ici, le paquet de base de GNU nano est la version 4.4 compilée avec les options --disable-libmagic et --enable-utf8.

$ nano --version
 GNU nano, version 4.4
 (C) 1999-2011, 2013-2019 Free Software Foundation, Inc.
 (C) 2014-2019 les contributeurs de nano
 Adr. él. : nano@nano-editor.org   Site : http://nano-editor.org/
 Compilé avec les options : --disable-libmagic --enable-utf8

Paramétrer le paquet de base

Les paquets Nix peuvent avoir des paramètres. Par exemple, le paquet nano de base contient le paramètre enableNls ? true, qui permet de régler l'option de compilation nls et est activée par défaut. Si on veut créer un paquet nano-no-nls qui reprend ce paquet mais en désactivant l'option nls, on peut ajouter le fichier ~/.config/nixpkgs/overlays/nano-no-nls.nix suivant :

self: super: {

  nano-no-nls = super.nano.override {
    enableNls = false;
  };

}

On peut alors installer notre nouveau paquet nano-no-nls (qui sera compilé automatiquement) et vérifier que nano est désormais notre version personnalisée :

$ nix-env -iA nixos.nano-no-nls
installing 'nano-4.4'
these derivations will be built:
  /nix/store/6pg25sqj2vv2jq8dn00ajbc9xx2s96r3-nano-4.4.drv
...

$ nano --version
 GNU nano, version 4.4
 (C) 1999-2011, 2013-2019 Free Software Foundation, Inc.
 (C) 2014-2019 the contributors to nano
 Email: nano@nano-editor.org    Web: https://nano-editor.org/
 Compiled options: --disable-libmagic --disable-nls --enable-utf8

Redéfinir le paquet de base

Nix permet de modifier les paquets encore plus profondément. Par exemple, on peut modifier le paquet existant nano de façon à utiliser la version 4.5 du code source de nano :

self: super: {

  nano = super.nano.overrideAttrs (oldAttrs: rec {
    pname = oldAttrs.pname;
    version = "4.5";
    src = super.fetchurl {
      url = "mirror://gnu/nano/${pname}-${version}.tar.xz";
      sha256 = "0czmz1yq8s5qcxcmfjdxzg9nkhbmlc9q1nz04jvf57fdbs7w7mfy";
    };
  });

}

Cet overlay reprend certains attributs du paquet initial (pname) et en modifie certains autres (version, src).

Si on installe le paquet nano, l'overlay est appliqué et on se retrouve bien avec la version 4.5 :

$ nix-env -iA nixos.nano
replacing old 'nano-4.4'
installing 'nano-4.5'
these derivations will be built:
  /nix/store/cg60jqfw8fk4fkkamvjrhhkkas79z0w2-nano-4.5.drv
these paths will be fetched (1.42 MiB download, 1.42 MiB unpacked):
  /nix/store/pbs1pf1vsk4zx6zis9a352j9lz88jrx2-nano-4.5.tar.xz
...

$ nano --version
 GNU nano, version 4.5
 (C) 1999-2011, 2013-2019 Free Software Foundation, Inc.
 (C) 2014-2019 les contributeurs de nano
 Adr. él. : nano@nano-editor.org   Site : http://nano-editor.org/
 Compilé avec les options : --disable-libmagic --enable-utf8

Mise en cache des paquets recompilés, avec cachix

Les overlays sont compatibles avec cachix, le service cloud de cache binaire. Par exemple, si on veut mettre en cache notre paquet nano 4.5 dans le dépôt de cache nokomprendo, on utilise la commande habituelle cachix push :

$ find /nix/store -maxdepth 1 -name "*nano-4.5*" -exec cachix push nokomprendo {} \;
pushing /nix/store/23wg5gf404zmnn8fixrg8rm38f06hqny-ncurses-6.1-20190112
pushing /nix/store/pnd2kl27sag76h23wa5kl95a76n3k9i3-glibc-2.27
pushing /nix/store/qq8nfcxvak3iic0dvw1dfk3jnr9acv4m-nano-4.5
...

Pour tester notre cache, on peut annuler l'installation de nano-4.5 et nettoyer les fichiers correspondants dans le /nix/store :

$ nix-env --rollback 
switching from generation 32 to 31

$ nix-env --delete-generations 32
removing generation 32

$ find /nix/store/ -maxdepth 1 -name "*nano-4.5*" -exec nix-store --delete {} 
finding garbage collector roots...
deleting '/nix/store/cg60jqfw8fk4fkkamvjrhhkkas79z0w2-nano-4.5.drv'
deleting '/nix/store/9csadwrlh6yvxl55143y55i8jx893k09-nano-4.5.tar.xz.drv'
deleting '/nix/store/jg6kivw3b0c2dak03ylvsn72jnd38774-nano-4.5-info'
deleting '/nix/store/pbs1pf1vsk4zx6zis9a352j9lz88jrx2-nano-4.5.tar.xz'
deleting '/nix/store/s9y641283gbkv1wpsnl5yr4b8vqsja0r-user-environment'
deleting '/nix/store/yjh8mcpxbyq8qbb6ndw6jizd3knfsclg-user-environment.drv'
deleting '/nix/store/y0856674ymjdzp277scsvg3qa084381i-env-manifest.nix'
deleting '/nix/store/qq8nfcxvak3iic0dvw1dfk3jnr9acv4m-nano-4.5'
deleting '/nix/store/trash'
deleting unused links...
note: currently hard linking saves -0.00 MiB
8 store paths deleted, 3.68 MiB freed

Désormais, si on active le cache et qu'on lance l'installation de notre paquet nano-4.5, Nix ne recompile pas le paquet mais télécharge directement le binaire depuis le cache :

$ cachix use nokomprendo
Configured https://nokomprendo.cachix.org binary cache in /home/nokomprendo/.config/nix/nix.conf

$ nix-env -iA nixos.nano
installing 'nano-4.5'
these paths will be fetched (0.51 MiB download, 2.19 MiB unpacked):
  /nix/store/jg6kivw3b0c2dak03ylvsn72jnd38774-nano-4.5-info
  /nix/store/qq8nfcxvak3iic0dvw1dfk3jnr9acv4m-nano-4.5
copying path '/nix/store/jg6kivw3b0c2dak03ylvsn72jnd38774-nano-4.5-info' from 'https://nokomprendo.cachix.org'...
copying path '/nix/store/qq8nfcxvak3iic0dvw1dfk3jnr9acv4m-nano-4.5' from 'https://nokomprendo.cachix.org'...
building '/nix/store/yjh8mcpxbyq8qbb6ndw6jizd3knfsclg-user-environment.drv'...
created 1185 symlinks in user environment

$ nano --version
 GNU nano, version 4.5
 (C) 1999-2011, 2013-2019 Free Software Foundation, Inc.
 (C) 2014-2019 les contributeurs de nano
 Adr. él. : nano@nano-editor.org   Site : http://nano-editor.org/
 Compilé avec les options : --disable-libmagic --enable-utf8

Home-manager

Home-manager est un outil qui permet de gérer son environnement utilisateur : environnement de bureau, thème de fenêtre, thème d'icones, logiciels, paramètres des logiciels, services utilisateur, "dot files"…

Home-manager est prévu pour fonctionner sur la distribution linux NixOS et utilise le gestionnaire de paquets Nix.

Présentation de home-manager

Pour faire simple, le but de home-manager est de fournir l'équivalent du fichier /etc/nixos/configuration.nix mais pour l'environnement utilisateur (au lieu de l'environnement système). Plus précisemment, l'utilisateur décrit sa configuration via un fichier ~/.config/nixpkgs/home.nix et lance une commande home-manager pour construire et installer la configuration correspondante.

Home-manager est capable de gérer finement l'environnement logiciel. Il permet non seulement d'indiquer l'environnement de bureau, les logiciels et les services à installer mais également de paramètrer tous ces éléments. Par exemple, home-manager peut configurer le user.name de git, les extensions de firefox, la police de caractères de vscode

Attention, home-manager n'est pas un outil officiel de Nix. Il est encore en développement, et donc incomplet. Enfin, il est prévu pour NixOS; son fonctionnement sur une autre distribution n'est pas garanti.

Voir le site officiel de home-manager et le wiki NixOS.

Installation

Home-manager est fourni dans les dépôts de paquets de Nix. Il est donc très simple à installer. Deux méthodes sont proposées.

Installation autonome

$ nix-env -iA nixos.home-manager

Installation modulaire

# nix-channel --add https://github.com/rycee/home-manager/archive/release-19.09.tar.gz home-manager

Il suffit ensuite de mettre à jour le système et d'importer home-manager dans votre /etc/nixos/configuration.nix.

imports = [ <home-manager/nixos> ];

Chacune des méthodes propose ses avantages :

  • L'installation autonome permet à l'utilisateur de modifier lui-même sa configuration alors qu'il faut avoir les droits administrateur dans le cas d'une installation modulaire.
  • L'intallation modulaire permet d'avoir l'intégralité de la configuration dans un seul dossier, ce qui permet de versionner plus facilement sa configuration et de mettre à jour l'intégralité du système avec une unique commande.

note : L'installation autonome peut se faire sur n'importe quel système, tandis que l'installation de home-manager en tant que module n'est disponible que sur NixOs.

Dans les exemples suivants, la méthode utilisée se base sur l'installation autonome.

Voir la documentation.

Premier exemple de configuration utilisateur

Le point d'entrée d'une configuration home-manager est le fichier ~/.config/nixpkgs/home.nix. Par exemple, le fichier suivant installe les logiciels geany, meld et vlc, et configure le clavier en français bépo.

{ pkgs, ... }: {

  home.packages = with pkgs; [
    geany
    meld
    vlc
  ];

  home.keyboard = {
    layout = "fr";
    variant = "bepo";
  };

}

Home-manager est documenté dans les pages man. Pour connaitre les options de configuration disponibles, il suffit de lancer :

$ man home-configuration.nix

Enfin, pour installer ou mettre à jour la configuration, on lance la commande :

$ home-manager switch

Séparer les fichiers de configuration

Pour éviter d'avoir un gros fichier home.nix difficile à lire, on peut le découper en plusieurs fichiers. Par exemple, on peut mettre les logiciels à installer dans un fichier ~/.config/nixpkgs/packages.nix :

{ pkgs, ... }: {

  home.packages = with pkgs; [
    geany
    meld
    vlc
  ];

}

et importer ce fichier dans le ~/.config/nixpkgs/home.nix :

{ pkgs, ... }: {

  imports = [
    ./packages.nix
  ];

  home.keyboard = {
    layout = "fr";
    variant = "bepo";
  };
}

Configurer des logiciels utilisateur

Home-manager permet de régler les paramètres de certains programmes. Par exemple, on peut ajouter le code suivant dans le home.nix pour installer firefox et bash (avec des alias shell) :

  programs = {

    firefox.enable = true;

    bash = {
      enable = true;
      shellAliases = {
        ll = "ls -lh";
        la = "ls -a";
      };
    };

  };

Autre exemple, on peut configurer git dans un fichier git.nix, que l'on importera dans home.nix :

{ pkgs, ... }: {

  programs.git = {
    enable = true;
    userName = "nokomprendo";
    userEmail = "nokomprendo@example.com";

    ignores =  [
      "*~"
      "*.swp"
    ];

}

Après mise à jour, le client git est configuré :

$ home-manager switch
...

$ git config --get user.name
nokomprendo

Configurer l’environnement de bureau

Home-manager peut configurer le thème de fenêtre et le thème d'icones. Par exemple, pour un thème "dark" :

  gtk = {
    enable = true;
    iconTheme = {
      name = "Adwaita";
      package = pkgs.gnome3.adwaita-icon-theme;
    };
    theme = {
      name = "Shades-of-gray";
      package = pkgs.shades-of-gray-theme;
    };
  };

  qt = {
    enable = true;
    platformTheme = "gtk";
  };

Home-manager peut également configurer finement certains environnements de bureau. Par exemple, avec i3 :

  xsession.enable = true;

  xsession.windowManager.i3 = {
    enable = true;
    config = let mod = "Mod4"; in {
      fonts = [ "DejaVu Sans 12" ];
      modifier = mod;
      keybindings = pkgs.lib.mkOptionDefault {
        "${mod}+m" = "exec ${pkgs.i3lock}/bin/i3lock -n -c 000000";
      };
    };
  };

Penser, dans ce cas, à activer le paquet dconf du service dbus, dans /etc/nixos/configuration.nix :

  services.dbus.packages = [ pkgs.gnome3.dconf ];

Gérer des « dot files »

Home-manager suit le fonctionnement habituel de Nix. Par exemple, quand on configure bash dans le home.nix (cf précédemment), Nix crée un fichier de configuration .bashrc dans le /nix/store et ajoute un lien symbolique dans le dossier utilisateur :

$ ll ~/.bashrc 
lrwxrwxrwx 1 toto users 70 11 nov.  15:48 /home/toto/.bashrc 
  -> /nix/store/z2arwbwyhvvwhy2caazlxasw5jnscyg3-home-manager-files/.bashrc

Cependant, home-manager peut également gérer des "dot files" classiques. Par exemple, on peut centraliser des "dot files" dans le dossier ~/.config/nixpkgs/ et demander à home-manager de les gérer, via le home.nix (il va alors les copier dans le /nix/store et créer les liens symboliques) :

  home.file.".i3status.conf".source = ./i3status.conf;

Utiliser les overlays et cachix

Comme home-manager est basé sur Nix, on peut utiliser les outils Nix classiques, comme les overlays ou cachix.

Par exemple, on peut empaqueter le plugin Vim minibufexpl en ajoutant un fichier dans le dossier ~/.config/nixpkgs/overlays/ :

self: super: {
  vimPlugins = super.vimPlugins // {
    minibufexpl = super.vimUtils.buildVimPluginFrom2Nix { 
      name = "minibufexpl.vim-2013-06-16";
      src = self.fetchgit {
        url = "https://github.com/fholgado/minibufexpl.vim";
        rev = "ad72976ca3df4585d49aa296799f14f3b34cf953";
        sha256 = "1bfq8mnjyw43dzav8v1wcm4rrr2ms38vq8pa290ig06247w7s7ng";
      };
      dependencies = [];
    };
  };
}

On peut ensuite utiliser ce plugin dans notre configuration Vim. Si on a déjà empaqueté ce plugin sur une autre machine et envoyé le paquet binaire sur un dépôt cachix, on peut utiliser ce cache et éviter de reconstruire le paquet :

$ cachix use nokomprendo
Configured https://nokomprendo.cachix.org binary cache in /home/toto/.config/nix/nix.conf

$ home-manager switch
...
copying path '/nix/store/2pkqy6nv5vmqq6cw7zhyd44qw7vigg4l-vimplugin-minibufexpl.vim-2013-06-16' 
  from 'https://nokomprendo.cachix.org'...
...

Conclusion

Nix est un gestionnaire de paquets suffisamment solide et évolutif pour servir de base à de nombreux outils, ciblant du paquet logiciel au parc de machines en passant par les services. Les trois outils présentés dans cette dépêche sont plutôt destinés à gérer un environnement utilisateur.

Cachix permet de mettre en cache des paquets binaires Nix pour pouvoir les récupérer ultérieurement sans avoir à les recompiler. Il est très pratique pour récupérer plus rapidement des paquets personnels ou des paquets officiels modifiés, par exemple pour mettre en place un environnement logiciel local ou pour optimiser un processus d’intégration continue. Dans un environnement Nix, cachix est facile à mettre en place et à utiliser. Enfin, il est assez complémentaire avec Hydra, qui permet de dérouler une intégration continue et de générer des paquets binaires mais qui est plus difficile à mettre en place.

Avec les overlays, Nix permet de modifier très facilement la logithèque (ajouter des nouveaux paquets, modifier les paquets existants…). Pour cela, il suffit d'ajouter nos fichiers d'overlays dans le dossier ~/.config/nixpkgs/overlays/ et les modifications correspondantes seront automatiquement appliquées. Les overlays s'intègrent complétement à l'écosystème Nix; on peut notamment mettre en cache les binaires générés et les réutiliser sur une autre machine sans avoir à les recompiler.

Enfin, Home-manager est un outil basé sur Nix et qui permet de configurer son environnement utilisateur. Le projet est encore en développement mais il est déjà très exploitable, s'intègre bien avec l'écosystème Nix et apporte des fonctionnalités intéressantes : spécifier et paramétrer l'environnement de bureau, les thèmes et les logiciels, gérer des "dot files" classiques, utiliser des overlays, utiliser cachix, etc.

Aller plus loin

Envoyer un commentaire

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.