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

## Index

- [Installer depuis un NixOS déjà installé](#installer-depuis-un-nixos-déjà-installé) -- appliquer cette config sans réinstaller, partitionnement existant préservé
- [Installer un PC](#installer-un-pc) -- clé USB ou PXE, depuis zéro (reformate le disque)
- [Installer le serveur PXE](#installer-le-serveur-pxe)
- [Référence](#référence)
- [Environnement de dev sous Windows (WSL + Nix)](#environnement-de-dev-sous-windows-wsl--nix)
- [Travailler avec Git](#travailler-avec-git)

---

# Installer depuis un NixOS déjà installé

Pour appliquer cette config (flotte ou poste nommé) sur une machine où NixOS tourne déjà -- sans réinstaller, **sans toucher au partitionnement existant**. Utilise `nixos-existing` (flotte, ce repo) ou `<profil>-existing` (poste nommé, [Nixos_Users](../nixos_users)) : même profil logiciel que l'install normale, mais basé sur le `hardware-configuration.nix` réel de la machine plutôt que sur disko.

Pour repartir de zéro (reformater le disque) à la place : voir "Installer un PC" plus bas.

## Flotte

```bash
git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git /etc/nixos-fleet
cd /etc/nixos-fleet
sudo nixos-rebuild switch --flake .#nixos-existing --impure
```

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

## Poste nommé (thomas/clara/jade/oreo/oreo-i3)

Repo privé -- voir "Token Gitea" dans [Nixos_Users](../nixos_users) pour en obtenir un.

```bash
git clone https://<token>@gitea.miniclic.net/Damien/Nixos_Users.git /etc/nixos-users
cd /etc/nixos-users
sudo nixos-rebuild switch --flake .#oreo-existing --impure
```

Remplacer `oreo-existing` par le profil concerné (`thomas-existing`, `clara-existing`, `jade-existing`, `oreo-i3-existing`).

Pour que les mises à jour automatiques continuent de fonctionner ensuite (repo privé), créer le netrc à la main -- normalement écrit par `install.sh`, absent ici puisqu'on ne passe pas par l'installeur :

```bash
sudo mkdir -p /etc/nix
{
  echo "machine gitea.miniclic.net"
  echo "login <token>"
  echo "password x-oauth-basic"
} | sudo tee /etc/nix/netrc
sudo chmod 600 /etc/nix/netrc
```

## Maintenance

Identique au reste du repo (voir "Mises à jour de la flotte" en Référence), avec `nixos-existing` (ou `<profil>-existing`) à la place de l'attribut normal :

```bash
cd /etc/nixos-fleet   # ou /etc/nixos-users
sudo git pull
sudo nixos-rebuild switch --flake .#nixos-existing --impure
```

# 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 0 — Support d'installation

Deux supports possibles, choisis-en un.

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

**Ce n'est pas l'ISO de nixos.org.** Celle-ci est construite depuis ce repo (`installer/iso.nix`) : paquets propres au parc (git, outils de partitionnement...), clavier/locale FR par défaut, et surtout `install.sh` qui se lance seul à l'ouverture de session -- l'ISO officielle démarre sur un shell nu, sans rien de tout ça, il faudrait tout faire à la main (partitionnement, `nixos-install`...).

Le `nix build` ci-dessous est **long** (10 à 30+ minutes) et n'affiche presque rien pendant la majeure partie du temps -- l'étape la plus lente (`mksquashfs`, compression de tout le store Nix pour l'ISO) ne montre aucune progression. Normal, pas figé : vérifier avec `top`/`htop` qu'un processus consomme du CPU avant de penser à interrompre.

**Clé USB, sur Linux :**

```bash
git clone https://gitea.miniclic.net/Damien/Nixos_Fleet.git
cd Nixos_Fleet
nix build .#nixosConfigurations.installer-iso.config.system.build.isoImage
lsblk                                              # repérer la clé -- pas ton disque système
sudo dd if=result/iso/*.iso of=/dev/sdX bs=4M status=progress conv=fsync
```

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

**Clé USB, sur Windows** (dans un terminal WSL2 -- voir "Installer WSL2" plus bas si pas encore fait) :

```bash
cd "/mnt/c/Users/<toi>/Desktop"    # ou un autre dossier Windows de ton choix
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
```

`dd` ne fonctionne pas depuis WSL2 (pas d'accès à la clé USB par défaut, [source](https://learn.microsoft.com/en-us/windows/wsl/connect-usb)). `nixos-installer.iso` apparaît dans l'explorateur Windows, dans le dossier du repo -- le graver avec [Rufus](https://rufus.ie/) (ou balenaEtcher, Win32DiskImager).

Une fois la clé prête (Linux ou Windows) : va à l'étape 1.

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

Suivre "Installer un PC" (Network Boot au lieu de Boot from USB) sur une seule machine avant d'en lancer 20. Tester BIOS et UEFI séparément si le parc a les deux.

## 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. 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 : mêmes commandes, dans WSL -- voir "Étape 0", section Windows.

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

Commandes complètes : voir "Étape 0 — Support d'installation" tout en haut de ce README.

Alternative avancée à Rufus (rattacher la clé USB à WSL et faire `dd` comme sur Linux) : [usbipd-win](https://github.com/dorssel/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 :

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