Commandes Nix classiques : nix-env, nix-build, nix-shell, nix-channel

Les commandes nix-env, nix-build, nix-shell et nix-channel constituent l'interface historique de Nix. Elles sont progressivement remplacées par les commandes modernes (nix search, nix shell, nix run, nix profile…), mais vous les rencontrerez encore dans de nombreux tutoriels, wikis et scripts existants. Ce guide les présente avec leur équivalent moderne pour vous permettre de lire et adapter le code legacy.

Ce que vous allez apprendre

Identifier les commandes classiques et comprendre leur rôle
Utiliser nix-build et nix-shell (les deux plus utiles encore aujourd'hui)
Comprendre pourquoi nix-env est incompatible avec nix profile
Gérer les channels avec nix-channel et comprendre le passage aux flakes
Traduire chaque commande classique vers son équivalent moderne

Dans quel contexte ?

Vous croiserez les commandes classiques dans plusieurs situations :

lire un tutoriel ou un README qui utilise nix-shell -p ou nix-build,
maintenir un projet qui utilise un shell.nix ou default.nix,
déboguer une installation sur une machine configurée avec les anciens channels,
migrer progressivement un workflow basé sur nix-env vers nix profile.

Les commandes modernes (nix profile) et classiques (nix-env) utilisent des formats de profil incompatibles. Si vous avez déjà utilisé nix profile add, nix-env refusera de fonctionner sur le même profil :

error: profile "/home/lab/.local/state/nix/profiles/profile"
is incompatible with 'nix-env'; please use 'nix profile' instead

Choisissez l'un ou l'autre pour gérer vos paquets installés.

`nix-build`, construire un paquet

nix-build est le prédécesseur de nix build. Il évalue une expression Nix, construit le résultat et crée dans le répertoire courant un lien symbolique nommé result qui pointe vers le chemin du store. Ce lien sert aussi de racine de garbage collection : tant qu'il existe, le résultat ne sera pas supprimé par nix-collect-garbage.

nix-build '<nixpkgs>' -A hello

/nix/store/10s5j3mfdg22k1597x580qrhprnzcjwb-hello-2.12.3

./result/bin/hello

Hello, world!

Différences avec `nix build`

Les deux commandes produisent la même dérivation, mais elles ne résolvent pas la source au même endroit et ne rendent pas le résultat de la même façon : nix-build affiche le chemin store sur la sortie standard, ce qui permet de le capturer dans un script, là où nix build se contente de créer le lien result.

Aspect	`nix-build`	`nix build`
Syntaxe source	`'<nixpkgs>' -A hello`	`nixpkgs#hello`
Résolution	Channels (`NIX_PATH`)	Registres flakes
Sortie	Chemin store sur stdout	Lien `result` (silencieux)
Pinning	Manuel (pas de lock)	`flake.lock` automatique

`nix-shell`, un shell avec des dépendances

nix-shell crée un environnement shell temporaire dans lequel les paquets demandés sont présents dans le PATH, sans rien installer dans le profil. C'est le prédécesseur commun de nix shell et de nix develop, ce qui explique qu'une seule commande classique couvre aujourd'hui deux commandes modernes.

Utilisation rapide avec `-p`

L'option -p construit un environnement jetable contenant les paquets nommés, et --run y exécute une commande puis rend la main au lieu d'ouvrir un shell interactif. Rien n'est installé dans le profil : à la sortie, seul le contenu téléchargé dans le store subsiste.

nix-shell -p cowsay --run 'cowsay "nix-shell classique"'

 _____________________
< nix-shell classique >
 ---------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Combiner plusieurs paquets

Plusieurs paquets se chaînent derrière un seul -p, séparés par des espaces et sans répéter l'option.

nix-shell -p curl jq --run 'echo "curl et jq disponibles"'

curl et jq disponibles

Avec un fichier `shell.nix`

L'usage le plus courant de nix-shell est avec un fichier shell.nix à la racine d'un projet :

{ pkgs ? import <nixpkgs> {} }:
pkgs.mkShell {
  buildInputs = [
    pkgs.python3
    pkgs.curl
    pkgs.jq
  ];
}

nix-shell
# → shell interactif avec python3, curl et jq

Différences avec les commandes modernes

nix-shell recouvre deux usages que les commandes modernes ont séparés en deux outils distincts. Le premier tableau compare l'usage jetable en ligne de commande, le second l'environnement de développement décrit par un fichier versionné avec le projet.

Aspect	`nix-shell -p pkg`	`nix shell nixpkgs#pkg`
Résolution	Channels (`NIX_PATH`)	Registre flakes
Environnement	Ajoute `stdenv` complet	Ajoute uniquement le paquet
Fichier projet	`shell.nix`	`flake.nix` → `devShells`

Aspect	`nix-shell` (fichier)	`nix develop`
Fichier	`shell.nix`	`flake.nix`
Pinning	Manuel	`flake.lock` automatique
Reproductibilité	Dépend de `NIX_PATH`	Garantie par le lock

`nix-env`, gérer les paquets du profil

nix-env est le prédécesseur de nix profile. Il permet de chercher, installer, lister et supprimer des paquets dans le profil utilisateur, c'est-à-dire l'ensemble de liens symboliques qui rend un programme disponible dans le PATH sans passer par un shell temporaire. C'est la seule commande classique dont la migration est bloquante : un profil créé par nix profile lui est définitivement fermé.

Commandes principales

Ces options tiennent en une lettre et se combinent : -q interroge, -i installe, -e supprime, et -A désigne le paquet par son chemin d'attribut (nixpkgs.htop) plutôt que par son nom affiché.

# Chercher un paquet
nix-env -qaP '.*htop.*'

# Installer
nix-env -iA nixpkgs.htop

# Lister les paquets installés
nix-env -q

# Supprimer
nix-env -e htop

# Mettre à jour tout
nix-env -u

# Rollback
nix-env --rollback

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

Pourquoi éviter `nix-env`

Sur un poste neuf, la question ne se pose pas vraiment : nix-env conserve un état global et non versionné, alors que tout l'intérêt de Nix tient à la reproductibilité. Les quatre limites ci-dessous se paient au moment où vous essayez de rejouer une installation sur une autre machine.

Incompatible avec nix profile, les deux formats de profil sont mutuellement exclusifs.
Pas de pinning, la version installée dépend de l'état du channel au moment de l'installation.
Résolution par nom, nix-env -i htop peut installer un paquet inattendu si plusieurs correspondent.
Pas de flake.lock, impossible de reproduire exactement le même environnement.

Table de correspondance

Chaque ligne se lit comme une traduction directe : la commande de gauche et celle de droite produisent le même effet fonctionnel. Elles ne s'appliquent simplement pas au même format de profil, donc la migration se fait en une fois, pas commande par commande.

`nix-env`	`nix profile`
`nix-env -qaP pattern`	`nix search nixpkgs pattern`
`nix-env -iA nixpkgs.pkg`	`nix profile add nixpkgs#pkg`
`nix-env -q`	`nix profile list`
`nix-env -e pkg`	`nix profile remove pkg`
`nix-env -u`	`nix profile upgrade '.*'`
`nix-env --rollback`	`nix profile rollback`
`nix-env --list-generations`	`nix profile history`

`nix-channel`, gérer les sources de paquets

Les channels sont l'ancien mécanisme pour résoudre <nixpkgs> vers une version spécifique de l'arbre nixpkgs. La liste est stockée dans ~/.nix-channels pour un channel utilisateur, et sous /nix/var/nix/profiles pour un channel installé en root, ce qui explique que sudo nix-channel --list puisse afficher autre chose que la même commande sans sudo.

Commandes principales

Un channel se déclare une fois, puis se rafraîchit à la demande : --update télécharge la nouvelle description de l'arbre nixpkgs et fait pointer <nixpkgs> dessus. Toutes les commandes classiques lancées ensuite résolvent donc des versions différentes, sans qu'aucun fichier de votre projet ne change.

# Lister les channels configurés
nix-channel --list

# Ajouter un channel
nix-channel --add https://nixos.org/channels/nixpkgs-unstable nixpkgs

# Mettre à jour
nix-channel --update

Channels vs flakes

La différence tient en un point : un channel est un curseur mobile partagé par toute la machine, un flake fige la version dans un fichier flake.lock propre au projet. Deux collègues qui ont mis à jour leur channel à des dates différentes n'obtiendront pas les mêmes paquets ; avec un lock committé, ils obtiennent le même hash.

Aspect	Channels	Flakes
Verrouillage	Non (rolling)	Oui (`flake.lock`)
Reproductibilité	Dépend du moment	Garantie par le hash
Configuration	Globale (`~/.nix-channels`)	Par projet (`flake.nix`)
Résolution	`<nixpkgs>` via `NIX_PATH`	`nixpkgs` via registre

Autres commandes classiques

Les trois commandes qui suivent n'ont pas d'urgence de migration : elles servent au diagnostic et au ménage du store, pas à la gestion quotidienne des paquets. Vous les croiserez surtout dans des scripts de maintenance et dans les réponses de forum consacrées à un /nix/store qui déborde.

`nix-instantiate`, évaluer une dérivation

nix-instantiate s'arrête à l'évaluation : il écrit le fichier .drv, la recette de construction, dans le store et affiche son chemin, sans compiler ni télécharger le paquet lui-même.

nix-instantiate '<nixpkgs>' -A hello

/nix/store/7mdg60drrnh0wq1j8hmmbhll47czm107-hello-2.12.3.drv

Équivalent moderne : nix derivation show nixpkgs#hello

`nix-collect-garbage`, libérer de l'espace

Sans option, la commande ne supprime que les chemins du store qu'aucune racine ne référence encore. L'option -d va plus loin et détruit les anciennes générations des profils, ce qui rend le rollback impossible vers les versions concernées ; --delete-older-than 30d limite la casse à celles de plus de trente jours.

# Supprimer les paquets non référencés
nix-collect-garbage

# Supprimer aussi les anciennes générations de plus de 30 jours
nix-collect-garbage -d --delete-older-than 30d

Équivalent moderne : nix profile wipe-history + nix store gc

`nix-store`, opérations sur le store

nix-store -q interroge le graphe de dépendances dans les deux sens : --references liste ce dont un chemin dépend, --referrers liste ce qui dépend de lui. Ce second sens répond à la question qui bloque une suppression, quand le ramasse-miettes refuse de libérer un chemin encore utilisé.

# Afficher les dépendances d'un chemin
nix-store -q --references /nix/store/922c...-ripgrep-15.1.0

# Afficher les référents (qui dépend de ce chemin)
nix-store -q --referrers /nix/store/922c...-ripgrep-15.1.0

# Vérifier l'intégrité du store
nix-store --verify --check-contents

Table de correspondance complète

Gardez ce tableau sous la main quand vous lisez un tutoriel ancien : il donne l'équivalent moderne de chaque commande classique. Attention, l'équivalence porte sur l'usage, pas sur la syntaxe des arguments, et surtout pas sur l'état : basculer de nix-env vers nix profile impose de réinstaller les paquets, les deux profils ne se lisent pas mutuellement.

Classique	Moderne	Usage
`nix-env -qaP`	`nix search`	Chercher
`nix-env -iA`	`nix profile add`	Installer
`nix-env -e`	`nix profile remove`	Supprimer
`nix-env -u`	`nix profile upgrade`	Mettre à jour
`nix-env --rollback`	`nix profile rollback`	Rollback
`nix-build`	`nix build`	Construire
`nix-shell -p`	`nix shell`	Shell temporaire
`nix-shell` (fichier)	`nix develop`	Env. de développement
`nix-channel`	Registres flakes	Sources de paquets
`nix-instantiate`	`nix derivation show`	Inspecter la dérivation
`nix-collect-garbage`	`nix store gc`	Garbage collection
`nix-store -q`	`nix path-info`	Info store

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

Le chronomètre démarre au clic sur Démarrer
Questions à choix multiples, vrai/faux et réponses courtes
Vous pouvez naviguer entre les questions
Les résultats détaillés sont affichés à la fin

À retenir

nix-build et nix-shell restent fonctionnels et utiles pour les projets qui utilisent default.nix ou shell.nix.
nix-env et nix profile sont mutuellement incompatibles, si vous utilisez les commandes modernes, n'utilisez pas nix-env.
Les channels sont remplacés par les registres flakes qui offrent un verrouillage automatique via flake.lock.
Pour un nouveau projet, préférez les commandes modernes et les flakes, les commandes classiques sont utiles principalement pour comprendre le code legacy.
nix-shell -p importe le stdenv complet, ce qui est plus lourd que nix shell qui n'ajoute que le paquet demandé.

Pour aller plus loin

Les flakes : Découvrez les flakes pour des projets reproductibles et verrouillés.

Commandes Nix classiques : nix-env, nix-build, nix-shell, nix-channel

Ce que vous allez apprendre

Dans quel contexte ?

`nix-build`, construire un paquet

Différences avec `nix build`

`nix-shell`, un shell avec des dépendances

Utilisation rapide avec `-p`

Combiner plusieurs paquets

Avec un fichier `shell.nix`

Différences avec les commandes modernes

`nix-env`, gérer les paquets du profil

Commandes principales

Pourquoi éviter `nix-env`

Table de correspondance

`nix-channel`, gérer les sources de paquets

Commandes principales

Channels vs flakes

Autres commandes classiques

`nix-instantiate`, évaluer une dérivation

`nix-collect-garbage`, libérer de l'espace

`nix-store`, opérations sur le store

Table de correspondance complète

Contrôle de connaissances

Contrôle de connaissances

Informations

Vérification

Profil de compétences

Quoi faire maintenant

À retenir

Pour aller plus loin

Commandes Nix classiques : nix-env, nix-build, nix-shell, nix-channel

Ce que vous allez apprendre

Dans quel contexte ?

nix-build, construire un paquet

Différences avec nix build

nix-shell, un shell avec des dépendances

Utilisation rapide avec -p

Combiner plusieurs paquets

Avec un fichier shell.nix

Différences avec les commandes modernes

nix-env, gérer les paquets du profil

Commandes principales

Pourquoi éviter nix-env

Table de correspondance

nix-channel, gérer les sources de paquets

Commandes principales

Channels vs flakes

Autres commandes classiques

nix-instantiate, évaluer une dérivation

nix-collect-garbage, libérer de l'espace

nix-store, opérations sur le store

Table de correspondance complète

Contrôle de connaissances

Contrôle de connaissances

Informations

Profil de compétences

Quoi faire maintenant

À retenir

Pour aller plus loin

`nix-build`, construire un paquet

Différences avec `nix build`

`nix-shell`, un shell avec des dépendances

Utilisation rapide avec `-p`

Avec un fichier `shell.nix`

`nix-env`, gérer les paquets du profil

Pourquoi éviter `nix-env`

`nix-channel`, gérer les sources de paquets

`nix-instantiate`, évaluer une dérivation

`nix-collect-garbage`, libérer de l'espace

`nix-store`, opérations sur le store