Installer NixOS 25.11 sur un poste de travail : tutoriel pas-à-pas

📍 Guide principal : NixOS pour développeurs et serveurs : reproductibilité totale en 2026
Ce tutoriel fait partie d’une série sur NixOS. Si vous découvrez les concepts (store, dérivations, générations, flakes), commencez par le guide principal pour la vue d’ensemble.

Avant de booter l’ISO : ce que vous gagnez et ce qu’il faut accepter

Installer NixOS 25.11 « Xantusia » prend une heure si tout va bien, deux ou trois si vous tâtonnez sur le partitionnement. Ce tutoriel suit le chemin le plus reproductible : un disque entier, schéma UEFI moderne, ext4 sans LUKS pour aller à l’essentiel, puis une variante chiffrée en fin d’article. À la sortie, vous aurez un système bootable avec un fichier configuration.nix versionnable, GNOME ou KDE installé selon votre choix, et la garantie qu’un nixos-rebuild switch --rollback vous ramène à la dernière configuration qui marchait.

Préparez deux choses avant de commencer. Une clé USB de 4 Go minimum qui sera réécrite par l’ISO. Un disque cible vide ou prêt à être effacé : ce tutoriel formate sans pitié. Vérifiez aussi que le PC démarre en UEFI pur, pas en mode Legacy/CSM ; les BIOS récents proposent ce réglage dans le menu boot. NixOS supporte aussi le BIOS hérité, mais les commandes de partitionnement diffèrent et le manuel officiel privilégie UEFI.

Étape 1 — Télécharger et flasher l’ISO 25.11

L’ISO officielle se télécharge depuis nixos.org/download. Choisissez la variante « Plasma Desktop » si vous voulez voir un environnement graphique fonctionnel dès le live, ou « Minimal » si vous prévoyez une installation serveur ou un workflow tout-clavier. Le SHA256 est publié à côté du lien : prenez l’habitude de le vérifier, c’est cinq secondes.

sha256sum nixos-plasma6-25.11.xxxxx.x86_64-linux.iso
# Comparer avec la valeur publiée sur la page de téléchargement

Ensuite, écrivez l’ISO sur la clé USB. Sous Linux ou macOS, dd reste l’outil le plus fiable. /dev/sdX est à remplacer par votre clé : confirmez avec lsblk avant pour éviter d’écraser le mauvais disque.

sudo dd if=nixos-plasma6-25.11.xxx.iso of=/dev/sdX bs=4M conv=fsync status=progress

Sur Windows, balenaEtcher ou Rufus en mode « DD Image » font le même travail sans risque. L’ISO est hybride : la même image marche en USB et en gravure DVD. Une fois la clé prête, branchez-la, redémarrez, entrez dans le menu boot du firmware (touche F12/F8/Esc selon le constructeur) et sélectionnez la clé.

Étape 2 — Démarrer le live et préparer le shell

Le live boote sur un environnement complet. Si vous avez choisi l’image graphique, vous arrivez sur un bureau Plasma 6 avec un terminal disponible, un navigateur Firefox et un installeur graphique Calamares. Ce tutoriel ignore Calamares volontairement : sa configuration ne tient pas en un fichier git, l’installation manuelle vous donne dès le départ un configuration.nix que vous pouvez archiver.

Ouvrez un terminal, devenez root avec sudo -i, puis vérifiez l’identifiant exact du disque cible. /dev/sda, /dev/nvme0n1 et /dev/vda sont les noms typiques selon que c’est un SSD SATA, un NVMe ou une VM. Notez ce nom, il revient partout dans la suite — toutes les commandes ci-dessous supposent /dev/sda, à adapter.

lsblk -o NAME,SIZE,MODEL,TYPE
ip addr show          # vérifier la connectivité réseau (Wi-Fi via nmtui si besoin)
ping -c 2 cache.nixos.org

Si la sortie de ping répond, vous êtes prêt. Si vous êtes en Wi-Fi, lancez nmtui pour configurer la connexion ; le live embarque NetworkManager. La connexion est indispensable : nixos-install télécharge plusieurs centaines de mégaoctets depuis cache.nixos.org.

Étape 3 — Partitionner le disque en GPT pour UEFI

NixOS suit la convention UEFI standard : une partition EFI System Partition (ESP) pour le bootloader, une swap si vous avez moins de 16 Go de RAM ou voulez de l’hibernation, et une partition racine ext4. Le manuel officiel propose la séquence ci-dessous, légèrement adaptée pour mettre l’ESP en premier (ordre plus lisible) ; le résultat est strictement équivalent.

