Aller au contenu principal

Nix

Overview​

Nix, c'est le package manager révolutionnaire qui pense que "ça marche sur ma machine" ne devrait plus jamais être un problème. Basé sur une approche fonctionnelle pure, Nix garantit des builds reproductibles, une isolation parfaite entre environments, et la possibilité de rollback instantané. Si tu veux éliminer définitivement les dependency hell et les divergences d'environnements, c'est parfait.

Nix utilise un langage déclaratif pour définir exactement quels packages, versions et configurations tu veux. Chaque package est stocké dans un path unique basé sur son hash, rendant impossible les conflits de versions. Rollbacks instantanés, environments isolés, reproductibilité mathématiquement garantie.

Nix se distingue par sa reproductibilité absolue (même build = même résultat, partout, toujours), son isolation parfaite (pas de pollution entre environnements), et sa philosophie fonctionnelle (pas d'état global, que des transformations pures).

Informations essentielles​

PropriétéValeur
Site officielhttps://nixos.org/
Repositoryhttps://github.com/NixOS/nix
LicenceLGPL 2.1+
OrganisationNixOS Foundation
LangageC++, Nix language
PlateformesLinux, macOS, WSL

Fonctionnalités principales​

Reproductibilité garantie​

  • Builds déterministes avec même résultat partout
  • Isolation complète des dépendances
  • Aucune pollution d'environnement global
  • Hash-based addressing pour éviter les conflits
  • Binary cache pour partage des builds

Gestion d'environnements​

  • Environnements développement isolés par projet
  • Shell environments temporaires avec nix-shell
  • Profiles utilisateur avec rollback instantané
  • Gestion de versions multiples en parallèle
  • Configuration déclarative complète

Langage fonctionnel​

  • Syntaxe déclarative Nix language
  • Expressions pures sans effets de bord
  • Composition et réutilisation de configurations
  • Lazy evaluation pour performance
  • Type system avec validation

Écosystème riche​

  • nixpkgs : plus de 60 000 packages
  • NixOS : distribution Linux basée sur Nix
  • Flakes : système moderne de gestion des dépendances
  • Home Manager : gestion des dotfiles utilisateur
  • Nix-darwin : support macOS avancé

Cas d'usage​

  • Dev environments : Environnements reproductibles par projet
  • CI/CD : Builds déterministes et cachés
  • Deployment : Déploiement atomique avec rollback
  • Data science : Environnements Python/R avec versions exactes
  • Infrastructure : Configuration système déclarative

Installation​

Installation Nix (single-user)​

# Linux/macOS/WSL
curl -L https://nixos.org/nix/install | sh

# Après installation
. ~/.nix-profile/etc/profile.d/nix.sh

# Vérification
nix --version

Installation multi-user (recommandée)​

# Linux/macOS avec daemon
curl -L https://nixos.org/nix/install | sh -s -- --daemon

# Redémarrer le shell
# Le daemon gère les builds en isolation

Configuration flakes (moderne)​

# Activer flakes (expérimental mais recommandé)
mkdir -p ~/.config/nix
echo 'experimental-features = nix-command flakes' >> ~/.config/nix/nix.conf

Utilisation basique​

Shell temporaire avec packages​

# Shell temporaire avec Python et pip
nix-shell -p python3 python3Packages.pip

# Shell avec version spécifique de Node.js
nix-shell -p nodejs-18_x npm

# Shell avec multiple packages
nix-shell -p gcc cmake git vim

# Shell avec package spécifique d'un channel
nix-shell -p 'pkgs.python3.withPackages(ps: [ps.numpy ps.pandas])'

Environnement de projet (shell.nix)​

# shell.nix dans le répertoire projet
{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = with pkgs; [
    nodejs-18_x
    yarn
    postgresql
    redis
    docker-compose
  ];

  shellHook = ''
    echo "Environment de développement activé!"
    echo "Node: $(node --version)"
    echo "PostgreSQL disponible: $(pg_config --version)"
    export DATABASE_URL="postgres://localhost:5432/myapp"
  '';
}

Utilisation avec flakes (moderne)​

# flake.nix - moderne way
{
  description = "Mon projet avec Nix flakes";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = nixpkgs.legacyPackages.${system};
      in
      {
        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
            python3
            python3Packages.pip
            python3Packages.virtualenv
            poetry
          ];
        };

        packages.default = pkgs.python3Packages.buildPythonApplication {
          pname = "myapp";
          version = "1.0.0";
          src = ./.;
          propagatedBuildInputs = with pkgs.python3Packages; [
            flask
            requests
          ];
        };
      });
}

Gestion des profiles​

# Installer un package dans le profile utilisateur
nix-env -iA nixpkgs.git

# Lister les packages installés
nix-env --query

# Rollback à la génération précédente
nix-env --rollback

# Lister les générations disponibles
nix-env --list-generations

# Garbage collection
nix-collect-garbage -d

Build et packaging​

# default.nix pour packager une application
{ pkgs ? import <nixpkgs> {} }:

pkgs.stdenv.mkDerivation {
  pname = "myapp";
  version = "1.0.0";

  src = ./.;

  buildInputs = with pkgs; [ cmake gcc ];

  buildPhase = ''
    cmake .
    make
  '';

  installPhase = ''
    mkdir -p $out/bin
    cp myapp $out/bin/
  '';

  meta = with pkgs.lib; {
    description = "My awesome application";
    homepage = "https://github.com/me/myapp";
    license = licenses.mit;
    platforms = platforms.linux;
  };
}

Avantages​

  • ✅ Reproductibilité absolue : même build = même résultat, partout, toujours, mathématiquement garanti
  • ✅ Isolation parfaite : pas de pollution entre environments, chaque projet indépendant
  • ✅ Rollback instantané : retour arrière immédiat en cas de problème, pas de casse
  • ✅ Écosystème énorme : 60 000+ packages, tout y est ou peut être packagé facilement
  • ✅ Multi-plateforme : Linux, macOS, WSL, même approche partout

Limitations​

  • Courbe d'apprentissage élevée : syntaxe et concepts nouveaux, mais ça vaut le coup
  • Documentation parfois dense : mais communauté très active et helpful
  • Builds initiaux peuvent être longs : mais binary cache accélère énormément
  • Stockage peut consommer plus d'espace : mais la reproductibilité le vaut

Alternatives​

  • Docker : Isolation par containers (plus lourd, moins flexible)
  • Conda : Package manager scientifique (limité aux langages supportés)
  • asdf : Version manager (pas de garantie de reproductibilité)
  • Homebrew : Package manager macOS (pas reproductible)

Ressources​