fix(airflow): fiabilise l'import horaire de la Mock API

feat(airflow): orchestre l'import de la Mock API
Add files via upload
2026-09-22 16:24:05 +02:00 · 2026-09-22 15:47:01 +02:00 · 2026-09-22 15:34:33 +02:00 · 2026-09-22 15:21:24 +02:00 · 2026-09-22 15:17:18 +02:00 · 2026-09-22 15:04:21 +02:00
51 changed files with 1786 additions and 98 deletions
@@ -93,11 +93,12 @@ jobs:
      # `--help` sort par argparse avant `get_settings()` : ni base ni secret requis, et
      # l'import des modules prouve que l'environnement /opt/backend est complet.
-      # Les deux commandes du DAG `alertes` et la commande du DAG historique sont couvertes.
+      # Les commandes des DAGs `alertes`, historique et API Mock sont couvertes.
-      - name: Vérifie que les trois commandes backend s'importent sans réseau
+      - name: Vérifie que les quatre commandes backend s'importent sans réseau
        run: >
          docker run --rm --network none enervision-airflow:ci
          bash -c "cd /opt/backend
          && env -u VIRTUAL_ENV uv run --no-sync python -m app.detection.internal_alerts --help
          && env -u VIRTUAL_ENV uv run --no-sync python -m app.cli generate-recommendations --help
-          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.historical_import --help"
+          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.historical_import --help
          && env -u VIRTUAL_ENV uv run --no-sync python -m app.etl.mock_api_import --help"
@@ -0,0 +1,325 @@
 name: DAST
 # Scan dynamique OWASP ZAP de l'API (issue #41). Il attaque une API qui tourne : le job démarre
 # la base et le backend sur le runner, sème un site et quelques relevés (sans ça le scan ne
 # frappe que des gestionnaires d'erreur), crée un compte `lecteur` jetable
 # (scripts/dast-token.sh), puis lance ZAP sur le contrat OpenAPI avec le jeton de ce compte.
 #
 # Non bloquant pour l'instant sur les alertes (`continue-on-error` sur la seule étape du scan) :
 # le volume d'un premier passage trié est inconnu. Deux étapes suivantes, elles, bloquent si le
 # scan n'a rien testé (import du contrat, absence de toute réponse de succès) : un job vert doit
 # vouloir dire qu'un scan a eu lieu.
 #
 # Piège : ce scan tape la configuration par défaut du backend (`APP_ENV=local`, pas de TLS, pas
 # de reverse proxy). Il ne dit rien des en-têtes ni du TLS posés par le proxy en production, et
 # remontera des alertes (HSTS absent...) qui n'existent pas derrière lui.
 on:
  workflow_dispatch:
  schedule:
    # Un scan actif est long : hebdomadaire plutôt qu'à chaque PR.
    - cron: "0 3 * * 1"
  pull_request:
    # Ne se lance sur une PR que si le scan lui-même change.
    paths:
      - ".github/workflows/dast.yml"
      - "scripts/dast-token.sh"
 permissions:
  contents: read
 concurrency:
  group: dast-${{ github.ref }}
  cancel-in-progress: true
 jobs:
  zap:
    name: Scan OWASP ZAP de l'API
    runs-on: ubuntu-latest
    # Généreux face aux ~2 minutes observées de bout en bout : le vrai plafond est
    # `scanner.maxScanDurationInMins` (étape Scan ZAP), sous le TTL du jeton. Une annulation par
    # ce timeout-ci n'exécute pas les étapes `always()` : mieux vaut ne jamais l'atteindre.
    timeout-minutes: 30
    # Même image que docker-compose.yml : la première migration refuse de s'appliquer sans
    # l'extension TimescaleDB (cf. backend.yml).
    services:
      db:
        image: timescale/timescaledb-ha:pg17
        env:
          POSTGRES_USER: enervision
          POSTGRES_PASSWORD: change_me
          POSTGRES_DB: enervision_dast
        ports:
          - "5433:5432"
        options: >-
          --health-cmd "pg_isready -U enervision -d enervision_dast"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 12
          --health-start-period 40s
    env:
      # Base jetable : ZAP y écrira et le script y crée deux comptes.
      DATABASE_URL: postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_dast
      APP_SECRET_KEY: secret-de-scan-assez-long-pour-le-validateur
      APP_ENV: local
      # Le jeton du lecteur doit survivre à toute la durée du scan (15 minutes par défaut).
      # 3600 est le plafond accepté par la configuration ; `scanner.maxScanDurationInMins`
      # (étape Scan ZAP) reste très en dessous, marge comprise pour les étapes qui l'entourent.
      APP_ACCESS_TOKEN_TTL_SECONDS: "3600"
      PGPASSWORD: change_me
    steps:
      - name: Récupère le dépôt
        uses: actions/checkout@v7
      - name: Installe uv
        # Épinglé sur le commit du tag v7 (règle Sonar githubactions:S7637 : dépendance tierce,
        # contrairement à actions/checkout ou actions/upload-artifact, premières parties).
        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7
        with:
          enable-cache: true
          cache-dependency-glob: apps/backend/uv.lock
          # `prune-cache` vaut `true` par défaut (encore sur ce commit) : l'étape de post-job
          # « Pruning cache » est restée bloquée 5 minutes avant d'échouer (exit code 2) sur un
          # run où les 16 étapes précédentes passaient, sans lien avec le scan. Le prune n'est
          # qu'une optimisation de taille de cache entre deux runs, pas une garantie : le
          # désactiver retire le blocage sans rien changer au comportement du job.
          prune-cache: false
      - name: Installe l'interpréteur déclaré par .python-version
        run: uv python install
        working-directory: apps/backend
      # `--no-build` : aucune dépendance n'est construite depuis ses sources, donc aucun script de
      # build exécuté (règle Sonar S8541). Le projet lui-même n'est pas installé : il tourne depuis
      # `apps/backend`, comme dans son Dockerfile. Les `uv run` suivants portent `--frozen
      # --no-sync` pour ne rien résoudre ni reconstruire (règle S8544).
      - name: Synchronise les dépendances sans dévier du verrou
        run: uv sync --frozen --no-dev --no-install-project --no-build
        working-directory: apps/backend
      - name: Active TimescaleDB sur la base du scan
        run: psql -h localhost -p 5433 -U enervision -d enervision_dast -c "CREATE EXTENSION IF NOT EXISTS timescaledb"
      - name: Applique les migrations
        run: uv run --frozen --no-sync --no-build alembic upgrade head
        working-directory: apps/backend
      # Sans données, `GET /sites` rend `[]`, chaque `/{site_id}` rend 404 et le scan actif ne
      # frappe que des gestionnaires d'erreur plutôt que la logique métier. `db/seeds/` est vide
      # (pas encore d'outillage de jeu de données pour la CI) : un site et deux relevés à la main,
      # juste assez pour que les routes de lecture aient quelque chose à rendre.
      - name: Insère un site et des relevés minimaux pour le scan
        run: |
          psql -h localhost -p 5433 -U enervision -d enervision_dast <<'SQL'
          INSERT INTO site (site_id, site_name, site_type, location, capacity_kw, status)
          VALUES ('dast-site', 'Site du scan DAST', 'bureau', 'CI', 50, 'actif')
          ON CONFLICT (site_id) DO NOTHING;
          INSERT INTO reading (site_id, timestamp, source, consumption_kw, consumption_kwh, is_working_hours, data_quality, raw_data)
          VALUES
            ('dast-site', now() - interval '2 hours', 'api_current', 12.5, 12.5, true, 'good', '{}'),
            ('dast-site', now() - interval '1 hour',  'api_current', 13.0, 13.0, true, 'good', '{}')
          ON CONFLICT DO NOTHING;
          SQL
      - name: Démarre l'API
        run: |
          nohup uv run --frozen --no-sync --no-build uvicorn app.main:create_app --factory \
            --host 0.0.0.0 --port 8000 > "$RUNNER_TEMP/api.log" 2>&1 &
          for _ in $(seq 1 30); do
            curl -fsS http://localhost:8000/api/v1/health/ready >/dev/null 2>&1 && exit 0
            sleep 2
          done
          echo "L'API ne répond pas sur /health/ready" >&2
          cat "$RUNNER_TEMP/api.log" >&2
          exit 1
        working-directory: apps/backend
      - name: Crée le compte lecteur du scan
        id: jeton
        run: |
          jeton="$(../../scripts/dast-token.sh)"
          echo "::add-mask::$jeton"
          echo "jeton=$jeton" >> "$GITHUB_OUTPUT"
        working-directory: apps/backend
      # Étape distincte du scan lui-même, et sans `continue-on-error` : un `curl` qui échoue ici
      # (API tombée juste après la sonde de readiness, par exemple) doit rester un échec visible,
      # pas se travestir en « ZAP n'a importé aucune URL » à l'étape de garde suivante.
      - name: Prépare le contrat pour ZAP
        run: |
          mkdir -p zap-out zap-logs
          curl -fsS http://localhost:8000/openapi.json -o zap-out/openapi.json
          # Le dossier passe à l'uid 1000 (utilisateur du conteneur ZAP) : le runner n'y écrit
          # plus après ce chown, d'où `zap-logs/` (uid du runner) pour les journaux ci-dessous.
          # Pas de `chmod 777` (règle Sonar S2612).
          sudo chown -R 1000:1000 zap-out
      # `--network host` : ZAP atteint l'API sur le localhost du runner.
      #
      # Piège vécu : la clé du nom d'en-tête est `matchstr`, pas `matchstring`. ZAP accepte
      # n'importe quelle clé `-config` sans erreur ; avec la mauvaise, il ajoutait à TOUTES les
      # requêtes un en-tête au nom vide (`: Bearer <jeton>`), qu'uvicorn refuse par un 400
      # (« Invalid HTTP request received »), y compris sur les routes publiques.
      #
      # Le jeton ne passe ni par `${{ }}` dans ce script (il finirait en clair dans le fichier de
      # commande que GitHub écrit sur le disque du runner pour toute la durée de l'étape), ni par
      # l'argv de `docker run` (visible par `ps aux` et par `docker inspect zap` tant que le
      # conteneur existe) : il est écrit dans un fichier de configuration ZAP séparé, monté en
      # lecture seule hors de `/zap/wrk` pour ne jamais atterrir dans l'artefact publié.
      #
      # Les routes d'authentification qui changent l'état du compte du scan sont exclues : un
      # scan actif y déclencherait la limitation de débit du login, la réinitialisation de mots de
      # passe et la fermeture des sessions, sans rien apprendre de plus.
      #
      # `scanner.maxScanDurationInMins`/`maxRuleDurationInMins` bornent le scan actif, que `-T` ne
      # couvre pas (il ne borne que le démarrage et le scan passif) : sans ça, une règle qui
      # traîne peut dépasser le TTL du jeton (401 muets en fin de scan) ou le timeout du job (qui
      # annule sans exécuter les étapes `always()`, rapport et journaux perdus).
      - name: Scan ZAP
        id: zap
        continue-on-error: true
        env:
          JETON: ${{ steps.jeton.outputs.jeton }}
        run: |
          set -o pipefail
          printf 'replacer.full_list(0).description=auth\nreplacer.full_list(0).enabled=true\nreplacer.full_list(0).matchtype=REQ_HEADER\nreplacer.full_list(0).matchstr=Authorization\nreplacer.full_list(0).regex=false\nreplacer.full_list(0).replacement=Bearer %s\n' "$JETON" > "$RUNNER_TEMP/zap-auth.conf"
          # Piège vécu : `chmod 600` seul rend le fichier illisible pour le conteneur, qui lit un
          # montage bind avec son propre uid (1000), distinct de celui du runner qui l'a écrit.
          # ZAP échoue alors dès le lancement (« File not readable: /zap/auth.conf »), et
          # `zap-api-scan.py` attend `-T` minutes complètes avant d'abandonner : dix minutes qui
          # ressemblent à un scan actif, pour un daemon mort depuis le début.
          #
          # Piège vécu (numéro deux) : une fois le fichier passé à l'uid 1000 par `sudo chown`,
          # l'utilisateur du runner n'en est plus propriétaire et un `chmod` sans `sudo` échoue
          # (« Operation not permitted »). Avec le `-e` implicite de bash sur les étapes GitHub
          # Actions, cette erreur arrêtait toute l'étape avant même `docker run` : scan « réussi »
          # en une fraction de seconde, sans le moindre journal ni rapport produit.
          sudo chown 1000:1000 "$RUNNER_TEMP/zap-auth.conf"
          sudo chmod 644 "$RUNNER_TEMP/zap-auth.conf"
          docker run --name zap --network host \
            -v "$PWD/zap-out:/zap/wrk:rw" \
            -v "$RUNNER_TEMP/zap-auth.conf:/zap/auth.conf:ro" \
            ghcr.io/zaproxy/zaproxy:stable zap-api-scan.py \
            -t /zap/wrk/openapi.json -f openapi -O http://localhost:8000 \
            -T 10 \
            -r zap-report.html -J zap-report.json -w zap-report.md \
            -z "-configfile /zap/auth.conf \
                -config globalexcludeurl.url_list.url(0).description=auth-etat \
                -config globalexcludeurl.url_list.url(0).enabled=true \
                -config globalexcludeurl.url_list.url(0).regex='.*/api/v1/auth/(login|password|logout-all|forgot-password|reset-password).*' \
                -config scanner.maxScanDurationInMins=15 \
                -config scanner.maxRuleDurationInMins=5" \
            2>&1 | tee "$RUNNER_TEMP/zap-stdout.log"
      - name: Récupère les journaux de ZAP
        if: always()
        run: |
          mkdir -p zap-logs
          # ZAP journalise la valeur de chaque `-config`/`-configfile` chargé, y compris le jeton,
          # à un niveau visible sans `-d` : les copies publiées en artefact sont donc caviardées,
          # même si `::add-mask::` (posé à la création du jeton) protège déjà le journal du job.
          masque() { sed -E 's/(Bearer )[A-Za-z0-9._-]+/\1[MASQUE]/Ig'; }
          [ -f "$RUNNER_TEMP/zap-stdout.log" ] && masque < "$RUNNER_TEMP/zap-stdout.log" > zap-logs/zap-stdout.log
          docker cp zap:/home/zap/.ZAP/zap.log "$RUNNER_TEMP/zap-internal.log" 2>/dev/null || true
          [ -f "$RUNNER_TEMP/zap-internal.log" ] && masque < "$RUNNER_TEMP/zap-internal.log" > zap-logs/zap.log
          [ -f "$RUNNER_TEMP/api.log" ] && masque < "$RUNNER_TEMP/api.log" > zap-logs/api.log
          rm -f "$RUNNER_TEMP/zap-auth.conf"
          docker rm -f zap >/dev/null 2>&1 || true
      # `continue-on-error` sur le scan ne doit pas faire passer pour vert un scan qui n'a rien
      # testé. Constaté une première fois : 2 URL importées sur 26 opérations, ZAP n'avait envoyé
      # que des requêtes vouées au 404. Le seuil est dérivé du contrat plutôt que d'un nombre fixe
      # : un contrat qui grossit ne doit pas rendre la garde plus permissive qu'elle ne l'était.
      - name: Vérifie que le contrat a bien été importé
        run: |
          attendu="$(python3 -c "
          import json
          d = json.load(open('zap-out/openapi.json'))
          methodes = ('get', 'post', 'put', 'patch', 'delete', 'head', 'options')
          print(sum(1 for chemin in d['paths'].values() for m in chemin if m in methodes))
          ")"
          minimum=$((attendu * 80 / 100))
          importees="$(sed -n 's/.*Number of Imported URLs: \([0-9]*\).*/\1/p' "$RUNNER_TEMP/zap-stdout.log" | tail -1)"
          echo "URL importées depuis le contrat OpenAPI : ${importees:-aucune} (contrat : $attendu opérations, minimum accepté : $minimum)"
          if [ "${importees:-0}" -lt "$minimum" ]; then
            echo "::error::ZAP n'a importé que ${importees:-0} URL sur $attendu opérations du contrat OpenAPI (minimum attendu : $minimum, soit 80%). Le scan n'a pas testé l'API, voir zap-logs/zap.log dans l'artefact zap-report."
            exit 1
          fi
      # Deuxième garde-fou : le contrat peut être importé et ZAP n'obtenir que des erreurs
      # (constaté : base sans données, toutes les routes de site répondaient 404).
      #
      # Piège de conception, trouvé en répétant ce job en local avant de l'écrire ici : borner le
      # pourcentage de 4xx ne marche pas. Un scan actif fuzze délibérément un grand nombre
      # d'entrées invalides (identifiants inventés, méthodes non supportées...), donc même un scan
      # sain, contre l'API seedée juste au-dessus, reste à 98% de 4xx avec seulement 1% de 2xx :
      # c'est la forme normale d'un scan actif, pas un signe d'échec. Le signal qui distingue
      # vraiment un scan cassé (0% de 2xx, `insight.code.2xx` absent du rapport dans le premier
      # incident) d'un scan sain (2xx non nul, aussi faible soit-il) est donc l'absence de succès,
      # pas la part d'échecs. Dérivé de `zap-report.json` (champ structuré `insights[]`) plutôt
      # que du texte libre du rapport Markdown, qui aurait le même défaut de conception en plus
      # d'être fragile au format.
      - name: Vérifie que le scan a obtenu au moins une réponse de succès
        run: |
          python3 - <<'PY'
          import json
          import sys
          try:
              rapport = json.load(open("zap-out/zap-report.json"))
          except FileNotFoundError:
              print("::error::Aucun rapport ZAP produit : le scan n'a rien testé.")
              sys.exit(1)
          pourcentage_2xx = 0.0
          for insight in rapport.get("insights", []):
              if insight.get("key") == "insight.code.2xx":
                  pourcentage_2xx = float(insight.get("statistic", 0))
                  break
          print(f"Pourcentage de réponses 2xx : {pourcentage_2xx}%")
          if pourcentage_2xx <= 0:
              print(
                  "::error::Aucune réponse 2xx (succès) reçue : le scan n'a atteint aucune route "
                  "réelle de l'API. Voir zap-logs/api.log et zap-logs/zap.log dans l'artefact "
                  "zap-report."
              )
              sys.exit(1)
          PY
      # Uniquement la synthèse (jusqu'à « Alert Detail » exclu) : `$GITHUB_STEP_SUMMARY` est
      # limité à 1 Mio, et cette étape tourne sous `always()` - son échec ferait échouer le job
      # après le passage des deux garde-fous, pour une simple raison de mise en forme. Le rapport
      # complet reste dans l'artefact `zap-report`.
      - name: Publie le résumé
        if: always()
        run: |
          if [ -f zap-out/zap-report.md ]; then
            awk '/^## Alert Detail/{exit} {print}' zap-out/zap-report.md >> "$GITHUB_STEP_SUMMARY"
            echo "" >> "$GITHUB_STEP_SUMMARY"
            echo "Rapport complet (HTML/JSON/Markdown) dans l'artefact \`zap-report\`." >> "$GITHUB_STEP_SUMMARY"
          else
            echo "Aucun rapport ZAP produit, voir le journal du job." >> "$GITHUB_STEP_SUMMARY"
          fi
      - name: Publie les rapports
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: zap-report
          path: |
            zap-out/
            zap-logs/
          if-no-files-found: warn
      # Diagnostic de dernier recours : les journaux de l'API sont déjà dans l'artefact
      # (zap-logs/api.log) via l'étape « Récupère les journaux de ZAP » (always()), mais les
      # afficher directement dans le journal du job évite d'avoir à le télécharger pour un échec
      # évident (l'API n'a jamais démarré, par exemple).
      - name: Journal de l'API en cas d'échec
        if: failure() || steps.zap.outcome == 'failure'
        run: cat "$RUNNER_TEMP/api.log" || true