parted /dev/sda -- mklabel gpt
parted /dev/sda -- mkpart ESP fat32 1MiB 512MiB
parted /dev/sda -- set 1 esp on
parted /dev/sda -- mkpart root ext4 512MiB -8GiB
parted /dev/sda -- mkpart swap linux-swap -8GiB 100%

Cette séquence crée trois partitions : 511 Mo d’ESP en début de disque, l’espace restant moins 8 Go pour la racine, et 8 Go finaux pour le swap. Un parted /dev/sda -- print doit lister les trois partitions ; si vous voyez « Partition table corruption » ou un avertissement d’alignement, c’est que le disque a un ancien layout MBR — relancez la première commande qui force GPT.

Les parties de disque sont créées mais pas formatées. On formate maintenant chacune avec son système de fichiers et un label lisible — les labels permettent de monter par /dev/disk/by-label/ au lieu de noms instables comme /dev/sda1.

mkfs.fat -F 32 -n boot /dev/sda1
mkfs.ext4 -L nixos /dev/sda2
mkswap -L swap /dev/sda3

À ce stade, blkid doit afficher trois entrées avec les labels boot, nixos et swap. Si l’une manque, vérifiez que vous formatez bien la bonne partition (les numéros suivent l’ordre de création, donc /dev/sda1 est l’ESP).

Étape 4 — Monter les partitions sous /mnt

L’installeur NixOS attend que la racine cible soit montée sur /mnt, et l’ESP sur /mnt/boot. Cette convention permet ensuite à nixos-install de générer les bons paths dans configuration.nix et d’écrire le bootloader sur la bonne partition. Le swap est activé tout de suite — utile pour les machines avec peu de RAM pendant la compilation.

mount /dev/disk/by-label/nixos /mnt
mkdir -p /mnt/boot
mount -o umask=077 /dev/disk/by-label/boot /mnt/boot
swapon /dev/sda3

Le umask=077 sur la partition de boot empêche les utilisateurs non-root de lire l’ESP, où certains binaires de boot (clés Secure Boot, par exemple) sont sensibles. Vérifiez le résultat avec findmnt /mnt et findmnt /mnt/boot ; les deux lignes doivent apparaître. Si findmnt ne renvoie rien, le mount a échoué silencieusement — relisez les commandes précédentes.

Étape 5 — Générer la configuration initiale

NixOS détecte le matériel via nixos-generate-config et écrit deux fichiers : /mnt/etc/nixos/hardware-configuration.nix (généré, ne pas éditer manuellement) et /mnt/etc/nixos/configuration.nix (votre point d’entrée, à personnaliser).

nixos-generate-config --root /mnt

La sortie liste les modules détectés (drivers SSD, modules virtio si vous êtes en VM, support nvme). Ouvrez /mnt/etc/nixos/configuration.nix avec nano, vim ou kak. C’est le fichier que vous éditerez ensuite tout au long de la vie de la machine, donc autant lui donner une forme propre dès le début.

Étape 6 — Personnaliser configuration.nix

Le fichier généré contient des lignes commentées en anglais qui décrivent chaque option. Voici un squelette minimaliste mais complet pour un poste de travail bureautique : bootloader systemd-boot, locale française, clavier AZERTY, NetworkManager pour le Wi-Fi, KDE Plasma, un utilisateur, OpenSSH activé pour les accès distants, flakes activés.

{ config, pkgs, ... }:

{
  imports = [ ./hardware-configuration.nix ];

  boot.loader.systemd-boot.enable = true;
  boot.loader.efi.canTouchEfiVariables = true;

  networking.hostName = "thanos";
  networking.networkmanager.enable = true;

  time.timeZone = "Europe/Paris";
  i18n.defaultLocale = "fr_FR.UTF-8";
  console.keyMap = "fr";

  services.xserver.enable = true;
  services.xserver.xkb.layout = "fr";
  services.displayManager.sddm.enable = true;
  services.desktopManager.plasma6.enable = true;

  users.users.alice = {
    isNormalUser = true;
    extraGroups = [ "wheel" "networkmanager" ];
    initialPassword = "changeme";
  };

  services.openssh.enable = true;

  nix.settings.experimental-features = [ "nix-command" "flakes" ];
  nix.gc.automatic = true;
  nix.gc.options = "--delete-older-than 14d";
  nix.optimise.automatic = true;

  environment.systemPackages = with pkgs; [
    git curl wget htop neovim firefox
  ];

  system.stateVersion = "25.11";
}

Trois lignes méritent un commentaire. nix.settings.experimental-features active les flakes et la nouvelle CLI nix dès le premier boot — vous éviterez de devoir éditer /etc/nix/nix.conf plus tard. nix.gc.automatic programme un nettoyage hebdomadaire des générations de plus de deux semaines, ce qui empêche le store de saturer le disque. system.stateVersion = "25.11" fige la version de contrat du système : les modules qui dépendent de cette version garderont leur comportement, même quand vous mettrez à jour vers 26.05 plus tard. Ne touchez plus jamais cette ligne après la première installation.

