Phase 1 perf : build (CSS/JS externes a empreinte, minification, precompression) + deploy avec garde-fou

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Opus 5.5 a révisé 2026-10-12 15:29:11 +02:00
1 Parent 4eb1009aa1
révision c6b4e4d550
14 fichiers modifiés
+346

Aucun fichier ne correspond à votre recherche

+2
Voir le fichier
@@ -0,0 +1,2 @@
# Scripts executes sur le serveur Linux : toujours en LF, sinon bash casse.
*.sh text eol=lf
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
+47
Voir le fichier
@@ -0,0 +1,47 @@
#!/bin/bash
# Phase 1 perf gastinel.me : /assets/build/* (fichiers a empreinte produits par
# tools/build.js) -> cache 1 an immutable + .br/.gz precompresses.
# Ne fait qu'AJOUTER un handle dans le bloc "gastinel.me, www.gastinel.me".
# Sauvegarde -> modification -> caddy validate -> reload ; retour arriere si echec.
# Usage (sur cornafsuisse) : sudo bash ~/appliquer-caddy-build.sh
set -euo pipefail
[ "$(id -u)" = 0 ] || { echo "A lancer avec sudo"; exit 1; }
CF=/etc/caddy/Caddyfile
BAK="$CF.avant-build-$(date +%Y%m%d-%H%M%S)"
cp -a "$CF" "$BAK"
echo "Sauvegarde : $BAK"
python3 - "$CF" <<'PY'
import sys
p = sys.argv[1]
s = open(p).read()
if "handle /assets/build/*" in s:
sys.exit("Deja applique : aucune modification.")
anchor = "\t# Assets (polices, images) : cache navigateur 30 jours.\n"
new = (
"\t# Assets a empreinte (tools/build.js) : le nom change avec le contenu,\n"
"\t# donc cache 1 an sans revalidation.\n"
"\thandle /assets/build/* {\n"
"\t\theader Cache-Control \"public, max-age=31536000, immutable\"\n"
"\t\troot * /srv/gastinel.me\n"
"\t\tfile_server {\n"
"\t\t\tprecompressed br gzip\n"
"\t\t}\n"
"\t}\n"
"\n"
)
n = s.count(anchor)
if n != 1:
sys.exit("Point d'insertion introuvable ou ambigu (%d) : aucune modification." % n)
open(p, "w").write(s.replace(anchor, new + anchor))
PY
if caddy validate --config "$CF" --adapter caddyfile && systemctl reload caddy; then
echo "OK : Caddy recharge."
else
echo "ECHEC : restauration de $BAK"
cp -a "$BAK" "$CF"
systemctl reload caddy || true
exit 1
fi
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
BIN
Voir le fichier
Fichier binaire non affiché.
+167
Voir le fichier
@@ -0,0 +1,167 @@
#!/usr/bin/env node
/**
* tools/build.js
*
* Build de production de gastinel.me — zéro dépendance (Node natif).
*
* Source : index.html (on continue à l'éditer tel quel, CSS/JS inline).
* Sortie : dist/ (miroir de /srv/gastinel.me, prêt à déployer)
* - index.html HTML allégé (commentaires, indentation retirés)
* - assets/build/app.<hash>.css tous les <style> regroupés + minifiés
* - assets/build/app.<hash>.js le script principal, chargé en defer
* - assets/build/<police>.<hash>.woff2 polices renommées (cache immutable)
* - llms.txt, robots.txt, sitemap.xml, data/news.json
* - un .br et un .gz pour chaque fichier texte (Caddy: precompressed br gzip)
* - build-manifest.json liste des fichiers + empreintes (utilisé par deploy.js)
*
* Usage : node tools/build.js
*/
'use strict';
const fs = require('fs');
const path = require('path');
const zlib = require('zlib');
const crypto = require('crypto');
const ROOT = path.resolve(__dirname, '..');
const DIST = path.join(ROOT, 'dist');
const BUILD_DIR = 'assets/build';
const COPY_AS_IS = ['llms.txt', 'robots.txt', 'sitemap.xml', 'data/news.json'];
const COMPRESSIBLE = new Set(['.html', '.css', '.js', '.json', '.txt', '.xml', '.svg']);
const hash = (buf) => crypto.createHash('sha256').update(buf).digest('hex').slice(0, 10);
const md5 = (buf) => crypto.createHash('md5').update(buf).digest('hex');
const kb = (n) => (n / 1024).toFixed(1) + ' Ko';
const brotli = (buf) => zlib.brotliCompressSync(buf, {
params: {
[zlib.constants.BROTLI_PARAM_QUALITY]: 11,
[zlib.constants.BROTLI_PARAM_SIZE_HINT]: buf.length,
},
});
const outputs = {}; // chemin publié -> Buffer
function emit(relPath, content) {
const buf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
outputs[relPath] = buf;
return relPath;
}
// --- CSS ---------------------------------------------------------------------
// Minification volontairement prudente : on ne touche ni aux combinateurs
// (> + ~), ni aux espaces avant ':' (".a :hover" != ".a:hover"), ni à calc().
// Les chaînes ("...", '...') sont mises de côté pour ne jamais être modifiées.
function minifyCss(css) {
const strings = [];
return css
.replace(/\/\*[\s\S]*?\*\//g, '')
.replace(/"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'/g, (s) => `\u0000${strings.push(s) - 1}\u0000`)
.replace(/\s+/g, ' ')
.replace(/\s*([{};,])\s*/g, '$1')
.replace(/:\s+/g, ':')
.replace(/;}/g, '}')
.replace(/\u0000(\d+)\u0000/g, (m, i) => strings[i])
.trim();
}
// --- HTML --------------------------------------------------------------------
// Retire commentaires, indentation de début de ligne et lignes vides.
// Sûr ici : aucun <pre>/<textarea> ni white-space:pre dans la page, et le seul
// script restant inline est le JSON-LD (minifié à part).
function minifyHtml(html) {
return html
.replace(/<!--(?!\[if)[\s\S]*?-->/g, '')
.replace(/\n[ \t]+/g, '\n')
.replace(/\n{2,}/g, '\n')
.trim() + '\n';
}
function build() {
fs.rmSync(DIST, { recursive: true, force: true });
const srcPath = path.join(ROOT, 'index.html');
const src = fs.readFileSync(srcPath, 'utf8');
if (/<pre[\s>]|<textarea[\s>]/i.test(src.replace(/<script[\s\S]*?<\/script>/gi, ''))) {
throw new Error('<pre>/<textarea> détecté : la minification HTML doit être revue.');
}
let html = src;
// 1. Polices : copies renommées avec empreinte -> cache immutable possible.
const fontMap = {};
for (const ref of new Set(html.match(/assets\/fonts\/[\w.-]+\.woff2/g) || [])) {
const buf = fs.readFileSync(path.join(ROOT, ref));
const name = path.basename(ref, '.woff2') + '.' + hash(buf) + '.woff2';
fontMap[ref] = emit(`${BUILD_DIR}/${name}`, buf);
}
// 2. CSS : tous les <style> (head + body), dans l'ordre -> un seul fichier.
const styles = [];
let firstStyleAt = -1;
html = html.replace(/<style>([\s\S]*?)<\/style>\n?/g, (m, css, offset) => {
if (firstStyleAt < 0) firstStyleAt = offset;
styles.push(css);
return firstStyleAt === offset ? '<!--@@CSS@@-->' : '';
});
let css = minifyCss(styles.join('\n'));
// Le CSS déménage dans assets/build/ : ses URL relatives deviennent absolues.
css = css.replace(/url\((['"]?)(assets\/[^'")]+)\1\)/g, (m, q, ref) =>
`url(${q}/${fontMap[ref] || ref}${q})`);
const cssPath = emit(`${BUILD_DIR}/app.${hash(css)}.css`, css);
// 3. JS : le script principal (ni src, ni JSON-LD) -> fichier externe en defer.
const scripts = [];
html = html.replace(/<script>([\s\S]*?)<\/script>\n?/g, (m, js) => {
scripts.push(js.trim());
return '';
});
if (scripts.length !== 1) throw new Error(`1 script inline attendu, ${scripts.length} trouvé(s).`);
const js = scripts[0] + '\n';
const jsPath = emit(`${BUILD_DIR}/app.${hash(js)}.js`, js);
html = html.replace('<!--@@CSS@@-->',
`<link rel="stylesheet" href="${cssPath}">\n<script src="${jsPath}" defer></script>\n`);
// 4. JSON-LD compacté.
html = html.replace(/(<script type="application\/ld\+json">)([\s\S]*?)(<\/script>)/,
(m, a, json, b) => a + JSON.stringify(JSON.parse(json)) + b);
// 5. Préchargements de polices -> versions avec empreinte.
for (const [ref, out] of Object.entries(fontMap)) html = html.split(`"${ref}"`).join(`"${out}"`);
emit('index.html', minifyHtml(html));
// 6. Fichiers recopiés tels quels.
for (const rel of COPY_AS_IS) emit(rel, fs.readFileSync(path.join(ROOT, rel)));
// 7. Écriture + précompression.
const manifest = { source: { 'index.html': md5(Buffer.from(src, 'utf8')) }, files: {} };
for (const [rel, buf] of Object.entries(outputs)) {
const abs = path.join(DIST, rel);
fs.mkdirSync(path.dirname(abs), { recursive: true });
fs.writeFileSync(abs, buf);
manifest.files[rel] = md5(buf);
if (COMPRESSIBLE.has(path.extname(rel))) {
fs.writeFileSync(abs + '.br', brotli(buf));
fs.writeFileSync(abs + '.gz', zlib.gzipSync(buf, { level: 9 }));
manifest.files[rel + '.br'] = md5(fs.readFileSync(abs + '.br'));
manifest.files[rel + '.gz'] = md5(fs.readFileSync(abs + '.gz'));
}
}
fs.writeFileSync(path.join(DIST, 'build-manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
// 8. Rapport.
const srcBuf = Buffer.from(src, 'utf8');
const size = (rel) => outputs[rel].length;
const br = (rel) => fs.statSync(path.join(DIST, rel + '.br')).size;
const first = ['index.html', cssPath, jsPath];
console.log('Build OK -> dist/');
console.log(` source index.html : ${kb(srcBuf.length)} brut, ${kb(brotli(srcBuf).length)} br`);
for (const rel of first) console.log(` ${rel.padEnd(38)} ${kb(size(rel)).padStart(9)} brut, ${kb(br(rel)).padStart(8)} br`);
console.log(` 1re visite (HTML+CSS+JS, br) : ${kb(first.reduce((t, r) => t + br(r), 0))}`);
console.log(` visite suivante (HTML seul, br) : ${kb(br('index.html'))}`);
return manifest;
}
if (require.main === module) build();
module.exports = { build, DIST };
+130
Voir le fichier
@@ -0,0 +1,130 @@
#!/usr/bin/env node
/**
* tools/deploy.js
*
* Build puis déploiement de dist/ vers la prod (cornafsuisse:/srv/gastinel.me).
*
* Garde-fou : avant d'écrire quoi que ce soit, vérifie que l'index.html en prod
* est bien celui du dernier déploiement (deploy/last-deploy.json). Si quelqu'un
* l'a modifié entre-temps (ex : publier.sh d'une release GWS), on s'arrête pour
* ne pas écraser une version plus récente. --force pour passer outre.
*
* Ordre d'écriture : assets/build (nouveaux noms, sans risque) -> fichiers texte
* envoyés dans un dossier temporaire puis renommés (mv atomique par fichier),
* .br/.gz d'abord, index.html en dernier.
*
* Usage : node tools/deploy.js [--dry-run] [--force]
*/
'use strict';
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const { spawnSync } = require('child_process');
const { build, DIST } = require('./build');
const HOST = 'cornafsuisse';
const PROD = '/srv/gastinel.me';
const SITE = 'https://gastinel.me';
const STATE = path.resolve(__dirname, '..', 'deploy', 'last-deploy.json');
const KEEP_PREVIOUS = true; // garde les assets du déploiement précédent (pages déjà ouvertes)
const args = new Set(process.argv.slice(2));
const DRY = args.has('--dry-run');
const FORCE = args.has('--force');
function run(cmd, argv, opts = {}) {
const r = spawnSync(cmd, argv, { encoding: 'utf8', ...opts });
if (r.status !== 0) {
throw new Error(`${cmd} ${argv.join(' ')}\n${r.stderr || r.stdout || r.error}`);
}
return r.stdout;
}
const ssh = (script) => run('ssh', ['-o', 'BatchMode=yes', HOST, script]);
const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
async function main() {
const manifest = build();
const state = fs.existsSync(STATE) ? JSON.parse(fs.readFileSync(STATE, 'utf8')) : null;
// 1. Garde-fou : la prod est-elle celle qu'on a déployée la dernière fois ?
// Premier déploiement : la prod doit contenir la source non construite.
const expected = state ? state.files['index.html'] : manifest.source['index.html'];
const prodMd5 = ssh(`md5sum ${PROD}/index.html | cut -d' ' -f1`).trim();
if (prodMd5 !== expected && !FORCE) {
console.error(
`\nARRÊT : ${PROD}/index.html a été modifié hors de ce script.\n` +
` attendu ${expected}, trouvé ${prodMd5}\n` +
`Récupère d'abord la version en prod (ssh ${HOST} cat ${PROD}/index.html), reporte\n` +
`les changements dans la source, puis relance. --force pour écraser quand même.`);
process.exit(1);
}
const files = Object.keys(manifest.files);
const assets = files.filter((f) => f.startsWith('assets/build/'));
const texts = files.filter((f) => !f.startsWith('assets/build/'))
// .br/.gz avant le fichier brut, index.html tout à la fin
.sort((a, b) => rank(a) - rank(b));
console.log(`\n${assets.length} assets, ${texts.length} fichiers texte -> ${HOST}:${PROD}`);
if (DRY) { console.log('(dry-run : rien envoyé)'); return; }
// 2. Assets à empreinte : noms nouveaux, aucun conflit possible.
ssh(`mkdir -p ${PROD}/assets/build ${PROD}/.deploy-tmp/data`);
run('scp', ['-q', ...assets.map((f) => path.join(DIST, f)), `${HOST}:${PROD}/assets/build/`]);
// 3. Fichiers texte : dossier temporaire puis mv (même disque = atomique).
for (const dir of [...new Set(texts.map((f) => path.posix.dirname(f)))]) {
const group = texts.filter((f) => path.posix.dirname(f) === dir);
run('scp', ['-q', ...group.map((f) => path.join(DIST, f)), `${HOST}:${PROD}/.deploy-tmp/${dir === '.' ? '' : dir + '/'}`]);
}
ssh(texts.map((f) => `mv -f ${q(`${PROD}/.deploy-tmp/${f}`)} ${q(`${PROD}/${f}`)}`).join(' && ') +
` && rm -rf ${PROD}/.deploy-tmp`);
// 4. Vérification depuis Internet : bon HTML, servi en Brotli, assets joignables.
await verify(manifest);
// 5. Ménage : supprime les assets/build qui ne sont ni actuels ni du déploiement précédent.
const keep = new Set(assets.map((f) => path.posix.basename(f)));
if (KEEP_PREVIOUS && state) {
Object.keys(state.files).filter((f) => f.startsWith('assets/build/'))
.forEach((f) => keep.add(path.posix.basename(f)));
}
const onServer = ssh(`ls -1 ${PROD}/assets/build`).split('\n').filter(Boolean);
const stale = onServer.filter((f) => !keep.has(f));
if (stale.length) {
ssh(`cd ${PROD}/assets/build && rm -f ${stale.map(q).join(' ')}`);
console.log(`Ménage : ${stale.length} ancien(s) fichier(s) supprimé(s).`);
}
fs.writeFileSync(STATE, JSON.stringify({
date: new Date().toISOString(),
source: manifest.source,
files: manifest.files,
}, null, 2) + '\n');
console.log(`Déploiement OK. État enregistré dans deploy/last-deploy.json (à commiter).`);
}
function rank(f) {
if (f === 'index.html') return 3;
if (f.endsWith('.br') || f.endsWith('.gz')) return 1;
return 2;
}
async function verify(manifest) {
const md5 = (b) => crypto.createHash('md5').update(b).digest('hex');
const res = await fetch(SITE + '/', { headers: { 'accept-encoding': 'br' } });
// fetch décompresse lui-même : on compare donc le HTML décodé au fichier construit.
const body = Buffer.from(await res.arrayBuffer());
const enc = res.headers.get('content-encoding');
if (md5(body) !== manifest.files['index.html']) {
throw new Error(`Vérification : le HTML servi ne correspond pas au build (encodage ${enc}).`);
}
for (const f of Object.keys(manifest.files).filter((f) => /^assets\/build\/[^/]+\.(css|js|woff2)$/.test(f))) {
const r = await fetch(`${SITE}/${f}`, { method: 'HEAD' });
if (!r.ok) throw new Error(`Vérification : ${f} -> HTTP ${r.status}`);
}
console.log(`Vérifié en ligne : HTML à jour (encodage ${enc || 'aucun'}), assets OK.`);
}
main().catch((e) => { console.error('\nÉCHEC :', e.message); process.exit(1); });