Découper un serveur physique en cellules d'exécution Linux cloisonnées et contingentées — les Sparks — dont la seule raison d'être est d'héberger une pile Docker Compose déjà industrialisée.
Un Spark, c'est un hôte Docker à soi : 0,5 CPU, 16 Gio de RAM, 10 Gio de
disque, 100 Mbit/s, une IP privée, ses clés SSH, ses domaines. Prélevés sur les
pools du serveur, comptabilisés, et rendus à la suppression.
INTERNET
│
22 / 80 / 443 seulement
│
┌────────────────────▼─────────────────────┐
│ SERVEUR PHYSIQUE │
│ sshd :22 Caddy :80 :443 │
│ 127.0.0.1:9876 sparkd │
│ bridge privé sparkbr0 │
│ ┌───────────────┼───────────────┐ │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │ SPARK │ │ SPARK │ │ SPARK │ │
│ │ dockerd│ │ dockerd│ │ dockerd│ │
│ └────────┘ └────────┘ └────────┘ │
└──────────────────────────────────────────┘
Le point de bascule : Docker n'est plus la frontière d'isolation. Docker appartient au locataire ; le Spark est la frontière. C'est ce qui permet de reprendre une pile Compose existante sans la réécrire.
Ce n'est pas un PaaS, pas un ordonnanceur de conteneurs, pas un Kubernetes de poche. C'est un très petit plan de contrôle de VPS privé, dont l'unité n'est ni une application ni une fonction, mais une cellule d'exécution à quota.
L'idée d'origine est conservée intégralement dans docs/ORIGIN_CONVERSATION.md.
Spark Environment est un gestionnaire de métal en service (metal as a service) : il sert le métal d'un serveur physique, découpé en cellules. Le vocabulaire suit la métallurgie.
- La Forge est le serveur physique, le métal lui-même, et l'atelier où l'on travaille ce métal.
- Forger un nouveau serveur dans la Forge, c'est en couler un : chaque coulée fait jaillir une étincelle — un Spark.
Le nom de la machine a été tranché le 2026-08-19, avec les candidats écartés et leurs motifs, dans le journal.
Le plan de contrôle tourne sur une Forge réelle. 149 unités au 2026-10-06 : 114 closes, 21 partielles, 14 non commencées — dont SPK-113, qui attend une mesure, et les neuf du lot 7. Le lot 6, Réseau entre Sparks, ouvert le 2026-09-17, a été clos le 2026-09-18. Le lot 7, La console hébergée derrière le SSO du domaine, est décidé depuis le 2026-09-26 et spécifié au §64 du DAT ; rien n'en est encore livré. L'état de chacune est dans docs/BACKLOG.md, qui fait foi — ce paragraphe se périme, lui.
Ce qui est établi par la mesure, et non par intention :
- une pile Docker Compose réelle tourne dans un Spark non privilégié, à plages UID/GID disjointes, sous AppArmor actif et sans aucun contournement ;
- elle est servie publiquement en TLS :
HTTPS 200, certificat Let's Encrypt, chaîne vérifiée depuis l'extérieur, et404sur un domaine non routé ; - un port publié de la Forge atteint réellement un Spark depuis Internet, et son retrait referme le port ;
- la réservation CPU est un plancher :
47,9 %obtenus pour47,4 %prédits, sous contention des trois tranches. Garantie sous contention totale, dépassée quand la Forge est au repos ; - un Spark saturé reste reconfigurable, un Spark redimensionné l'est à chaud, et un Spark dont la cellule a disparu se reconstruit.
Ce que la mesure a infirmé en chemin, et qui est corrigé dans le
DAT : le paquet Docker d'une distribution est inutilisable sous
imbrication — son profil AppArmor refuse socketpair() —, et un conteneur
n'hérite jamais de l'environnement ambiant de sa cellule.
La campagne du catalogue du 2026-09-08 a balayé les 24 familles que publie le
dépôt amont, une cellule chacune. Elle a établi que cinq d'entre elles sont
servies — apt, apk, dnf, zypper, pacman — et que la famille RHEL reçoit
Docker aussi bien que Debian. Elle a aussi infirmé trois choses que le produit
tenait pour vraies : les images Debian d'aujourd'hui embarquent un sshd ;
la suite d'une distribution dérivée ne se recopie pas de VERSION_CODENAME ; et
une famille sans dépôt Docker n'est pas pour autant une famille qu'on ne sait pas
équiper. Le détail est au §42.11 du DAT.
Ce qui manque encore tient en trois lignes : le plan de reprise n'est joué
qu'à moitié, l'installation n'a jamais été rejouée sur une machine neuve, et rien
n'a jamais tourné ailleurs que sur cette Forge-là. Le détail est au §13 du
DAT et dans les unités [~].
Dell PowerEdge R320, relevé le 2026-09-01, après réinstallation complète depuis
un schéma de partitionnement qui réserve sda5 et sdb5 — la règle qui produit un
tel schéma pour n'importe quelle offre est décrite plus bas.
| Ressource | Capacité physique | Remarque |
|---|---|---|
| CPU | Xeon E5-1410 v2, 4 cœurs / 8 threads, 1 socket, 1 nœud NUMA | SMT actif, frères (0,4) (1,5) (2,6) (3,7) |
| RAM | 94 Gio (4 × 16 Gio DDR3-1600) | aucun swap actif |
| Stockage | 200 Gio système + 5,25 Tio de pool | 2 × 6 To Toshiba MG08 7200 tr/min ; md1 RAID1 → /, sda5+sdb5 miroir ZFS natif → pool spark |
| Réseau | 1 Gbit/s (eno1) |
eno2 non raccordé |
| Système | Ubuntu 26.04.1, noyau 7.0, systemd 259, cgroup v2 | Incus 7.4, ZFS 2.4.1 ; VT-x présent, donc runtime: vm possible |
Les pools réels sont donc plus petits que ceux évoqués dans la conversation d'origine — 94 Gio et non 256, 1 Gbit/s et non 3. Sur 4 cœurs physiques, dédier un cœur coûte un quart de la machine : le mode partagé n'est pas seulement le défaut, c'est le mode normal sur cette machine.
Ce que le partitionnement à la commande a débloqué : cette machine a
d'abord été livrée avec ses deux disques entièrement consommés par un unique
RAID1 ext4 monté sur /, sans aucun périphérique bloc libre — la disposition
sur fichier était alors la seule possible. Le schéma de partitionnement fourni à la création
réserve désormais sda5 et sdb5, et la Forge tourne sur un miroir ZFS
natif. Le partitionnement ne se change plus après la
livraison : il se décide à la commande. Voir le §8 du DAT.
Le runtime de Forge est un paquet Python autonome : les migrations et les unités systemd voyagent avec lui. Depuis un poste ayant l'accès SSH, sur une Forge dont les prérequis Incus, pool, bridge et Caddy sont déjà conformes :
ssh <compte>@<forge> 'sudo apt-get update && sudo apt-get install -y --no-install-recommends git python3-venv && sudo python3 -m venv /opt/sparkd/venv'
ssh <compte>@<forge> 'sudo /opt/sparkd/venv/bin/pip install --upgrade "git+https://github.com/P2Enjoy/spark-environment.git@main#subdirectory=services/sparkd" && sudo /opt/sparkd/venv/bin/python -m sparkd.install'Le second geste redémarre brièvement le plan de contrôle et ne réussit qu'après
/healthz et le préflight. Il ne supprime jamais /var/lib/sparkd/spark.db.
La procédure complète et son retour arrière sont dans le
runbook d'agent.
Fixé par le responsable le 2026-09-26 (docs/DAT.md §64.3, point 11). Les deux
premières étapes existent ; les suivantes sont celles du lot 7, pas encore
livrées.
cloud-initprépare le serveur métal et y installesparkd—deploy/cloud-init/, décrit plus bas (disponible).- La console locale joint la Forge et installe le SSO du domaine dans un
Spark, selon le runbook du dépôt
lelabs-sso(disponible : c'est ainsi quesso-p2enjoya été installé). - La console locale installe la console hébergée par un geste guidé : un
Spark marqué infrastructure, la route
forge.lelabs.tech, la build de la Forge (lot 7, SPK-125). - L'interface de vérification du SSO crée le client de la console, à partir de la déclaration que le geste a composée ; son secret devient un secret de la cellule (lot 7).
- Le geste vérifie le client et une connexion d'essai, puis active
l'exigence du SSO. Dès lors, on administre par
https://forge.lelabs.tech, et la console locale sert au secours (lot 7).
Le produit ne suppose ni le nom du pool, ni son emplacement, ni sa taille. Le pool se crée par un geste, et toutes ses valeurs viennent de l'environnement :
sudo SPARK_POOL_SOURCE=/dev/sda5,/dev/sdb5 scripts/creer-pool.shSur une machine commandée avec les fichiers que produit scripts/preparer-forge.py (voir
plus bas), le pool est déclaré à l'hébergeur par le schéma de partitionnement et
l'amorce l'adopte au premier démarrage ; elle n'appelle ce geste elle-même qu'en repli, si
aucun pool n'est importable. Le lancer à la main reste le geste de secours, ou celui d'une
machine installée autrement.
| Variable | Rôle | Défaut |
|---|---|---|
SPARK_POOL_NAME |
nom du pool à créer | spark |
SPARK_POOL_DRIVER |
pilote Incus — zfs, btrfs, dir |
zfs |
SPARK_POOL_SOURCE |
les deux supports du miroir, séparés par une virgule — obligatoire | aucun |
Le script est idempotent : sur un pool déjà en place, il ne touche à rien. Il refuse de créer un pool sur un support qui porte déjà des données, et montre ce qu'il y a trouvé. Il refuse aussi de créer un pool sans miroir.
Ce que le miroir natif apporte en propre : ZFS gère lui-même la redondance,
donc il détecte et répare la corruption silencieuse. Un md RAID1 ne le peut
pas — il ignore laquelle des deux copies est la bonne.
Depuis le 2026-09-02, c'est une règle d'éligibilité, pas un manque
(docs/DAT.md §8.5). Une machine qui n'a ni pool ZFS existant, ni deux supports
libres sur deux disques physiques distincts, n'est pas une Forge installable.
Sont hors périmètre :
- le VPS à disque unique entièrement alloué à
/, qui ne se repartitionne pas après livraison ; - toute machine n'offrant qu'un seul support libre.
Un support est un disque entier libre ou une partition libre — y compris sur un disque qui porte le système, ce qui est précisément le cas du schéma que produit la commande ci-dessous. Le remède à une machine inéligible est en amont : la commander partitionnée, ou lui ajouter un disque. Le produit promet le quota, les instantanés et le miroir ; il n'offre pas de repli qui n'en tiendrait que deux en silence.
Le pool sur fichier, décrit ici jusqu'au 2026-09-02, est retiré : il n'apportait pas la protection contre la corruption silencieuse, n'a jamais été exécuté sur une Forge réelle, et portait la plus grande part de la surface d'installation. Une Forge déjà installée ainsi continue de fonctionner ; le préflight la relève en avertissement et l'assistant n'en reproduira pas.
Pour une offre déjà relevée, refaire un serveur de la même configuration tient en deux collages dans la console de l'hébergeur :
-
Le JSON de partition, versionné, dans l'éditeur de partitions (Custom configuration) :
Offre (Scaleway Elastic Metal) JSON de partition à coller EM-L101X-SATAEM-L101X-SATA.partitionnement.jsonEM-B311X-SATAEM-B311X-SATA.partitionnement.json -
Le cloud-init, produit à la demande, par le nom de l'offre, dans Cloud-init configuration :
python3 scripts/preparer-forge.py cloud-init --offre EM-B311X-SATA
Le cloud-init n'est pas versionné, et c'est voulu : il dépend de l'amorce et de
creer-pool.sh, qui évoluent. Une copie versionnée serait en retard sur eux et poserait une
vieille amorce sur une machine neuve ; la commande l'écrit toujours depuis l'amorce
courante. Le JSON de partition, lui, ne dépend que de la règle : il est versionné, et
une preuve échoue s'il n'est plus ce que la commande produit.
Le cloud-init est léger par défaut (environ 1 Ko) : il ne contient pas les
scripts. Au premier démarrage il les télécharge depuis GitHub au commit épinglé
(sha complet, celui de HEAD à la génération), vérifie leur sha256 et ne lance l'amorce
que si l'empreinte est bonne. C'est la réponse au refus de l'hébergeur : un user-data qui
embarquait les scripts (19 431 octets) a été refusé, « HTTP error 400: Invalid argument:
UserData: greater than max ». La commande refuse de produire un cloud-init qui ne
marcherait pas : si un script local diffère de celui du commit (committez d'abord), ou si
le commit n'est pas poussé (poussez d'abord). Pour un cloud-init autonome, sans
téléchargement : --embarquer (environ 11 Ko, les lignes de commentaire des scripts en
moins) ou --embarquer --compresser (environ 6,6 Ko).
Le schéma original de chaque offre est versionné à côté
(deploy/cloud-init/offres/) : c'est l'entrée de
scripts/preparer-forge.py. Chez un hébergeur qui accepte un
schéma de partitionnement à la création du serveur — Scaleway le fait —, c'est ce qui évite
tout repartitionnement ultérieur (il ne se change plus après la livraison : seule une
réinstallation le refait).
Pour une offre nouvelle : dans la console, à la commande, section Configure disk
partitions, Custom configuration, Reset to default ; copier le JSON affiché tel
quel dans deploy/cloud-init/offres/<offre>.json, puis python3 scripts/preparer-forge.py offres écrit son JSON de partition (le README du dossier dit le reste). Pour un cloud-init
réglé sur la RAM du serveur — l'amorce garde 16 Gio d'ARC, réglé pour 94 Gio de RAM :
python3 scripts/preparer-forge.py cloud-init --offre EM-B311X-SATA --arc-gib <N>Chaque sous-commande a son --help. La sortie va sur la sortie standard, ce que la
commande a décidé sur la sortie d'erreur ; un refus sort avec le code 2, un message,
et rien à coller. --defaut - lit l'entrée standard.
| Argument | Sous-commande | Rôle | Défaut |
|---|---|---|---|
--offre NOM |
partitionnement, cloud-init |
une offre connue, par son nom : son schéma par défaut est deploy/cloud-init/offres/<NOM>.json |
un seul parmi --offre, --defaut et (cloud-init) --pool-source |
--defaut FICHIER |
partitionnement, cloud-init |
le schéma par défaut d'une offre nouvelle, tel que la console l'affiche | idem |
--racine-gio N |
les trois | taille de la partition système root, en Gio |
200 — la Forge de validation en consomme 2,7 |
--sans-zfs |
partitionnement |
repli : ne déclare pas le pool à l'hébergeur ; la partition reste data et l'amorce crée le pool |
absent : l'offre décide (--offre), sinon le pool est déclaré |
--pool-source A,B |
cloud-init |
les deux supports du miroir, à la place de --offre et de --defaut |
déduits du schéma |
--arc-gib N |
cloud-init |
plafond de l'ARC ZFS, en Gio, retiré de la mémoire allouable | l'amorce garde 16, réglé pour 94 Gio de RAM : à adapter sur une machine qui en a moins |
--net-mbit N |
cloud-init |
débit du lien, seulement si la carte n'en annonce aucun (virtio) |
absent : le débit est mesuré |
--embarquer |
cloud-init |
mode autonome : embarque les scripts, sans leurs lignes de commentaire (≈ 11 Ko) | absent : cloud-init léger (≈ 1 Ko), les scripts sont téléchargés |
--ref REF |
cloud-init |
mode léger : la branche, l'étiquette ou le commit des scripts à télécharger, épinglé par son sha complet | HEAD ; doit être poussé, et les scripts locaux doivent être ceux de ce commit |
--compresser |
cloud-init |
avec --embarquer : scripts en gz+b64 (≈ 6,6 Ko), illisible à l'œil |
absent : texte lisible |
--verifier |
offres |
n'écrit rien : échoue si un JSON versionné est absent, périmé ou sans offre | absent : (ré)écrit les JSON |
La règle, appliquée à chaque disque du schéma par défaut (docs/DAT.md §66.3, §66.8) :
-
tout est conservé tel quel — partitions
uefi,legacy,boot,swap, RAID, systèmes de fichiers ; -
la partition
root, qui prend « tout l'espace restant » dans le défaut, est bornée ; -
une partition
datalui succède et prend ce qui reste :sda5etsdb5(ounvme0n1p5etnvme1n1p5) sont les deux supports du pool ; -
ces deux supports n'apparaissent ni dans
raidsni dansfilesystems: ils restent des périphériques bloc nus, ce qu'exige le miroir natif. Les confier àmdreproduirait exactement le problème que le miroir ZFS résout ; -
qui crée le pool se décide par offre (
docs/DAT.md§66.8, décision 3) :- l'hébergeur : la section
zfsdu schéma déclare le miroirsparksur ces deux partitions, enashift=12. C'est clé pour clé le schéma avec lequelspark-experimenta été installée, en Ubuntu 26.04. L'amorce adopte ce pool au premier démarrage ; - l'amorce : aucun pool n'est déclaré, et l'amorce le crée par
creer-pool.shavec--pool-source. C'est le cas d'EM-B311X-SATA : en Ubuntu 24.04, l'installateur de l'hébergeur se fige quand le pool est déclaré, et s'installe sinon (2026-11-18).
Le tableau de
deploy/cloud-init/offres/README.mddonne le choix de chaque offre ; une offre versionnée qui ne le dit pas est refusée ; - l'hébergeur : la section
-
la commande refuse, en le disant, un schéma qui n'a pas deux disques, qui déclare déjà un pool, dont la partition « reste » n'est pas
rootet dernière, ou qui est déjà dérivé.
Ce qui est vu chez l'hébergeur : le schéma avec le pool déclaré s'installe sur l'offre
de spark-experiment, en Ubuntu 26.04. Sur EM-B311X-SATA en Ubuntu 24.04, seul le schéma
sans pool déclaré s'installe ; la console accepte aussi le cloud-init léger, et la machine
télécharge les scripts. Pour une offre nouvelle dont l'installation bloque,
partitionnement --defaut <FICHIER> --sans-zfs donne le repli ; le cloud-init est le même.
Une machine réinstallée garde ses partitions. L'installateur de l'hébergeur ne les
efface pas, et un pool spark laissé par une installation précédente reste importable.
L'amorce n'importe un tel pool que s'il est sain (ONLINE), et le dit. Sinon elle
s'arrête sans rien effacer et donne les deux issues : l'importer à la main pour garder
ses données, ou effacer ses partitions puis rejouer avec --pool-source (SPK-170,
docs/DAT.md §70.2). Après l'installation, sudo zpool status spark doit
montrer les deux moitiés ONLINE. Le préflight le vérifie : STO-MIROIR signale un
miroir dégradé avec le support en cause, et SYS-RAID un RAID du système qui a perdu
un membre (SPK-169, docs/DAT.md §70.1).
Ce que la commande ne sait pas : la capacité des disques. La console de l'hébergeur la contrôle, et l'hébergeur sait aussi vérifier un schéma avant toute installation par l'API — c'est la seule réponse qui engage :
curl -i -X POST -H "X-Auth-Token: $SCW_SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{"offer_id":"…","os_id":"…","partitioning_schema":{…}}' \
https://api.scaleway.com/baremetal/v1/zones/fr-par-2/partitioning-schemas/validateUn 204 vaut acceptation ({…} est le JSON de partition de l'offre).
Limite de taille du user-data : Scaleway a refusé 19 431 octets (2026-11-16) et
ne documente pas sa limite. Le mode léger (≈ 1 Ko) n'a pas été vu accepté ; le mode
embarqué sans commentaires (≈ 11 Ko, ≈ 6,6 Ko compressé) non plus. La commande écrit la taille
produite sur la sortie d'erreur. Non vérifié : le téléchargement depuis une machine
livrée par l'hébergeur (réseau sortant au premier démarrage), et --compresser sur une VM.
Le script d'amorce est deploy/cloud-init/spark-amorce.sh.
Il n'est pas à copier : le cloud-init que produit la commande ci-dessus le dépose, avec
scripts/creer-pool.sh — par téléchargement vérifié au commit
épinglé, ou embarqué avec --embarquer — et le lance. Il installe Incus depuis le dépôt amont Zabbly, adopte le pool — celui
que l'hébergeur a créé d'après le schéma (zfs) — et, si aucun pool n'est importable, ne
le crée que quand on lui donne --pool-source, ce que fait le cloud-init (le repli) :
il appelle alors creer-pool.sh, qui refuse tout support déjà écrit —, pose le paquet sparkd, puis laisse l'exécuteur
sparkd.forge_install poser Caddy, nftables, l'ARC, le bridge, le durcissement SSH
et les unités systemd, et finir par la recette préflight / healthz / readyz.
Ses réglages sont des arguments nommés, lus dans --help — ni variable
d'environnement, ni texte à éditer :
| Argument | Rôle | Défaut |
|---|---|---|
--pool-source A,B |
les deux supports du miroir ZFS, ex. /dev/nvme0n1p5,/dev/nvme1n1p5 ; sans pool importable, l'amorce le crée dessus (repli) |
absent : l'amorce ne crée jamais rien |
--arc-gib N |
plafond de l'ARC ZFS en Gio | 16, réglé pour 94 Gio de RAM |
--net-mbit N |
débit déclaré, seulement si la carte n'en annonce aucun | absent : mesuré |
Un argument inconnu ou invalide est refusé avant toute écriture. Le pool et le pont
(spark, sparkbr0) sont des conventions du produit, pas des réglages.
L'amorce est idempotente et se rejoue :
ssh <compte>@<forge> 'sudo /opt/spark-amorce.sh'Un second passage réinstalle et remet d'aplomb ce qui a dérivé, et ne
réinitialise pas les Sparks existants : le rejeu ne passe pas --pool-source, donc
il ne crée jamais rien ; le pool est adopté (kind: reuse,
jamais destructive), le registre /var/lib/sparkd/spark.db n'est jamais
touché par l'installation, et les migrations de schéma sont additives. Ce que le
rejeu refait, ce sont les paquets, les unités, la configuration du socle et la
recette finale.
Le rejeu passe par le script, pas par cloud-init : runcmd ne s'exécute
qu'une seule fois par instance, et cloud-init clean effacerait aussi l'état et
les journaux de la première installation. Le script est déposé en
/opt/spark-amorce.sh par cloud-init au premier démarrage ; il peut aussi être
copié à la main sur une Forge existante.
| Couche | Choix | Écrit ici ? |
|---|---|---|
| Console d'administration | React + Vite + TypeScript | oui |
| Hôte local de la console | Node (tunnels SSH, proxy) | oui |
| Runtime serveur | Python 3 + FastAPI | oui |
| Registre de ressources | SQLite | oui |
| Isolation et cycle de vie | Incus ≥ 6.19 (Apache-2.0), dépôt amont obligatoire | non |
| Stockage | pool à quotas et copie sur écriture — voir DAT §8 | non |
| Ingress et TLS | Caddy | non |
| Transport d'administration | OpenSSH | non |
| Runtime applicatif | Docker + Compose, dans le Spark | non |
Ni Kubernetes, ni Nomad, ni OpenStack, ni Proxmox. Et aucune socket Docker exposée au plan de contrôle.
apps/webui/ console locale : SPA React + hôte Node (tunnels SSH)
services/sparkd/ runtime serveur : FastAPI, écoute 127.0.0.1 uniquement
packages/contract/ contrat d'API partagé (OpenAPI + types générés)
deploy/ piles dev / staging / prod
scripts/ bootstrap, seed, preuves
docs/ DAT, schéma, backlog, journal, design system, manuel
- Node ≥ 22 et pnpm ≥ 9 (console)
- Python ≥ 3.11 (runtime serveur)
- Docker et Docker Compose (pile de développement)
- côté serveur : Incus ≥ 6.19 — la version des dépôts Ubuntu (6.0.0) ne permet pas de faire tourner Docker dans un Spark —, un pool de stockage à quotas, Caddy. Voir le contrat de déploiement.
Les commandes ci-dessous seront disponibles au fur et à mesure des unités du backlog. Elles sont documentées ici pour fixer le contrat ; celles qui n'existent pas encore sont marquées.
| Commande | Rôle | Disponible |
|---|---|---|
make bootstrap |
installe les dépendances des deux livrables | oui |
make sparkd-install |
crée le venv et installe le runtime serveur | oui |
make sparkd-test |
tests unitaires du runtime serveur. Une preuve (test_identite_rootless_conteneur_debian.py, SPK-167) joue le script d'identité dans un conteneur Debian 13 : elle demande docker et le réseau (image debian:13-slim, paquets openssh), et s'ignore avec sa raison sans eux |
oui |
make sparkd-run |
lance sparkd sur 127.0.0.1:9876 — migre le registre puis sert |
oui |
make test |
toutes les suites de tests, contrat compris | oui |
make contract |
régénère le contrat d'API et ses types | oui |
make contract-check |
échoue si le contrat committé a dérivé du code | oui |
make hooks |
pose la garde du contrat avant chaque git push (voir ci-dessous) |
oui |
make gestes |
parcours navigateur des gestes d'administration | oui |
make runDev |
pile de développement : sparkd factice + console, inventaire jetable |
oui |
make runProd |
console d'exploitation seule sur :5175 : inventaire du poste, tunnels vers de vraies Forges. Port distinct de runDev, donc les deux tournent ensemble. Démarrée par son lanceur, elle se redémarre depuis son avertissement « Console à redémarrer » (docs/DAT.md §62) |
oui |
make seed |
recrée le registre de développement et le peuple | oui |
make captures |
captures d'interface, à observer | oui |
make build |
build de tous les paquets | oui |
pnpm -r test / build / typecheck |
paquets TypeScript de l'espace de travail | oui |
pnpm dev |
hôte console sur http://127.0.0.1:5173 — inventaire et tunnels |
oui |
| make e2e / pnpm e2e | parcours complets contre la pile réelle | oui |
| make manuel | reproduit les illustrations du manuel | oui |
| make forge-vm | une Forge montée par le cloud-init du dépôt, dans une machine virtuelle du poste (6 Gio, KVM), un Spark et une route créés par l'API, puis redémarrée pour de vrai et revérifiée sans aucun geste (docs/DAT.md §51.5). ARGS="--roue <x.whl>" éprouve une roue donnée, --carte virtio une carte qui n'annonce aucun débit. --compresser joue le cloud-init embarqué et compressé (gz+b64) ; son texte ne se modifie pas, donc sparkd y vient de main publié, et le banc le dit comme un écart (SPK-158). --garder garde la machine et lance une console à part, branchée sur elle seule, jusqu'à Ctrl-C ; --epreuve <a,b> joue e2e/forge-vm/epreuves/<a>.mjs (puis <b>) contre cette console, souris et clavier, puis démonte (docs/DAT.md §51.6). --travail <dossier> écrit les disques de la machine et son répertoire jetable dans ce dossier au lieu de /tmp — qui peut être un tmpfs, donc de la RAM : à partir de quelques Gio écrits, la machine y serait tuée (SPK-160). Dans ces deux modes, la machine reçoit les clés publiques du poste et une clé d'hôte fixe de banc, sur le port SSH --port-ssh (2222 par défaut), et le known_hosts du poste apprend une fois [127.0.0.1]:<port>. Épreuve lourde : elle prend le verrou. L'image Ubuntu et la clé d'hôte du banc sont gardées dans ~/.cache/spark-environment/vm/ | oui |
| make s3-minio | les faits du protocole S3 (batterie V1 à V11 du docs/DAT.md §67.6), contre trois MinIO éphémères sur la boucle locale — principal, réglé sur eu-west-3, TLS auto-signé —, 38 faits comparés à ce qui a été mesuré (SPK-160). Rouge si l'un cesse de tenir. Prérequis : docker, openssl, le venv de sparkd ; boto3 est installé dans un dossier jetable, jamais dans le venv. MinIO est sous AGPLv3 : il ne sert qu'aux preuves | oui |
| node scripts/mesures-spk132.mjs | banc de « Recréer » contre un vrai Docker, avec les commandes composées par le code : un redémarrage ne fait pas relire une variable d'env_file, la recréation si, le service voisin n'est pas touché, une image absente est refusée sans toucher l'ancien conteneur (docs/DAT.md §37.7.5). Docker et l'image alpine:latest requis ; conteneurs jetables | oui |
| scripts/mesures-spk128.sh | banc de l'ingress sur Caddy 2.6.2 — la version de la Forge — avec la configuration produite par le code : ni écoute UDP/443 ni annonce HTTP/3, Alt-Svc: clear partout, passage à chaud (docs/DAT.md §18.6). Docker requis ; trois conteneurs jetables | oui |
| scripts/mesures-spk155.sh | banc de l'émetteur de certificats et du journal d'émission sur Caddy 2.6.2, avec la configuration produite par le code : la forme d'avant se replie sur ZeroSSL, la forme produite ne tente que Let's Encrypt sous la même clé de stockage, est relue à l'identique, écrit le journal que le diagnostic lit (docs/DAT.md §18.3, §18.9). Docker requis ; deux conteneurs jetables | oui |
Une seule épreuve lourde à la fois, et plafonnée (CLAUDE.md §15 bis,
docs/DAT.md §29.8 et §29.8 bis) : make e2e, make e2e-un NOM="<nom du parcours>", make captures et make gestes tournent dans un scope systemd
borné à 8 Go (systemd-run --user --scope -p MemoryMax=8G) — un emballement
est tué par le noyau, jamais la machine —, et e2e/verrou.mjs refuse toute
seconde pile, y compris une épave dont les navigateurs survivent. Aucun
réglage ne relève la borne ni ne lève le verrou.
Contre quoi on valide (règle du responsable, docs/DAT.md §28.7) : la pile
au pilote factice — make runDev, make seed, make captures, make e2e,
make gestes, les preuves pytest sur le doublon FakeIncus — est un
diagnostic. Elle ne valide aucune unité. En local, une unité se valide
exclusivement contre une machine virtuelle qui porte une installation
fraîche de sparkd : make forge-vm, monté par le cloud-init du dépôt avec
la roue de l'arbre de travail.
Un réglage d'installation est un argument nommé, jamais une variable
d'environnement : il se lit dans la commande qui l'a employé, et dans son
--help (docs/DAT.md §53.4). Les deux scripts refusent une option inconnue
plutôt que de l'ignorer.
| Commande | Argument | Rôle | Défaut |
|---|---|---|---|
scripts/install-serveur.sh |
--prefix <chemin> |
où poser le venv et le code du runtime | /opt/sparkd |
scripts/dev.sh [up|seed] |
--state <chemin> |
répertoire d'état de la pile de développement | <dépôt>/.dev |
Aucune valeur réelle n'apparaît dans ce dépôt, et aucun secret n'y sera ajouté.
Le produit n'a aucun levier que cette page ne nomme pas (docs/DAT.md §53).
Un réglage se pose depuis un écran, par un argument de script, ou par une
variable documentée ci-dessous. Une variable que seul le code connaîtrait est un
défaut, pas une commodité.
| Variable | Rôle | Format | Requis | Exemple |
|---|---|---|---|---|
SPARKD_BIND |
adresse d'écoute | host:port |
non | 127.0.0.1:9876 |
SPARKD_DB |
fichier du registre | chemin absolu | non | /var/lib/sparkd/spark.db |
SPARKD_INCUS_SOCKET |
socket Incus | chemin absolu | non | /var/lib/incus/unix.socket |
SPARKD_CADDY_ADMIN |
API d'administration Caddy | URL | non | http://127.0.0.1:2019 |
SPARKD_DRIVER |
pilote d'exécution | incus | fake |
non | incus |
SPARKD_STORAGE_POOL |
pool Incus dont la capacité fait foi | nom | non | spark |
SPARKD_NETWORK_BRIDGE |
pont réseau auquel les cellules sont rattachées — écrit par l'écran d'installation de la Forge, champ Bridge (docs/DAT.md §50) |
nom d'interface | non | sparkbr0 |
SPARKD_STORAGE_DATASET |
jeu de données ZFS dont la compression est vérifiée | nom | non | la valeur de SPARKD_STORAGE_POOL |
SPARKD_ALLOWED_SIGNERS |
fichier allowed_signers d'OpenSSH — clés publiques autorisées à signer un geste (docs/DAT.md §36.10). Posé par la console à la connexion, pour la ligne console/<serveur> (docs/DAT.md §70.3) |
chemin absolu | non | /etc/sparkd/allowed_signers ; absent ou vide, la vérification est désactivée |
SPARKD_SECRET_KEY_FILE |
clé de chiffrement des secrets d'environnement — 32 octets, 0600, créée si absente et jamais remplacée (docs/DAT.md §43.9.2) |
chemin absolu | non | secret.key à côté du registre |
SPARKD_NOTIFY_URL |
REPLI seulement — le canal d'alerte se règle désormais au registre, depuis l'onglet de la Forge (docs/DAT.md §47.3). Cette variable ne sert plus qu'aux Forges dont la configuration n'a pas encore été reprise, et le registre l'emporte dès qu'un canal y est posé |
URL | non | vide |
SPARKD_NOTIFY_TEMPLATE |
REPLI seulement, même règle que ci-dessus | JSON avec des {champ} |
non | vide |
Le canal courriel (SMTP) n'a aucune variable d'environnement : il ne se règle qu'au registre, depuis Forge → Alertes (docs/DAT.md §47.3.2). Son mot de passe est scellé avec la clé de SPARKD_SECRET_KEY_FILE.
| SPARKD_FORGE_PUBLIC_ADDRESS | adresse ou nom public de la Forge, rendu dans le briefing d'un Spark (docs/DAT.md §44.8) | IPv4, IPv6 ou nom sans schéma | non | vide : l'adresse est inconnue du plan de contrôle |
| SPARKD_MEMORY_RESERVE | mémoire soustraite du pool pour la Forge elle-même, hors ARC | octets ou suffixe | non | 2GiB |
| SPARKD_NETWORK_CAPACITY_MBIT | débit du lien déclaré, retenu seulement quand aucune carte n'annonce le sien (carte virtio) ; un débit mesuré l'emporte toujours ; posé par l'exécuteur (networkCapacityMbit, --net-mbit de l'amorce) ou à la main (docs/DAT.md §5.3 bis) | entier > 0, Mbit/s | non — absent, le débit est mesuré | 1000 |
| SPARKD_CPU_RESERVE | part de processeur que la Forge garde pour lui, en cœurs | décimal ≥ 0 | non | 0.5 |
| SPARKD_STORAGE_METADATA_MARGIN | marge posée au-dessus de la taille vendue de chaque Spark, pour qu'un disque plein n'empêche plus sa reconfiguration | octets ou suffixe | non | 64MiB |
| SPARKD_LOG_LEVEL | niveau de journalisation | debug…error | non | info |
| SPARKD_METRICS_INTERVAL | cadence de l'historien d'usage : à chaque tic, l'usage de chaque Spark en marche est relevé et conservé (docs/DAT.md §52) | durée (15s, 1m) | non | 15s — 0 désactive l'historien |
| SPARKD_METRICS_RETENTION | durée conservée par l'historien ; ce qui dépasse est purgé à chaque tic | durée (7d, 24h) | non | 7d — 0 désactive la purge, et le registre croît sans limite |
| SPARKD_RESERVED_PORTS | ports que la Forge occupe déjà, jamais attribuables à un Spark — en plus de 22, 80 et 443, que le produit réserve toujours | entiers séparés par des virgules | non | 9100,9090 |
SPARKD_BIND ne peut pas être positionné sur une adresse routable : sparkd
refuse de démarrer et sort en code 2. L'absence d'API d'administration exposée
au réseau est une propriété de sécurité du produit, pas un réglage laissé à la
vigilance de l'exploitant.
| Variable | Rôle | Format | Requis | Exemple |
|---|---|---|---|---|
SPARK_CONSOLE_PORT |
port local de la console | entier | non | 5173 |
SPARK_CONSOLE_STATE |
inventaire des serveurs | chemin | non | ~/.config/spark/servers.json |
SPARK_ENV_FILE |
fichier .env lu par l'hôte console |
chemin | non | ./.env |
SCW_SECRET_KEY |
jeton du fournisseur DNS ; son absence désactive le pilotage DNS, ce n'est pas une panne | jeton | non | (jamais dans le dépôt) |
SCW_DEFAULT_ORGANIZATION_ID |
organisation dont les zones sont listées | UUID | non | 00000000-0000-0000-0000-000000000000 |
SCW_DEFAULT_PROJECT_ID |
projet dont les zones sont listées ; absent, aucun projet n'est envoyé et le fournisseur applique le sien | UUID | non | 00000000-0000-0000-0000-000000000000 |
SPARK_DNS_ALLOW_PATTERN |
expression régulière bornant les domaines écrivables depuis ce poste | regex | non | ^test\.[a-z0-9-]+\.exemple\.tech$ |
SPARK_DNS_BASE_URL |
racine de l'API DNS, pour pointer un doublon local | URL | non | http://127.0.0.1:8099 |
SPARK_GITHUB_DEPLOY_TOKEN |
jeton GitHub qui pose, vérifie et retire la clé d'un Spark en deploy key sur son dépôt (SPK-178, docs/DAT.md §71). Jeton fine-grained (un seul propriétaire : votre compte ou une organisation) limité aux dépôts visés, permission « Administration : Read and write » ; ou jeton classic au seul scope repo pour mêler dépôts personnels et d'organisation, avec une expiration courte et le SSO autorisé si l'organisation l'impose. Le compte du jeton doit être administrateur de chaque dépôt visé (.env.example détaille les deux). Son absence désactive la fonction, ce n'est pas une panne ; la clé se copie alors à la main. Lu par la console, jamais par la Forge |
jeton | non | (jamais dans le dépôt) |
SPARK_EPREUVE |
interrupteur de la pile d'épreuve : 1 — et cette valeur seule — autorise les sept doublons ci-dessous. Sans lui elles sont ignorées, et le refus est écrit au démarrage ; avec lui, la console affiche un avertissement permanent qui nomme ce qui est remplacé (docs/DAT.md §53.3) |
1 |
non | (absent en exploitation) |
SPARK_SIGN_COMMAND |
remplace la commande de signature d'un geste, pour éprouver la chaîne sans agent (docs/DAT.md §36.10.9) |
commande shell | non | (lue sous SPARK_EPREUVE=1 seulement) |
SPARK_CONSOLE_IDENTITY |
doublon d'épreuve — remplace la clé qu'OpenSSH emploie pour joindre la Forge (docs/DAT.md §53.3 bis). Remplace un fait, pas une commande. Ignoré sans SPARK_EPREUVE=1 |
chemin d'un fichier .pub |
non | vide |
SPARK_TERMINAL_COMMAND |
remplace la commande du terminal — ssh vers un Spark (docs/DAT.md §37.4.2 bis) |
commande shell ou table JSON | non | (lue sous SPARK_EPREUVE=1 seulement) |
SPARK_DOCKER_COMMAND |
remplace la commande docker interrogée dans un Spark (docs/DAT.md §37.6 ter) |
table JSON par geste | non | (lue sous SPARK_EPREUVE=1 seulement) |
SPARK_REBOOT_COMMAND |
remplace la commande de redémarrage de la Forge (docs/DAT.md §51.1) |
commande shell | non | (lue sous SPARK_EPREUVE=1 seulement) |
SPARK_GITHUB_BASE_URL |
doublon d'épreuve — remplace l'adresse de l'API GitHub où se posent les clés de déploiement (docs/DAT.md §71.6) ; sans lui la pile d'épreuve toucherait un vrai dépôt. Ignoré sans SPARK_EPREUVE=1 |
URL | non | http://127.0.0.1:8098 |
SPARK_UPGRADE_COMMAND |
doublon d'épreuve — remplace la commande qui applique les mises à jour du système de la Forge (docs/DAT.md §73.2) ; reçoit le script sur stdin et les paquets en arguments, finit par marqueur=code:<n>. Ignoré sans SPARK_EPREUVE=1 |
commande shell | non | (lue sous SPARK_EPREUVE=1 seulement) |
Lues par les scripts de preuve, jamais par la console en exploitation. Elles figurent ici parce que le produit n'a aucun levier que cette page ne nomme pas : un réglage de harnais reste un réglage.
| Variable | Rôle | Format | Requis | Exemple |
|---|---|---|---|---|
SPARK_CONSOLE_URL |
console à viser pour les scripts qui n'en montent pas (e2e/reel.mjs, e2e/forge-conformite.mjs, e2e/forge-reelle/*.mjs — ceux-ci visent sparkui, http://localhost:5175/, par défaut) |
URL | non | http://127.0.0.1:5173 |
SPARK_SORTIE |
répertoire où ces scripts déposent leurs captures | chemin | non | e2e/captures |
Une seule épreuve à la fois sur le poste (docs/DAT.md §29.8). Chaque
harnais monte une pile complète — sparkd, la console, un Chromium — et deux
campagnes simultanées suffisent à mettre une machine à genoux : mesuré le
2026-09-14, quatre lancées coup sur coup ont épuisé la mémoire et fait tuer un
processus par le noyau.
Un verrou exclusif l'empêche. Il est pris dans monterPile(), avant la
première allocation, et à l'import pour les scripts qui visent une console déjà
servie. Une seconde épreuve est refusée immédiatement, avec le PID, la
commande et l'âge de celle qui tient :
Une pile d'épreuve tourne DÉJÀ sur ce poste…
tenue par le PID 12345 — e2e/parcours.test.mjs
depuis 42 s
verrou : /tmp/spark-e2e.verrou
Il n'a aucun réglage : ni variable d'environnement, ni argument pour le lever. Un verrou qu'on peut désactiver est un verrou qu'on désactive le jour où il gêne, c'est-à-dire le jour où il sert. Un verrou dont le porteur a disparu — tué par le noyau, par exemple — est repris tout seul au prochain essai, et la reprise le dit.
La clé de signature d'un serveur se déclare dans l'écran Serveurs, champ
Clé de signature : un chemin vers une clé publique, retenu dans
servers.json. La console demande la signature à l'agent SSH, qui ne rend jamais
la clé privée. Vide, les gestes de ce serveur partent non signés — un état
normal, que la console dit sans le traiter comme une panne (docs/DAT.md
§36.10.8, §36.10.9). Côté Forge, SPARKD_ALLOWED_SIGNERS décide quelles clés
sont recevables. La console y pose elle-même sa clé, à la première ouverture du
tunnel, par SSH et python -m sparkd.signataires poser, et l'écran Serveurs dit
le résultat dans sa colonne Signature (docs/DAT.md §70.3).
Par défaut, une clé qui atteint la Forge y ouvre un shell — et qui a un shell a le registre. Deux gestes ferment cela sans rien retirer à la console, et ils vont ensemble :
# 1. Sur la Forge, deux réglages de /etc/ssh/sshd_config :
# AllowTcpForwarding local sans lui, tout tombe, même clé sans options
# AllowStreamLocalForwarding no ferme les redirections vers une socket
# 2. Poser la garde sur la Forge :
install -m 0755 scripts/garde-ssh.sh /usr/local/sbin/spark-garde-ssh
# 3. Produire la ligne, et remplacer celle de cette clé dans authorized_keys :
./scripts/cle-restreinte.sh ~/.ssh/id_ed25519.pub 9876Ce que la clé garde : le tunnel vers sparkd, le rebond vers un Spark, et le
dépannage. Ce qu'elle perd : le shell interactif, la lecture des fichiers de la
Forge, et l'accès à tout autre service que sparkd — y compris les sockets,
celle d'Incus comprise, mesuré le 2026-09-26 (docs/DAT.md §46.7).
Gardez une seconde session SSH ouverte pendant l'opération : elle est votre
retour arrière. La marche à suivre complète, avec ses six vérifications, est dans
docs/PROD_MIGRATIONS.md (OP-10) ; le raisonnement et les mesures sont au §46 du
docs/DAT.md.
Attention à un faux ami mesuré, et il a deux visages : restrict seul ne
ferme ni l'exécution de commande — une clé « restreinte » sans command= lit
encore tout le registre —, ni les redirections vers une socket : sans
permitopen, elle atteint la socket d'Incus, donc Incus en root. Les deux ont
été mesurés (§46.1, §46.7). C'est pourquoi la ligne se produit et ne se
recopie pas.
Le jeton DNS vit sur le poste qui fait tourner la console, dans un .env
ignoré par Git — jamais sur la Forge, où il serait lisible par qui y détient
root, et jamais dans servers.json, dont le contrat interdit tout secret.
Une variable exportée vide n'écrase pas le fichier : elle neutralise un
héritage.
Un jeton présent ne veut pas dire un jeton valide. Une clé expirée ou privée
de la permission de lire les zones fait répondre 401 au fournisseur ; la
console rend alors son message tel quel, sous le champ « Zone » de l'écran, et ne
le confond ni avec l'absence de jeton, ni avec un compte sans zone
(docs/DAT.md §38.1.1).
- Aucune API d'administration n'est joignable depuis le réseau. Seul un porteur de
clé SSH valide atteint
sparkd, par tunnel. - Les Sparks sont non privilégiés, avec des plages UID/GID disjointes.
- Un Spark n'a pas de port SSH public : l'accès se fait par rebond sur la Forge.
- Seules des clés publiques sont stockées.
- La clé d'accès du responsable peut être restreinte au strict nécessaire : elle n'ouvre alors plus de shell sur la Forge, ni aucune de ses sockets (voir ci-dessous).
- Décidé, non livré (lot 7,
docs/DAT.md§64) : l'administration passera par une console hébergée dans un Spark, où l'on entre par le SSO du domaine avec le rôleadminet un second facteur, vérifiés parsparkdlui-même ;sparkdrestera injoignable du réseau ; la console locale deviendra l'outil d'installation et de secours. - Un system container partage le noyau de la Forge. Pour des charges hostiles, la
réponse prévue est le mode
vm, pas un durcissement du modecontainer.
La garde du contrat d'API ne protège que les postes qui l'ont posée. Le
contrat packages/contract/ est ce sur quoi la console se règle ; une dérive non
vue se découvre à l'exécution, chez l'utilisateur. make hooks installe un
pre-push qui refuse un push dont le contrat a dérivé — mais il ne s'exécute que
là où on l'a installé, et git push --no-verify le contourne sans rien dire.
Une intégration continue serait plus forte ; elle n'a jamais tourné sur ce dépôt,
et le responsable a tranché le 2026-09-14 de s'en passer plutôt que de laisser
une garde qui n'existe que dans un fichier de workflow.
- Un seul serveur. Aucun ordonnancement inter-machines. Le transfert d'un Spark d'une Forge à une autre est exploré, non planifié : docs/EXPLORATION_TRANSFERT.md.
- La console n'obéit qu'à sa propre page, pas au poste entier (
docs/DAT.md§63). Elle refuse les requêtes d'un autre site et le DNS rebinding ; elle ne distingue pas, en revanche, un programme local d'elle-même — la frontière est le poste, comme pour la clé SSH qu'elle emploie. - La console ne se redémarre depuis son écran que si son lanceur l'a démarrée
(
make runProd,make runDev,pnpm dev;docs/DAT.md§62). Le préflight prouve que le nouveau code se charge, pas qu'il démarre : une erreur levée à la création de l'hôte n'apparaît qu'au redémarrage, et la page le dit au bout de 30 s. Un changement duMakefilelui-même demande toujours un arrêt à la main. runtime: vmest porté par le modèle de données mais n'est pas implémenté.- La réservation réseau est une grandeur de comptabilité : le noyau n'applique qu'un plafond, il n'y a pas de garantie de bande passante.
- Le relevé de topologie est explicite : la capacité n'est pas rafraîchie à chaque requête. L'écran de la Forge affiche la date du dernier relevé et offre un bouton pour le refaire.
- Une Forge exige deux disques (
docs/DAT.md§8.5, arbitré le 2026-09-02). Le pool est un miroir ZFS natif sur deux supports portés par deux disques distincts, ou un pool ZFS déjà existant qu'on réutilise. Une machine à disque unique, ou n'offrant qu'un seul support libre, n'est pas installable — et le diagnostic le nomme au lieu de basculer vers un repli. La Forge de validation tourne sursda5+sdb5depuis la réinstallation du 2026-08-30 : la corruption silencieuse y est détectée et réparée. - La réservation CPU est un plancher : garantie sous contention totale,
dépassée sinon. Mesuré sur la Forge de validation le 2026-08-21 — 47,9 %
obtenus pour 47,4 % prédits, sous contention des trois tranches. Ce n'est pas
une égalité : quand la Forge est au repos, un Spark obtient plus que sa
réservation, et c'est voulu (
docs/DAT.md§32.2). - Les disques de la Forge sont mécaniques (7200 tr/min) : la copie sur écriture n'y est pas un confort mais une condition de temps de création acceptable.
- Le réseau entre Sparks se limite à une Forge. Chaque Spark est isolé du
réseau des autres (SPK-109) ; les réseaux privés (SPK-110,
docs/DAT.md§58) et les liens privés (SPK-111, §59) les relient à dessein, déployés et prouvés sur la Forge le 2026-09-18. Le produit configure l'interface d'un réseau privé dans la cellule sur les familles àsystemd-networkd(Ubuntu, Debian), et dit quand il n'a pas pu ; un lien n'a pas de nom dans le résolveur du réseau — ses membres emploientadresse:port, que la console donne. http://d'une route TLS répond en clair, sans renvoyer vershttps://. Constaté le 2026-09-23 sur la Forge (docs/DAT.md§18.3) : le certificat est bien servi sur443, mais80sert aussi le site, sans redirection. Ouvert endocs/BACKLOG.md#SPK-113, qui demande une mesure avant d'être corrigé.- L'ingress ne sert pas HTTP/3 (
docs/DAT.md§18.6) : HTTP/1.1 et HTTP/2 seulement, etAlt-Svc: clearsur chaque réponse pour effacer une annonce mémorisée. - Accepter une note proposée ne revérifie pas le texte comparé (
docs/DAT.md§55.9.3). La comparaison en deux colonnes est celle de l'ouverture de l'onglet Notes ; si la note est réécrite entre-temps depuis un autre onglet, l'acceptation remplace cette version sans l'avoir montrée. L'empreinte garde la version proposée, rien ne garde le texte actuel.
Le registre spark.db porte toute la correspondance Spark ↔ quotas ↔ routes ↔
clés, et le journal d'audit. Les cellules, elles, vivent dans Incus : perdre le
registre ne détruit aucune donnée de locataire, mais détruit la connaissance que
le produit en a.
python3 -m sparkd.sauvegarde /var/backups/sparkdN'arrête rien, écrit un fichier daté, et vérifie ce qu'il vient d'écrire — structure SQLite et chaîne du journal — avant de rendre la main.
Ne copiez pas spark.db à la main. Il est en mode WAL : une copie de fichier
laisse derrière les transactions validées qui vivent encore dans le -wal, et la
copie s'ouvre ensuite sans se plaindre. Mesuré : 490 lignes sur 500.
Pour restaurer, sparkd doit être arrêté :
systemctl stop sparkd
python3 -m sparkd.sauvegarde --restaurer /var/backups/sparkd/spark-….db
systemctl start sparkdLe registre remplacé est déplacé, pas écrasé. La marche à suivre complète, ce qui est perdu et ce qu'il faut vérifier après : docs/CONTINGENCE.md.
| Document | Contenu |
|---|---|
| docs/DAT.md | architecture, modèle de ressources, sécurité |
| docs/SCHEMA.md | modèle de données du registre |
| docs/BACKLOG.md | unités de travail et état réel |
| docs/JOURNAL.md | décisions et investigations |
| docs/DESIGN_SYSTEM.md | règles d'interface |
| docs/manuel/ | manuel utilisateur |
| docs/MANUAL_PLAN.md | plan du manuel utilisateur |
| docs/PROD_MIGRATIONS.md | contrat de déploiement |
| docs/CONTINGENCE.md | plans d'urgence : ce qu'on fait quand ça casse |
| docs/ORIGIN_CONVERSATION.md | conversation fondatrice |
Voir LICENSE.