Étape 7 — Lancer nixos-install

Une fois la configuration enregistrée, lancez l’installation. Sur NixOS 25.11, nixos-install appelle automatiquement nixos-rebuild-ng, la nouvelle implémentation Python du gestionnaire de rebuild qui remplace l’ancien Perl.

nixos-install --root /mnt

La commande télécharge les paquets, compile ce qui n’est pas dans le cache binaire, écrit la configuration dans /nix/store, installe le bootloader et termine en demandant un mot de passe root. Comptez 15 à 40 minutes selon la connexion. Si la compilation se bloque, c’est presque toujours cache.nixos.org temporairement lent — patientez ou interrompez avec Ctrl-C et relancez.

À la fin, nixos-install affiche « installation finished, no error reported ». Démontez les partitions et redémarrez :

umount -R /mnt
swapoff /dev/sda3
reboot

Retirez la clé USB pendant que le BIOS revient. Le disque doit booter sur le menu systemd-boot, qui n’affiche qu’une seule entrée (la première génération). Connectez-vous avec l’utilisateur alice et le mot de passe changeme, changez-le immédiatement avec passwd.

Étape 8 — Premier nixos-rebuild switch et vérification

Vous tournez sur la première génération. Toute modification future suit le cycle éditer-rebuild-vérifier. Ouvrez /etc/nixos/configuration.nix, ajoutez par exemple tmux dans environment.systemPackages, sauvegardez, puis :

sudo nixos-rebuild switch

La commande compile une nouvelle génération, l’active, met à jour le bootloader et affiche les services redémarrés. which tmux doit maintenant renvoyer un chemin sous /run/current-system/sw/bin/tmux. Listez les générations pour vous habituer à la commande clé du rollback :

sudo nix-env --list-generations --profile /nix/var/nix/profiles/system

Deux entrées doivent apparaître : la génération initiale et celle qui inclut tmux. Pour revenir en arrière, sudo nixos-rebuild switch --rollback. Pour redémarrer sur une ancienne génération, sélectionnez l’entrée correspondante dans systemd-boot au prochain reboot. C’est ce filet de sécurité qui rend NixOS sûr en production.

Erreurs fréquentes à l’installation

Variante : installation chiffrée avec LUKS

Pour un poste de travail mobile, le chiffrement de la racine est non négociable. La séquence change légèrement : on crée un volume LUKS sur la partition racine avant le formatage ext4. Adaptez l’étape 3 et 4 ci-dessus comme suit.

cryptsetup luksFormat /dev/sda2
cryptsetup luksOpen /dev/sda2 cryptroot
mkfs.ext4 -L nixos /dev/mapper/cryptroot
mount /dev/mapper/cryptroot /mnt
# ... reste inchangé : mkdir, mount /mnt/boot, swapon

Dans configuration.nix, ajoutez la déclaration LUKS pour que le boot demande la passphrase. Le UUID vient de blkid /dev/sda2 :

boot.initrd.luks.devices."cryptroot".device =
  "/dev/disk/by-uuid/<UUID-DE-SDA2>";

Au prochain boot, systemd-boot lance l’initrd qui demande la passphrase avant de monter la racine. Si vous oubliez ce bloc, la machine ne pourra plus booter ; gardez la clé USB d’installation à portée pour récupérer.

Comprendre ce que nixos-install a vraiment fait

Beaucoup d’utilisateurs déballent NixOS sans saisir le mécanisme exact qui a transformé un disque vide en système bootable. Cinq actions se sont enchaînées en arrière-plan. Premièrement, Nix a évalué configuration.nix et hardware-configuration.nix pour produire une grosse expression qui décrit l’ensemble du système : tous les paquets, les unités systemd, les fichiers de /etc, le bootloader. Deuxièmement, il a téléchargé ou compilé chaque chemin du /nix/store nécessaire à cette description. Troisièmement, il a écrit dans /nix/var/nix/profiles/system-1-link un lien symbolique vers le dérivé final, qui est la « génération » 1. Quatrièmement, il a généré /etc à partir des templates des modules : /etc/passwd, /etc/ssh/sshd_config, /etc/locale.conf. Cinquièmement, il a copié les binaires du noyau dans l’ESP et écrit la configuration systemd-boot.

Cette mécanique explique pourquoi le rollback est si rapide : l’ancienne génération existe toujours sous /nix/store, et la « remettre » consiste juste à pointer /run/current-system vers son lien et à redémarrer les services concernés. Aucun fichier n’a été remplacé sur place ; aucun snapshot LVM n’est nécessaire.

