# Nixos_Fleet

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

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 ou oreo → 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 ou oreo).

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

Mot de passe : `nixos`

Mot de passe stable, ne change jamais tout seul et n'est jamais redemandé (poste partagé, pas nominatif -- 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/usagers/` → 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/usagers/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/usagers/dconf.ini` par ce fichier, commit, push. Rien à changer dans le `.nix`.

## Réactiver un changement de mot de passe forcé

Par défaut, `usagers` garde `nixos` comme mot de passe stable, sans expiration (`hosts/usagers/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 usagers
    mkdir -p /var/lib
    touch "$marker"
  fi
'';
```

Pour réactiver la même chose sur `usagers`, reprendre ce bloc tel quel dans `hosts/usagers/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. Le choix se fait à l'écran au démarrage (`1) flotte` / `2) poste nommé`), pas au moment de la gravure.

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

## Mises à jour de la flotte

Chaque PC tire ses mises à jour directement depuis ce repo, chaque semaine.

Pas de `git pull` manuel sur les PC. Juste `git push` ici.

## 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 `usagers` (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 `usagers` plutôt que d'insister sur le zram seul.

```bash
nix flake check --no-build          # évalue usagers/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.usagers.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) : `usagers` 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 .#usagers
```

---

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

## 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).