04 — INSTALLATION : monter le système pas à pas

Où suis-je ? Tu as choisi ton matériel (02) et validé le concept (03). Ici on installe le cluster : cerveau → nœuds → surveillance. Suite : Opération.

Vue d’ensemble des étapes

Cerveau : CAS 2 → boot de la clé USB Winux sur la carte mère PC · CAS 3 → flash Debian/Armbian ARM64 · CAS 4 → flash Linux ARM64 glibc sur le smartphone
Nœuds : joindre chaque carte mère (ARM64 ou amd64) avec le token
Labels d’architecture : k8s/labels-arch.yaml
Vérifs hardware : hub-scan.sh, hub-ports.sh, hub-keys.sh
Surveillance : dashboard dédié + (option) Rancher/Portainer/Cockpit

1. Le cerveau (CAS 2 — clé de boot / CAS 3 — SBC / CAS 4 — smartphone)

Prérequis commun : Ethernet Gigabit et ≥ 8 Go de RAM (voir Matériel).

CAS 2 (MVP) : brancher la clé de boot USB sur la carte mère PC (mini-PC récupéré) → régler l’ordre de boot BIOS sur USB → Winux s’installe depuis la clé → la carte mère devient le maître.

CAS 3 : SBC ≥ 8 Go (Pi 5…) avec Debian/Armbian ARM64 flashée sur MicroSD.

CAS 4 : smartphone ARM64 (Pixel 6/7/8, OnePlus 9/10/11) avec bootloader débloqué → flash d’un Linux ARM64 glibc (postmarketOS variante glibc, Ubuntu Touch ou Manjaro ARM) sur le stockage interne → dock USB-C avec Ethernet GbE branché → le smartphone devient le maître.

# k3s control-plane (désactive traefik, qui n'est pas utile ici)
curl -sfL https://get.k3s.io | sh -s - --disable traefik

# Personnalisation du boîtier (taint, rôles, timezone, etc.)
sudo cp scripts/brain-install.sh /root/ && sudo bash /root/brain-install.sh

# Récupérer le token de jointure (à donner à chaque nœud)
sudo cat /var/lib/rancher/k3s/server/node-token

2. Les nœuds de calcul

Smartphone (ARM64)

# 1. Récupérer le token sur le cerveau (étape 1)
# 2. Sur le phone (via ADB ou script) :
curl -sfL https://get.k3s.io |
  K3S_URL=https://<IP-BOITIER>:6443 K3S_TOKEN=<TOKEN> sh -

Ou via le script prêt à l’emploi : sudo bash scripts/join-arm64.sh.

PC (amd64)

Même principe, ou via une VM Proxmox :

curl -sfL https://get.k3s.io |
  K3S_URL=https://<IP-BOITIER>:6443 K3S_TOKEN=<TOKEN> sh -

Script : sudo bash scripts/join-amd64.sh.

Règle d’or : Proxmox VE tourne uniquement sur les nœuds PC (amd64). Jamais sur le boîtier ARM.

3. Labels d’architecture

Pour que les pods atterrissent sur le bon type de processeur :

kubectl apply -f k8s/labels-arch.yaml
kubectl get nodes -o wide   # vérifier les colonnes arch + état

4. Vérifications hardware

sudo bash scripts/hub-scan.sh      # ports par famille (serveurs/clés/dongles)
sudo bash scripts/hub-ports.sh     # tty serveurs (ttyUSB0..9)
sudo bash scripts/hub-keys.sh      # montage des clés dans /mnt/keys/
bash scripts/node-control.sh status phone-01   # contrôle sans contact
bash scripts/status.sh             # état global du cluster

5. Surveillance & interfaces

Dashboard dédié (sur mesure — port 8081)

sudo bash dashboard/install-dashboard.sh
# → http://<IP-BOITIER>:8081

Cerveau (uptime/RAM), ports (hub-scan.sh), nœuds k3s, boutons de contrôle (node-control.sh) et déploiement LLM (deploy-llm.sh) en un clic.

Interfaces éprouvées (optionnelles)

Outil	Usage	Install rapide
Rancher (Helm)	Cluster k3s + web UI	`helm install rancher rancher-latest/rancher -n cattle-system --set hostname=rancher.local`
Portainer	Variante Docker Swarm	`docker run -d --name portainer -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce`
Cockpit	Admin du boîtier	`apt install -y cockpit && systemctl enable --now cockpit.socket`

Rancher veut ~2 Go de RAM en plus sur le control-plane → 8 Go conseillés.

6. Provisioning PXE — réinstallation d’OS à distance (optionnel)