Sécuriser le poste tout de suite après le premier boot

Une installation par défaut suffit pour démarrer mais laisse plusieurs ajustements de sécurité à faire avant de poser des données sensibles dessus. Quatre lignes complètent configuration.nix et passent l’essentiel.

services.openssh.settings.PasswordAuthentication = false;
services.openssh.settings.PermitRootLogin = "no";
networking.firewall.enable = true;
networking.firewall.allowedTCPPorts = [ ];

La désactivation du login par mot de passe en SSH suppose que vous avez déjà déposé votre clé publique via users.users.alice.openssh.authorizedKeys.keys. Faites-le avant le rebuild pour ne pas vous fermer la porte. Le pare-feu activé bloque tout par défaut ; ajoutez les ports utiles dans allowedTCPPorts au cas par cas (22 si vous voulez SSH depuis l’extérieur, 80/443 pour un serveur web, etc.).

Variante : installation sur ZFS

ZFS apporte les snapshots de système de fichiers, la déduplication et la résilience multi-disque. NixOS supporte ZFS comme racine, mais l’installation diffère sensiblement. Le principe est de créer un pool, puis des datasets pour /, /home, /nix. Les commandes typiques après le partitionnement parted habituel :

zpool create -O mountpoint=none -O acltype=posixacl \
             -O xattr=sa -O compression=zstd -O atime=off \
             zpool /dev/sda2
zfs create -o mountpoint=legacy zpool/root
zfs create -o mountpoint=legacy zpool/home
zfs create -o mountpoint=legacy zpool/nix
mount -t zfs zpool/root /mnt
mkdir -p /mnt/{home,nix,boot}
mount -t zfs zpool/home /mnt/home
mount -t zfs zpool/nix /mnt/nix
mount /dev/sda1 /mnt/boot

Dans configuration.nix, deux lignes obligatoires : boot.supportedFilesystems = [ "zfs" ]; et networking.hostId = "<8 hex chars>";. Le hostId est exigé par ZFS pour empêcher le montage simultané d’un pool depuis deux machines. Une commande aléatoire suffit : head -c 4 /dev/urandom | od -A none -t x4. Le wiki communautaire détaille les variantes (mirror à deux disques, encryption native ZFS, snapshots automatiques).

Cohabiter avec Windows : le cas du dual-boot

Beaucoup d’utilisateurs ne veulent pas effacer Windows tout de suite — un logiciel propriétaire de comptabilité, un jeu, un VPN d’entreprise. NixOS gère le dual-boot proprement à condition de respecter deux règles. Première règle : ne pas partager l’ESP avec Windows si vous pouvez l’éviter. Windows réécrit régulièrement son entrée bootmgfw et peut perturber systemd-boot. Un disque secondaire pour NixOS, ou une seconde ESP isolée sur le même disque, évite les conflits.

Deuxième règle : désactiver le « fast startup » de Windows (Panneau de configuration → Options d’alimentation → Choisir l’action des boutons d’alimentation → Décocher « Activer le démarrage rapide »). Sans cette désactivation, Windows met le système de fichiers NTFS dans un état « monté » qui empêche NixOS de le lire ou d’y écrire en toute sécurité.

Côté NixOS, déclarez l’entrée Windows pour la voir dans le menu systemd-boot :

boot.loader.systemd-boot.extraEntries."windows.conf" = ''
  title Windows 11
  efi /EFI/Microsoft/Boot/bootmgfw.efi
'';

Le chemin /EFI/Microsoft/Boot/bootmgfw.efi doit exister sur l’ESP de Windows ; si vous avez deux ESP séparées, il faut monter la partition Windows et copier le binaire ou pointer vers la bonne ESP. Le wiki documente les variantes pour les configurations à deux disques.

Suite logique

Le système marche, la configuration est versionnable. Les étapes naturelles ensuite sont d’ajouter git, de mettre configuration.nix dans un dépôt, puis de transformer ce fichier en flake — c’est l’objet du tutoriel Flakes : essentiels et premier projet reproductible. Pour tout l’environnement utilisateur (zsh, neovim, dotfiles), Home-Manager : gérer son environnement utilisateur prend le relais. Et si vous voulez retrouver la vue d’ensemble du modèle, le guide principal NixOS reste le point de référence.

Références officielles

• Manuel d’installation NixOS — section « Installation » du manuel officiel.
• Téléchargement et SHA256 des ISO.
• Wiki communautaire — Installation guide — variantes ZFS, Btrfs, dual-boot.
• Wiki — Full disk encryption — détails LUKS et configurations avancées.