@@ -0,0 +1,52 @@
 name: Infra
 # Pourquoi : le Terraform du dépôt est resté cassé sans que rien ne le dise, faute de job qui le
 # joue. Ce workflow n'applique rien : il vérifie le formatage et la validité de chaque racine.
 # Piège : la boucle parcourt `environments/*`, pour qu'une racine ajoutée soit couverte sans
 # toucher à ce fichier.
 on:
  push:
    paths:
      - "infra/terraform/**"
      - ".github/workflows/infra.yml"
  pull_request:
    paths:
      - "infra/terraform/**"
      - ".github/workflows/infra.yml"
 permissions:
  contents: read
 concurrency:
  group: infra-${{ github.ref }}
  cancel-in-progress: true
 jobs:
  terraform:
    name: Formatage et validation Terraform
    runs-on: ubuntu-latest
    steps:
      - name: Récupère le dépôt
        uses: actions/checkout@v7
      # Action tierce, donc epinglee sur un SHA de commit et pas sur un tag mobile : un tag se
      # redeplace, et ce workflow tourne avec les droits du depot (regle Sonar githubactions:S7637).
      - name: Installe Terraform
        uses: hashicorp/setup-terraform@dfe3c3f87815947d99a8997f908cb6525fc44e9e # v4.0.1
        with:
          terraform_version: 1.16.3
          terraform_wrapper: false
      - name: Vérifie le formatage
        run: terraform fmt -check -recursive infra/terraform
      - name: Valide chaque racine
        run: |
          for racine in infra/terraform/environments/*/; do
            echo "::group::${racine}"
            terraform -chdir="${racine}" init -backend=false -input=false
            terraform -chdir="${racine}" validate
            echo "::endgroup::"
          done
@@ -63,7 +63,8 @@ ml/models/*
 !ml/models/.gitkeep
 ml/mlruns/
 ml/mlartifacts/
-ml/mlflow.db
+ml/mlflow.db*
 ml/.env
 # Airflow : base sqlite locale generee par les tests d'integrite des DAGs (etl/airflow/tests)
 etl/airflow/tests/.airflow_home/
@@ -20,6 +20,8 @@ PG_USER := $(or $(strip $(call env-val,POSTGRES_USER)),enervision)
 PG_PASSWORD := $(or $(strip $(call env-val,POSTGRES_PASSWORD)),change_me)
 PG_DB := $(or $(strip $(call env-val,POSTGRES_DB)),enervision)
 PG_PORT := $(or $(strip $(call env-val,POSTGRES_PORT)),5433)
 ml-env-val = $(shell sed -n 's/^$(1)=//p' ml/.env 2>/dev/null | tail -1)
 ML_ENV_DB_PASSWORD := $(call ml-env-val,MLFLOW_DB_PASSWORD)
 AIRFLOW_PORT := $(or $(strip $(call env-val,AIRFLOW_PORT)),8080)
 MAILPIT_UI_PORT := $(or $(strip $(call env-val,MAILPIT_UI_PORT)),8025)
 ML_DATABASE_URL ?= postgresql+psycopg://$(PG_USER):$(PG_PASSWORD)@localhost:$(PG_PORT)/$(PG_DB)
@@ -35,7 +37,7 @@ DEMO_NOW ?= 2024-12-31T00:00:00Z
        lint format typecheck test test-cov test-integration check \
        openapi docker-build db-up db-down db-reset db-logs db-psql db-wait db-ensure-airflow \
        migrate bootstrap-admin services-up demo-data demo-data-force \
-        ml-lint ml-typecheck ml-test ml-check ml-train ml-score detect-alerts recommendations \
+        ml-lint ml-typecheck ml-test ml-check ml-train ml-score mlflow-up detect-alerts recommendations \
        airflow-lint airflow-test airflow-check airflow-up airflow-down airflow-logs \
        tls-selfsigned tls-acme tls-renew stack-up stack-down stack-logs
@@ -118,6 +120,14 @@ ml-train: ## Entraine le modele LightGBM. CSV=chemin optionnel, sinon lit ML_DAT
 ml-score: ## Score le prochain pas horaire et l'ecrit dans `prediction`. CSV= et NOW= optionnels
 	cd $(ML) && uv run python -m enervision_ml.score $(if $(CSV),--csv $(CSV),) $(if $(NOW),--now $(NOW),)
 mlflow-up: ## Démarre le serveur MLflow (tracking + registry) en conteneur. ml/.env requis
 	@test -n "$(strip $(ML_ENV_DB_PASSWORD))" \
 		|| { echo "MLFLOW_DB_PASSWORD absente de ml/.env (copier ml/.env.example)"; exit 1; }
 	@echo "$(ML_ENV_DB_PASSWORD)" | grep -qE '^[A-Za-z0-9]+$$' \
 		|| { echo "MLFLOW_DB_PASSWORD doit contenir uniquement lettres et chiffres (interpolee dans l'URI postgresql://)"; exit 1; }
 	cd $(ML) && docker compose -f docker-compose.mlflow.yml up -d --build
 	@echo "mlflow   -> http://localhost:5000"
 detect-alerts: ## Détecte les alertes internes depuis les lectures en base. SITE= et NOW= optionnels
 	cd $(BACKEND) && uv run python -m app.detection.internal_alerts $(if $(SITE),--site-id $(SITE),) $(if $(NOW),--now $(NOW),)
@@ -23,7 +23,7 @@ Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.m
 | Backend    | FastAPI, Python 3.14                | `apps/backend`      | En place    |
 | Frontend   | Angular 22, Node 26                 | `apps/frontend`     | En place |
 | Base       | PostgreSQL 17 + TimescaleDB         | `db`                | En place    |
-| ETL        | Apache Airflow                      | `etl/airflow`       | Quatre DAGs   |
+| ETL        | Apache Airflow                      | `etl/airflow`       | Cinq DAGs     |
 | Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
 | Reverse proxy | Nginx, TLS                       | `infra/proxy`       | En place      |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | En place |
@@ -50,7 +50,7 @@ L'etat detaille de chaque brique et les vues d'architecture sont dans
 │   ├── migrations/     Migrations SQL versionnees
 │   └── seeds/          Jeux de donnees de reference
 ├── etl/airflow/
-│   ├── dags/           DAGs d'orchestration (pipeline ML, alertes, import historique)
+│   ├── dags/           DAGs d'orchestration (pipeline ML, alertes, imports historique et API Mock)
 │   ├── plugins/        Operateurs et hooks maison
 │   ├── include/        Requetes SQL et ressources des DAGs
 │   └── tests/          Tests d'integrite des DAGs
@@ -48,7 +48,9 @@ SettingsDep = Annotated[Settings, Depends(get_settings)]
 CODE_CHANGEMENT_REQUIS = "password_change_required"
-_porteur = HTTPBearer(auto_error=False, scheme_name="Jeton d'accès")
+# Nom ASCII : un outillage tiers (ZAP, cf. .github/workflows/dast.yml) peut mal analyser un nom
 # de schéma accentué dans le contrat OpenAPI. Piège vécu, pas anticipé.
 _porteur = HTTPBearer(auto_error=False, scheme_name="JetonAcces")
 CredentialsDep = Annotated[HTTPAuthorizationCredentials | None, Depends(_porteur)]
@@ -94,7 +94,9 @@ TAGS: Final[list[dict[str, Any]]] = [
 cookie_de_rafraichissement = APIKeyCookie(
    name=REFRESH_COOKIE_DEFAUT,
-    scheme_name="Cookie de rafraîchissement",
+    # Nom ASCII : un outillage tiers (ZAP, cf. .github/workflows/dast.yml) peut mal analyser un
    # nom de schéma accentué dans le contrat OpenAPI. Piège vécu, pas anticipé.
    scheme_name="CookieRafraichissement",
    description=(
        "Cookie `HttpOnly` posé par `/auth/login` et tourné par `/auth/refresh`. Il prend le "
        "préfixe `__Secure-` dès que l'API tourne derrière TLS, et n'est émis que vers "
@@ -45,15 +45,19 @@ CAPACITY_BOUNDS = (0.0, 100_000.0)
 def create_mock_api_client() -> httpx.AsyncClient:
    settings = get_settings()
-    if settings.mock_api_username is None or settings.mock_api_password is None:
+    username = settings.mock_api_username
    password = (
        settings.mock_api_password.get_secret_value()
        if settings.mock_api_password is not None
        else None
    )
    if not username or not username.strip() or not password or not password.strip():
        raise ValueError("Les identifiants de l'API Mock ne sont pas configurés.")
    return httpx.AsyncClient(
        base_url=settings.mock_api_base_url.rstrip("/"),
-        auth=(
+        auth=(username, password),
            settings.mock_api_username,
            settings.mock_api_password.get_secret_value(),
        ),
        timeout=settings.mock_api_timeout_seconds,
    )
@@ -213,7 +213,7 @@
        },
        "security": [
          {
-            "Cookie de rafraîchissement": []
+            "CookieRafraichissement": []
          }
        ]
      }
@@ -252,7 +252,7 @@
        },
        "security": [
          {
-            "Cookie de rafraîchissement": []
+            "CookieRafraichissement": []
          }
        ]
      }
@@ -301,7 +301,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -347,7 +347,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -423,7 +423,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -673,7 +673,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      },
@@ -757,7 +757,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -771,7 +771,7 @@
        "operationId": "update_user_api_v1_users__user_id__patch",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -889,7 +889,7 @@
        "operationId": "reset_password_api_v1_users__user_id__password_reset_post",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1023,7 +1023,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -1037,7 +1037,7 @@
        "operationId": "get_site_api_v1_sites__site_id__get",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1124,7 +1124,7 @@
        "operationId": "get_current_api_v1_sites__site_id__current_get",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1211,7 +1211,7 @@
        "operationId": "list_alerts_api_v1_alerts_get",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1361,7 +1361,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -1375,7 +1375,7 @@
        "operationId": "get_recommendation_api_v1_recommendations__recommendation_id__get",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1462,7 +1462,7 @@
        "operationId": "generate_recommendations_api_v1_recommendations_generate_post",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1588,7 +1588,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -1602,7 +1602,7 @@
        "operationId": "list_readings_api_v1_readings_get",
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ],
        "parameters": [
@@ -1799,7 +1799,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -1855,7 +1855,7 @@
        },
        "security": [
          {
-            "Jeton d'accès": []
+            "JetonAcces": []
          }
        ]
      }
@@ -3225,13 +3225,13 @@
      }
    },
    "securitySchemes": {
-      "Cookie de rafraîchissement": {
+      "CookieRafraichissement": {
        "type": "apiKey",
        "description": "Cookie `HttpOnly` posé par `/auth/login` et tourné par `/auth/refresh`. Il prend le préfixe `__Secure-` dès que l'API tourne derrière TLS, et n'est émis que vers `/api/v1/auth`.",
        "in": "cookie",
        "name": "ev_refresh"
      },
-      "Jeton d'accès": {
+      "JetonAcces": {
        "type": "http",
        "scheme": "bearer"
      }
@@ -104,8 +104,8 @@ def test_the_rate_limit_documents_the_delay_header(schema: dict[str, Any]) -> No
 def test_the_refresh_cookie_appears_in_the_security_schemes(schema: dict[str, Any]) -> None:
    schemes = schema["components"]["securitySchemes"]
-    assert schemes["Cookie de rafraîchissement"]["in"] == "cookie"
+    assert schemes["CookieRafraichissement"]["in"] == "cookie"
-    assert schemes["Cookie de rafraîchissement"]["name"] == "ev_refresh"
+    assert schemes["CookieRafraichissement"]["name"] == "ev_refresh"
 def test_each_tag_used_by_a_route_is_described(schema: dict[str, Any]) -> None:
@@ -283,6 +283,41 @@ def test_create_mock_api_client_requires_credentials(
        mock_api_import.create_mock_api_client()
@pytest.mark.parametrize(
    ("username", "password_value"),
    [
        ("", "test-password"),
        ("test-user", ""),
        ("   ", "test-password"),
        ("test-user", "   "),
    ],
 )
 def test_create_mock_api_client_rejects_empty_credentials(
    monkeypatch: pytest.MonkeyPatch,
    username: str,
    password_value: str,
 ) -> None:
    password = MagicMock()
    password.get_secret_value.return_value = password_value
    settings = SimpleNamespace(
        mock_api_username=username,
        mock_api_password=password,
    )
    monkeypatch.setattr(
        mock_api_import,
        "get_settings",
        lambda: settings,
    )
    with pytest.raises(
        ValueError,
        match="Les identifiants de l'API Mock ne sont pas configurés",
    ):
        mock_api_import.create_mock_api_client()
 async def test_create_mock_api_client_uses_configuration(
    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -34,12 +34,14 @@ x-airflow-common: &airflow-common
    # memes identifiants que le backend en attendant.
    ML_DATABASE_URL: postgresql+psycopg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
    MLFLOW_TRACKING_URI: sqlite:////opt/ml/state/mlflow.db
-    # Le DAG `alertes` lance le backend en sous-processus : il lit `DATABASE_URL`, en
+    # Les DAGs backend lisent `DATABASE_URL` en dialecte asyncpg, là où le pipeline ML
-    # dialecte asyncpg, là où le pipeline ML lit `ML_DATABASE_URL`.
+    # utilise `ML_DATABASE_URL`.
    DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
-    # Clé distincte de celle de l'API : la détection ne signe ni ne vérifie aucun jeton, et
+
-    # Airflow permet d'exécuter du code depuis son interface (cf. ADR 0008).
+    # Clé distincte de celle de l'API : les traitements lancés par Airflow ne signent ni ne
    # vérifient aucun jeton. Airflow permet d'exécuter du code depuis son interface (ADR 0008).
    APP_SECRET_KEY: ${AIRFLOW_APP_SECRET_KEY:-}
  volumes:
    - ./etl/airflow/dags:/opt/airflow/dags
    - ./etl/airflow/plugins:/opt/airflow/plugins
@@ -167,6 +169,14 @@ services:
  airflow-scheduler:
    <<: *airflow-common
    command: scheduler
    environment:
      <<: *airflow-common-env
      # LocalExecutor exécute les tâches dans le scheduler : lui seul a besoin des
      # identifiants de l'API Mock.
      APP_MOCK_API_BASE_URL: ${APP_MOCK_API_BASE_URL:-https://api-mock.charlieandre.fr}
      APP_MOCK_API_USERNAME: ${APP_MOCK_API_USERNAME:-}
      APP_MOCK_API_PASSWORD: ${APP_MOCK_API_PASSWORD:-}
      APP_MOCK_API_TIMEOUT_SECONDS: ${APP_MOCK_API_TIMEOUT_SECONDS:-10}
    depends_on:
      db:
        condition: service_healthy
@@ -16,3 +16,4 @@
 | [0007](adr/0007-terminaison-tls-et-reverse-proxy-nginx.md) | Terminaison TLS par un reverse proxy Nginx, en Docker Compose |
 | [0008](adr/0008-airflow-execute-le-code-du-backend.md) | Airflow exécute le code du backend en sous-processus, dans son propre environnement |
 | [0009](adr/0009-deux-environnements-compose-sur-la-vm-eni.md) | Deux environnements sur la VM ENI, un projet Compose chacun, déployés par un runner auto-hébergé |
 | [0010](adr/0010-terraform-provisionne-github-actions-deploie.md) | Terraform provisionne la machine, GitHub Actions déploie l'application |
@@ -76,6 +76,7 @@ secret.
  à chaque push : plusieurs minutes par déploiement, acceptable pour la cadence du projet.
 - `environments/prod` de Terraform reste vide. Le provisionnement de la machine est porté par
  `scripts/provision-host.sh`, que Terraform pourra appeler par `remote-exec` le jour où une
-  racine visant la VM existera.
+  racine visant la VM existera. Cette racine existe depuis l'[ADR 0010](0010-terraform-provisionne-github-actions-deploie.md),
  sous le nom `environments/vm-eni`, et `environments/prod` a disparu avec elle.
 - L'image frontend quitte `dhi.io/nginx`, registre authentifié dont personne n'a l'accès, pour
  `nginx:1.28-alpine`, la même image que le proxy. Elle n'avait jamais été construite.
@@ -0,0 +1,77 @@
 # 0010 - Terraform provisionne la machine, GitHub Actions déploie l'application
 - Statut : accepté
 - Date : 2026-09-22
 ## Contexte
 L'[ADR 0009](0009-deux-environnements-compose-sur-la-vm-eni.md) a posé la livraison : deux
 projets Compose sur la VM ENI, alignés sur `dev` et sur `main` par un runner auto-hébergé. Elle
 ne dit pas qui prépare la machine. C'est `scripts/provision-host.sh`, lancé à la main en SSH.
 La grille d'évaluation attend en C22 que l'infrastructure soit « provisionnée via du code
 (Terraform, Ansible…) ». Le seul Terraform du dépôt installe un cluster k3s que rien ne
 consomme, qui n'a jamais été appliqué, et dont la racine ne passait même pas `terraform init`
 depuis que Terraform refuse les provisioners `destroy` dont la connexion lit autre chose que
 `self`. Sa racine s'appelait `environments/dev`, nom qui laissait croire à un environnement
 applicatif alors que les deux environnements réels sont `rec` et `prod`, sur la même machine.
 La branche `feat/deploy` (PR #141) proposait la réponse inverse : Terraform construit les
 images, lance les conteneurs et copie les sources par SSH. La revue a relevé deux racines sur
 trois qui ne passent pas `terraform validate`, le mot de passe SSH écrit en clair dans le state,
 un backend lancé sans base ni variables d'environnement, et trois architectures différentes pour
 trois environnements.
 ## Décision
 **Terraform provisionne la machine, GitHub Actions déploie l'application.** La frontière est
 nette et vérifiable : `infra/terraform/environments/vm-eni` installe Docker et le plugin
 Compose, exécute `scripts/provision-host.sh`, enregistre le runner. Il ne construit aucune
 image, ne lance aucun conteneur, et un `apply` n'interrompt pas la stack qui tourne.
 **Le déploiement continu ne change pas.** `deploy.yml` reste le seul chemin de livraison : push
 sur `dev` ou `main`, alignement du clone, `make stack-up`, sonde `/api/v1/health/ready`.
 **Le Bash reste la mécanique, Terraform devient le point d'entrée.** `provision-host.sh` connaît
 les deux environnements, leurs ports décalés, leurs secrets et leurs certificats. Le réécrire en
 HCL créerait une seconde source de vérité qui divergerait au premier changement de port.
 **Aucun secret dans le state.** Authentification SSH par clé seulement, pas de variable de mot
 de passe. Le jeton d'enregistrement du runner est une variable `sensitive` fournie à l'`apply`,
 jamais un `trigger` : les `triggers` sont la seule partie d'un `null_resource` que Terraform
 persiste.
 **Les racines portent le nom de ce qu'elles provisionnent**, pas d'un environnement applicatif :
 `vm-eni` pour la machine, `k3s-cible` pour le cluster resté en cible. `environments/prod`,
 dossier vide, disparaît.
 ## Alternatives écartées
 - **Ansible à la place du Bash** : plus idiomatique pour de la configuration de machine, et le
  jury le reconnaîtrait immédiatement comme de l'IaC. Mais c'est un outil de plus à installer et
  à faire tourner, pour réécrire un script qui fonctionne, à trois jours du gel technique.
 - **Provisioners applicatifs de `feat/deploy`** : voir la revue sur #141. Terraform y devenait un
  orchestrateur concurrent de Compose, sans base de données ni migrations.
 - **Terraform appelle aussi `make stack-up`** : le premier démarrage serait plus court d'une
  commande, mais Terraform se mettrait à porter la livraison, que le runner rejoue à chaque
  push. Deux chemins pour le même acte, c'est précisément ce que #141 montre qu'il ne faut pas.
 - **k3s tout de suite** : le cluster serait vide, sans manifeste, sans registre et sans stockage
  persistant. Le module reste, documenté comme cible.
 - **State Terraform distant** : un seul opérateur, pas d'exécution concurrente. Le backend local
  suffit, comme pour `k3s-cible`.
 ## Conséquences
 - Le premier `apply` exige un jeton d'enregistrement du runner, valable une heure et pour une
  seule inscription, que seul un administrateur du dépôt peut créer. L'`apply` n'est donc pas
  rejouable sans intervention humaine, ce qui est acceptable : il ne se joue qu'à l'installation.
 - L'utilisateur propriétaire de `/srv/enervision` doit exister sur la machine avant l'`apply`.
  Terraform vérifie et échoue tôt plutôt que de le créer : décider d'un compte système est une
  décision d'administration, pas un effet de bord de déploiement.
 - Terraform ne sait rien de l'état de la stack. `terraform plan` ne dira jamais que la recette
  est tombée ; c'est la sonde de `deploy.yml` qui le dit.
 - Pas de provisioner `destroy` sur le runner : il imposerait de mettre le chemin de la clé SSH
  dans le state, et `svc.sh uninstall` ne désinscrit pas le runner côté GitHub. Le retrait reste
  manuel, depuis les paramètres du dépôt.
 - C22 cesse de reposer sur `docker-compose.prod.yml` seul. C23 reste porté par les scripts, que
  Terraform appelle désormais au lieu de les remplacer.
@@ -0,0 +1,162 @@
 # EnerVision · procédure de déploiement (22/09/2026)
 Terraform provisionne la machine, GitHub Actions déploie (ADR 0010). Deux environnements Compose
 sur la VM ENI `10.101.200.37` : `rec` sur la branche `dev`, `prod` sur `main` (ADR 0009).
 | | recette | production |
 |---|---|---|
 | Branche, environnement GitHub | `dev`, `rec` | `main`, `prod` |
 | Dossier, projet Compose | `/srv/enervision/rec`, `enervision-rec` | `/srv/enervision/prod`, `enervision-prod` |
 | URL | `https://rec.enervision.local:8443` | `https://enervision.local` |
 | Proxy HTTP / HTTPS | `127.0.0.1:8081` / `8443` | `80` / `443` |
 | Postgres / Mailpit / Airflow (locaux) | `5434` / `8026` / `8082` | `5433` / `8025` / `8080` |
 ## 0. Avant toute commande
 1. **Clé SSH déposée** sur la VM : `ssh-copy-id -i ~/.ssh/id_ed25519.pub root@10.101.200.37`.
   Terraform ne gère **pas** l'authentification par mot de passe (elle finirait dans le state).
 2. **L'utilisateur propriétaire existe déjà** sur la VM (ex. `enervision`) : il possède
   `/srv/enervision` et fait tourner le runner. Terraform échoue tôt s'il manque, il ne le crée pas.
 3. **Jeton d'enregistrement du runner** : Settings > Actions > Runners > New self-hosted runner.
   Valable 1 h, une seule inscription, créé par un administrateur du dépôt (ineszang).
 4. **`main` est en retard de 64 commits** et ne porte ni `deploy.yml`, ni `provision-host.sh`, ni
   le Terraform, ni l'overlay paramétré (ports et `PUBLIC_ORIGIN` en dur). Tant que `dev` n'est pas
   remonté dans `main`, seule la recette est déployable : le clone `prod` sera préparé mais son
   `make stack-up` publierait 80/443 sans les variables, et aucun push sur `main` ne déclencherait
   de déploiement (le workflow n'y existe pas). **Remonter `dev` → `main` avant de toucher à prod.**
 ## 1. Provisionner la machine (depuis le poste)
 ```bash
 cd infra/terraform/environments/vm-eni
 cp terraform.tfvars.example terraform.tfvars
 terraform init
 terraform apply
 ```
 `terraform.tfvars`, ignoré par git, trois valeurs à renseigner :
 ```hcl
 proprietaire   = "enervision"   # doit exister sur la VM
 runner_version = "2.330.0"      # épingler depuis github.com/actions/runner/releases
 runner_token   = "..."          # jeton d'1 h, à retirer du fichier après l'apply
 ```
 Défauts utiles : `ssh_host = "10.101.200.37"`, `ssh_user = "root"`,
 `ssh_private_key_path = "~/.ssh/id_ed25519"`, `racine = "/srv/enervision"`,
 `runner_labels = "eni-g3"` (ciblé par `deploy.yml`), `runner_dossier = "/opt/actions-runner"`.
 L'apply fait trois choses, dans cet ordre : Docker + plugin Compose et `usermod -aG docker`,
 puis `scripts/provision-host.sh`, puis l'installation et l'enregistrement du runner en service.
 Il ne construit aucune image et ne démarre aucun conteneur : un apply n'interrompt pas la stack.
 Rejouable : un clone existant est réaligné, un `.env` présent n'est **jamais** réécrit, un
 certificat présent n'est jamais régénéré. Un nouvel apply de la ressource runner redemande un
 jeton frais (il expire en 1 h).
 ## 2. Variables d'environnement
 Un `.env` par dossier, en `600`, généré sur la machine depuis `.env.example`. **Aucun secret ne
 passe par git ni par GitHub** : le runner n'en reçoit aucun (seul `SONAR_TOKEN` existe côté CI).
 **Générés automatiquement** : `POSTGRES_PASSWORD`, `APP_SECRET_KEY`, `AIRFLOW_FERNET_KEY`,
 `AIRFLOW_API_SECRET_KEY`, `AIRFLOW_JWT_SECRET`, `AIRFLOW_ADMIN_PASSWORD`, `AIRFLOW_APP_SECRET_KEY`.
 **Fixés par environnement** : `COMPOSE_PROJECT_NAME`, `PUBLIC_HOST`, `PUBLIC_ORIGIN`,
 `PROXY_HTTP_PORT`, `PROXY_HTTPS_PORT`, `POSTGRES_PORT`, `MAILPIT_UI_PORT`, `AIRFLOW_PORT`.
 **À renseigner à la main**, dans chaque `.env`, avant le premier démarrage :
 ```
 APP_MOCK_API_USERNAME=...
 APP_MOCK_API_PASSWORD=...
 ```
 Garde-fou : le script refuse d'écrire un `.env` s'il reste un `change_me` hors `APP_MOCK_API_*`
 (cas vécu d'une clé renommée en amont, `AIRFLOW_WEBSERVER_SECRET_KEY` sous Airflow 3).
 `APP_ENV=prod` et `APP_DEBUG=false` sont en dur dans l'overlay, pas dans le `.env` : la valeur
 `local` du poste reprendrait le dessus et rouvrirait `/docs` sans cookie `__Secure-`.
 `TS_TUNE_MEMORY=2GB` et `TS_TUNE_NUM_CPUS=2` sont obligatoires : deux TimescaleDB sur 8 Go se
 réserveraient 25 % de la RAM chacune. La montée à 32 Go est à demander.
 Certificats auto-signés générés par le script (`infra/proxy/tls/`), couvrant le nom d'hôte,
 `localhost` et l'IP. Let's Encrypt (`make tls-acme`, `ACME_EMAIL`) reste hors d'atteinte sans
 domaine public résolvable.
 ## 3. Premier démarrage (manuel, une seule fois, sur la VM)
 ```bash
 cd /srv/enervision/rec && make stack-up      # build + up + alembic upgrade head
 cd /srv/enervision/prod && make stack-up     # seulement après la remontée dev → main
 ```
 `stack-up` refuse de démarrer si le certificat manque ou ne couvre pas `PUBLIC_HOST`, et applique
 les migrations : sans elles la stack démarrerait verte sur une base sans schéma.
 Premier administrateur, stack démarrée, dans chaque dossier :
 ```bash
 docker compose -f docker-compose.yml -f docker-compose.prod.yml exec backend \
    python -m app.cli create-admin --email <adresse>
 ```
 Données historiques : `data/raw` n'est pas dans git. Déposer les fichiers dans chaque dossier
 avant de déclencher le DAG `historical_import`.
 ## 4. Réglages GitHub (administrateur du dépôt)
 - Environnement `prod` : branche `main` seule autorisée, **approbation d'un relecteur** requise.
 - Environnement `rec` : branche `dev` seule autorisée, sans approbation.
 - Settings > Actions : **« Require approval for all outside collaborators »**. Un runner
  auto-hébergé sur un dépôt public exécute ce qu'on lui envoie ; `deploy.yml` ne se déclenche
  jamais sur `pull_request`, et le runner ne tourne jamais en root.
 ## 5. Déploiement continu, ensuite
 Un push sur `dev` déploie la recette, un push sur `main` la production après approbation.
 Le job (runner `eni-g3`) aligne le clone (`fetch`, `checkout`, `reset --hard`), lance
 `make stack-up`, puis sonde `/api/v1/health/ready` derrière le proxy pendant 3 minutes ; en cas
 d'échec il publie `ps` et les 50 dernières lignes de `backend` et `proxy`. Pas de `checkout` dans
 l'espace du runner : `.env`, certificats et volumes doivent survivre d'un déploiement à l'autre.
 Concurrence par branche, sans annulation.
 Déclenchement manuel possible : `workflow_dispatch`.
 ## 6. Vérifier
 ```bash
 curl -k https://localhost:8443/api/v1/health/ready    # recette, sur la VM
 curl -k https://localhost/api/v1/health/ready         # production, sur la VM
 ```
 Depuis un poste, ajouter à `/etc/hosts` :
 ```
 10.101.200.37 enervision.local rec.enervision.local
 ```
 Les deux noms sont obligatoires : le cookie `__Secure-ev_refresh` est posé par hôte et non par
 port ; un seul nom déconnecterait la production à chaque connexion en recette.
 ## Pièges à connaître
 - Compose **2.24.4 minimum** : l'overlay emploie `!override` et `!reset`, sans quoi l'API resterait
  joignable en clair à côté du proxy. Le script le vérifie.
 - Le runner doit tourner sous le propriétaire de `/srv/enervision` : sinon git refuse les clones
  (propriété douteuse) et le `.env` en `600` lui échappe. Correctif :
  `PROPRIETAIRE=<utilisateur> bash scripts/provision-host.sh`.
 - Chaque environnement reconstruit ses images à partir du même commit : la production n'exécute
  pas l'artefact validé en recette, mais un second build. Le passage à GHCR lèvera cette limite.
 - Un `.env` perdu se régénère, mais invalide les sessions et les connexions chiffrées par Airflow :
  ils ne sont sauvegardés nulle part ailleurs.
 - Retirer le runner se fait à la main, depuis les paramètres du dépôt : `terraform destroy` ne le
  désinscrit pas.
 ## Références dans le dépôt
 `docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md`,
 `docs/adr/0010-terraform-provisionne-github-actions-deploie.md`,
 `docs/architecture/50-cicd.md`, `docs/architecture/10-infra.md`, `infra/README.md`,
 `scripts/provision-host.sh`, `.github/workflows/deploy.yml`, `docker-compose.prod.yml`.
@@ -0,0 +1,120 @@
 # EnerVision · Recette et production sur la VM ENI, aujourd'hui
 État au lundi 21 septembre 2026, 15h. Cible : deux environnements qui tournent sur la VM
 `eadl-2025-nantes-g3` (`10.101.200.37`) avant vendredi 25/09 9h, déployés automatiquement depuis
 GitHub. Ce document donne la solution retenue, ce qu'elle change dans le dépôt, et le déroulé de
 l'après-midi avec qui fait quoi.
 ## 1. La décision en une phrase
 **Deux projets Docker Compose sur la même VM, un par environnement, déployés par un runner GitHub
 Actions installé sur la VM.** `dev` alimente la recette, `main` alimente la production. Terraform
 reste ce qu'il est : le module k3s, cible à terme, non utilisé pour cette mise en ligne.
 | | Recette (`rec`) | Production (`prod`) |
 |---|---|---|
 | Branche | `dev` | `main` |
 | Environnement GitHub | `rec` (créé ce midi) | `prod` (créé ce midi) |
 | Dossier sur la VM | `/srv/enervision/rec` | `/srv/enervision/prod` |
 | Projet Compose | `enervision-rec` | `enervision-prod` |
 | URL | `https://rec.enervision.local:8443` | `https://enervision.local` |
 | Proxy HTTPS | `8443` | `443` |
 | Proxy HTTP (redirection) | `127.0.0.1:8081`, inutilisé | `80` |
 | PostgreSQL, Mailpit, Airflow | `127.0.0.1` : `5434`, `8026`, `8082` | `127.0.0.1` : `5433`, `8025`, `8080` |
 | Certificat | auto-signé, SAN `rec.enervision.local` | auto-signé, SAN `enervision.local` |
 | Déclenchement | chaque push sur `dev` | push sur `main`, après approbation dans GitHub |
 Les deux noms d'hôte pointent sur la même IP. Deux lignes dans le `/etc/hosts` des postes de
 l'équipe suffisent. Deux noms distincts sont indispensables : le cookie de rafraîchissement
 `__Secure-ev_refresh` est posé par hôte, pas par port, et un seul nom ferait se déconnecter la
 prod à chaque connexion sur la recette.
 ## 2. Pourquoi c'est la solution la plus simple
 - **Tout existe déjà.** L'overlay `docker-compose.prod.yml`, le proxy Nginx TLS, les scripts de
  certificat et `make stack-up` sont écrits et validés sur poste (PR #117, ADR 0007). Il ne
  manque que quatre variables pour que deux instances cohabitent sur une machine.
 - **Un projet Compose isole tout.** Volumes, réseau, noms de conteneurs sont préfixés par le nom
  du projet. Casser la recette ne touche pas la prod, ce qui est la raison d'être d'une recette.
 - **Le runner sur la VM est la seule façon d'atteindre une IP privée d'école depuis GitHub.** Les
  runners hébergés par GitHub ne voient pas `10.101.200.37`. Le runner se connecte en sortie
  vers GitHub, aucun port entrant n'est nécessaire. C'était le choix 16 du dossier EC01 : il
  redevient tenu.
 - **La promotion existe déjà dans la stratégie de branches** : `dev` puis `main` par PR. Le
  même code est déployé en recette, puis en production, sans troisième mécanisme.
 Ce qu'on écarte, et pourquoi :
 | Piste | Pourquoi pas cette semaine |
 |---|---|
 | k3s avec deux namespaces | Le cluster serait vide : aucun manifeste, aucun registre d'images, aucun stockage persistant. Trois jours de travail sans valeur visible au J10 |
 | Terraform de `feat/deploy` (nginx système + copie de fichiers) | Revue postée sur l'issue #21 : huit points bloquants, `rec` et `prod` ne passent pas `terraform validate`. On abandonne cette voie |
 | Azure ENI pour la prod | Deuxième infrastructure à provisionner, choix à justifier devant le jury (document 03), et rien n'est prêt côté Azure |
 | Images publiées sur GHCR | Meilleure pratique, mais un registre de plus à authentifier sur la VM. Les images se construisent sur la VM, où le runner tourne déjà. À faire ensuite, issue à ouvrir |
 | Let's Encrypt | Aucun domaine public ne résout vers la VM. Auto-signé assumé, chemin ACME déjà câblé |
 ## 3. Ce qui change dans le dépôt (une PR vers `dev`)
 | Fichier | Changement | Raison |
 |---|---|---|
 | `apps/frontend/Dockerfile` | `FROM nginx:1.28-alpine` à la place de `dhi.io/nginx:...` | Le registre Docker Hardened Images demande une authentification. L'image frontend n'a jamais été construite, sur aucun poste : c'est le premier point où `make stack-up` échouerait sur la VM |
 | `docker-compose.prod.yml` | Ports du proxy en variables `PROXY_HTTP_PORT` et `PROXY_HTTPS_PORT`. Origine publique `PUBLIC_ORIGIN` pour CORS et le lien de réinitialisation. `TS_TUNE_MEMORY` sur la base | Deux proxys ne peuvent pas publier 80 et 443. L'origine de la recette porte un port. Deux TimescaleDB sur 8 Go se réserveraient chacune 2 Go sans réglage |
 | `.env.example` | `COMPOSE_PROJECT_NAME`, les variables ci-dessus, ports de la recette en commentaire | Le `.env` de chaque dossier est la seule différence entre les deux environnements |
 | `.github/workflows/deploy.yml` | Nouveau. `on: push` sur `dev` et `main`, `runs-on: [self-hosted, eni-g3]`, `environment: rec` ou `prod`, puis `git reset --hard origin/<branche>` et `make stack-up` dans le dossier de l'environnement | Le D de CI/CD, issue #21 |
 | `scripts/provision-host.sh` | Nouveau. Vérifie Docker et Compose 2.24.4 ou plus, crée `/srv/enervision/{rec,prod}`, clone les deux branches | Rejouable, et réutilisable par Terraform plus tard |
 | `docs/adr/0009-...md`, `10-infra.md`, `50-cicd.md`, `infra/proxy/README.md` | Décision, vue infra, vue CI/CD, tableau des ports | Règle du dépôt : la vue change dans la même PR que le composant |
 Ce qui ne change pas : `docker-compose.yml`, la configuration Nginx, `infra/terraform`.
 ## 4. Déroulé de l'après-midi
 | # | Qui | Quoi | Durée |
 |---|---|---|---|
 | 1 | **ineszang** (seule admin du dépôt) | Environnement `prod` : branche autorisée `main`, un relecteur requis. Environnement `rec` : branche `dev`. Settings > Actions : « Require approval for all outside collaborators ». Générer le jeton d'enregistrement du runner (Settings > Actions > Runners > New self-hosted runner, Linux x64) et le transmettre à Johan | 10 min |
 | 2 | **Johan** | Déposer sa clé sur la VM : `ssh-copy-id -i ~/.ssh/id_ed25519.pub root@10.101.200.37`, mot de passe du compte administrateur local des postes de l'école | 2 min |
 | 3 | Johan + Claude | **Fait à 15h** : branche locale `feat/deploy-rec-prod` avec tous les changements du §3, image frontend reconstruite avec succès, fusion Compose vérifiée pour les deux environnements. Reste : commit, push, PR vers `dev` | fait |
 | 4 | Claude, par SSH | `scripts/provision-host.sh` sur la VM. Écrire les deux `.env` (secrets générés sur la VM, jamais dans git). Certificats : `PUBLIC_HOST=rec.enervision.local PUBLIC_IP=10.101.200.37 make tls-selfsigned` dans `rec`, idem avec `enervision.local` dans `prod`. Puis `make stack-up` dans chaque dossier | 20 min plus la construction des images |
 | 5 | Johan, sur la VM | Installer le runner sous un utilisateur non-root membre du groupe `docker`, label `eni-g3`, en service systemd (`./config.sh --unattended --labels eni-g3`, `sudo ./svc.sh install && sudo ./svc.sh start`) | 10 min |
 | 6 | Équipe | Merger la PR dans `dev` : la recette se redéploie seule. Ouvrir la PR `dev` vers `main` : la prod se déploie après approbation dans l'onglet Environments | 15 min |
 | 7 | Tous | Vérifier depuis un poste de l'équipe, `/etc/hosts` renseigné : connexion, tableau de bord, Airflow par tunnel SSH | 15 min |
 Contrôle en fin de chaîne, depuis la VM :
 ```bash
 curl -k https://localhost/api/v1/health/ready          # prod
 curl -k https://localhost:8443/api/v1/health/ready     # rec
 docker compose -p enervision-prod ps
 docker compose -p enervision-rec ps
 ```
 ## 5. Ce qui peut faire échouer la journée, et la parade
 | Risque | Parade |
 |---|---|
 | **8 Go de RAM pour deux stacks complètes** (deux Airflow, deux TimescaleDB, deux API) | Demander dès maintenant le passage à 32 Go, prévu par les consignes. En attendant : `TS_TUNE_MEMORY=2GB` et deux workers gunicorn pour Airflow. Si la RAM ne suit pas, démarrer la recette sans Airflow (`docker compose up -d --scale airflow-webserver=0 --scale airflow-scheduler=0`) |
 | **Compose trop ancien sur la VM** (les marqueurs `!override` et `!reset` exigent 2.24.4) | `docker compose version` en premier. Sinon installer le paquet `docker-compose-plugin` depuis le dépôt Docker |
 | **Pas de sortie Internet depuis la VM** | `curl -sI https://github.com` et `docker pull hello-world` avant tout. Sans sortie, ni construction d'image ni runner : déploiement manuel par `scp` d'images, plan B lourd |
 | **Runner auto-hébergé sur un dépôt public** | Le workflow de déploiement ne s'exécute que sur `push` vers `dev` et `main`, jamais sur `pull_request`. Réglage d'approbation des PR externes (étape 1). Runner sous un utilisateur dédié, jamais root |
 | **Premier démarrage avec un volume `pgdata` vide** | C'est le cas nominal sur la VM : `db/init` crée les bases `enervision`, `enervision_test` et `airflow`. Ne pas restaurer un volume de poste |
 | **Le jury accepte mal un certificat auto-signé** | Dire pourquoi avant qu'on le demande : aucun DNS public, ACME câblé et documenté, ADR 0007. Un clic « continuer » dans le navigateur |
 | **Conflit avec `feat/deploy`** (ineszang y a mergé `dev` à 14h06) | Partager ce document avant de pousser. La PR remplace `feat/deploy`, elle ne s'y ajoute pas |
 ## 6. Ce que ça donne pour la grille
 - **EC03, CI/CD** : la chaîne ne s'arrête plus au merge. Deux environnements, déploiement
  automatique en recette, promotion approuvée en production, journal des déploiements dans
  l'onglet Environments de GitHub.
 - **EC04, cloud et sécurisation** : une application déployée et fonctionnelle, une seule surface
  exposée par environnement, secrets hors de git et hors de GitHub, base et Airflow joignables
  uniquement par tunnel SSH.
 - **Dossier EC01** : le choix 16 (runner auto-hébergé, déploiement automatique) passe de « non
  fait » à « tenu ». Le choix 12 (Ansible) reste non fait, et la réponse est prête : le
  durcissement de la machine n'est pas automatisé, le script de provisionnement en est la
  première brique, Terraform pourra l'appeler.
 ## 7. Après vendredi, si on continue
 Dans l'ordre de valeur : images construites une fois en CI et publiées sur GHCR, puis déployées
 par digest (vraie promotion d'artefact). Racine Terraform `environments/eni-g3` qui provisionne
 la machine et le runner à partir du script. Sauvegarde de `pgdata` par `pg_dump` planifié.
 Monitoring (issue #26). Et seulement ensuite la bascule k3s, si elle garde un sens.
@@ -70,11 +70,11 @@ Le lien `front -.-> api` reste en pointillé : le frontend appelle bien une API,
 intercepteur répond à sa place tant que les endpoints n'existent pas. Voir
 [30-frontend.md](30-frontend.md).
-Le lien `airflow --> db` est maintenant en trait plein : quatre DAGs tournent, deux pour
+Le lien `airflow --> db` est maintenant en trait plein : cinq DAGs tournent, deux pour
 l'entraînement et le scoring du modèle ML (issue #115), un pour la détection d'alertes et la
-génération des recommandations (issue #116), et `historical_import` pour l'ingestion du dataset
+génération des recommandations (issue #116), `historical_import` pour le dataset historique
-historique (issue #119). L'orchestration de l'import API Mock et la réconciliation globale des
+(issue #119) et `mock_api_import` pour l'ingestion horaire de l'API Mock (issue #15).
-deux sources restent à compléter dans l'issue #15.
+La réconciliation globale des données provenant des deux sources reste à compléter dans l'issue #15.
 Le lien `prom -.-> api` de même : l'API expose bien `/metrics` au format Prometheus, mais aucun
 collecteur ne vient le lire.
@@ -87,17 +87,18 @@ collecteur ne vient le lire.
 | Frontend | Angular 22, Node 24 | `apps/frontend` | `En cours` | Tableau de bord sur route `/dashboard`, authentification complète (garde de route, intercepteur de jeton), cinq services HTTP, graphiques Chart.js. `stats`/`alerts` sur fixtures, `predictions` branché sur l'API réelle |
 | Base | PostgreSQL 17 + TimescaleDB | `db` | `Fait` | Bootstrap de l'extension, base de test, chaîne Alembic. Schéma applicatif créé (`site`, `dataset`, `reading` en hypertable, `prediction`, `alert`, `recommendation`) |
 | ML | LightGBM, MLflow | `ml` | `En cours` | Pipeline d'entraînement et de scoring (`enervision_ml.train`/`.score`, features par lags/moyennes glissantes partagées entre les deux, baseline de persistance saisonnière, suivi MLflow local), exposé en lecture via `GET /predictions`, orchestré par Airflow (`ml_train`/`ml_score`). Voir [ADR 0005](../adr/0005-modele-prediction-lightgbm.md) et [ML-START.md](../ML-START.md). Surveillance de dérive (EC06, #44/#45) pas encore construite |
-| Infra | Docker Compose, Nginx, Terraform, k3s single-node | `infra`, `docker-compose.prod.yml` | `En cours` | Reverse proxy et overlay de déploiement écrits et validés, jamais lancés sur le serveur ([ADR 0007](../adr/0007-terminaison-tls-et-reverse-proxy-nginx.md)). Module d'installation k3s jamais appliqué, aucune ressource Kubernetes déclarée |
+| Infra | Docker Compose, Nginx, Terraform, k3s single-node | `infra`, `docker-compose.prod.yml` | `En cours` | Reverse proxy et overlay de déploiement écrits et validés, jamais lancés sur le serveur ([ADR 0007](../adr/0007-terminaison-tls-et-reverse-proxy-nginx.md)). Provisionnement de la VM par Terraform, qui installe Docker, prépare les deux environnements et enregistre le runner, jamais appliqué ([ADR 0010](../adr/0010-terraform-provisionne-github-actions-deploie.md)). Module d'installation k3s jamais appliqué, aucune ressource Kubernetes déclarée |
 | Monitoring | Prometheus, Grafana, Alertmanager | `monitoring` | `Cible` | Rien, hors le `/metrics` exposé par l'API |
-| ETL | Apache Airflow | `etl/airflow` | `En cours` | Webserver + scheduler (LocalExecutor) tournent via docker-compose, base de métadonnées Postgres dédiée. Quatre DAGs en sous-processus `uv run` : `ml_train`, `ml_score`, `alertes` et `historical_import`. Le DAG historique orchestre `app.etl.historical_import` et charge `dataset`, `site` et `reading`. L'orchestration API Mock reste à compléter dans #15 |
+| ETL | Apache Airflow | `etl/airflow` | `En cours` | Webserver et scheduler avec LocalExecutor via Docker Compose, sur une base PostgreSQL dédiée. Cinq DAGs sont présents : `ml_train`, `ml_score`, `alertes`, `historical_import` et `mock_api_import`. L'import historique reste manuel et l'import API Mock est exécuté chaque heure. La réconciliation globale des deux sources reste à compléter dans l'issue #15. |
-| CI/CD | GitHub Actions | `.github/workflows` | `En cours` | 6 workflows, 18 jobs : lint, typage, tests avec seuil de couverture bloquant, tests d'intégration sur TimescaleDB réel, audit de dépendances, SAST Bandit, quality gate SonarCloud, intégrité des DAGs Airflow. Déploiement continu vers la VM ENI écrit par `deploy.yml`, `dev` en recette et `main` en production après approbation ([ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md)), mais jamais exécuté : la machine n'est pas provisionnée et le runner n'y est pas enregistré. Détail dans [50-cicd.md](50-cicd.md) |
+| CI/CD | GitHub Actions | `.github/workflows` | `En cours` | 7 workflows, 19 jobs : lint, typage, tests avec seuil de couverture bloquant, tests d'intégration sur TimescaleDB réel, audit de dépendances, SAST Bandit, quality gate SonarCloud, intégrité des DAGs Airflow, formatage et validation du Terraform. Déploiement continu vers la VM ENI écrit par `deploy.yml`, `dev` en recette et `main` en production après approbation ([ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md)), mais jamais exécuté : la machine n'est pas provisionnée et le runner n'y est pas enregistré. Détail dans [50-cicd.md](50-cicd.md) |
 ## Flux bout en bout
-Statut : `En cours`. **Le chemin de lecture tourne** : base, API et frontend. **Le chemin
+Statut : `En cours`. **Le chemin de lecture tourne** entre la base, l'API et le frontend.
-d'ingestion dessiné ci-dessous n'existe pas** : les trois DAGs livrés (`ml_train`, `ml_score`,
+**Le chemin d'ingestion est maintenant orchestré par Airflow** : `historical_import` charge
-issue #115 ; `alertes`, issue #116) orchestrent le pipeline ML et la détection d'alertes, pas
+manuellement le dataset CSV/JSON et `mock_api_import` collecte périodiquement les mesures de
-l'ingestion, qui reste lancée à la main par les scripts d'import (issues #15 et #16).
+l'API Mock. La réconciliation globale des données provenant des deux sources reste à compléter
 dans l'issue #15.
 ```mermaid
 sequenceDiagram
@@ -189,3 +190,4 @@ Elles vivent dans `../adr/`, pas ici.
 | [0007](../adr/0007-terminaison-tls-et-reverse-proxy-nginx.md) | Terminaison TLS par un reverse proxy Nginx, en Docker Compose |
 | [0008](../adr/0008-airflow-execute-le-code-du-backend.md) | Airflow exécute le code du backend en sous-processus, dans son propre environnement |
 | [0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md) | Deux environnements sur la VM ENI, un projet Compose chacun, déployés par un runner auto-hébergé |
 | [0010](../adr/0010-terraform-provisionne-github-actions-deploie.md) | Terraform provisionne la machine, GitHub Actions déploie l'application |
@@ -1,14 +1,16 @@
 # Infrastructure
-Trois topologies coexistent et ne servent pas la même chose. Ce document dit laquelle vaut dans
+Plusieurs topologies coexistent et ne servent pas la même chose. Ce document dit laquelle vaut
-quel contexte, quelles décisions sont arrêtées, et ce qui manque encore entre elles.
+dans quel contexte, quelles décisions sont arrêtées, et ce qui manque encore entre elles.
 | Topologie | Sert à | Statut |
 |---|---|---|
 | Docker Compose | Développer et recetter sur le poste | `Fait` |
 | Docker Compose plus reverse proxy | Déployer sur la machine on-premise | `Fait` |
 | Deux projets Compose sur la VM ENI, recette et production | Déploiement continu depuis GitHub | `En cours` |
 | Provisionnement Terraform de la VM | Préparer la machine et enregistrer le runner | `En cours` |
 | k3s single-node | Cible à terme | `En cours` |
 | MLflow (`ml/`) | Tracker les expériences et le registre de modèles en local | `Fait`, non relié aux autres topologies |
 ## Poste de développement
@@ -52,7 +54,7 @@ Trois pièges sont documentés en tête du `docker-compose.yml`, ils ne se devin
 - `LocalExecutor` exécute les tâches comme sous-processus du **scheduler**, jamais de l'api-server :
  c'est le scheduler qui a besoin du volume `airflow_ml_state` (modèle, magasin MLflow).
-### Airflow (issues #115, #116 et #119)
+### Airflow (issues #15, #115, #116 et #119)
 Quatre services (Airflow 3.3), `docker compose profiles` non utilisés (démarrage explicite via `make
 airflow-up`, pas dans `make dev`) :
@@ -85,12 +87,24 @@ l'[ADR 0008](../adr/0008-airflow-execute-le-code-du-backend.md).
 | `ml_score` | `0 * * * *` | `enervision_ml.score`, dans `/opt/ml/.venv` |
 | `alertes` | `15 * * * *` | `app.detection.internal_alerts` puis `app.cli generate-recommendations`, dans `/opt/backend/.venv` |
 | `historical_import` | manuelle | `app.etl.historical_import`, dans `/opt/backend/.venv` ; les fichiers de `data/raw` sont montés en lecture seule dans `/opt/data/raw` |
 | `mock_api_import` | `45 * * * *` | `app.etl.mock_api_import`, dans `/opt/backend/.venv` ; importe l'heure précédant son déclenchement depuis l'API Mock |
 Le DAG `historical_import` réutilise le pipeline historique existant sans dupliquer sa logique.
 Il reste manuel, car le dataset sert à initialiser l'environnement. Le montage
 `./data/raw:/opt/data/raw:ro` permet au scheduler de lire les fichiers CSV/JSON sans pouvoir les
 modifier.
 Le DAG `mock_api_import` exécute le pipeline API Mock toutes les heures, à la minute `:45`.
 Un `CronTriggerTimetable` explicite lui attribue un intervalle d'une heure, y compris lors d'un
 déclenchement manuel. Il transmet cet intervalle au script backend et charge les mesures dans
 les tables communes `site` et `reading`. Le décalage à `:45` laisse quinze minutes avant le
 scoring exécuté à l'heure pile, puis quinze minutes supplémentaires avant les alertes à `:15`.
 `max_active_runs=1` empêche deux exécutions du DAG de se chevaucher.
 Le DAG conserve `catchup=False` pour éviter un rattrapage massif depuis sa date de démarrage.
 Une interruption du scheduler peut donc créer un intervalle manquant, qui devra être rejoué
 explicitement par une opération de backfill.
 **Pourquoi `alertes` tourne à la quinzième minute.** Sa règle `anomaly` compare une lecture à la
 `prediction` du même instant, que `ml_score` écrit à l'heure pile. Le décalage laisse le scoring
 finir. Aucune dépendance n'est déclarée entre les deux DAGs pour autant, ni `ExternalTaskSensor` ni
@@ -147,6 +161,34 @@ est minimale et n'embarque pas la runtime OpenMP dont LightGBM a besoin, sans qu
 (`OSError: libgomp.so.1`) n'apparaît qu'à la première tâche réellement exécutée, pas à la
 construction de l'image.
 ### MLflow (`ml/`)
 Statut : `Fait`, en local uniquement. Défini par `ml/docker-compose.mlflow.yml`, indépendant
 du `docker-compose.yml` principal (réseau, volumes et démarrage séparés).
 | Service | Image | Points notables |
 |---|---|---|
 | `mlflow-db` | `postgres:17` | Stocke le tracking store MLflow. Mot de passe obligatoire via `MLFLOW_DB_PASSWORD` |
 | `mlflow` | Construite depuis `ml/` | Expose l'UI et l'API MLflow sur `127.0.0.1:5000`. Artefacts sur volume `mlflow-artifacts`, tracking store sur `mlflow-db` |
 Portée actuelle : environnement de tracking et de registre de modèles pour le développement
 local uniquement. Ce compose n'est relié ni à `docker-compose.prod.yml`, ni aux deux
 environnements Compose de la VM ENI, ni à la cible k3s. Le magasin utilisé par Airflow pour
 `ml_train`/`ml_score` (SQLite, volume `airflow_ml_state`) en est distinct — les deux MLflow ne
 se voient pas tant que `MLFLOW_TRACKING_URI` n'est pas posé côté Airflow.
 Limite connue : le DAG Airflow `ml_train` enregistre lui aussi une version a chaque execution
 via `registered_model_name` (magasin SQLite du volume `airflow_ml_state`, distinct de ce
 serveur). Versions et artefacts s'y accumulent sans politique de nettoyage -- fonctionne en
 l'etat, mais a surveiller si les entrainements deviennent frequents.
 Pour relier les runs Airflow (`ml_train`, magasin SQLite local) a ce serveur MLflow, positionner
 `MLFLOW_TRACKING_URI=http://mlflow:5000` dans l'environnement du service `airflow-scheduler` (ou
 `http://host.docker.internal:5000` si le serveur MLflow tourne hors du reseau Compose principal),
 et s'assurer que le conteneur Airflow peut joindre le service `mlflow` -- ce qui suppose de les
 rapprocher sur le meme reseau Docker ou d'exposer MLflow autrement qu'en `127.0.0.1` uniquement
 (cf. point 1 sur l'exposition du port). Non fait a ce jour : aucun besoin de centraliser les runs
 d'entrainement Airflow et locaux n'a encore ete identifie.
 ## Machine cible, exécution Docker
 Statut : `Fait`. Défini par l'overlay `docker-compose.prod.yml`, appliqué par-dessus le
@@ -209,10 +251,38 @@ Nginx renvoie vers `https://$host` sans port, c'est-à-dire vers la production.
 Le déploiement est décrit dans [50-cicd.md](50-cicd.md) : un runner GitHub Actions installé sur
 la VM aligne le dossier sur la branche poussée et lance `make stack-up`.
 ### Provisionnement de la machine
 Statut : `En cours`. Décision et frontière dans
 l'[ADR 0010](../adr/0010-terraform-provisionne-github-actions-deploie.md) : **Terraform
 provisionne la machine, GitHub Actions déploie l'application**. La racine
 `infra/terraform/environments/vm-eni/` fait trois choses, et rien d'autre.
 ```mermaid
 sequenceDiagram
  participant TF as terraform apply
  participant VM as VM eadl-2025-nantes-g3
  participant GH as GitHub
  TF->>VM: SSH, get.docker.com puis docker compose version
  TF->>VM: copie et exécute scripts/provision-host.sh
  VM->>VM: deux clones, deux .env, deux certificats
  TF->>VM: installe actions-runner, config.sh, svc.sh
  VM->>GH: le runner s'enregistre avec le label eni-g3
 ```
 Aucune image n'y est construite, aucun conteneur lancé : un `apply` n'interrompt pas la stack qui
 tourne. Le premier démarrage reste manuel, `make stack-up` dans chaque dossier ; les suivants
 sont joués par le runner à chaque push. Terraform ne sait rien de l'état de la stack, c'est la
 sonde de `deploy.yml` qui le dit.
 Le jeton d'enregistrement du runner est valable une heure et ne vaut que pour une inscription :
 l'`apply` n'est pas rejouable sans qu'un administrateur du dépôt en crée un nouveau.
 ## Cible à terme, k3s
-Statut : `En cours`. Le module `infra/terraform/modules/k3s/` installe le cluster. Il n'a jamais
+Statut : `En cours`. Le module `infra/terraform/modules/k3s/` installe le cluster, depuis la
-été appliqué.
+racine `infra/terraform/environments/k3s-cible/`. Il n'a jamais été appliqué.
 ```mermaid
 flowchart LR
@@ -260,11 +330,13 @@ Ces arbitrages sont pris. Ils ne vivaient jusqu'ici que dans des commentaires de
 | `k3s_version` obligatoire, valeur vide refusée | Sans épinglage, `get.k3s.io` installe la dernière version à chaque exécution : le déploiement cesse d'être reproductible | `validation` dans `modules/k3s/variables.tf` |
 | Traefik désactivé | Le choix d'ingress reste ouvert, on ne veut pas en subir un par défaut | `k3s_disable_components`, défaut `["traefik"]` |
 | Kubeconfig laissé en `600/root`, lu par `sudo` | `--write-kubeconfig-mode 644` exposerait `cluster-admin` à tout utilisateur local de la machine | Commentaire et `fetch_kubeconfig` dans `modules/k3s/main.tf` |
-| State Terraform en backend `local` | Un seul opérateur, pas d'exécution concurrente, pas de dépendance à un stockage distant | `environments/dev/versions.tf` |
+| State Terraform en backend `local` | Un seul opérateur, pas d'exécution concurrente, pas de dépendance à un stockage distant | `versions.tf` de chaque racine |
 | `.terraform.lock.hcl` versionné | Fige les versions de provider entre contributeurs et future CI | Commentaire dans `.gitignore` |
 | `*.tfvars` ignoré, `*.tfvars.example` versionné | Les tfvars portent l'adresse du serveur et le chemin de la clé | `.gitignore` |
 | Désinstallation gérée au `destroy` | `k3s-uninstall.sh` en `on_failure = continue` : un serveur injoignable ne bloque pas le `destroy` | `modules/k3s/main.tf` |
-| Deux racines, `dev` et `prod` | Séparation des états et des variables par environnement | `environments/` |
+| Une racine Terraform par machine provisionnée, nommée d'après elle | `environments/dev` laissait croire à un environnement applicatif, alors que `rec` et `prod` vivent sur la même machine et ne sont pas provisionnés par Terraform | `environments/vm-eni`, `environments/k3s-cible` |
 | Terraform provisionne, GitHub Actions déploie | Deux chemins pour le même acte de livraison, c'est ce que la revue de #141 relève sur la VM | [ADR 0010](../adr/0010-terraform-provisionne-github-actions-deploie.md) |
 | Connexion SSH par clé, jamais par mot de passe | Une variable de mot de passe finit en clair dans le state, ou dans les `triggers` qui y sont persistés | `environments/vm-eni/variables.tf`, `modules/k3s/main.tf` |
 | Terminaison TLS par un reverse proxy Nginx en Compose | L'ingress k3s supposait un registre et des manifestes qui n'existent pas, à quatre jours du rendu | `docker-compose.prod.yml`, [ADR 0007](../adr/0007-terminaison-tls-et-reverse-proxy-nginx.md) |
 | Certificat auto-signé par défaut, chemin ACME câblé | Aucun domaine public ne résout vers la machine : le défi HTTP-01 ne peut pas aboutir | `scripts/tls-selfsigned.sh`, `infra/proxy/acme-deploy-hook.sh` |
 | Un projet Compose par environnement, sur la même machine | Une seule VM, et l'isolation par nom de projet ne demande ni cluster ni registre | `.env` de chaque dossier, [ADR 0009](../adr/0009-deux-environnements-compose-sur-la-vm-eni.md) |
@@ -304,4 +376,3 @@ question à trancher, avant toute ressource Kubernetes.
 - **Quel stockage persistant** côté Kubernetes pour PostgreSQL, et si la base tourne dans le
  cluster ou à côté.
 - **Quelle stratégie de sauvegarde et de restauration** des données de mesure.
 - **Que devient `environments/prod/`**, aujourd'hui réduit à un `.gitkeep`.
@@ -331,8 +331,10 @@ pas prise :
 | `license_info` | Aucune licence n'est choisie |
 | `contact` | Aucun canal de support n'existe |
-Deux schémas de sécurité sont déclarés : `Jeton d'accès` pour le porteur JWT, et
+Deux schémas de sécurité sont déclarés : `JetonAcces` pour le porteur JWT, et
-`Cookie de rafraîchissement` pour `/auth/refresh` et `/auth/logout`. **Le second est purement
+`CookieRafraichissement` pour `/auth/refresh` et `/auth/logout`, des noms ASCII délibérés (issue
 #41 : un outillage tiers comme ZAP peut mal analyser un nom de schéma accentué dans le contrat).
 **Le second est purement
 documentaire** : son `auto_error=False` garantit qu'il ne décide d'aucun refus. Le passer à vrai
 ferait répondre 403 avant d'atteindre `lit_le_cookie()`, et `/auth/refresh` cesserait de rendre le
 401 sur lequel le frontend déclenche sa déconnexion.
@@ -287,6 +287,10 @@ Chaque table remplit un rôle précis dans le traitement et l'exploitation des d
 | `alert` | Enregistrer les alertes, leur type, leur gravité et leur message | API Mock `/alerts` et détections EnerVision |
 | `recommendation` | Proposer des actions et expliquer la règle qui les motive | Règles métier d'EnerVision |
 Le scoring (`ml_score`) charge le modèle depuis un fichier local (`models/lightgbm-consumption.txt`)
 et trace son empreinte SHA-256 dans `prediction.model_reference`. Il ne lit aucune version depuis
 le Model Registry MLflow (`ml/`) : ce registre sert aujourd'hui à la traçabilité des
 entraînements, pas au déploiement du modèle de scoring.
 Les anomalies historiques décrites dans les JSON sont conservées dans `dataset.metadata`.
 Elles servent à l'analyse des données et ne sont pas considérées comme des alertes actuelles.
@@ -16,6 +16,12 @@ basculer sur `Fait` au premier déploiement vert. Sa limite, nommée ici plutôt
 soutenance : les images sont construites sur la machine à chaque déploiement, aucun artefact
 n'est publié puis promu d'un environnement à l'autre.
 Ce que ce workflow ne fait pas, et ne fera pas : préparer la machine. Installation de Docker,
 clones, `.env`, certificats et enregistrement du runner sont provisionnés par
 `infra/terraform/environments/vm-eni`
 ([ADR 0010](../adr/0010-terraform-provisionne-github-actions-deploie.md)). Terraform provisionne,
 GitHub Actions déploie ; aucun des deux ne fait le travail de l'autre.
 ## Vue d'ensemble
 ```mermaid
@@ -45,6 +51,10 @@ flowchart TB
    ab["image<br/>construction de l'image"]
  end
  subgraph infw["Infra · infra.yml"]
    it["terraform<br/>fmt -check, init et validate par racine"]
  end
  subgraph sq["SonarQube · sonarqube.yml"]
    sb1["build-front / test-front"]
    sb2["build-back / test-back"]
@@ -57,22 +67,36 @@ flowchart TB
  push --> fd
  push --> mv & ms
  push --> av & ab
-  push --> sb1 & sb2 --> sscan
+  push --> it
  push --> sb1 & sb2 & sb3 --> sscan
  subgraph cd["Déploiement · deploy.yml"]
    dep["deploy<br/>runner eni-g3, environnement rec ou prod"]
  end
  push -->|"push sur dev ou main"| dep
  planifie["chaque lundi 3h UTC,<br/>ou à la main"]
  subgraph dastw["DAST · dast.yml"]
    zscan["zap<br/>seed + scan actif OWASP ZAP"]
  end
  planifie --> zscan
  push -->|"PR sur dast.yml<br/>ou dast-token.sh"| zscan
 ```
 ## Déclenchement
-Les cinq workflows se déclenchent sur `push` **et** sur `pull_request`, filtrés par **chemin** :
+Les six workflows hébergés par GitHub qui vérifient le code se déclenchent sur `push` **et** sur
-`backend.yml` sur `apps/backend/**`, `frontend.yml` sur `apps/frontend/**`, `ml.yml` sur `ml/**`,
+`pull_request`, filtrés par **chemin** : `backend.yml` sur `apps/backend/**`, `frontend.yml` sur
-`airflow.yml` sur `etl/airflow/**` **plus des chemins de `ml/` et de `apps/backend/`**, chacun
+`apps/frontend/**`, `ml.yml` sur `ml/**`, `infra.yml` sur `infra/terraform/**`, `airflow.yml` sur
-incluant son propre fichier de workflow dans le filtre pour qu'une modification du pipeline
+`etl/airflow/**` **plus des chemins de `ml/` et de `apps/backend/`**, chacun incluant son propre
-déclenche le pipeline.
+fichier de workflow dans le filtre pour qu'une modification du pipeline déclenche le pipeline.
 `dast.yml` s'en écarte volontairement (détail dans sa propre section plus bas) : aucun
 déclenchement sur `push`, seulement `workflow_dispatch`, une planification hebdomadaire, et
 `pull_request` restreint à ses deux seuls fichiers. Un scan actif est trop long pour tourner à
 chaque commit.
 Le filtre d'`airflow.yml` mérite un mot : il inclut `ml/pyproject.toml`, `ml/uv.lock`,
 `ml/enervision_ml/**`, `apps/backend/pyproject.toml`, `apps/backend/uv.lock` et
@@ -97,7 +121,8 @@ environnement.
 ## Déploiement
-`deploy.yml` est le sixième workflow, et le seul qui ne tourne pas chez GitHub : il s'exécute sur
+`deploy.yml` est le huitième workflow (`backend`, `frontend`, `ml`, `infra`, `airflow`,
 `sonarqube`, `dast`, plus lui-même), et le seul qui ne tourne pas chez GitHub : il s'exécute sur
 un runner auto-hébergé installé sur la VM ENI, label `eni-g3`, parce que les runners hébergés ne
 joignent pas une adresse privée d'école. Le runner se connecte en sortie vers GitHub, aucun port
 entrant n'est ouvert.
@@ -151,6 +176,7 @@ dans [10-infra.md](10-infra.md).
 | Build `npm run build` | frontend | compilation | Bloque |
 | Intégrité des DAGs | airflow | chargement des DAGs sans erreur d'import | Bloque |
 | Construction de l'image Airflow | airflow | `docker build` de `etl/airflow/Dockerfile` | Bloque |
 | Formatage et validité Terraform | infra | `fmt -check -recursive`, puis `init` et `validate` par racine | Bloque |
 Deux seuils portent une décision qu'il faut savoir défendre :
@@ -242,12 +268,112 @@ Ils ne transitent ni par git ni par GitHub, et le runner, qui travaille dans ce
 à recevoir. Le revers : ils ne sont sauvegardés nulle part ailleurs. Un `.env` perdu se
 régénère, ce qui invalide les sessions et les connexions chiffrées par Airflow.
 ## Scan DAST (OWASP ZAP)
 Statut : `En cours`. Le workflow `dast.yml` attaque l'API **en fonctionnement**, ce que ni Bandit,
 ni `pip-audit`, ni Sonar ne font. Il se lance à la main (`workflow_dispatch`), chaque lundi à 3h
 UTC, et sur une PR qui modifie le scan lui-même. Pas à chaque PR : un scan actif dure plusieurs
 minutes.
 Le job démarre sur le runner la base (même image TimescaleDB que `docker-compose.yml`, base
 jetable), applique les migrations, y sème un site et deux relevés (`db/seeds/` est vide, pas
 encore d'outillage de jeu de données pour la CI ; sans données, `GET /sites` rend `[]`, chaque
 `/{site_id}` rend 404, et le scan actif ne frappe que des gestionnaires d'erreur), démarre le
 backend, puis `scripts/dast-token.sh` crée un compte **`lecteur`** et rend son jeton.
 ZAP charge le contrat `/openapi.json` depuis un fichier (`zap-api-scan.py -f openapi -t
 /zap/wrk/openapi.json`) et en importe les 26 opérations **quel que soit le jeton** : c'est le
 contrat qui décide de ce qui est exploré, pas l'authentification. Le jeton ne change que les
 réponses obtenues sur les routes gardées : sans lui, elles répondraient toutes `401` plutôt que
 de dérouler leur logique. Huit routes n'exigent aucun jeton porteur (les deux sondes, `login`,
 `refresh`, `logout`, `forgot-password`, `reset-password` et `reset-password/validate`) et
 répondent donc pareil avec ou sans lui.
 Décisions à savoir défendre :
 - **Le compte du scan est `lecteur`, jamais `admin`.** Un scan actif avec un jeton admin frapperait
  `POST /users` et la réinitialisation de mots de passe pour de bon. Le script passe par un admin
  jetable pour créer le lecteur (l'API n'a pas d'inscription publique) puis ne s'en sert plus.
 - **Un compte neuf est en `must_change_password`**, et toute route gardée le refuse tant que le
  mot de passe n'est pas changé. Le script fait ce changement et vérifie `GET /sites` = 200 avant
  de rendre le jeton ; sans cela, tout le scan authentifié ne testerait que des `403`.
  `POST /auth/password` rend déjà un nouveau jeton valide (l'`iat` tronqué documenté dans
  `app/api/deps.py` ne le rejette pas comme antérieur à la session) : le script s'en sert
  directement plutôt que de se reconnecter, deux hachages Argon2id (19456 Kio chacun) et deux
  allers-retours de refresh-token de moins sur le chemin critique de la CI.
 - **`APP_ACCESS_TOKEN_TTL_SECONDS=3600`** (plafond de la configuration) : le jeton par défaut
  dure 15 minutes. `scanner.maxScanDurationInMins=15` (ci-dessous) borne le scan actif très en
  dessous, marge comprise pour les étapes qui l'entourent.
 - **Le jeton ne transite ni par `${{ }}` dans le script de l'étape, ni par l'argv de `docker
  run`.** Le premier finirait en clair dans le fichier de commande que GitHub écrit sur le disque
  du runner pour toute la durée de l'étape ; le second serait visible par `ps aux` et par
  `docker inspect zap` tant que le conteneur existe. Il est écrit dans un fichier de
  configuration ZAP séparé (`-configfile`), monté en lecture seule hors de `/zap/wrk` pour ne
  jamais atterrir dans l'artefact publié. ZAP journalise malgré tout la valeur de chaque
  `-config`/`-configfile` chargé à un niveau visible sans `-d` : les copies de `zap.log` et
  `zap-stdout.log` publiées en artefact sont donc caviardées avant publication.
 **Deux pièges d'autorisation** sur ce fichier de configuration (`zap-auth.conf`), tous les deux
 propres au montage bind Docker : le conteneur y lit avec son propre uid (1000), distinct de celui
 du runner qui l'a écrit, sans remappage automatique.
 - Un `chmod 600` seul rend le fichier illisible pour le conteneur (« File not readable :
  /zap/auth.conf »). ZAP échoue dès le lancement, mais `zap-api-scan.py` attend les `-T` minutes
  complètes avant d'abandonner : dix minutes qui ressemblent à un scan actif, pour un daemon mort
  depuis le début. Corrigé par `sudo chown 1000:1000` du fichier avant de le passer à `644`.
 - Ce `chown` déplace la propriété du fichier hors de l'utilisateur du runner : un `chmod` qui
  suit sans `sudo` échoue alors (« Operation not permitted »), et le `-e` implicite des étapes
  bash de GitHub Actions arrête toute l'étape avant même `docker run` — un scan « réussi » en une
  fraction de seconde, sans le moindre journal ni rapport produit. Les deux commandes doivent
  passer par `sudo`.
 Les routes d'authentification qui changent l'état du compte (`login`, `password`, `logout-all`,
 `forgot-password`, `reset-password`) sont exclues du scan actif : elles y déclencheraient la
 limitation de débit et fermeraient les sessions sans rien apprendre de plus.
 **Un scan vert n'est pas un scan qui a testé quelque chose.** Deux garde-fous, eux, **bloquent** :
 - **Moins de 80% des opérations du contrat importées.** Constaté une première fois : 2 URL sur 26
  opérations importées, ZAP n'avait envoyé que des requêtes vouées au 404 (l'analyseur de ZAP
  refusait alors le nom accentué d'un des deux schémas de sécurité du contrat, corrigé depuis en
  ASCII côté backend). Le seuil est dérivé du contrat (`zap-out/openapi.json`, présent à cette
  étape) plutôt que d'un nombre fixe : un contrat qui grossit ne doit pas rendre la garde plus
  permissive qu'elle ne l'était.
 - **Aucune réponse 2xx.** Constaté une deuxième fois, cause différente : la clé de configuration
  du nom d'en-tête pour la règle Replacer est `matchstr`, pas `matchstring` (celui-ci n'existe que
  pour le job d'automatisation ZAP, pas pour `-config`) ; ZAP acceptait la mauvaise clé sans
  erreur et laissait le nom d'en-tête vide, qu'uvicorn refusait par un `400` sur **toute** requête,
  y compris les routes publiques. Piège de conception rencontré en corrigeant cette garde : borner
  le *pourcentage* de 4xx ne marche pas, un scan actif fuzze délibérément un grand nombre
  d'entrées invalides, si bien qu'un scan sain contre l'API seedée reste à 98% de 4xx avec
  seulement 1% de 2xx. C'est la forme normale d'un scan actif. Le signal qui distingue vraiment un
  scan cassé (2xx nul, absent du rapport dans les deux incidents) d'un scan sain (2xx non nul,
  aussi faible soit-il) est l'absence de succès, pas la part d'échecs. Les deux gardes lisent
  `zap-out/zap-report.json` (champs structurés `insights[]`), pas le texte libre du rapport
  Markdown.
 Le journal interne de ZAP (`zap.log`) et sa sortie complète (`zap-stdout.log`) sont publiés dans
 l'artefact `zap-report` (dossier `zap-logs/`, propriété du runner : `zap-out/` bascule sous l'uid
 1000 du conteneur ZAP dès que le contrat y est copié, le runner n'y écrit plus ensuite) pour
 diagnostiquer un futur import raté.
 **Non bloquant pour l'instant** (`continue-on-error`, sur la seule étape du scan) pour ce qui est
 des alertes elles-mêmes. Le volume d'un premier passage trié est inconnu ; le rapport
 HTML/JSON/Markdown est publié en artefact `zap-report`, et sa synthèse (jusqu'aux tableaux
 d'alertes, sans le détail par alerte) dans le résumé du job. Fixer un seuil viendra une fois les
 alertes triées.
 **Limite à ne pas oublier :** le scan tape la configuration par défaut du backend (`APP_ENV=local`,
 pas de TLS, pas de reverse proxy). Il remontera des alertes qui n'existent pas derrière le proxy
 (HSTS absent...) et ne dit **rien** des en-têtes ni du TLS que le proxy pose en production. Un
 second passage sur la stack complète reste à faire.
 ## Ce qui manque, et pourquoi
 | Manque | Issue | Conséquence assumée |
 |---|---|---|
 | Images publiées et promues par digest (GHCR) | aucune | Chaque environnement reconstruit ses images : la production n'exécute pas l'artefact validé en recette, mais un second build du même commit |
-| DAST (OWASP ZAP) | #41 | Aucune vérification sur l'application en fonctionnement, seulement sur le code et les dépendances |
+| DAST bloquant | #41 | Le scan ZAP existe mais ne bloque rien : aucun seuil n'est fixé tant que les alertes du premier passage ne sont pas triées |
 | Tests end to end | #46 | Les parcours utilisateur ne sont pas vérifiés en CI |
 | Tests de charge | #47 | Aucun garde-fou de performance |
 | Scan d'image de conteneur | aucune | Les `Dockerfile` sont construits en local, pas analysés |
@@ -38,6 +38,7 @@ lecture seule ; plusieurs lignes resteront à compléter une fois les endpoints
 | Caviardage des jetons, empreintes, mots de passe et cookies dans les journaux | `app/core/logging.py` | A09, A02 |
 | Cinq gardes de configuration qui refusent le démarrage plutôt que de dégrader silencieusement | `app/core/config.py` | A05 |
 | Documentation interactive fermée hors développement, `/metrics` derrière un jeton, sonde qui ne publie plus de version | `app/main.py`, `app/api/security.py` | A05 |
 | Scan dynamique OWASP ZAP de l'API authentifiée (compte `lecteur` jetable), non bloquant, configuration par défaut du backend uniquement (ni TLS ni en-têtes du reverse proxy) | `.github/workflows/dast.yml`, `scripts/dast-token.sh` | A05, API8 Security Misconfiguration |
 | En-têtes `nosniff`, `DENY`, `no-referrer`, et `no-store` sur les routes d'authentification | `app/api/middleware.py` | A05 |
 | Refus de rétrograder ou désactiver le dernier administrateur actif | `app/services/user.py` | A04 Insecure Design |
 | Amorçage du premier administrateur hors dépôt, mot de passe jamais dans `argv` ni dans Git | `app/cli.py` | A02, A05 |
@@ -663,16 +663,22 @@ mock_api_import.py
 La logique d'extraction, de transformation et de chargement est donc disponible pour les deux sources de données du MVP.
-Airflow tourne désormais réellement (`etl/airflow/`, `make airflow-up`) et orchestre le pipeline
+Airflow tourne désormais réellement (`etl/airflow/`, `make airflow-up`) et orchestre cinq DAGs :
-ML (`ml_train`/`ml_score`, issue #115), la détection d'alertes et la génération des
+le pipeline ML (`ml_train` et `ml_score`, issue #115), la détection d'alertes et la génération
-recommandations (`alertes`, issue #116), ainsi que l'import historique
+des recommandations (`alertes`, issue #116), l'import historique (`historical_import`,
-(`historical_import`, issue #119).
+issue #119) et l'import périodique de l'API Mock (`mock_api_import`, issue #15).
-Le DAG `historical_import` est déclenché manuellement. Il exécute
+Le DAG `mock_api_import` s'exécute chaque heure, à la minute `:45`. Il appelle
-`app.etl.historical_import` avec les fichiers montés en lecture seule depuis `data/raw` vers
+`app.etl.mock_api_import` avec un intervalle explicite d'une heure et une limite de 1 000 lectures
-`/opt/data/raw`. L'orchestration de l'import API Mock et la réconciliation globale des deux
+par site. Les deux pipelines normalisent leurs données vers les tables communes `site` et
-sources restent couvertes par l'issue #15.
+`reading`, tout en conservant leur source (`csv` ou `api_history`). La réconciliation globale
 des deux sources reste à compléter dans l'issue #15.
-Airflow permet de planifier les traitements, gérer leur ordre d'exécution, suivre leur état et remonter les erreurs. Il ne remplace pas la logique ETL Python existante : les scripts actuels restent responsables de l'extraction, de la validation, de la transformation et du chargement. `etl/airflow/dags/ml_train.py`, `ml_score.py` et `alertes.py` et `historical_import.py` montrent le patron retenu (des `BashOperator` qui invoquent le script tel quel, dans l'environnement `uv` que l'image embarque pour lui).
+Le DAG `mock_api_import` exécute `app.etl.mock_api_import` toutes les heures. Chaque exécution
 traite l'intervalle Airflow précédent. Les deux pipelines normalisent leurs données vers les
 tables communes `site` et `reading`, tout en conservant leur source (`csv` ou `api_history`).
 Airflow permet de planifier les traitements, gérer leur ordre d'exécution, suivre leur état et remonter les erreurs. Il ne remplace pas la logique ETL Python existante : les scripts actuels restent responsables de l'extraction, de la validation, de la transformation et du chargement. `etl/airflow/dags/ml_train.py`, `ml_score.py`, `alertes.py`, `historical_import.py` et
 `mock_api_import.py` montrent le patron retenu (des `BashOperator` qui invoquent le script tel quel, dans l'environnement `uv` que l'image embarque pour lui).
 Le pipeline Data servira ensuite à préparer les données nécessaires au modèle de Machine Learning.
@@ -0,0 +1,61 @@
 """DAG d'import périodique des données de l'API Mock EnerVision (issue #15).
 Orchestre le pipeline existant `app.etl.mock_api_import` sans dupliquer sa logique ETL.
 Chaque exécution traite l'heure précédant son déclenchement.
 Le pipeline backend reste responsable de la validation, de la normalisation, du suivi de la
 qualité, de l'idempotence et du chargement dans PostgreSQL/TimescaleDB.
 """
 from __future__ import annotations
 from datetime import datetime, timedelta
 from airflow.providers.standard.operators.bash import BashOperator
 from airflow.sdk import DAG
 from airflow.timetables.trigger import CronTriggerTimetable
 # Le backend possède son propre environnement uv dans l'image Airflow (ADR 0008).
 COMMANDE_BACKEND = "cd /opt/backend && env -u VIRTUAL_ENV uv run --no-sync python -m"
 # Le pipeline backend et l'API acceptent au maximum 1 000 lectures par site.
 # Cette marge évite de perdre silencieusement une lecture si une heure en contient plus de 60.
 LIMITE_LECTURES = 1000
 # Deux reprises donnent trois tentatives au total. Même dans le pire cas, l'exécution reste
 # inférieure au pas horaire du DAG.
 NOMBRE_REPRISES = 2
 DELAI_ENTRE_REPRISES = timedelta(minutes=2)
 PLAFOND_PAR_TENTATIVE = timedelta(minutes=10)
 # L'intervalle est déclaré explicitement pour ne pas dépendre de la valeur du paramètre Airflow
 # `create_cron_data_intervals`. Le déclenchement à :45 laisse quinze minutes avant `ml_score`,
 # exécuté à l'heure pile, puis avant `alertes`, exécuté à :15.
 PLANIFICATION = CronTriggerTimetable(
    "45 * * * *",
    timezone="UTC",
    interval=timedelta(hours=1),
 )
 with DAG(
    dag_id="mock_api_import",
    description="Importe chaque heure les données de l'API Mock dans site et reading.",
    schedule=PLANIFICATION,
    start_date=datetime(2026, 1, 1),
    catchup=False,
    # Deux exécutions simultanées pourraient demander et traiter le même intervalle.
    max_active_runs=1,
    tags=["etl", "mock-api"],
 ) as dag:
    BashOperator(
        task_id="import_mock_api",
        bash_command=(
            f"{COMMANDE_BACKEND} app.etl.mock_api_import "
            "--start-time \"{{ data_interval_start.strftime('%Y-%m-%dT%H:%M:%S') }}\" "
            "--end-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:%M:%S') }}\" "
            f"--limit {LIMITE_LECTURES}"
        ),
        retries=NOMBRE_REPRISES,
        retry_delay=DELAI_ENTRE_REPRISES,
        execution_timeout=PLAFOND_PAR_TENTATIVE,
    )
@@ -1,22 +1,30 @@
 """Tests d'integrite des DAGs : s'importent sans erreur, structure attendue. Pas d'execution
 reelle des taches (ca reclamerait le conteneur avec `uv`/`enervision_ml`), juste la definition."""
-from datetime import timedelta
+from datetime import datetime, timedelta
 from pathlib import Path
 import pytest
 from airflow.dag_processing.dagbag import DagBag
 from airflow.sdk import BaseOperator
 from airflow.timetables.trigger import CronTriggerTimetable
 DAGS_FOLDER = Path(__file__).resolve().parent.parent / "dags"
-DAG_IDS = ["ml_train", "ml_score", "alertes", "historical_import"]
+DAG_IDS = [
    "ml_train",
    "ml_score",
    "alertes",
    "historical_import",
    "mock_api_import",
 ]
 TACHES = [
    ("ml_train", "train"),
    ("ml_score", "score"),
    ("alertes", "detection"),
    ("alertes", "recommandations"),
    ("historical_import", "import_historical"),
    ("mock_api_import", "import_mock_api"),
 ]
@@ -52,6 +60,19 @@ def test_historical_import_has_no_schedule(dagbag: DagBag) -> None:
    assert dagbag.dags["historical_import"].schedule is None
 def test_mock_api_import_uses_an_explicit_hourly_interval(dagbag: DagBag) -> None:
    timetable = dagbag.dags["mock_api_import"].timetable
    assert isinstance(timetable, CronTriggerTimetable)
    assert timetable.serialize()["expression"] == "45 * * * *"
    manual_interval = timetable.infer_manual_data_interval(
        run_after=datetime.fromisoformat("2026-09-22T12:30:00+00:00"),
    )
    assert manual_interval.end - manual_interval.start == timedelta(hours=1)
 def test_ml_train_task_calls_the_training_module(dagbag: DagBag) -> None:
    tache = dagbag.dags["ml_train"].get_task("train")
    assert "enervision_ml.train" in tache.bash_command
@@ -84,6 +105,20 @@ def test_historical_import_uses_the_expected_source_files(dagbag: DagBag) -> Non
    assert "--metadata /opt/data/raw/dataset_metadata.json" in commande
 def test_mock_api_import_calls_the_existing_backend_module(dagbag: DagBag) -> None:
    commande = dagbag.dags["mock_api_import"].get_task("import_mock_api").bash_command
    assert "app.etl.mock_api_import" in commande
 def test_mock_api_import_uses_the_airflow_data_interval(dagbag: DagBag) -> None:
    commande = dagbag.dags["mock_api_import"].get_task("import_mock_api").bash_command
    assert "--start-time \"{{ data_interval_start.strftime('%Y-%m-%dT%H:%M:%S') }}\"" in commande
    assert "--end-time \"{{ data_interval_end.strftime('%Y-%m-%dT%H:%M:%S') }}\"" in commande
    assert "--limit 1000" in commande
@pytest.mark.parametrize("task_id", ["detection", "recommandations"])
 def test_alertes_tasks_run_in_the_backend_environment(dagbag: DagBag, task_id: str) -> None:
    # Le backend a son propre venv dans l'image, distinct de celui de ml/ (ADR 0008).
@@ -95,6 +130,12 @@ def test_historical_import_runs_in_the_backend_environment(dagbag: DagBag) -> No
    assert "/opt/backend" in commande
 def test_mock_api_import_runs_in_the_backend_environment(dagbag: DagBag) -> None:
    commande = dagbag.dags["mock_api_import"].get_task("import_mock_api").bash_command
    assert "/opt/backend" in commande
 def test_alertes_generates_recommendations_after_detecting(dagbag: DagBag) -> None:
    # `recommendation.alert_id` est une cle etrangere `NOT NULL` : la generation n'a rien a lire
    # tant que la detection n'a pas ecrit.
@@ -136,6 +177,14 @@ def duree_au_pire(tache: BaseOperator) -> timedelta:
    return (tache.retries + 1) * tache.execution_timeout + tache.retries * tache.retry_delay
 def test_mock_api_import_worst_case_stays_below_its_hourly_step(
    dagbag: DagBag,
 ) -> None:
    tache = dagbag.dags["mock_api_import"].get_task("import_mock_api")
    assert duree_au_pire(tache) < timedelta(hours=1)
 def test_alertes_worst_case_stays_below_its_hourly_step(dagbag: DagBag) -> None:
    # Les deux taches s'enchainent : c'est leur somme, reprises comprises, qui doit tenir dans le
    # pas horaire, sinon `max_active_runs=1` fait attendre l'execution suivante.
@@ -159,6 +208,10 @@ def test_historical_import_retries_after_a_transient_failure(dagbag: DagBag) ->
    assert dagbag.dags["historical_import"].get_task("import_historical").retries >= 1
 def test_mock_api_import_retries_after_a_transient_failure(dagbag: DagBag) -> None:
    assert dagbag.dags["mock_api_import"].get_task("import_mock_api").retries >= 1
@pytest.mark.parametrize(("dag_id", "task_id"), TACHES)
 def test_tasks_never_resync_the_baked_environment(
    dagbag: DagBag, dag_id: str, task_id: str
@@ -1,18 +1,48 @@
 # Infrastructure
-Provisionnement Terraform de la machine on-premise (serveur physique, accessible en SSH).
+Provisionnement Terraform des machines on-premise. Terraform prepare la machine, GitHub Actions
 deploie l'application : voir l'[ADR 0010](../docs/adr/0010-terraform-provisionne-github-actions-deploie.md).
 Rien ici ne construit d'image ni ne lance de conteneur.
 - `terraform/modules` : modules reutilisables.
  - `k3s` : installe un cluster k3s single-node sur une machine distante via SSH
    (script officiel `get.k3s.io`) et rapatrie le kubeconfig en local.
- `terraform/environments/<env>` : racines Terraform, une par environnement.
+- `terraform/environments/<racine>` : une racine par machine provisionnee.
-  - `dev` : instancie le module `k3s` sur le serveur de l'ecole.
+  - `vm-eni` : la VM `eadl-2025-nantes-g3`, qui porte les environnements `rec` et `prod`
-  - `prod` : non initialise, voir le ticket dedie.
+    ([ADR 0009](../docs/adr/0009-deux-environnements-compose-sur-la-vm-eni.md)). Installe Docker,
    execute `scripts/provision-host.sh`, enregistre le runner GitHub Actions.
  - `k3s-cible` : le cluster k3s, cible a terme de `docs/architecture/10-infra.md`. Jamais
    applique.
-## Usage (environments/dev)
+## Usage (environments/vm-eni)
 ```bash
-cd infra/terraform/environments/dev
+cd infra/terraform/environments/vm-eni
 cp terraform.tfvars.example terraform.tfvars
 terraform init
 terraform apply
 ```
 `terraform.tfvars` est ignore par git. Trois valeurs sont a renseigner avant l'apply :
 - `proprietaire` : l'utilisateur qui possede `/srv/enervision` et fait tourner le runner. Il doit
  deja exister sur la machine.
 - `runner_version` : a epingler depuis <https://github.com/actions/runner/releases>.
 - `runner_token` : jeton d'enregistrement, valable une heure et pour une seule inscription.
  Parametres du depot, Actions, Runners, New self-hosted runner. Seul un administrateur du depot
  peut le creer.
 Apres l'apply, la machine porte `/srv/enervision/rec` et `/srv/enervision/prod`, chacun avec son
 `.env` et son certificat. Le premier demarrage reste manuel, `make stack-up` dans chaque dossier ;
 les suivants sont joues par le runner a chaque push sur `dev` et sur `main`.
 Retirer le runner se fait a la main, depuis les parametres du depot : `terraform destroy` ne le
 desinscrit pas.
 ## Usage (environments/k3s-cible)
 ```bash
 cd infra/terraform/environments/k3s-cible
 cp terraform.tfvars.example terraform.tfvars   # renseigner ssh_host / ssh_private_key_path
 terraform init
 terraform apply
@@ -0,0 +1,23 @@
 # This file is maintained automatically by "terraform init".
 # Manual edits may be lost in future updates.
 provider "registry.terraform.io/hashicorp/null" {
  version     = "3.3.2"
  constraints = "~> 3.2"
  hashes = [
    "h1:IQ1qrkht1sC1nibUR+AJ3ulryyhVDHfCHZhoJi0sg2Y=",
    "zh:10ec43b8b7b18d5639238c7fb9e111f6a4b038523dd66c7a426bf27b25fa4c08",
    "zh:60beb9cc2ad5b871c710860cee75b42850cc6acd43db0d77cb5e00fda7288b55",
    "zh:62538582d0a4a2f10ad8a8d9a6c3cd3f05af6c6d91c6641ffc78d4f0e8e69b27",
    "zh:64a8f9ce7852d9efc5b464c12306c946366d59f5e2757def97969c9fd64bd1d6",
    "zh:78d5eefdd9e494defcb3c68d282b8f96630502cac21d1ea161f53cfe9bb483b3",
    "zh:92a374fb736a52f465283326d0a5bf4f495132eb99be209dfb4c75ec803fe8db",
    "zh:98da9c42785d27a50f0604758bcb61a30f6278b9f2acd92bb3b2046e0e71916c",
    "zh:b0f7896fae554729cdf4a24ac06359a050cff5817e6cd8597cba8a4ae01a7409",
    "zh:bc8179ee35d67c72fb03012e7023b9f9816f033a7ec4109c001dd6d29752e812",
    "zh:d23a598f713bfb6098bc003571d7de90b5a33b78f9be240488252fe5f3c2a60d",
    "zh:d2855b922ea345dbd89ea287e4c6c4757e38bc0aaffeb2b79aa0b8004f9c53ff",
    "zh:d3a60422bc6a2f9244d076c5222c07060c826ef91bdbaf4634cb752b86057473",
    "zh:faa01928c25d2a6ecd9c7eb8b88134cb08de55a6b11ca6c703ac0092845344ba",
  ]
 }
@@ -0,0 +1,23 @@
 # This file is maintained automatically by "terraform init".
 # Manual edits may be lost in future updates.
 provider "registry.terraform.io/hashicorp/null" {
  version     = "3.3.2"
  constraints = "~> 3.2"
  hashes = [
    "h1:IQ1qrkht1sC1nibUR+AJ3ulryyhVDHfCHZhoJi0sg2Y=",
    "zh:10ec43b8b7b18d5639238c7fb9e111f6a4b038523dd66c7a426bf27b25fa4c08",
    "zh:60beb9cc2ad5b871c710860cee75b42850cc6acd43db0d77cb5e00fda7288b55",
    "zh:62538582d0a4a2f10ad8a8d9a6c3cd3f05af6c6d91c6641ffc78d4f0e8e69b27",
    "zh:64a8f9ce7852d9efc5b464c12306c946366d59f5e2757def97969c9fd64bd1d6",
    "zh:78d5eefdd9e494defcb3c68d282b8f96630502cac21d1ea161f53cfe9bb483b3",
    "zh:92a374fb736a52f465283326d0a5bf4f495132eb99be209dfb4c75ec803fe8db",
    "zh:98da9c42785d27a50f0604758bcb61a30f6278b9f2acd92bb3b2046e0e71916c",
    "zh:b0f7896fae554729cdf4a24ac06359a050cff5817e6cd8597cba8a4ae01a7409",
    "zh:bc8179ee35d67c72fb03012e7023b9f9816f033a7ec4109c001dd6d29752e812",
    "zh:d23a598f713bfb6098bc003571d7de90b5a33b78f9be240488252fe5f3c2a60d",
    "zh:d2855b922ea345dbd89ea287e4c6c4757e38bc0aaffeb2b79aa0b8004f9c53ff",
    "zh:d3a60422bc6a2f9244d076c5222c07060c826ef91bdbaf4634cb752b86057473",
    "zh:faa01928c25d2a6ecd9c7eb8b88134cb08de55a6b11ca6c703ac0092845344ba",
  ]
 }
@@ -0,0 +1,137 @@
 # Pourquoi : Terraform provisionne la machine, GitHub Actions la deploie (ADR 0010). Rien ici ne
 # construit d'image ni ne lance de conteneur : la livraison reste portee par `deploy.yml` et
 # `make stack-up`, et un `apply` n'interrompt pas la stack qui tourne.
 # Piege : seul le bloc `triggers` d'un `null_resource` atterrit dans le state. Ni le jeton du
 # runner ni la cle SSH n'y figurent, et ne doivent jamais y etre ajoutes pour forcer un rejeu.
 # Contrainte : pas de provisioner `destroy` sur le runner. Il imposerait une connexion ne lisant
 # que `self`, donc le chemin de la cle SSH dans le state, et `svc.sh uninstall` ne desinscrit pas
 # le runner cote GitHub : le retrait reste manuel, depuis les parametres du depot.
 # Ref : ADR 0009 pour les deux environnements, `scripts/provision-host.sh` pour leur contenu.
 locals {
  sudo           = var.ssh_user == "root" ? "" : "sudo "
  en_tant_que    = "${var.ssh_user == "root" ? "" : "sudo "}runuser -u ${var.proprietaire} --"
  provisionneur  = "${path.root}/../../../../scripts/provision-host.sh"
  runner_archive = "actions-runner-linux-x64-${var.runner_version}.tar.gz"
  # Substitution shell, evaluee par le sh -c distant : un nom de runner doit etre unique dans
  # le depot, le nom d'hote l'est deja et le reste si cette racine sert a une autre machine.
  runner_nom = var.runner_nom != "" ? var.runner_nom : "$(hostname -s)"
 }
 resource "null_resource" "docker_engine" {
  triggers = {
    hote = var.ssh_host
    user = var.proprietaire
  }
  connection {
    type        = "ssh"
    host        = var.ssh_host
    port        = var.ssh_port
    user        = var.ssh_user
    private_key = file(pathexpand(var.ssh_private_key_path))
    timeout     = "5m"
  }
  provisioner "remote-exec" {
    inline = [
      <<-EOT
        set -eu
        id ${var.proprietaire} >/dev/null 2>&1 || {
          echo "l'utilisateur ${var.proprietaire} n'existe pas sur la machine" >&2
          exit 1
        }
        command -v docker >/dev/null || ${local.sudo}sh -c 'curl -fsSL https://get.docker.com | sh'
        ${local.sudo}systemctl enable --now docker
        ${local.sudo}usermod -aG docker ${var.proprietaire}
        ${local.sudo}docker compose version
      EOT
    ]
  }
 }
 # `provision-host.sh` verifie lui-meme docker, compose et la sortie HTTPS, puis prepare un clone
 # par environnement, son `.env` et son certificat. Il est rejouable : un `.env` existant n'est
 # jamais reecrit, un certificat present jamais regenere.
 resource "null_resource" "environnements" {
  depends_on = [null_resource.docker_engine]
  triggers = {
    script = filesha256(local.provisionneur)
    racine = var.racine
    depot  = var.depot_url
  }
  connection {
    type        = "ssh"
    host        = var.ssh_host
    port        = var.ssh_port
    user        = var.ssh_user
    private_key = file(pathexpand(var.ssh_private_key_path))
    timeout     = "5m"
  }
  provisioner "file" {
    source      = local.provisionneur
    destination = "/tmp/provision-host.sh"
  }
  provisioner "remote-exec" {
    inline = [
      <<-EOT
        set -eu
        ${local.sudo}env RACINE='${var.racine}' \
          REPO_URL='${var.depot_url}' \
          PROPRIETAIRE='${var.proprietaire}' \
          PUBLIC_IP='${var.adresse_publique}' \
          bash /tmp/provision-host.sh
        rm -f /tmp/provision-host.sh
      EOT
    ]
  }
 }
 # Piege : le jeton d'enregistrement expire en une heure. Un `apply` rejoue cette ressource des
 # que `runner_version`, `runner_labels` ou `runner_nom` change, et redemande donc un jeton frais.
 resource "null_resource" "runner_github" {
  depends_on = [null_resource.environnements]
  triggers = {
    version = var.runner_version
    labels  = var.runner_labels
    nom     = local.runner_nom
    dossier = var.runner_dossier
  }
  connection {
    type        = "ssh"
    host        = var.ssh_host
    port        = var.ssh_port
    user        = var.ssh_user
    private_key = file(pathexpand(var.ssh_private_key_path))
    timeout     = "5m"
  }
  provisioner "remote-exec" {
    inline = [
      <<-EOT
        set -eu
        ${local.sudo}install -d -o ${var.proprietaire} -g ${var.proprietaire} ${var.runner_dossier}
        if [ ! -x ${var.runner_dossier}/config.sh ]; then
          curl -fsSL -o /tmp/${local.runner_archive} \
            https://github.com/actions/runner/releases/download/v${var.runner_version}/${local.runner_archive}
          ${local.sudo}tar -xzf /tmp/${local.runner_archive} -C ${var.runner_dossier}
          ${local.sudo}chown -R ${var.proprietaire}:${var.proprietaire} ${var.runner_dossier}
          rm -f /tmp/${local.runner_archive}
        fi
        if [ ! -f ${var.runner_dossier}/.runner ]; then
          ${local.en_tant_que} sh -c 'cd ${var.runner_dossier} && ./config.sh --unattended --replace \
            --url ${var.runner_url} --token ${var.runner_token} \
            --labels ${var.runner_labels} --name ${local.runner_nom} --work _work'
          ${local.sudo}${var.runner_dossier}/svc.sh install ${var.proprietaire}
        fi
        ${local.sudo}${var.runner_dossier}/svc.sh start
      EOT
    ]
  }
 }
@@ -0,0 +1,9 @@
 output "machine" {
  description = "Machine provisionnee et racine qui porte un clone par environnement."
  value       = "${var.ssh_user}@${var.ssh_host}:${var.racine}"
 }
 output "runner" {
  description = "Dossier d'installation du runner et libelles supplementaires annonces a GitHub."
  value       = "${var.runner_dossier} (${var.runner_labels})"
 }
@@ -0,0 +1,22 @@
 ssh_host             = "10.101.200.37"
 ssh_port             = 22
 ssh_user             = "root"
 ssh_private_key_path = "~/.ssh/id_ed25519"
 # Utilisateur qui possede la racine et fait tourner le runner. Il doit deja exister sur la
 # machine : git refuse les depots appartenant a un autre utilisateur, et un .env en 600 lui
 # echapperait.
 proprietaire = "enervision"
 # Epingler une version reelle : https://github.com/actions/runner/releases
 runner_version = "2.330.0"
 # Jeton d'enregistrement du runner, valable une heure et pour une seule inscription :
 # Parametres du depot > Actions > Runners > New self-hosted runner. Seul un administrateur du
 # depot peut le creer. terraform.tfvars est ignore par git, mais le jeton ne doit pas y rester
 # apres l'apply.
 runner_token = "A_RENSEIGNER"
 # Nom du runner cote GitHub. Vide par defaut : le nom d'hote de la machine. A renseigner
 # seulement si deux runners doivent tourner sur la meme machine, leurs noms devant differer.
 # runner_nom = "eni-g3-bis"
@@ -0,0 +1,90 @@
 variable "ssh_host" {
  type        = string
  description = "Adresse de la VM ENI qui porte les deux environnements (ADR 0009)."
 }
 variable "ssh_port" {
  type        = number
  description = "Port SSH de la VM."
  default     = 22
 }
 variable "ssh_user" {
  type        = string
  description = "Utilisateur SSH du provisionnement. Different de root, les commandes privilegiees sont prefixees par sudo."
  default     = "root"
 }
 variable "ssh_private_key_path" {
  type        = string
  description = "Chemin local vers la cle privee SSH. L'authentification par mot de passe n'est volontairement pas prise en charge : une variable de mot de passe finit en clair dans le state ou dans les triggers."
  sensitive   = true
 }
 variable "proprietaire" {
  type        = string
  description = "Utilisateur qui possede la racine et fait tourner le runner. Il doit exister sur la machine : git refuse les depots appartenant a un autre utilisateur, et un .env en 600 lui echapperait."
  validation {
    condition     = can(regex("^[a-z_][a-z0-9_-]*$", var.proprietaire))
    error_message = "proprietaire doit etre un nom d'utilisateur Unix valide."
  }
 }
 variable "racine" {
  type        = string
  description = "Dossier qui porte un clone du depot par environnement."
  default     = "/srv/enervision"
 }
 variable "depot_url" {
  type        = string
  description = "URL de clonage du depot, passee a provision-host.sh."
  default     = "https://github.com/ineszang/ProjetPiscine_EnerVision.git"
 }
 variable "adresse_publique" {
  type        = string
  description = "Adresse annoncee dans les certificats auto-signes. Vide : la premiere adresse de la VM."
  default     = ""
 }
 variable "runner_url" {
  type        = string
  description = "Depot GitHub auquel le runner s'enregistre."
  default     = "https://github.com/ineszang/ProjetPiscine_EnerVision"
 }
 variable "runner_version" {
  type        = string
  description = "Version d'actions-runner a installer, sans le v initial (ex: 2.330.0). Voir https://github.com/actions/runner/releases."
  validation {
    condition     = can(regex("^[0-9]+\\.[0-9]+\\.[0-9]+$", var.runner_version))
    error_message = "runner_version doit etre epinglee explicitement (ex: 2.330.0), sinon l'installation cesse d'etre reproductible."
  }
 }
 variable "runner_token" {
  type        = string
  description = "Jeton d'enregistrement du runner. Expire au bout d'une heure et ne vaut que pour une inscription : Parametres du depot > Actions > Runners > New self-hosted runner. Seul un administrateur du depot peut le creer."
  sensitive   = true
 }
 variable "runner_labels" {
  type        = string
  description = "Libelles supplementaires du runner. deploy.yml cible [self-hosted, linux, eni-g3], les deux premiers etant poses par GitHub."
  default     = "eni-g3"
 }
 variable "runner_nom" {
  type        = string
  description = "Nom du runner cote GitHub, unique dans le depot. Vide : le nom d'hote de la machine, qui reste unique si cette racine est reprise pour une seconde VM. A renseigner pour faire tourner deux runners sur la meme machine."
  default     = ""
 }
 variable "runner_dossier" {
  type        = string
  description = "Dossier d'installation du runner sur la machine."
  default     = "/opt/actions-runner"
 }
@@ -0,0 +1,14 @@
 terraform {
  required_version = ">= 1.7"
  required_providers {
    null = {
      source  = "hashicorp/null"
      version = "~> 3.2"
    }
  }
  backend "local" {
    path = "terraform.tfstate"
  }
 }
@@ -5,19 +5,26 @@ locals {
  kubeconfig_cmd = "${local.sudo_prefix}cat /etc/rancher/k3s/k3s.yaml"
 }
 # Piege : un provisioner `destroy` impose que tout le bloc `connection` ne lise que `self`, sinon
 # `terraform init` refuse le module. D'ou la connexion batie sur `triggers`, ou ne figurent que
 # l'adresse, le port, l'utilisateur et le chemin de la cle : jamais la cle ni un mot de passe.
 resource "null_resource" "k3s_install" {
  triggers = {
-    ssh_host            = var.ssh_host
+    ssh_host           = var.ssh_host
-    k3s_version         = var.k3s_version
+    ssh_port           = tostring(var.ssh_port)
-    disable_components  = join(",", var.k3s_disable_components)
+    ssh_user           = var.ssh_user
    ssh_key_path       = var.ssh_private_key_path
    sudo_prefix        = local.sudo_prefix
    k3s_version        = var.k3s_version
    disable_components = join(",", var.k3s_disable_components)
  }
  connection {
    type        = "ssh"
-    host        = var.ssh_host
+    host        = self.triggers.ssh_host
-    port        = var.ssh_port
+    port        = tonumber(self.triggers.ssh_port)
-    user        = var.ssh_user
+    user        = self.triggers.ssh_user
-    private_key = file(var.ssh_private_key_path)
+    private_key = file(pathexpand(self.triggers.ssh_key_path))
  }
  provisioner "remote-exec" {
@@ -33,7 +40,7 @@ resource "null_resource" "k3s_install" {
    when       = destroy
    on_failure = continue
    inline = [
-      "${local.sudo_prefix}sh -c 'test -x /usr/local/bin/k3s-uninstall.sh && /usr/local/bin/k3s-uninstall.sh || true'",
+      "${self.triggers.sudo_prefix}sh -c 'test -x /usr/local/bin/k3s-uninstall.sh && /usr/local/bin/k3s-uninstall.sh || true'",
    ]
  }
 }
@@ -0,0 +1,6 @@
 .venv
 data
 mlruns
 mlflow.db*
 models
 .env
@@ -0,0 +1 @@
 MLFLOW_DB_PASSWORD=change-me
@@ -0,0 +1,7 @@
 FROM python:3.14-slim
 RUN pip install --no-cache-dir --only-binary :all: mlflow==3.16.1 psycopg2-binary==2.9.13
 RUN useradd --create-home --uid 1000 mlflow \
    && mkdir /mlartifacts \
    && chown mlflow /mlartifacts
 USER mlflow
 EXPOSE 5000
@@ -57,6 +57,50 @@ validation. La coupure est **chronologique**, jamais un tirage aleatoire de lign
 aleatoire laisserait des lignes de validation "voir" des lignes d'entrainement via leurs
 lags/moyennes glissantes, une fuite qui masquerait un surapprentissage.
 ## Serveur MLflow (conteneur)
 Premiere utilisation : copier `.env.example` en `.env` et y choisir un mot de passe PostgreSQL
 (lettres et chiffres uniquement). Le fichier `.env` est ignore par git.
 ```bash
 cp .env.example .env
 ```
 Un serveur MLflow (PostgreSQL pour les metadonnees, volume pour les artefacts) se lance avec
 Docker. Prerequis : Docker Desktop demarre.
 ```bash
 make mlflow-up
 ```
 La cible vérifie que `MLFLOW_DB_PASSWORD` (définie dans `ml/.env`) ne contient que des lettres et
 des chiffres avant de démarrer le serveur : ce mot de passe est interpolé directement dans l'URI
 PostgreSQL (`postgresql://mlflow:${MLFLOW_DB_PASSWORD}@...`), un caractère spécial la rendrait
 invalide sans message d'erreur clair.
 Interface : http://localhost:5000. Entrainer vers ce serveur :
 ```
 uv run python -m enervision_ml.train --csv data/all_sites_combined.csv --mlflow-tracking-uri http://localhost:5000
 ```
 Arreter : `docker compose -f docker-compose.mlflow.yml down` (ajouter `-v` pour effacer aussi les
 runs et les modeles).
 Pour voir les runs dans l'interface (MLflow 3.x) :
 - Passer le selecteur en haut a gauche sur **Model training**. Le mode **GenAI** affiche des
  traces LLM et reste vide pour un entrainement LightGBM.
 - **Runs** liste les entrainements, **Models** les artefacts de modele de chaque run (tous nommes
  `model`), et **Model registry** les versions numerotees de `consumption-forecast-lightgbm`.
 Limites : l'identifiant PostgreSQL du compose est fixe a `mlflow`, le mot de passe vient de la
 variable obligatoire `MLFLOW_DB_PASSWORD` (aucune valeur par defaut, le compose refuse de
 demarrer sans elle) -- ce mot de passe est choisi lors de la copie de `.env.example`, il ne
 convient donc qu'au developpement local tel quel. Un deploiement partage demandera des secrets,
 de l'authentification et un stockage d'artefacts dedie (S3/MinIO). Le port 5000 doit etre libre : arreter `mlflow ui` avant,
 ou changer le mapping (`"5001:5000"`) dans le compose.
 ## Scoring
 ```bash
@@ -83,6 +127,13 @@ section 2 :
 fichier : `train.py` reecrit toujours le meme chemin a chaque entrainement, donc le nom seul ne
 distinguerait pas deux versions du modele.
 **Le scoring ne lit pas le Model Registry.** Le fichier charge par `--model` est local
 (`models/lightgbm-consumption.txt`), independant des versions enregistrees dans le
 **Model registry** MLflow (`consumption-forecast-lightgbm`). `train.py` enregistre bien une
 version a chaque entrainement (tracabilite), mais aucun alias (`champion` par exemple) n'est
 pose, et `enervision_ml.score` ne les lit pas. Le registre sert aujourd'hui a la tracabilite des
 entrainements, pas au deploiement du modele utilise en scoring.
 En mode `--csv`, rien n'est ecrit en base : c'est un instantane historique fige (l'heure "future"
 calculee a partir de la fin du CSV n'existe dans aucune base reelle), utile pour valider le
 pipeline sans base joignable.
@@ -0,0 +1,32 @@
 services:
  mlflow-db:
    image: postgres:17
    environment:
      POSTGRES_USER: mlflow
      POSTGRES_PASSWORD: ${MLFLOW_DB_PASSWORD:?definir MLFLOW_DB_PASSWORD dans ml/.env}
      POSTGRES_DB: mlflow
    volumes:
      - mlflow-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U mlflow"]
      interval: 5s
      retries: 10
  mlflow:
    build: .
    depends_on:
      mlflow-db:
        condition: service_healthy
    ports:
      - "127.0.0.1:5000:5000"
    volumes:
      - mlflow-artifacts:/mlartifacts
    environment:
      MLFLOW_DB_PASSWORD: ${MLFLOW_DB_PASSWORD}
    entrypoint: [ "/bin/sh", "-c" ]
    command:
      - exec mlflow server --host 0.0.0.0 --port 5000 --backend-store-uri "postgresql://mlflow:$$MLFLOW_DB_PASSWORD@mlflow-db:5432/mlflow" --artifacts-destination /mlartifacts --serve-artifacts
 volumes:
  mlflow-db-data:
  mlflow-artifacts:
@@ -181,7 +181,11 @@ def _log_to_mlflow(
        )
        mlflow.log_metrics({f"model_{cle}": valeur for cle, valeur in model_metrics.items()})
        mlflow.log_metrics({f"baseline_{cle}": valeur for cle, valeur in baseline_metrics.items()})
-        mlflow.lightgbm.log_model(booster, name="model")
+        mlflow.lightgbm.log_model(
            booster,
            name="model",
            registered_model_name="consumption-forecast-lightgbm",
        )
        mlflow.log_artifact(str(model_output))
@@ -3,6 +3,7 @@ from pathlib import Path
 import numpy as np
 import pandas as pd
 import pytest
 from enervision_ml.features import TARGET_COLUMN, build_features, feature_columns
 from enervision_ml.train import chronological_split, prepare_dataset, train
@@ -74,3 +75,19 @@ def test_train_runs_end_to_end_on_synthetic_data_and_beats_a_dummy_baseline(
    assert model_metrics["n_observations"] > 0
    assert model_metrics["mae"] >= 0
    assert baseline_metrics["n_observations"] == model_metrics["n_observations"]
    assert model_metrics["mae"] < baseline_metrics["mae"]
 def test_train_raises_when_the_validation_window_is_empty(tmp_path: Path) -> None:
    depart = datetime(2026, 1, 1, tzinfo=UTC)
    frame = make_frame("site-a", heures=50, depart=depart)  # trop court pour un lag de 168h
    csv_path = tmp_path / "trop_court.csv"
    frame.to_csv(csv_path, index=False)
    with pytest.raises(ValueError, match="Fenetre d'entrainement ou de validation vide"):
        train(
            csv_path=csv_path,
            model_output=tmp_path / "model.txt",
            test_fraction=0.2,
            tracking_uri=f"sqlite:///{tmp_path / 'mlflow.db'}",
        )
@@ -1,3 +1,11 @@
 # Scripts
 Outillage local du monorepo. Les taches courantes passent par le `Makefile` racine.
 ## dast-token.sh
 Prépare le scan DAST (`.github/workflows/dast.yml`) : sur une API déjà démarrée, crée un compte
 `lecteur` jetable, lui fait passer le changement de mot de passe obligatoire et écrit son jeton
 d'accès sur la sortie standard. À lancer depuis `apps/backend`, contre une base **jetable** (il y
 crée deux comptes) : `BASE_URL=http://localhost:8000 ../../scripts/dast-token.sh`. Nécessite `curl`,
 `jq` et `openssl`.
@@ -0,0 +1,78 @@
 #!/usr/bin/env bash
 # Prépare le scan DAST : crée un compte `lecteur` sur une API déjà démarrée, lui fait passer le
 # changement de mot de passe obligatoire, et écrit son jeton d'accès sur la sortie standard.
 #
 # Piège : un compte neuf est en `must_change_password`, et toute route gardée le refuse tant que
 # le mot de passe n'a pas été changé. Sans cette étape, ZAP ne verrait que 403 sur les routes
 # gardées et le scan ne testerait rien de l'API authentifiée.
 #
 # Contrainte : le compte du scan est `lecteur`, jamais `admin`. Un scan actif avec un jeton admin
 # frapperait POST /users ou la réinitialisation de mots de passe pour de bon.
 #
 # L'administrateur n'existe que pour créer ce compte (l'API n'a pas d'inscription publique).
 # À lancer depuis apps/backend, dans un environnement où DATABASE_URL et APP_SECRET_KEY visent
 # une base JETABLE : le script y crée deux comptes.
 set -euo pipefail
 BASE_URL="${BASE_URL:-http://localhost:8000}"
 API="$BASE_URL/api/v1"
 SUFFIXE="$(openssl rand -hex 4)"
 EMAIL_ADMIN="dast-admin-$SUFFIXE@enervision.fr"
 EMAIL_LECTEUR="dast-lecteur-$SUFFIXE@enervision.fr"
 # Classes exigées par le validateur : majuscule, minuscule, chiffre, caractère spécial.
 nouveau_mot_de_passe() { echo "Dast-$(openssl rand -hex 12)-Aa1!"; }
 # Tout ce qui n'est pas la sortie finale part sur stderr : la sortie standard ne porte que le jeton.
 journal() { echo "dast-token: $*" >&2; }
 connexion() {
    local email="$1" mot_de_passe="$2"
    curl -fsS -X POST "$API/auth/login" -H 'Content-Type: application/json' \
        -d "$(jq -n --arg e "$email" --arg p "$mot_de_passe" '{email:$e, password:$p}')" \
        | jq -r '.access_token'
 }
 # Rend le nouveau jeton d'accès : `/auth/password` en émet un (avec l'`iat` de la session en
 # cours, cf. le piège documenté dans `app/api/deps.py`), pas seulement une confirmation. S'y fier
 # évite une reconnexion, donc un second hachage Argon2id (19456 Kio) et un aller-retour de
 # refresh-token superflus sur le chemin critique de la CI.
 changer_mot_de_passe() {
    local jeton="$1" ancien="$2" nouveau="$3"
    curl -fsS -X POST "$API/auth/password" \
        -H "Authorization: Bearer $jeton" -H 'Content-Type: application/json' \
        -d "$(jq -n --arg a "$ancien" --arg n "$nouveau" '{current_password:$a, new_password:$n}')" \
        | jq -r '.access_token'
 }
 journal "création de l'administrateur $EMAIL_ADMIN"
 if ! SORTIE="$(uv run --frozen --no-sync --no-build python -m app.cli create-admin --email "$EMAIL_ADMIN" --generate)"; then
    journal "la création de l'administrateur a échoué :"
    journal "$SORTIE"
    exit 1
 fi
 MDP_ADMIN="$(sed -n 's/^Mot de passe généré, il ne sera plus affiché : //p' <<<"$SORTIE")"
 [[ -n "$MDP_ADMIN" ]] || { journal "mot de passe administrateur introuvable dans la sortie :"; journal "$SORTIE"; exit 1; }
 JETON="$(connexion "$EMAIL_ADMIN" "$MDP_ADMIN")"
 NOUVEAU_ADMIN="$(nouveau_mot_de_passe)"
 JETON="$(changer_mot_de_passe "$JETON" "$MDP_ADMIN" "$NOUVEAU_ADMIN")"
 journal "création du lecteur $EMAIL_LECTEUR"
 REPONSE="$(curl -fsS -X POST "$API/users" -H "Authorization: Bearer $JETON" \
    -H 'Content-Type: application/json' \
    -d "$(jq -n --arg e "$EMAIL_LECTEUR" '{email:$e, role:"lecteur"}')")"
 MDP_TEMPORAIRE="$(jq -r '.temporary_password // empty' <<<"$REPONSE")"
 [[ -n "$MDP_TEMPORAIRE" ]] || { journal "mot de passe temporaire introuvable dans la réponse de POST /users :"; journal "$REPONSE"; exit 1; }
 JETON="$(connexion "$EMAIL_LECTEUR" "$MDP_TEMPORAIRE")"
 NOUVEAU_LECTEUR="$(nouveau_mot_de_passe)"
 JETON="$(changer_mot_de_passe "$JETON" "$MDP_TEMPORAIRE" "$NOUVEAU_LECTEUR")"
 # Vérifie que le jeton ouvre bien une route gardée avant de le rendre.
 CODE="$(curl -sS -o /dev/null -w '%{http_code}' "$API/sites" -H "Authorization: Bearer $JETON")"
 [[ "$CODE" == "200" ]] || { journal "GET /sites répond $CODE avec le jeton du lecteur, attendu 200"; exit 1; }
 journal "jeton du lecteur prêt"
 echo "$JETON"
Author	SHA1	Message	Date
Meryemel-gham	e118c008bf	fix(airflow): fiabilise l'import horaire de la Mock API Airflow / Construction de l'image (push) Successful in 1m4s Details Backend / Analyse statique de sécurité (push) Successful in 7s Details Backend / Tests exigeant une base (push) Failing after 4m55s Details Airflow / Lint et intégrité des DAGs (push) Successful in 9m49s Details Backend / Lint, typage et tests (push) Successful in 10m12s Details Backend / Audit des dépendances (push) Successful in 9m36s Details SonarQube / build-front (push) Successful in 9m35s Details SonarQube / test-ml (push) Failing after 5m37s Details SonarQube / build-back (push) Successful in 9m46s Details SonarQube / test-front (push) Failing after 5m4s Details SonarQube / test-back (push) Failing after 5m9s Details SonarQube / SonarQube (push) Skipped Details	2026-09-22 16:24:05 +02:00
Meryemel-gham	d86224a0f7	feat(airflow): orchestre l'import de la Mock API	2026-09-22 15:47:01 +02:00
ineszangandGitHub	6b3908d321	Add files via upload	2026-09-22 15:34:33 +02:00
ValentinDeFariaandGitHub	57b9735804	Merge pull request #123 from ineszang/feat/entrainement-du-modele feat(ml): enregistrer le modèle dans le MLflow Model Registry	2026-09-22 15:21:24 +02:00
PhyriosandGitHub	c007ea01bd	Merge pull request #140 from ineszang/feat/scan-dast-owasp-zap ci(backend): ajoute un scan DAST OWASP ZAP de l'API avec un compte le…	2026-09-22 15:17:18 +02:00
Valentin	44163bfb98	fix(ml): corrige le build MLflow (psycopg2), le garde-fou Makefile, la doc et la fuite de mot de passe ML / Analyse statique de sécurité (push) Successful in 6s Details SonarQube / test-ml (push) Failing after 6m4s Details SonarQube / build-front (push) Successful in 9m44s Details SonarQube / build-back (push) Successful in 9m50s Details ML / Lint, typage et tests (push) Successful in 11m41s Details SonarQube / test-front (push) Failing after 5m1s Details SonarQube / test-back (push) Failing after 5m11s Details SonarQube / SonarQube (push) Skipped Details	2026-09-22 15:04:21 +02:00
Dorian	ea8f9d0a3a	fix(ci): applique aussi le chmod du fichier d'authentification DAST via sudo	2026-09-22 14:57:29 +02:00
Dorian	f58fc4ba81	fix(ci): corrige les permissions du fichier d'authentification qui bloquait le scan DAST 10 minutes	2026-09-22 14:31:29 +02:00
Dorian	2c7ee2c064	Merge remote-tracking branch 'origin/dev' into feat/scan-dast-owasp-zap	2026-09-22 14:11:31 +02:00
Dorian	e220f8f0c6	fix(ci,backend): securise le jeton du scan DAST, seme des donnees et refait ses garde-fous	2026-09-22 14:08:51 +02:00
Johan LEROYandGitHub	fb4235df3a	Merge pull request #144 from ineszang/feat/terraform-provisionnement feat(infra): Terraform provisionne la VM, GitHub Actions continue de déployer	2026-09-22 12:39:12 +02:00
Johan LEROYandClaude Opus 5	357cf996ed	fix(infra): donne au runner un nom distinct de son label Infra / Formatage et validation Terraform (push) Successful in 9s Details --name reprenait runner_labels : un runner et son label portaient le meme eni-g3. Deux machines qui reprendraient cette racine s'enregistreraient sous le meme nom, ce que GitHub refuse. Le nom vaut desormais celui de l'hote, resolu sur la machine, et runner_nom permet de le forcer. Point 2 de la revue de la PR #144. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 12:36:38 +02:00
Dorian	d9103ee4ed	fix(ci): prune-cache set false	2026-09-22 11:29:54 +02:00
Johan LEROY	fca36649f9	ci(infra): épingle setup-terraform sur un SHA de commit Action tierce sur un workflow qui tourne avec les droits du dépôt : un tag mobile se redéplace. Constat SonarCloud githubactions:S7637, seul écart de la quality gate sur la PR.	2026-09-22 11:29:24 +02:00
Johan LEROY	0db69fd023	feat(infra): Terraform provisionne la VM, GitHub Actions continue de déployer Le seul Terraform du dépôt installait un cluster k3s que rien ne consomme, et sa racine ne passait même pas `terraform init` : depuis Terraform 1.x, un provisioner `destroy` impose que tout le bloc `connection` ne lise que `self`, et celui du module k3s lisait `var.`. Il est corrigé en batissant la connexion sur `triggers`, où ne figurent que l'adresse, le port, l'utilisateur et le chemin de la clé : jamais la clé ni un mot de passe. `environments/vm-eni` provisionne la machine qui porte la recette et la production : Docker et le plugin Compose, `scripts/provision-host.sh`, puis l'enregistrement du runner. Rien n'y construit d'image ni ne lance de conteneur, et un `apply` n'interrompt pas la stack qui tourne. Le déploiement continu ne bouge pas : `deploy.yml` reste le seul chemin de livraison. `environments/dev` devient `k3s-cible`, parce qu'il provisionnait un cluster et pas un environnement applicatif, et que `rec` et `prod` vivent sur la même machine. `environments/prod`, dossier vide, disparaît. `infra.yml` formate et valide chaque racine à chaque push : c'est l'absence d'un tel job qui a laissé ce Terraform cassé sans que rien ne le dise. La boucle parcourt `environments/`, une racine ajoutée est couverte sans y toucher. ADR 0010 pour la frontière entre provisionnement et livraison, et la doc d'architecture alignée dessus.	2026-09-22 11:27:21 +02:00
Dorian	3ddeb24207	Merge remote-tracking branch 'origin/dev' into feat/scan-dast-owasp-zap	2026-09-22 11:16:51 +02:00
Valentin	8760ebc701	fix(ml): applique les corrections de la review MLflow (securite, documentation, robustesse)	2026-09-22 10:41:02 +02:00
Valentin	a013dfa87f	Merge remote-tracking branch 'origin/dev' into feat/registry-modele-prediction	2026-09-22 10:11:24 +02:00
Dorian	6d741e45fb	fix(ci): corrige la cle matchstr de l'en-tete Authorization dans le scan DAST et retire le diagnostic socat	2026-09-21 16:59:13 +02:00
Dorian	1bec2c1376	fix(ci): diagnostique les 400 du scan DAST avec socat et echoue si toutes les reponses sont des 4xx	2026-09-21 16:49:44 +02:00
Dorian	00fab49d80	fix(ci): charge le contrat OpenAPI depuis un fichier dans le scan DAST et publie les journaux ZAP	2026-09-21 16:42:25 +02:00
Dorian	de88c4f156	fix(ci): corrige les issues Sonar du scan DAST et fait echouer un scan qui n'importe pas le contrat	2026-09-21 16:26:29 +02:00
Dorian	67dcf506e9	ci(backend): ajoute un scan DAST OWASP ZAP de l'API avec un compte lecteur jetable*	2026-09-21 16:11:36 +02:00
Valentin	9cd4f0de1c	Merge branch 'feat/entrainement-du-modele' of https://github.com/ineszang/ProjetPiscine_EnerVision into feat/registry-modele-prediction	2026-09-21 15:41:14 +02:00
Valentin	5cc99178c2	fix(ml): execute MLflow en non-root et installe uniquement des wheels	2026-09-21 15:41:02 +02:00
ValentinDeFariaandGitHub	b41a16364b	Merge branch 'dev' into feat/entrainement-du-modele	2026-09-21 15:14:57 +02:00
Valentin	33aeea835b	fix(ml): retire le mot de passe PostgreSQL du compose	2026-09-21 15:06:05 +02:00
Valentin	9312d3b60f	feat(ml): enregistrer le modèle dans le MLflow Model Registry	2026-09-21 14:52:00 +02:00
Valentin	268496a8c4	feat(ml): enregistrer le modèle dans le MLflow Model Registry	2026-09-21 12:04:49 +02:00