Nixos_Fleet/README.md

# 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](../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 :

```bash
nix-shell -p git
```

Équivalent flakes :

```bash
nix shell nixpkgs#git
```

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

```bash
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 1 — Brancher

Branche le câble réseau.

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.

## É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](../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

```bash
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

```bash
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

```bash
$EDITOR pxe-server/configuration.nix
```

## Étape 5 — Construire

```bash
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

```bash
sudo systemctl start pxe-publish
sudo systemctl status pxe-publish
```

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

## Étape 7 — Vérifier

```bash
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 :

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

Absente → forcer manuellement une fois :

```bash
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 :

```bash
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 :

```bash
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/` :

```bash
sudo systemctl start pxe-publish
```

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

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

Voir les logs DHCP/TFTP :

```bash
journalctl -u dnsmasq -f
```

Voir les logs HTTP :

```bash
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 :

```bash
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` :

```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) :

```bash
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à) :

```nix
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.

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 : `2) poste nommé` puis le prénom -- voir "Étape 4 — Choisir un cas" et "Étape 4B" plus haut pour le déroulé exact (prénom, chiffrement, token Gitea).

Le fichier `.iso` n'existe pas tant qu'on ne l'a pas construit :

```bash
nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
```

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

```bash
lsblk
```

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

Vérifier `/dev/sdX` avant de lancer `dd`.

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 :

```bash
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 :

```bash
sudo systemctl start nixos-upgrade.service
```

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

```bash
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.

```bash
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`.

```nix
networking.networkmanager.enable = true;
```

Commandes :

```bash
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` :

```nix
networking.wireless.iwd.enable = true;
```

Commandes :

```bash
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 :

```bash
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** :

```powershell
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) :

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

Fermer/rouvrir le terminal ensuite. Vérifier :

```bash
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 :

```bash
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 :

```bash
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

Construire l'ISO fonctionne exactement comme sur Linux, depuis WSL (voir "Utiliser les repos depuis WSL" plus haut) :

```bash
cd "/mnt/c/Users/<toi>/Desktop/Claude/Nixos/nixos_fleet"
nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
```

`result` est un lien symbolique qui pointe dans `/nix/store/...` -- un chemin qui n'existe que côté Linux. Vu depuis Windows (Explorer, PowerShell, même via `\\wsl$\...`), ce lien apparaît comme un objet de 0 Ko, pas comme un dossier : **ne pas essayer d'y accéder directement depuis Windows**, ça ne marche pas de façon fiable.

Copier le vrai fichier (pas le lien) résout ça -- par exemple directement dans le dossier du repo, déjà visible depuis Windows et déjà ignoré par git (`.gitignore`) :

```bash
cp result/iso/*.iso ./nixos-installer.iso
```

`nixos-installer.iso` apparaît alors normalement dans l'explorateur Windows, au même endroit que le reste du repo -- prêt pour Rufus.

**Le graver sur la clé USB est une autre affaire** : WSL2 n'a par défaut aucun accès aux disques amovibles (`wsl --mount` ne fonctionne que sur des disques fixes/VHD, pas sur une clé USB -- source : [Microsoft Learn](https://learn.microsoft.com/en-us/windows/wsl/connect-usb)). Deux façons de faire, pas de troisième :

**Option simple (recommandée)** : graver `nixos-installer.iso` (le fichier copié ci-dessus) avec un outil Windows natif (Rufus, balenaEtcher, Win32DiskImager...). Fonctionne toujours, aucune configuration supplémentaire.

**Option avancée** : rattacher la clé USB à WSL avec [usbipd-win](https://github.com/dorssel/usbipd-win) ([doc officielle](https://learn.microsoft.com/en-us/windows/wsl/connect-usb)), puis utiliser `dd` normalement depuis WSL comme sur Linux :

```powershell
winget install --interactive --exact dorssel.usbipd-win
usbipd list                          # repérer le bus ID de la clé USB
usbipd attach --wsl --busid <busid>
```

Puis, dans WSL, `lsblk` doit faire apparaître la clé (ex. `/dev/sde`) -- vérifier ce nom avant tout `dd` (voir la mise en garde `dd` dans [AGENTS.md](AGENTS.md)).

## 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 :

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

---

# Travailler avec Git

## Cloner (première fois)

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

## Avant de modifier

```bash
git pull
```

Toujours, avant de commencer à éditer.

## Modifier et envoyer

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

## Si le push est refusé

Quelqu'un a poussé avant toi.

```bash
git pull
```

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

Puis repousser :

```bash
git push
```

## Travailler à plusieurs

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

Règle : une branche par changement.

```bash
git checkout -b mon-changement
```

Modifier. Commit. Push la branche :

```bash
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.

```bash
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).