Permet au maître de réinstaller l’OS de n’importe quel esclave sans clé USB ni contact (Boot PXE). Prérequis : switch Ethernet Gigabit, tous les esclaves reliés en RJ45, Boot Réseau (PXE) en première priorité dans le BIOS de chaque esclave, et un gros SSD sur le maître pour les images d’OS.

Option débutant — FOG Project ou Cobbler (clé en main)

# FOG Project (interface web, images d'OS par le réseau)
# → https://fogproject.org/ — installation guidée sur le maître
# Cobbler (plus léger, CLI + web)
sudo apt install -y cobbler cobbler-web
sudo systemctl enable --now cobblerd

Une fois installés : ajouter une image d’OS, puis « réinstaller la machine X » en un clic depuis l’interface web.

Option professionnelle — Canonical MAAS (standard industrie)

# MAAS transforme les cartes mères en « cloud privé »
sudo snap install maas
sudo maas init --mode all
sudo maas createadmin --username admin --email admin@example.com
# → PXE + réseau gérés tout seuls ; clic « Installer Ubuntu/CentOS », « Éteindre »

Vérification

# Le maître répond-il aux requêtes PXE ? (DHCP + TFTP actifs)
sudo systemctl status tftp-hpa    # FOG/Cobbler
# ou
sudo systemctl status maas-dhcpd  # MAAS

7. Accès sans fil — 2 modes au choix (prêts à copier)

Le boîtier maître est headless (pas d’écran permanent). Deux modes permettent d’y accéder sans câble après le boot. Les deux sont des services systemd qui démarrent automatiquement. Il faut un module/dongle WiFi (plugin WIFI-1).

⚠️ Règle d’or (05 §5) : le WiFi sert à accéder au boîtier et au dashboard, pas au trafic LLM entre nœuds (préférer Ethernet Gigabit pour le sharding --rpc).

Mode A — Connexion au WiFi local existant (le plus simple)

Le boîtier rejoint ton réseau WiFi au démarrage. Accès ensuite :

par IP : http://192.168.x.x:8081
par nom : http://winux-maitre.local:8081 (mDNS/avahi)

Fichier /etc/netplan/50-wifi.yaml (à adapter : SSID + mot de passe) :

network:
  version: 2
  wifis:
    wlan0:
      dhcp4: true
      access-points:
        "NOM_DU_WIFI":
          password: "MOT_DE_PASSE"

Activer puis tester :

sudo netplan apply
ip a show wlan0            # l'adresse obtenue (192.168.x.x)
# mDNS (facultatif mais pratique) :
sudo apt install -y avahi-daemon && sudo systemctl enable --now avahi-daemon
ping winux-maitre.local    # répond par son nom

Mode B — Point d’accès WiFi autonome (hotspot « WINUX-XXXX »)

Le boîtier crée son propre réseau sans fil, sans aucun réseau existant. Vous vous y connectez depuis un téléphone/PC → http://192.168.4.1:8081.

Fichier /etc/hostapd/hostapd.conf (point d’accès) :

interface=wlan0
ssid=WINUX-MAITRE
country_code=FR
hw_mode=g
channel=6
wmm_enabled=0
auth_algs=1
wpa=2
wpa_passphrase=CHANGE-MOI
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP

Fichier /etc/dnsmasq.conf (serveur DHCP du hotspot) :

interface=wlan0
dhcp-range=192.168.4.10,192.168.4.50,255.255.255.0,12h
address=/#/192.168.4.1

Activer au boot :

sudo apt install -y hostapd dnsmasq
sudo systemctl unmask hostapd
sudo systemctl enable --now hostapd dnsmasq

🔁 Basculer entre les modes : désactiver le service inutilisé : sudo systemctl disable --now hostapd dnsmasq (mode B) ou enlever le fichier netplan et sudo netplan apply (mode A). Un boîtier peut aussi cumuler les deux (WiFi en client + USB Ethernet), mais pas deux réseaux sur la même wlan0.

8. Variante Docker Swarm (alternative à k3s)

# Sur le cerveau
apt-get install -y docker.io
docker swarm init --advertise-addr <IP-BOITIER>
docker node update --availability drain <nom-boîtier>

# Sur chaque carte mère
docker swarm join --token <TOKEN-WORKER> <IP-BOITIER>:2377

# Déployer avec placement par arch
docker service create --name app --replicas 4 \
  --constraint 'node.platform.arch == arm64' nginx

Swarm gère nativement le multi-arch (amd64 + arm64). Choix : k3s (défaut du projet) ou Swarm — les deux coexistent dans le projet.

9. Voyant allumé ✅ — et ensuite ?

Le cluster est monté. Passe à l’exploitation au quotidien → Opération (contrôle des cartes, clés USB, déploiement de LLM).