Nix est un gestionnaire de packages fonctionnel pour Linux et d’autres systèmes Unix, rendant la gestion des packages plus fiable et reproductible.

Avec un gestionnaire de packages traditionnel, lors de la mise à jour d’un package, une nouvelle version est téléchargée et utilisée pour écraser les fichiers associés. Les modifications ne peuvent pas être annulées. Si pour une raison quelconque, un ou plusieurs fichiers ne sont pas correctement mis à jour lors de la mise à jour, ces fichiers du package vont être corrompus. Cela pourrait rendre l’ensemble du package non fonctionnel. De plus, si différents packages nécessitent différentes versions du même package en tant que dépendance, au moins un sera cassé.

Cet article présente le gestionnaire de packages Nix, comment le déployer et comment faire ses premiers pas avec. Dans l’article suivant, nous couvrons l’installation de NixOS, une distribution Linux reposant intégralement sur Nix.

Qu’est-ce que Nix

Nix est un gestionnaire de packages fonctionnel. Vous trouverez ci-dessous les trois principaux avantages de l’utilisation de Nix par rapport à un gestionnaire de packages traditionnel :

• Nix apporte la fiabilité : l’installation ou la mise à jour d’un paquet n’endommage pas les autres paquets. Il garantit qu’aucun package n’est incohérent lors d’une mise à niveau. Il est possible de revenir aux versions précédentes.
• Nix apporte la reproductibilité : les packages sont construits par Nix indépendamment les uns des autres. Cela garantit qu’ils sont reproductibles et n’ont pas de dépendances non déclarées, donc si un paquet fonctionne sur une machine, il fonctionne sur une autre.
• Nix est déclaratif : Nix facilite le partage des environnements de développement et de construction pour les projets, quels que soient les langages de programmation et les outils utilisés.

Avec Nix, les fichiers sont associés à des liens symboliques. Lorsqu’un paquet est installé, les liens symboliques pointent vers un emplacement à l’intérieur du répertoire Nix store, situé dans /nix/store. Lors de la mise à jour d’un package, les nouveaux fichiers de package sont extraits à un emplacement différent (pas d’écrasement), les liens symboliques pointent alors vers l’emplacement des nouveaux fichiers.

L’utilisation de liens symboliques pour faire référence à des packages présente certains avantages :

• Aucun risque de corruption entre dépendances : plusieurs versions d’une même dépendance peuvent être installées
• Moins d’exigence de stockage : la même version d’une dépendance n’est pas dupliquée

Le processus de mise à niveau d’un package crée ce que Nix appelle une génération. Il est possible de revenir en arrière et d’avancer dans les générations précédentes. Cela laisse le système entièrement fonctionnel car on peut toujours revenir à une génération précédente. Il est possible de sauvegarder et de conserver autant de générations que l’on veut. L’inconvénient est l’espace disque utilisé pour stocker les générations, mais il est possible de nettoyer les anciennes générations.

Déploiement Nix

Nix peut être déployé sur un système d’exploitation existant, Linux ou macOS, ou en utilisant NixOS qui l’utilise à partir de zéro pour créer un système Linux.

Déploiement via NixOS

NixOS est une distribution Linux construite sur Nix. L’installation de NixOS est similaire à celle d’une distribution Linux alternative : partitionnement et formatage du disque avant l’installation du système d’exploitation. La documentation officielle donne les étapes à suivre pour déployer Nix via l’installation de NixOS.

Déploiement sur un système d’exploitation existant

Nix est pris en charge sur Linux (i686, x86_64, aarch64) et macOS (x86_64, aarch64). Voici les commandes pour installer Nix :

-Linux

