Skip to content

About

Sparks are fully isolated partitionned hardware servers to accomodate the deploy of our applications

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

Spark Environment

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.

Pourquoi « Forge » et « Spark »

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.

Statut

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, et 404 sur 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 pour 47,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 [~].

Forge cible

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.

Installer le plan de contrôle sans copier le dépôt

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.

Le parcours officiel d'une Forge

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.

  1. cloud-init prépare le serveur métal et y installe sparkd — deploy/cloud-init/, décrit plus bas (disponible).
  2. 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 que sso-p2enjoy a été installé).
  3. 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).
  4. 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).
  5. 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 stockage : un miroir ZFS natif, et rien d'autre

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

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

Une Forge exige deux disques

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.

Commander une Forge : le JSON de partition versionné, le cloud-init à la demande

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 :

  1. Le JSON de partition, versionné, dans l'éditeur de partitions (Custom configuration) :

    Offre (Scaleway Elastic Metal) JSON de partition à coller
    EM-L101X-SATA EM-L101X-SATA.partitionnement.json
    EM-B311X-SATA EM-B311X-SATA.partitionnement.json
  2. 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 data lui succède et prend ce qui reste : sda5 et sdb5 (ou nvme0n1p5 et nvme1n1p5) sont les deux supports du pool ;

  • ces deux supports n'apparaissent ni dans raids ni dans filesystems : ils restent des périphériques bloc nus, ce qu'exige le miroir natif. Les confier à md reproduirait 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 zfs du schéma déclare le miroir spark sur ces deux partitions, en ashift=12. C'est clé pour clé le schéma avec lequel spark-experiment a é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.sh avec --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.md donne le choix de chaque offre ; une offre versionnée qui ne le dit pas est refusée ;

  • 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 root et 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/validate

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

Amorcer la Forge au premier démarrage, et rejouer l'amorce

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.

Stack

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.

Structure du dépôt

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

Prérequis

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

Commandes principales

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.

Les deux scripts et leurs arguments

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

Variables d'environnement

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

services/sparkd

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.

apps/webui

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)

Harnais de preuves (e2e/)

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

Restreindre la clé d'accès du responsable

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 9876

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

Sécurité

  • 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ôle admin et un second facteur, vérifiés par sparkd lui-même ; sparkd restera 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 mode container.

Limites connues

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 du Makefile lui-même demande toujours un arrêt à la main.
  • runtime: vm est 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 sur sda5+sdb5 depuis 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 emploient adresse:port, que la console donne.
  • http:// d'une route TLS répond en clair, sans renvoyer vers https://. Constaté le 2026-09-23 sur la Forge (docs/DAT.md §18.3) : le certificat est bien servi sur 443, mais 80 sert aussi le site, sans redirection. Ouvert en docs/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, et Alt-Svc: clear sur 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.

Sauvegarder le registre

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/sparkd

N'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 sparkd

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

Documentation

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

Licence

Voir LICENSE.

About

Sparks are fully isolated partitionned hardware servers to accomodate the deploy of our applications

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages