Projet / Project: DevOps Playground — l’expérience “apprendre DevOps en faisant” / the “learn DevOps by doing” experiment Date: 2026-09-19 · Statut / Status: ✅ Sprint 1 terminé, service en marche / Sprint 1 complete, service running Environnement / Environment: Fedora 44, Node v24.20.0, npm 11.19.0, SQLite 3.53 (sandbox Obsidian : pas de systemd ni docker / no systemd or docker in the sandbox) Auteur / Author: Moi, avec mon copilote IA comme partenaire de travail / Me, with my AI copilot as working partner
1. Pourquoi cette expérience
Au lieu d’apprendre le DevOps « normalement » (cours, vidéos, théorie), j’ai fait l’inverse : construire un vrai petit produit en jouant trois rôles distincts — Développeur, Opérateur, DevOps — et documenter ce que chacun fait, comment, et pourquoi, le tout cadré par une méthodologie Agile/Scrum expliquée. Le produit : TinyType, un mini-entraîneur de frappe (clone minimal de monkeytype), qui tourne sur ma machine.
Objectif : déclencher les vrais problèmes (commit cassé, sauvegarde, déploiement) au lieu de les lire dans un cours — et garder chaque décision avec son pourquoi.
2. La méthodologie : Agile & Scrum (ce que c’est, pourquoi)
Le problème qu’Agile résout : avant, on construisait en cascade (analyse → design → code → test → livraison, des mois par phase). On ne voyait le résultat qu’à la fin ; si le besoin était faux, on le découvrait trop tard. Agile inverse : livrer de petites tranches qui marchent, en continu, et s’adapter à chaque feedback.
Scrum met Agile en pratique avec 3 rôles, 3 artefacts, 5 cérémonies :
| Composant | Ce que c’est |
|---|---|
| Rôles | Product Owner (le quoi), Scrum Master (le comment de Scrum), Developers (le comment construire) |
| Artefacts | Product Backlog (liste priorisée), Sprint Backlog (engagement du sprint), Increment (logiciel qui marche, « Done ») |
| Cérémonies | Sprint Planning, Daily Scrum (15 min, 3 questions), Sprint Review (démo), Sprint Retrospective (amélioration continue) |
Pourquoi : empirisme — cycle construire → inspecter → adapter ; feedback rapide ; risque réduit (les grosses erreurs sortent au 1er sprint, pas au dernier mois) ; focus et prévisibilité (sprints de durée fixe). Agile rétrécit la boucle besoin → code ; DevOps rétrécit la boucle code → production : même philosophie, c’est pour ça qu’ils vont ensemble.
Application concrète : un sprint de 3 jours compressés, un Product Backlog de 5 user stories (US-1…US-5), une Definition of Done en 6 points, des standups quotidiens (dont un vrai blocage : pas de systemd dans le sandbox → scripts + unit file), une Review avec démo réelle, une Retrospective honnête. Détails : 0 - Agile & Scrum.
3. Les trois rôles : ce qu’ils font, comment, pourquoi
3.1 Développeur 🧑💻 — construire l’Increment
Rôle : transformer des besoins en code qui marche — et que les autres peuvent relire et modifier. La preuve que c’est fini = tests automatisés (la DoD, pas un bonus). Mentalité : optimiser la capacité de changement.
Processus suivi (le métier) :
- Comprendre avant de coder — user story US-1 (« taper une phrase, voir WPM + précision »), critères d’acceptation, stack choisie avec arbitrage argumenté (pas la mode)
- Environnement reproductible —
git init,.gitignore,package.jsonavecstart/test/check: une machine fraîche démarre le projet avec 2 commandes - Boucle interne — petites tranches : écrire une route →
node server.js→ vérifier aveccurl→ voir le JSON réel, jamais supposer - Lire l’erreur — compétence n°1 (vraie erreur rencontrée :
node --test test/→MODULE_NOT_FOUND→ corrigée ennode --test) - Tests — 6 tests (intégration sur HTTP réel + 1 unitaire) : filet de sécurité + documentation vivante
- Finir proprement — DoD, commentaires pourquoi (pas quoi), README honnête, commit
Décisions & pourquoi (tableau complet dans 1 - Role Developer) : Express 5 (1 seule dépendance), node:sqlite intégré (zéro build natif), node:test (zéro config), frontend vanilla sans build step (moins de pièces = moins de pannes — gain DevOps dès le code), health endpoint qui touche la DB (un “ok” qui signifie quelque chose), validation côté serveur (les clients mentent/cassent), split app.js/server.js (testable), journal WAL (choix friendly-opérateur : rend la sauvegarde sûre).
Preuve : ℹ tests 6 | pass 6 | fail 0
3.2 Opérateur 🛠️ — garder le service vivant
Rôle : le service reste vivant, rapide, sûr — le processus vivant ≠ service sain. Produit de l’opérateur : la fiabilité (l’utilisateur ne doit jamais remarquer les opérations).
Processus suivi :
- Cycle de vie —
scripts/start.sh(nohup + PID file + sonde immédiate),stop.sh,status.sh,restart.sh - Santé — sonde
/api/healthqui touche la DB ;status.shvérifie processus ET endpoint - Journaux —
logs/tinytype.log(en prod : journalctl via systemd) - Sauvegarde —
scripts/backup.sh:sqlite3 .backup+ rétention (7 sauvegardes) - Unité de production —
deploy/tinytype.service(systemd : supervision, logs, durcissement) pour le vrai hôte
Décisions & pourquoi : sonde l’endpoint, pas le processus (un process peut être vivant et coincé) ; SIGTERM avant SIGKILL (finir les requêtes, SQLite flush proprement) ; .backup et pas cp (en mode WAL, cp peut copier un fichier incomplet → corruption silencieuse — leçon classique d’opérateur) ; rétention 7 (pas de disque qui se remplit) ; port 3417 (vérifié contre Local Services : 3000, 8080, 8081, 8899, 9000, 18789, 27017 déjà pris).
Preuve (démo réelle) : démarrage ✓, backup créé (16K), restauration prouvée : 2/2 lignes, arrêt propre ✓, redémarrage ✓.
3.3 DevOps 🔗 — le pont entre les deux
Rôle : DevOps n’est pas un titre ni un outil — c’est raccourcir et adoucir la frontière entre « qui écrit » et « qui opère » (modèle CALMS : Culture, Automatisation, Lean, Mesure, Partage). Mesures clés : lead time (commit → prod) et temps de récupération.
Processus suivi (le pont en 4 mouvements) :
- Git comme colonne vertébrale — l’historique raconte le sprint :
feat:(dev) →ops:(opérateur) →ci:(devops) →chore:(hygiène) - Shift-left : gate local —
.githooks/pre-commitexécutenpm testet refuse le commit cassé (installé viacore.hooksPath→ versionné, partagé par l’équipe) - Deuxième ligne : CI —
.github/workflows/ci.yml: tests +npm run checksur machine propre (ubuntu-latest),npm ci(dépendances exactes du lockfile → reproductible) - CD : la recette de déploiement —
deploy/deploy.sh: test → pull (ff-only) → npm ci → restart → verify (la 5e étape est obligatoire : un déploiement qui casse le service n’est pas un succès)
Démonstration réelle (le moment clé de l’expérience) : j’ai volontairement cassé le health endpoint (ok → oops) et tenté de le committer → le hook a bloqué le commit (assertion actual: 'oops', expected: 'ok'). Le code cassé n’est jamais arrivé.
Erreur vécue documentée : mon « revert » (git checkout -- src/app.js) n’a pas annulé l’état cassé — cette commande restaure depuis l’index, qui contenait encore le fichier cassé ; le bon réflexe est git restore --staged --worktree. La leçon est écrite dans le message du commit CI pour rester cherchable.
4. Le processus de développement (le métier, pour apprendre)
Modèle mental : développer = une boucle penser → modifier → exécuter → vérifier, répétée des milliers de fois, en petits pas, sans se mentir. Tout le reste (outils, tests, git) sert à : rétrécir la boucle, et garder la boucle honnête.
- 3 boucles : interne (secondes-minutes : edit → run → verify), CI (minutes : push → tests machine propre), livraison (heures-jours : deploy → users)
- Phases : comprendre (30% que les débutants sautent) → environnement reproductible → boucle interne en tranches minuscules → lire les erreurs → habitudes git → tests → protocole anti-blocage (timebox 25 min, réduire le problème, chercher l’erreur exacte, poser une bonne question, faire une pause) → finir (DoD) → remise au pipeline
- Loi de Kernighan : « Déboguer est deux fois plus dur qu’écrire le code. Donc si vous écrivez le code le plus astucieux possible, vous êtes, par définition, pas assez malin pour le déboguer. »
- Détails complets : 1b - The Developer Process
5. Journal du sprint (cérémonies réelles)
| Cérémonie | Résultat |
|---|---|
| Product Backlog | US-1…US-5, le reste coupé volontairement (discipline Agile) |
| Sprint Planning | Sprint Goal : un entraîneur de frappe utilisable en local, avec tests, CI et service redémarrable — ✅ atteint |
| Daily Scrum ×3 | Jour 1 : scaffold + moteur de textes + API + DB. Jour 2 : blocage réel (pas de systemd → scripts + unit file). Jour 3 : hooks, CI, déploiement, rétro |
| Definition of Done (6 points) | ✅ tous validés (fonctionne au navigateur, 6/6 tests, 4 commits, service géré, health OK, CI+hook, backup prouvé) |
| Sprint Review | Démo : health {"status":"ok"}, résultats round-trip {id:2}, restore 2/2, deploy ok ✔, service vivant pid 33660 |
| Sprint Retrospective | Bien : incrément sain à chaque commit, gate prouvé, backup vérifié par restauration, décisions avec pourquoi. À améliorer : CI jamais exécutée (pas de remote GitHub), Dockerfile non testé, un seul sprint = un seul point de données. Prochain : push GitHub, drill de récupération, systemd réel |
6. Artefacts & état final
Dépôt : ~/dev/tinytype — 4 commits :
6090a4c feat: TinyType v0.1 — typing trainer API + UI + tests ← Développeur
b61bb3c ops: supervised lifecycle — scripts + systemd unit ← Opérateur
d57f48c ci: delivery pipeline — pre-commit gate, CI, deploy ← DevOps
db447aa chore: keep runtime artifacts out of version control ← Hygiène
| Élément | Valeur |
|---|---|
| Service | en marche — http://127.0.0.1:3417 (pid vérifié, health OK) |
| Tests | 6/6 verts (npm test) |
| API | GET /api/health · GET /api/text · GET/POST /api/results |
| Base | data/tinytype.db (SQLite, WAL) · sauvegarde dans backups/ |
| Port | 3417 (libre au moment du choix, documenté dans Local Services) |
| Docs détaillées | DevOps Playground : 0 - Agile & Scrum · 1 - Role Developer · 1b - The Developer Process · 2 - Role Operator · 3 - Role DevOps |
Rejouer l’expérience (2 commandes) :
npm ci && npm start # à partir de ~/dev/tinytype → http://127.0.0.1:3417
./scripts/status.sh # vérifier santé (processus + endpoint)
./deploy/deploy.sh # rejouer le pipeline complet (test → pull → ci → restart → verify)
Mistakes / leçons (gardées visibles, comme demandé) : node --test test/ ≠ découverte auto (MODULE_NOT_FOUND) → node --test ; git checkout -- restaure depuis l’index, pas HEAD → git restore --staged --worktree ; Dockerfile + compose écrits mais non testés (pas de docker dans le sandbox) — signalés honnêtement ; .write-test, pid file et backup .db commités par git add -A → .gitignore élargi (logs/, backups/).