• Pour une installation multi-utilisateurs

  sh <(curl -L https://nixos.org/nix/install) --daemon

• Pour une installation monoposte :

  sh <(curl -L https://nixos.org/nix/install) --no-daemon

-MacOS :

sh <(curl -L https://nixos.org/nix/install)

Suivez la Documentation officielle pour en savoir plus sur l’installation sur un système d’exploitation existant.

Utilisation de Nix

Environnement utilisateur

Un environnement utilisateur est un ensemble d’applications actives. Différents utilisateurs peuvent avoir différents environnements et des utilisateurs individuels peuvent basculer entre différents environnements. ~/.nix-profile est un lien symbolique vers l’environnement utilisateur actuel.

La gestion d’un environnement utilisateur se fait soit via une configuration déclarative à l’aide de Home Manager, soit via des opérations impératives à l’aide des commandes nix-env.

Home Manager

Home Manager est le meilleur moyen de gérer les environnements des utilisateur. Il offre une configuration déclarative pour déployer des packages et de fichiers spécifiques à l’utilisateur dans son répertoire personnel. Il s’installe via les commandes :

nix-channel --add https://github.com/nix-community/home-manager/archive/master.tar.gz home-manager
# If you follow a Nixpkgs version 21.11 channel, run nix-channel add https://github.com/nix-community/home-manager/archive/release-21.11.tar.gz home-manager instead of the command below
nix-channel --update
nix-shell '<home-manager>' -A install
home-manager edit

La commande home-manager edit installe Home Manager, initialise et expose le fichier de configuration de Home Manager situé dans .config/nixpkgs/home.nix.

Chaque fois que quelque chose change dans le fichier de configuration de Home Manager, la commande ci-dessous crée et active la configuration pour l’utilisateur.

home-manager switch

Vous trouverez ci-dessous une version modifiée du fichier home.nix pour installer le package firefox et configurer la configuration de git.

{ config, pkgs, ... }:

{
  # Home Manager needs a bit of information about you and the
  # paths it should manage.
  home.username = "florent";
  home.homeDirectory = "/home/florent";

  # Packages to install
  home.packages = [
    # pkgs is the set of all packages in the default home.nix implementation
    pkgs.firefox
  ];

  # Git config using Home Manager
  programs.git = {
    enable = true;
    userName = "Florent";
    userEmail = "florent@adaltas.com";
  };

  # This value determines the Home Manager release that your
  # configuration is compatible with. This helps avoid breakage
  # when a new Home Manager release introduces backwards
  # incompatible changes.
  #
  # You can update Home Manager without changing this value. See
  # the Home Manager release notes for a list of state version
  # changes in each release.
  home.stateVersion = "22.05";

  # Let Home Manager install and manage itself.
  programs.home-manager.enable = true;
}

Notez que les méthodes d’installation alternatives intègrent Home Manager à la configuration NixOS et nix-darwin. C’est ainsi que nous déployons nos systèmes. Suivez la documentation officielle pour plus de détails.

Nix opérations impératives : nix-env

L’environnement utilisateur, y compris l’installation et la suppression de packages, peut être géré avec les commandes nix-env. Voici quelques-unes des commandes les plus utiles :

• Pour rechercher un packet :

  nix search <pkg-name>

• Pour installer un package dans le profil utilisateur actuel en utilisant le channel par défaut :

  nix-env -i <pkg-name>

• Pour installer un package dans le profil utilisateur actuel à l’aide d’un channel spécifique :

nix-env -iA <nixpkgs.pkg-name>

• Pour désinstaller un package :

  nix-env -e <pkg-name>

• Pour mettre à niveau un package :

  nix-env -u <some-packages>

Exemple : installation de virtualenv avec Nix

Voici les étapes pour installer le package virtualenv à l’aide du gestionnaire de packages Nix.

• Recherchez virtualenv en utilisant la commande nix search :

  nix search virtualenv
  warning: using cached results; pass '-u' to update the cache
  * nixpkgs.pew (pew-1.2.0)
  Tools to manage multiple virtualenvs written in pure python
  
  * nixpkgs.python38Packages.pytest-virtualenv (python3.8-pytest-virtualenv)
  Create a Python virtual environment in your test that cleans up on teardown. The fixture has utility methods to ins>
  
  * nixpkgs.python38Packages.tox (python3.8-tox-3.23.0)
  Virtualenv-based automation of test activities
  
  * nixpkgs.python38Packages.virtualenv (python3.8-virtualenv)
  A tool to create isolated Python environments
  
  * nixpkgs.python38Packages.virtualenv-clone (python3.8-virtualenv-clone)
  Script to clone virtualenvs
  
  * nixpkgs.python38Packages.virtualenvwrapper (python3.8-virtualenvwrapper)
  Enhancements to virtualenv
  
  * nixpkgs.python39Packages.pytest-virtualenv (python3.9-pytest-virtualenv)
  Create a Python virtual environment in your test that cleans up on teardown. The fixture has utility methods to ins>
  
  * nixpkgs.python39Packages.tox (python3.9-tox-3.23.0)
  Virtualenv-based automation of test activities
  
  * nixpkgs.python39Packages.virtualenv (python3.9-virtualenv)
  A tool to create isolated Python environments
  
  * nixpkgs.python39Packages.virtualenv-clone (python3.9-virtualenv-clone)
  Script to clone virtualenvs
  
  * nixpkgs.python39Packages.virtualenvwrapper (python3.9-virtualenvwrapper)
  Enhancements to virtualenv

  Le résultat de la recherche propose plusieurs options pour installer virtualenv. Nous avons sélectionné nixpkgs.python38Packages.virtualenv pour les commandes suivantes.

• Installation de nixpkgs.python38Packages.virtualenv

  • Option 1 : avec la commande nix-env :

  nix-env -iA nix-env -iA nixpkgs.python38Packages.virtualenv

  • Option 2 : avec Home Manager

    Le contenu de la configuration de Home Manager inclue :

    { config, pkgs, ... }:
    
    {   
      ...
      # Packages to install
      home.packages = [
        # pkgs is the set of all packages in the default home.nix implementation
        ...
        nixpkgs.python38Packages.virtualenv
        ...
      ];
      ...
    }

    Pour appliquer les changements effectués :

    home-manager switch

  virtualenv est installé. Voici les commandes pour créer et activer un nouvel environnement python nommé myPythonEnv :

  virtualenv myPythonEnv # create the python environment
  source myPythonEnv/bin/activate # To activate the environement

Génération

Chaque fois qu’une opération nix-env est effectuée, une version de l’environnement utilisateur appelée generation est nouvellement créée. Quelques commandes associées aux générations :

• Pour lister les générations :

  nix-env --list-generations

• Pour passer à une génération spécifique :

  nix-env --switch-generation <generation-number>

• Pour supprimer des générations spécifiques :

  nix-env --delete-generations <generation-numbers separated by space>

• Pour revenir à la dernière commande nix-env (à la dernière génération) :

  nix-env --rollback

• Pour supprimer les anciennes générations :

  nix-env --delete-generations old

Profils

Les profils sont des groupes de générations afin que les différents utilisateurs n’interfèrent pas les uns avec les autres s’ils ne le souhaitent pas. Profiles et User Environments sont des mécanismes de Nix pour permettre à différents utilisateurs de disposer de configurations différentes.

Dérivation

Une dérivation est une expression Nix décrivant tout ce qui entre dans la construction de package (outils de construction, dépendances, sources, scripts de construction, variables d’environnement). C’est tout ce qui est nécessaire pour constituer un package.

Channels

Un channel est un dépôts git contenant une liste de packages. Les channels officiels sont vérifiés par Nix. Quelques commandes associées aux canaux :

• Pour lister les channels installés :

  nix-channel --list

• Pour vous abonner à un nouveau channel :

  nix-channel --add <https://some.channel/url> <channel-alias>

• Pour supprimer un channel :

  nix-channel --remove <alias-channel>

• Pour mettre à jour un channel :

  nix-channel --update <alias-channel>

Garbage collection

Lorsqu’un paquet est désinstallé, il n’est pas réellement supprimé du système même si aucun utilisateur ne s’y réfère. De cette façon, il ne sera pas re-téléchargé s’il arrive que vous en ayez à nouveau besoin. Les packages inutilisés sont supprimés avec la commande :

nix-collect-garbage

Conclusion

Nix est un gestionnaire de packages multiplateforme qui gère efficacement les dépendances par lui-même. Il simplifie le processus de gestion d’un environnement utilisateur via une méthode déclarative et facilite le partage d’un environnement utilisateur. Cependant, sa courbe d’apprentissage peut en décourger plus d’un. Mon expérience personnelle est que cela en valait la peine.