Nixos_Fleet

Déploiement en masse (PXE ou USB) du profil générique nixos.

Repo public. git pull sans mot de passe.

Ne contient aucune donnée des utilisateurs nommés. Ça, c'est dans Nixos_Users, repo privé séparé.

---

Installer un paquet sans le mettre "en dur"

Pour tester un outil sans toucher à configuration.nix.

Un shell temporaire, le paquet disparaît en sortant :

nix-shell -p git

Équivalent flakes :

nix shell nixpkgs#git

Lancer un programme une seule fois, sans même ouvrir de shell :

nix run nixpkgs#git -- --version

Aucune de ces méthodes ne survit à un reboot ni à un nixos-rebuild. Pour que ça reste en permanence, ajouter le paquet dans environment.systemPackages d'un configuration.nix puis sudo nixos-rebuild switch.

---

Installer un PC

Une étape à la fois. Ne saute pas d'étape.

Étape 0 — Support d'installation

Deux options, choisis-en une.

PXE (serveur déjà monté) : rien à préparer ici. Va à l'étape 1.

Clé USB (autonome, depuis zéro) :

git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
cd Nixos_Fleet
nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage

Repérer la clé USB avant de graver — vérifier le chemin, pas ton disque système :

lsblk
sudo dd if=result/iso/*.iso of=/dev/sdX bs=4M status=progress conv=fsync

Vérifier /dev/sdX avant de lancer dd. Une fois gravée, va à l'étape 1.

Depuis Windows : voir "Construire l'ISO et la graver, depuis Windows" plus bas.

Étape 1 — Brancher

Branche le câble réseau (PXE) ou la clé USB gravée à l'étape 0 (USB).

Branche le PC au secteur.

Allume le PC.

Étape 2 — Menu de démarrage

Appuie plusieurs fois sur une touche dès l'allumage.

Dell → F12

HP → F9

Lenovo → F12

Choisis : Network Boot (PXE) ou Boot from USB (clé) -- le menu qui suit est identique dans les deux cas.

Étape 3 — Attendre

Un écran noir avec du texte apparaît seul.

Attends.

Étape 4 — Choisir un cas

Il y a deux cas. Choisis-en un seul.

PC normal → va à l'étape 4A.

PC pour thomas, clara, jade, oreo ou oreo-i3 → va à l'étape 4B.

Étape 4A — PC normal

Tape : 1

Appuie sur Entrée.

N'appuie plus sur rien.

Attends la fin (plusieurs minutes).

Va à l'étape 5.

Étape 4B — PC pour une personne

Tape : 2

Appuie sur Entrée.

Tape le prénom (thomas, clara, jade, oreo ou oreo-i3).

Appuie sur Entrée.

Une question sur le chiffrement apparaît.

Pas sûr → appuie juste sur Entrée.

Tape le token (donné à part, pas dans ce guide).

Appuie sur Entrée.

Si une passphrase est demandée :

Tape-la.

Note-la sur papier tout de suite.

Attends la fin (plusieurs minutes).

Va à l'étape 5.

Étape 5 — Redémarrage

Le PC redémarre seul.

N'y touche pas.

Étape 6 — Connexion

PC normal :

Utilisateur : nixos

Mot de passe : nixos

Utilisateur et mot de passe identiques, volontairement (un seul mot à retenir sur un poste partagé). Stable, ne change jamais tout seul et n'est jamais redemandé (voir "Réactiver un changement de mot de passe forcé" en référence si ça doit changer un jour).

PC pour une personne :

Utilisateur : le prénom tapé à l'étape 4B

Mot de passe : nixos

Un nouveau mot de passe est demandé tout de suite (changement forcé au premier login, seulement sur les postes nominatifs -- voir Nixos_Users). Le choisir maintenant.

Étape 7 — Vérifier

Le bureau s'affiche.

Firefox s'ouvre.

Le son fonctionne.

Tout est bon → le PC est prêt.

Si ça bloque

N'insiste pas seul.

Préviens le référent technique.

---

Installer le serveur PXE

Une étape à la fois.

Étape 1 — Installer NixOS

ISO : https://nixos.org/download

Partitionnement normal.

Définir un mot de passe root.

Étape 2 — Cloner le repo

nix-shell -p git
git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git /etc/nixos-fleet
cd /etc/nixos-fleet

Étape 3 — Générer le fichier matériel

sudo nixos-generate-config

Écrit /etc/nixos/hardware-configuration.nix — en dehors du repo, rien à ajouter/committer.

Étape 4 — Éditer 3 valeurs

Fichier : pxe-server/configuration.nix

interface → sortie de ip a

serverIp → IP fixe du serveur

standaloneDhcp → laisser false si le réseau a déjà un DHCP

$EDITOR pxe-server/configuration.nix

Étape 5 — Construire

sudo nixos-rebuild switch --flake .#pxe-server --impure

--impure : nécessaire pour lire /etc/nixos/hardware-configuration.nix, hors du repo.

Étape 6 — Publier l'image

sudo systemctl start pxe-publish
sudo systemctl status pxe-publish

Doit finir en "success". Première fois : plusieurs minutes.

Étape 7 — Vérifier

sudo systemctl status dnsmasq caddy
ls /var/lib/tftpboot
ls /var/www/pxe
curl -I http://192.168.1.10/netboot.ipxe   # remplacer par le vrai serverIp

Tout doit répondre sans erreur.

Si curl reste bloqué : l'IP statique de l'interface PXE ne s'est peut-être pas appliquée toute seule au premier switch (connu, arrive parfois sur une install neuve). Vérifier :

ip a show <interface>   # cherche une ligne "inet <serverIp>/24"

Absente → forcer manuellement une fois :

sudo systemctl start network-addresses-<interface>.service

Un reboot du serveur applique aussi ça correctement au démarrage suivant.

Étape 8 — Tester sur 1 PC

Démarrer un seul PC en PXE.

Vérifier qu'il arrive sur l'écran de choix.

Si le parc a du BIOS et de l'UEFI, tester les deux.

Ne pas lancer 20 PC avant que cette étape fonctionne.

Après l'installation

Noter l'IP du serveur quelque part accessible à l'équipe.

Vérifier que pxe-publish.timer est actif :

systemctl is-enabled pxe-publish.timer

Ce serveur n'a rien à sauvegarder à part le repo git.

Entretien

Récupérer les derniers changements, et vérifier qu'ils sont bien là avant de rebuild :

git pull
git log --oneline -3

Le dernier commit affiché doit correspondre à ce que tu attends. S'il manque, le pull n'a rien ramené de neuf — inutile de rebuild avant de comprendre pourquoi (mauvaise branche, push pas fait côté dev, etc.).

Republier l'image après une modif de installer/ :

sudo systemctl start pxe-publish

Appliquer une modif de pxe-server/configuration.nix :

sudo nixos-rebuild switch --flake .#pxe-server --impure

Voir les logs DHCP/TFTP :

journalctl -u dnsmasq -f

Voir les logs HTTP :

journalctl -u caddy -f

Si ça bloque

Un fix censé être appliqué ne change rien → vérifier git log --oneline -3 avant toute autre piste (le pull n'a peut-être rien ramené).

Écran PXE ne trouve rien → revérifier serverIp et interface.

Boucle infinie au démarrage → regarder journalctl -u dnsmasq pendant un boot.

UEFI ou BIOS ne boote pas → vérifier les deux fichiers dans /var/lib/tftpboot.

IP qui changent tout le temps → un autre DHCP tourne déjà, repasser standaloneDhcp à false.

---

Référence

Contenu du repo

hosts/nixos/ → le seul profil du repo. Jamais chiffré.

diskos/plain.nix → layout disko (disque main, GPT+ESP+btrfs).

installer/ → l'image d'installation, PXE et USB. Même image pour tous les cas.

pxe-server/ → le serveur PXE (dnsmasq + Caddy).

Personnaliser le bureau (dconf)

hosts/nixos/dconf.ini contient les réglages Cinnamon (thème, fond d'écran, panneau...), chargés par home-manager à chaque rebuild.

Pour changer un réglage : le faire en direct dans l'interface Cinnamon sur une machine, puis exporter :

dconf dump /org/cinnamon/ > dconf.ini

Remplacer hosts/nixos/dconf.ini par ce fichier, commit, push. Rien à changer dans le .nix.

Changer le nom d'utilisateur ou le mot de passe

Deux fichiers à toucher, dans hosts/nixos/configuration.nix :

users.users.nixos = {
  ...
  initialPassword = "nixos";
};

Renommer nixos (l'attribut users.users.nixos) change le compte système. Changer la valeur d'initialPassword change le mot de passe.

Si le nom d'utilisateur change, mettre à jour aussi la référence dans hosts/common/default.nix (home-manager.users.nixos = ... doit cibler le même nom, sinon home-manager configure un compte qui n'existe plus).

initialPassword ne s'applique qu'à la création du compte. Sur une machine déjà installée, changer cette valeur dans le repo + laisser l'auto-upgrade tourner ne change RIEN au mot de passe réel -- NixOS ne réécrit jamais un mot de passe déjà défini. Ça ne s'applique qu'aux nouvelles installations à partir de ce moment-là.

Pour changer le mot de passe sur une machine déjà déployée : à la main, sur place ou à distance (SSH/console) :

sudo passwd nixos

Pareil pour renommer le compte sur une machine déjà installée : usermod -l ne suffit pas à tout migrer proprement (home directory, permissions) -- plus simple de considérer que le renommage ne s'applique qu'aux futures installations, pas de le faire à chaud sur le parc existant.

Réactiver un changement de mot de passe forcé

Par défaut, le compte nixos garde nixos comme mot de passe stable, sans expiration (hosts/nixos/configuration.nix). Voulu : poste partagé, pas nominatif -- forcer un changement casserait le mot de passe commun affiché sur l'étiquette/le guide remis aux gens.

nixos_users force ce changement au premier login pour les postes nominatifs, via un script d'activation one-shot (hosts/common/accounts.nix de ce repo-là) :

system.activationScripts.forcePasswordChangeOnce.text = ''
  marker=/var/lib/nixos-force-pwchange-done
  if [ ! -e "$marker" ]; then
    ${pkgs.shadow}/bin/chage -d 0 nixos
    mkdir -p /var/lib
    touch "$marker"
  fi
'';

Pour réactiver la même chose sur nixos, reprendre ce bloc tel quel dans hosts/nixos/configuration.nix (ou hosts/common/default.nix si ça doit s'appliquer à un futur deuxième profil de flotte). Le marqueur est nécessaire : sans lui, chage -d 0 s'appliquerait à nouveau à chaque nixos-rebuild switch, redemandant un mot de passe à chaque redémarrage.

Pourquoi deux repos

Une machine de la flotte pull uniquement ce repo.

Les comptes thomas/clara/jade/oreo vivent dans un autre repo, privé.

La flotte ne voit jamais ce second repo.

Graver la clé USB

Marche sans le serveur PXE. Utile pour tester avant de monter le PXE, ou en secours. Commandes : voir "Étape 0" au tout début de ce README.

NixOS permet nativement de fabriquer une image d'installation sur mesure : un ISO avec nos propres paquets et notre propre script (install.sh) qui se lance seul au démarrage. C'est une fonctionnalité standard de NixOS, pas un bricolage — installer/iso.nix dans ce repo est la définition de cette image.

C'est le même ISO pour la flotte et les postes nommés — pas deux images différentes, pas de commande de build spécifique à jade/oreo/oreo-i3. Le choix se fait à l'écran au démarrage, une fois la clé branchée sur le PC cible (voir étapes 4/4B).

Depuis Windows : construire l'ISO se fait pareil, depuis WSL, mais la graver est différent (WSL2 n'a pas accès aux disques amovibles par défaut) -- voir "Construire l'ISO et la graver, depuis Windows" dans la section WSL plus bas.

Mises à jour de la flotte

Chaque PC tire ses mises à jour directement depuis ce repo, chaque semaine (system.autoUpgrade, persistent = true : se rattrape au boot suivant même si le PC était éteint au moment prévu).

Pas de git pull manuel sur les PC en fonctionnement normal. Juste git push ici.

Appliquer un changement immédiatement (sans attendre la semaine)

1. Pousser le changement depuis le poste de dev :

git add -A
git commit -m "description"
git push

2. Sur le PC cible, trois options, du plus lent au plus immédiat :

Rien faire : le timer hebdomadaire s'en charge tout seul.

Forcer maintenant, sans y toucher physiquement (ex. à distance via SSH) : lancer le même service que le timer, il fetch tout seul depuis l'URL du repo, pas besoin que /etc/nixos soit à jour :

sudo systemctl start nixos-upgrade.service

Rebuild manuel sur place (typique en test, devant la machine) :

cd /etc/nixos
sudo git pull
sudo nixos-rebuild switch --flake .#nixos

Le git pull est obligatoire ici : contrairement à nixos-upgrade.service, ce rebuild lit les fichiers locaux de /etc/nixos, pas l'URL distante.

Avant la première vague de 100 PC

Rien de ce repo n'a été testé sur du vrai matériel.

À vérifier avant de lancer 100 PC :

Détection du disque, sur une machine à 2 disques internes.

Comportement du proxyDHCP, face au routeur réel.

Boot BIOS et boot UEFI, sur le parc réel.

Test sur 1-2 PC réels d'abord.

PC à seulement 4 Go de RAM : le zram (installer-base.nix) doit suffire pour installer nixos (Cinnamon + Firefox + LibreOffice + VLC), mais pas testé en dessous de 12 Go pour l'instant. Si ça échoue encore sur du 4 Go réel : alléger la liste de paquets de nixos plutôt que d'insister sur le zram seul.

nix flake check --no-build          # évalue nixos/installer-netboot/installer-iso
nix flake check --no-build --impure # inclut pxe-server (lit /etc/nixos, réel sur le serveur seulement)
nix build .#nixosConfigurations.nixos.config.system.build.toplevel --dry-run
nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage --dry-run

Vérifié (WSL, testé le 2026-09-12) : nixos s'évalue et résout entièrement sa fermeture de paquets sans erreur. pxe-server échoue sans --impure en dehors du vrai serveur PXE (attendu, lit /etc/nixos/hardware-configuration.nix).

Ce que ces commandes ne couvrent pas : elles vérifient que la config s'évalue et que les paquets existent, pas que le poste installé fonctionne réellement (Wi-Fi, wallpaper, LightDM, avatar...). Seul un test sur machine réelle (étape 8 plus haut) le confirme.

Connexion Wi-Fi

Pour un PC sans câble réseau (après l'installation, ou en dépannage).

Option 1 — NetworkManager

Déjà actif par défaut dans ce repo (hosts/common/default.nix). Rien à ajouter dans configuration.nix.

networking.networkmanager.enable = true;

Commandes :

nmcli device wifi list
nmcli device wifi connect "SSID" password "MOTDEPASSE"
nmcli connection show
nmcli radio wifi on

Option 2 — iwd

Alternative non nécessaire. Plus léger que NetworkManager, mais NetworkManager est déjà en place et suffit — à utiliser seulement si une raison précise l'impose.

configuration.nix :

networking.wireless.iwd.enable = true;

Commandes :

iwctl station wlan0 scan
iwctl station wlan0 get-networks
iwctl station wlan0 connect "SSID"
iwctl station wlan0 show

Aucun paquet à installer manuellement : enable = true suffit dans les deux cas.

Après édition :

sudo nixos-rebuild switch --flake .#nixos

---

Environnement de dev sous Windows (WSL + Nix)

Pour tester nix flake check / nix build depuis un poste Windows. Nix ne tourne pas nativement sur Windows : il faut un vrai noyau Linux, donc WSL2.

Installer WSL2

PowerShell en administrateur :

wsl --install

Installe WSL2 + Ubuntu par défaut. Redémarrer si demandé, puis laisser Ubuntu créer l'utilisateur Linux (indépendant du compte Windows).

Installer Nix

Dans le terminal Ubuntu, commande officielle (nixos.org) :

curl --proto '=https' --tlsv1.2 -L https://nixos.org/nix/install | sh -s -- --daemon

Fermer/rouvrir le terminal ensuite. Vérifier :

nix --version

Les flakes sont activées par défaut sur les versions récentes de Nix (2.35+) — rien à configurer en plus. Si nix flake check répond une erreur experimental-features, ajouter dans /etc/nix/nix.conf :

experimental-features = nix-command flakes

Utiliser les repos depuis WSL

Les fichiers Windows sont accessibles depuis WSL sous /mnt/c/... — pas besoin de cloner une deuxième fois :

cd "/mnt/c/Users/<toi>/Desktop/Claude/Nixos/nixos_fleet"
nix flake check --no-build

pxe-server échouera à nix flake check (sans --impure) : il lit /etc/nixos/hardware-configuration.nix, qui n'existe que sur le vrai serveur PXE. Normal, pas une régression.

Si "pas de réseau" dans WSL

Symptôme typique : ping 8.8.8.8 répond, mais curl https://nixos.org (ou tout domaine) time out à la résolution — le tunnel DNS de WSL2 est cassé (fréquent avec VPN/antivirus). Vérifier :

curl -m 5 https://1.1.1.1        # IP brute : doit marcher
curl -m 5 https://nixos.org      # domaine : si ça time out, c'est le DNS

Correctif (côté Windows, PowerShell, pas besoin d'être admin) : créer %USERPROFILE%\.wslconfig avec :

[wsl2]
networkingMode=mirrored

Puis wsl --shutdown et rouvrir Ubuntu. Ce mode partage directement la pile réseau de Windows à WSL, au lieu de passer par le NAT + proxy DNS interne.

Construire l'ISO et la graver, depuis Windows

Depuis un terminal WSL (voir "Installer WSL2" plus bas si pas encore fait) :

cd "/mnt/c/Users/<toi>/Desktop"
git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
cd Nixos_Fleet
nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
cp result/iso/*.iso ./nixos-installer.iso

nixos-installer.iso apparaît dans l'explorateur Windows, dans le dossier du repo (cp copie le vrai fichier ; result seul est un lien Linux, invisible depuis Windows).

Graver avec Rufus (ou balenaEtcher, Win32DiskImager) : ouvrir l'outil → sélectionner nixos-installer.iso → sélectionner la clé USB → lancer.

Puis reprendre à l'étape 1 de "Installer un PC" tout en haut.

Ne pas faire dd directement depuis WSL : WSL2 n'a par défaut aucun accès à la clé USB (source). Rufus est plus simple et fonctionne toujours. Alternative avancée (rattacher la clé à WSL et faire dd comme sur Linux) : usbipd-win.

Appeler nix depuis un outil qui pilote WSL sans shell interactif

wsl.exe nix --version échoue avec nix: command not found : une commande non-interactive ne source pas le profil qui ajoute nix au PATH. Forcer un shell de login :

wsl.exe -e bash -lc "nix --version"

---

Travailler avec Git

Cloner (première fois)

git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
cd Nixos_Fleet

Avant de modifier

git pull

Toujours, avant de commencer à éditer.

Modifier et envoyer

git add -A
git commit -m "description courte"
git push

Si le push est refusé

Quelqu'un a poussé avant toi.

git pull

Résoudre les conflits s'il y en a (voir plus bas).

Puis repousser :

git push

Travailler à plusieurs

Un repo, plusieurs personnes : risque d'écraser le travail des autres.

Règle : une branche par changement.

git checkout -b mon-changement

Modifier. Commit. Push la branche :

git push -u origin mon-changement

Ouvrir une Pull Request sur Gitea.

Quelqu'un relit, merge depuis l'interface Gitea.

Jamais de push direct sur main à plusieurs.

Si un conflit apparaît

Git l'annonce avec CONFLICT dans le message.

Ouvrir le(s) fichier(s) listé(s).

Chercher les marqueurs <<<<<<<, =======, >>>>>>>.

Choisir quelle version garder.

Supprimer les marqueurs.

git add <fichier>
git commit
git push

Ce workflow git ne concerne que les développeurs

Les PC de la flotte ne font jamais git pull.

Ils tirent les mises à jour directement depuis l'URL git (voir plus haut).