DevOps Playground

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 :

ComposantCe que c’est
RôlesProduct Owner (le quoi), Scrum Master (le comment de Scrum), Developers (le comment construire)
ArtefactsProduct Backlog (liste priorisée), Sprint Backlog (engagement du sprint), Increment (logiciel qui marche, « Done »)
CérémoniesSprint 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) :

  1. 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)
  2. Environnement reproductible — git init, .gitignore, package.json avec start/test/check : une machine fraîche démarre le projet avec 2 commandes
  3. Boucle interne — petites tranches : écrire une route → node server.js → vérifier avec curl → voir le JSON réel, jamais supposer
  4. Lire l’erreur — compétence n°1 (vraie erreur rencontrée : node --test test/ → MODULE_NOT_FOUND → corrigée en node --test)
  5. Tests — 6 tests (intégration sur HTTP réel + 1 unitaire) : filet de sécurité + documentation vivante
  6. 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 :

  1. Cycle de vie — scripts/start.sh (nohup + PID file + sonde immédiate), stop.sh, status.sh, restart.sh
  2. Santé — sonde /api/health qui touche la DB ; status.sh vérifie processus ET endpoint
  3. Journaux — logs/tinytype.log (en prod : journalctl via systemd)
  4. Sauvegarde — scripts/backup.sh : sqlite3 .backup + rétention (7 sauvegardes)
  5. 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) :

  1. Git comme colonne vertébrale — l’historique raconte le sprint : feat: (dev) → ops: (opérateur) → ci: (devops) → chore: (hygiène)
  2. Shift-left : gate local — .githooks/pre-commit exécute npm test et refuse le commit cassé (installé via core.hooksPath → versionné, partagé par l’équipe)
  3. Deuxième ligne : CI — .github/workflows/ci.yml : tests + npm run check sur machine propre (ubuntu-latest), npm ci (dépendances exactes du lockfile → reproductible)
  4. 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émonieRésultat
Product BacklogUS-1…US-5, le reste coupé volontairement (discipline Agile)
Sprint PlanningSprint Goal : un entraîneur de frappe utilisable en local, avec tests, CI et service redémarrable — ✅ atteint
Daily Scrum ×3Jour 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 ReviewDémo : health {"status":"ok"}, résultats round-trip {id:2}, restore 2/2, deploy ok ✔, service vivant pid 33660
Sprint RetrospectiveBien : 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émentValeur
Serviceen marche — http://127.0.0.1:3417 (pid vérifié, health OK)
Tests6/6 verts (npm test)
APIGET /api/health · GET /api/text · GET/POST /api/results
Basedata/tinytype.db (SQLite, WAL) · sauvegarde dans backups/
Port3417 (libre au moment du choix, documenté dans Local Services)
Docs détailléesDevOps 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/).