docs(docs): ajoute schema de donnees et sa description

docs: fonder la documentation d'architecture du monorepo

.env.example

@@ -0,0 +1,17 @@
+# Variables lues par docker-compose.yml a la racine.
+# Le backend lance hors conteneur (`make dev`) lit apps/backend/.env, pas ce fichier.
+
+POSTGRES_USER=enervision
+POSTGRES_PASSWORD=change_me
+POSTGRES_DB=enervision
+# 5432 est souvent deja pris par une autre base du poste.
+POSTGRES_PORT=5433
+# `basic` renvoie des statistiques d'usage a Timescale.
+TIMESCALEDB_TELEMETRY=off
+
+APP_ENV=local
+APP_DEBUG=true
+APP_LOG_LEVEL=INFO
+APP_SECRET_KEY=change_me
+APP_CORS_ORIGINS=http://localhost:4200
+BACKEND_PORT=8000

.gitignore

@@ -9,6 +9,7 @@ venv/
 .coverage
 coverage.xml
 htmlcov/
+test-results/
 dist/
 build/
 *.egg-info/
@@ -23,7 +24,7 @@ yarn-error.log*
 
 # Terraform
 .terraform/
-.terraform.lock.hcl
+# .terraform.lock.hcl est versionne (pas ignore) pour figer les versions de provider entre contributeurs/CI
 *.tfstate
 *.tfstate.*
 *.tfplan
@@ -32,6 +33,9 @@ override.tf
 override.tf.json
 *_override.tf
 *_override.tf.json
+*.tfvars
+!*.tfvars.example
+kubeconfig
 
 # Airflow
 etl/airflow/logs/

Makefile

@@ -1,7 +1,8 @@
 BACKEND := apps/backend
 
 .DEFAULT_GOAL := help
-.PHONY: help install dev lint format typecheck test check docker-build
+.PHONY: help install dev lint format typecheck test test-cov test-integration check \
+        docker-build db-up db-down db-reset db-logs db-psql migrate
 
 help: ## Liste les cibles disponibles
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
@@ -21,10 +22,35 @@ format: ## Formate et corrige le backend
 typecheck: ## Verifie le typage du backend
 	cd $(BACKEND) && uv run mypy app
 
-test: ## Execute les tests backend
+test: ## Execute les tests backend ne demandant pas de base
-	cd $(BACKEND) && uv run pytest
+	cd $(BACKEND) && uv run pytest --cov-fail-under=85
+
+test-cov: ## Rapports de couverture HTML et XML, plus les resultats au format JUnit
+	cd $(BACKEND) && uv run pytest --cov-fail-under=85 --cov-report=html \
+		--cov-report=xml --junitxml=test-results/junit.xml
+
+test-integration: ## Execute les tests exigeant une base joignable
+	cd $(BACKEND) && uv run pytest -m integration
 
 check: lint typecheck test ## Chaine de verification complete
 
 docker-build: ## Construit l'image du backend
 	docker build -t enervision-backend:local $(BACKEND)
+
+db-up: ## Demarre la base PostgreSQL TimescaleDB
+	docker compose up -d db
+
+db-down: ## Arrete la base en conservant ses donnees
+	docker compose stop db
+
+db-reset: ## Detruit la base et rejoue db/init
+	docker compose down -v && docker compose up -d db
+
+db-logs: ## Suit les journaux de la base
+	docker compose logs -f db
+
+db-psql: ## Ouvre une session psql sur la base applicative
+	docker compose exec db psql -U $${POSTGRES_USER:-enervision} -d $${POSTGRES_DB:-enervision}
+
+migrate: ## Applique les migrations Alembic
+	cd $(BACKEND) && uv run alembic upgrade head

README.md

@@ -3,20 +3,35 @@
 Monorepo de la plateforme EnerVision : collecte, stockage, analyse et restitution de
 series temporelles energetiques, deployee sur une machine on-premise.
 
+## Jalons
+
+| Jalon | Intitulé |
+|-------|----------------------------------------------------------|
+| J1    | Valider la préparation de l'environnement et du repo     |
+| J2    | Valider le périmètre retenu et les choix technologiques  |
+| J3    | Valider l'architecture et la gestion de la sécurité      |
+| J4    | Valider la robustesse et assurer les livrables           |
+
+Ce que la documentation apporte à chacun : [docs/architecture/00-vue-ensemble.md](docs/architecture/00-vue-ensemble.md).
+
 ## Stack cible
 
 | Domaine    | Technologie                         | Emplacement         | Etat          |
 |------------|-------------------------------------|---------------------|---------------|
 | Backend    | FastAPI, Python 3.14                | `apps/backend`      | Initialise    |
-| Frontend   | Angular, Node 24 LTS                | `apps/frontend`     | A initialiser |
+| Frontend   | Angular 22, Node 24 LTS             | `apps/frontend`     | Squelette     |
-| Base       | PostgreSQL + TimescaleDB            | `db`                | A initialiser |
+| Base       | PostgreSQL 17 + TimescaleDB         | `db`                | Initialise    |
 | ETL        | Apache Airflow                      | `etl/airflow`       | A initialiser |
-| Infra      | Terraform                           | `infra/terraform`   | A initialiser |
+| Infra      | Terraform (k3s single-node)         | `infra/terraform`   | Initialise    |
 | CI/CD      | GitHub Actions                      | `.github/workflows` | A initialiser |
 | Monitoring | Prometheus, Grafana, Alertmanager   | `monitoring`        | A initialiser |
 
-Seul le backend est initialise a ce stade. Les autres dossiers portent l'arborescence et
+Le backend, la base et l'infrastructure (Terraform/k3s) sont initialises a ce stade. Le frontend
-un README de cadrage, leur contenu fait l'objet d'un ticket dedie.
+porte le squelette Angular, sans code metier : aucune route, aucun appel d'API. Les autres dossiers
+portent l'arborescence et un README de cadrage, leur contenu fait l'objet d'un ticket dedie.
+
+L'etat detaille de chaque brique et les vues d'architecture sont dans
+[docs/architecture](docs/architecture/README.md).
 
 ## Arborescence
 
@@ -50,15 +65,36 @@ un README de cadrage, leur contenu fait l'objet d'un ticket dedie.
 Prerequis : uv, Docker. Le poste doit disposer de Python 3.14, que `uv` installe seul.
 
 ```bash
+cp .env.example .env                               # variables de docker-compose
+cp apps/backend/.env.example apps/backend/.env     # variables du backend hors conteneur
+
+make db-up     # PostgreSQL + TimescaleDB, publie sur le port 5433
 make install   # dependances du backend
+make migrate   # applique les migrations Alembic
 make dev       # API sur http://localhost:8000, docs sur /docs
 make check     # lint + typage + tests
 ```
 
 `make help` liste les cibles disponibles.
 
+Deux fichiers d'environnement, deux usages : `.env` a la racine alimente `docker-compose.yml`,
+`apps/backend/.env` alimente le backend lance sur le poste. Le port 5433 est publie plutot que
+5432, souvent deja pris par une autre base.
+
+La boucle de developpement est `make db-up` puis `make dev` : seule la base tourne en
+conteneur. Le service `backend` du `docker-compose.yml` sert la stack complete et la recette,
+et n'embarque pas le source, donc toute modification y demande un
+`docker compose up -d --build backend`.
+
+Verifier que la base repond et que l'extension est chargee :
+
+```bash
+curl -s localhost:8000/api/v1/health/ready
+```
+
 ## Conventions
 
-- Branches : `feat/`, `fix/`, `chore/`, `docs/` suivi d'un libelle court.
+- Branches : `feat/`, `fix/`, `chore/`, `docs/`, `test/` suivi d'un libelle court.
 - Commits : Conventional Commits, portee = dossier de premier niveau concerne.
 - Toute decision structurante donne lieu a un ADR dans `docs/adr`.
+- Toute PR qui change un composant met a jour sa vue dans `docs/architecture`, dans la meme PR.

apps/backend/.env.example

@@ -3,4 +3,4 @@ APP_DEBUG=true
 APP_LOG_LEVEL=INFO
 APP_SECRET_KEY=change_me
 APP_CORS_ORIGINS=http://localhost:4200
-DATABASE_URL=postgresql+asyncpg://enervision:change_me@localhost:5432/enervision
+DATABASE_URL=postgresql+asyncpg://enervision:change_me@localhost:5433/enervision

apps/backend/README.md

@@ -22,6 +22,9 @@ uv sync --all-groups
 `APP_SECRET_KEY` et `DATABASE_URL` n'ont pas de valeur par defaut : l'application refuse
 de demarrer sans elles.
 
+`DATABASE_URL` pointe sur `localhost:5433`, le port publie par le service `db` du
+`docker-compose.yml` racine. Demarrer la base depuis la racine avec `make db-up`.
+
 ## Commandes
 
 Depuis la racine du monorepo, via le `Makefile` : `make install`, `make dev`, `make lint`,
@@ -35,8 +38,16 @@ uv run ruff check .          # lint
 uv run ruff format .         # format
 uv run mypy app              # typage strict
 uv run pytest                # tests + couverture
+uv run pytest -m integration # tests exigeant une base joignable
 ```
 
+Les conventions de tests, les gabarits et le detail des marqueurs sont dans
+[`TESTING.md`](TESTING.md).
+
+`pytest` ecarte par defaut les tests marques `integration`, pour que `make check` reste
+jouable sans Docker. Ces tests visent la base `enervision_test`, creee par
+`db/init/110-test-database.sql` au premier demarrage du conteneur.
+
 L'application est exposee par une factory (`create_app`) et non par un objet module :
 aucune configuration n'est lue a l'import, ce qui rend les tests et les migrations
 independants de l'environnement.
@@ -73,7 +84,7 @@ Le sens de dependance est unique : `endpoints` vers `services` vers `repositorie
 | Route                  | Role                                            |
 |------------------------|-------------------------------------------------|
 | `/api/v1/health/live`  | Sonde de vivacite, aucune dependance externe    |
-| `/api/v1/health/ready` | Sonde de disponibilite, verifie la base         |
+| `/api/v1/health/ready` | Sonde de disponibilite, verifie la base et TimescaleDB |
 | `/metrics`             | Metriques au format Prometheus                  |
 | `/docs`, `/openapi.json` | Documentation, desactivee quand `APP_ENV=prod` |
 
@@ -86,6 +97,10 @@ uv run alembic upgrade head
 
 L'URL de connexion vient de `DATABASE_URL`, pas de `alembic.ini`.
 
+La premiere revision ne cree aucune table : elle refuse de s'appliquer si l'extension
+TimescaleDB manque, ce qui arrive quand `db/init` n'a pas ete joue. Le DDL propre a
+TimescaleDB qui ne depend pas du schema applicatif vit dans `db/`, pas ici.
+
 ## Image Docker
 
 Build multi-stage, dependances resolues par uv depuis `uv.lock`, execution sous un

apps/backend/TESTING.md

@@ -0,0 +1,143 @@
+# Conventions de tests unitaires : Backend
+
+## Outil
+
+pytest, avec pytest-asyncio en mode `auto` : un `async def test_*` est collecte sans
+decorateur. Les appels HTTP passent par httpx sur `ASGITransport`, qui parle a
+l'application en memoire, sans serveur ni port ouvert.
+
+## Ou ecrire les tests
+
+`tests/` est le miroir de `app/` : un test de `app/services/consumption.py` va dans
+`tests/services/test_consumption.py`. Les paquets `core`, `db`, `services` et
+`repositories` existent deja, vides, pour cette raison.
+
+## Nommage
+
+- Fonctions en anglais : `test_<sujet>_<comportement>_when_<condition>`.
+- `ids=` de `parametrize` en francais : `ids=["erreur_sqlalchemy", "erreur_reseau"]`.
+- Pas de docstring : le nom porte l'intention.
+
+## Structure attendue (Arrange / Act / Assert)
+
+Une ligne vide separe les trois temps, sans commentaire pour les annoncer.
+
+```python
+async def test_readiness_returns_503_when_the_extension_is_missing(
+    fake_session: Callable[..., None], client: AsyncClient
+) -> None:
+    fake_session(result=None)
+
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 503
+    assert response.json()["detail"] == "Extension TimescaleDB absente"
+```
+
+## Ce qui doit etre teste en priorite
+
+Le sens de dependance du backend est `endpoints -> services -> repositories -> models`.
+
+| Couche | Ce qu'on teste |
+|---|---|
+| `services/` | La logique metier, cas nominal et cas d'erreur. C'est la priorite. |
+| `repositories/` | Chaque branche de decision, sous le marqueur `integration`. |
+| `endpoints/` | Le code de statut et la forme de la reponse, pas la logique metier. |
+| `schemas/` | Rien, sauf si le schema porte une validation ecrite a la main. |
+
+## Doubles
+
+On remplace une dependance FastAPI par `app.dependency_overrides`, jamais par
+`unittest.mock`. `tests/factories.py` fournit le necessaire.
+
+- `fake_session(result=...)` : la session repond `result`.
+- `fake_session(failure=...)` : la session leve l'exception.
+- `make_settings(**overrides)` : fabrique une `Settings`, dont les valeurs priment sur
+  l'environnement et sur `.env`. C'est le moyen de tester `create_app` en `prod`.
+
+## Gabarit : un endpoint
+
+```python
+from collections.abc import Callable
+
+from httpx import AsyncClient
+
+
+async def test_endpoint_returns_the_expected_payload(
+    fake_session: Callable[..., None], client: AsyncClient
+) -> None:
+    fake_session(result=42)
+
+    response = await client.get("/api/v1/...")
+
+    assert response.status_code == 200
+    assert response.json() == {"valeur": 42}
+```
+
+## Gabarit : un service avec repository factice
+
+Un service ne connait que son repository : on lui en passe un faux, sans base ni session.
+
+```python
+from app.services.consumption import ConsumptionService
+
+
+class FakeRepository:
+    async def total_for(self, site_id: int) -> float:
+        return 12.5
+
+
+async def test_service_converts_the_total_to_kilowatt_hours() -> None:
+    service = ConsumptionService(FakeRepository())
+
+    total = await service.total_kwh(site_id=1)
+
+    assert total == 12.5
+```
+
+## Gabarit : un repository sur la vraie base
+
+Un repository parle du SQL : le tester sur un double ne prouve rien. Il porte donc le
+marqueur `integration`, ecarte par defaut.
+
+```python
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.site import Site
+from app.repositories.site import SiteRepository
+
+
+@pytest.mark.integration
+async def test_repository_reads_back_what_it_wrote(session: AsyncSession) -> None:
+    repository = SiteRepository(session)
+
+    await repository.add(Site(name="Toulouse"))
+
+    assert await repository.by_name("Toulouse") is not None
+```
+
+## Marqueurs
+
+`integration` designe tout test exigeant une base joignable. `pytest` les ecarte par
+defaut, ce qui garde `make check` jouable sans Docker. Tout autre marqueur doit etre
+declare dans `pyproject.toml` : `--strict-markers` refuse les marqueurs inconnus.
+
+## Couverture
+
+Les branches sont mesurees, pas seulement les lignes. Le seuil de 85 % ne s'applique
+qu'aux cibles qui jouent toute la suite, `make test` et `make test-cov` : un fichier
+joue seul affiche sa couverture sans jamais echouer dessus. Le detail se lit dans
+`htmlcov/index.html` apres `make test-cov`.
+
+## Lancer les tests
+
+```bash
+make test                          # suite unitaire, sans base
+make test-cov                      # idem, plus les rapports HTML, XML et JUnit
+make db-up && make test-integration # tests exigeant une base, demande Docker
+make check                         # lint + typage + suite unitaire
+
+uv run pytest tests/api/test_health.py           # un seul fichier
+uv run pytest -k readiness                       # par motif de nom
+```

apps/backend/alembic/versions/5353c0e4f094_socle_garde_extension_timescaledb.py

@@ -0,0 +1,37 @@
+"""socle garde extension timescaledb
+
+Revision ID: 5353c0e4f094
+Revises:
+Create Date: 2026-09-14 14:17:17.556764
+
+Premiere revision du schema applicatif. Elle ne cree aucune table : elle etablit
+alembic_version et refuse de s'appliquer sur une base ou l'extension TimescaleDB
+manque, cas qui se produit quand db/init n'a pas ete joue.
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+revision: str = "5353c0e4f094"
+down_revision: str | Sequence[str] | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+GARDE_EXTENSION = """
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') THEN
+        RAISE EXCEPTION 'extension timescaledb absente, voir db/init et db/README.md';
+    END IF;
+END
+$$;
+"""
+
+
+def upgrade() -> None:
+    op.execute(GARDE_EXTENSION)
+
+
+def downgrade() -> None:
+    pass

apps/backend/app/api/v1/endpoints/health.py

@@ -9,6 +9,8 @@ from app.schemas.health import LivenessStatus, ReadinessStatus
 logger = get_logger(__name__)
 router = APIRouter(tags=["health"])
 
+TIMESCALEDB_VERSION = text("SELECT extversion FROM pg_extension WHERE extname = 'timescaledb'")
+
 
 @router.get("/live", summary="Sonde de vivacite")
 async def liveness(settings: SettingsDep) -> LivenessStatus:
@@ -23,11 +25,19 @@ async def liveness(settings: SettingsDep) -> LivenessStatus:
 @router.get("/ready", summary="Sonde de disponibilite")
 async def readiness(session: SessionDep) -> ReadinessStatus:
     try:
-        await session.execute(text("SELECT 1"))
+        version: str | None = await session.scalar(TIMESCALEDB_VERSION)
     except SQLAlchemyError, OSError:
         logger.exception("Base de donnees injoignable")
         raise HTTPException(
             status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
             detail="Base de donnees injoignable",
         ) from None
-    return ReadinessStatus(status="ready", database="reachable")
+
+    if version is None:
+        logger.error("Extension TimescaleDB absente de la base")
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Extension TimescaleDB absente",
+        )
+
+    return ReadinessStatus(status="ready", database="reachable", timescaledb=version)

apps/backend/app/schemas/health.py

@@ -13,3 +13,4 @@ class LivenessStatus(BaseModel):
 class ReadinessStatus(BaseModel):
     status: Literal["ready"]
     database: Literal["reachable"]
+    timescaledb: str

apps/backend/pyproject.toml

@@ -79,8 +79,14 @@ disallow_untyped_defs = false
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 asyncio_mode = "auto"
-addopts = "-q --strict-markers --cov=app --cov-report=term-missing"
+asyncio_default_fixture_loop_scope = "function"
+addopts = "-q --strict-markers -m 'not integration' --cov=app --cov-report=term-missing"
+markers = ["integration: requiert une base PostgreSQL joignable, hors `make test`"]
 
 [tool.coverage.run]
 source = ["app"]
-omit = ["app/main.py", "alembic/*"]
+branch = true
+omit = ["alembic/*"]
+
+[tool.coverage.report]
+show_missing = true

apps/backend/tests/api/test_health.py

@@ -1,12 +1,9 @@
-from collections.abc import AsyncIterator
+from collections.abc import Callable
 
 import pytest
-from fastapi import FastAPI
 from httpx import AsyncClient
 from sqlalchemy.exc import OperationalError
 
-from app.db.session import get_session
-
 
 async def test_liveness_exposes_service_metadata(client: AsyncClient) -> None:
     response = await client.get("/api/v1/health/live")
@@ -20,6 +17,32 @@ async def test_liveness_exposes_service_metadata(client: AsyncClient) -> None:
     }
 
 
+async def test_readiness_reports_the_timescaledb_version(
+    fake_session: Callable[..., None], client: AsyncClient
+) -> None:
+    fake_session(result="2.22.1")
+
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "ready",
+        "database": "reachable",
+        "timescaledb": "2.22.1",
+    }
+
+
+async def test_readiness_returns_503_when_the_extension_is_missing(
+    fake_session: Callable[..., None], client: AsyncClient
+) -> None:
+    fake_session(result=None)
+
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 503
+    assert response.json()["detail"] == "Extension TimescaleDB absente"
+
+
 @pytest.mark.parametrize(
     "failure",
     [
@@ -29,16 +52,9 @@ async def test_liveness_exposes_service_metadata(client: AsyncClient) -> None:
     ids=["erreur_sqlalchemy", "erreur_reseau_asyncpg"],
 )
 async def test_readiness_returns_503_when_database_is_unreachable(
-    app: FastAPI, client: AsyncClient, failure: Exception
+    fake_session: Callable[..., None], client: AsyncClient, failure: Exception
 ) -> None:
-    class UnreachableSession:
+    fake_session(failure=failure)
-        async def execute(self, *_: object, **__: object) -> None:
-            raise failure
-
-    async def override() -> AsyncIterator[UnreachableSession]:
-        yield UnreachableSession()
-
-    app.dependency_overrides[get_session] = override
 
     response = await client.get("/api/v1/health/ready")
 
@@ -49,3 +65,14 @@ async def test_readiness_returns_503_when_database_is_unreachable(
 @pytest.mark.parametrize("path", ["/openapi.json", "/metrics"])
 async def test_technical_endpoints_are_served(client: AsyncClient, path: str) -> None:
     assert (await client.get(path)).status_code == 200
+
+
+@pytest.mark.integration
+async def test_readiness_reaches_the_real_database(client: AsyncClient) -> None:
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 200, response.text
+    body = response.json()
+    assert body["status"] == "ready"
+    assert body["database"] == "reachable"
+    assert body["timescaledb"]

apps/backend/tests/conftest.py

@@ -1,25 +1,49 @@
 import os
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 
 import pytest
 from fastapi import FastAPI
 from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.config import get_settings
+from app.db.session import get_engine, get_session, get_session_factory
 from app.main import create_app
+from tests.factories import FakeSession
 
 
+# Piege : les variables d'environnement priment sur apps/backend/.env. Celles qu'on ne
+# pose pas ici, c'est le .env du poste qui les decide, et les assertions avec.
 @pytest.fixture(autouse=True, scope="session")
 def environment() -> Iterator[None]:
-    os.environ.setdefault("APP_SECRET_KEY", "secret-de-test")
+    os.environ.update(
+        {
+            "APP_ENV": "local",
+            "APP_DEBUG": "false",
+            "APP_LOG_LEVEL": "WARNING",
+            "APP_CORS_ORIGINS": "",
+            "APP_SECRET_KEY": "secret-de-test",
+        }
+    )
     os.environ.setdefault(
-        "DATABASE_URL", "postgresql+asyncpg://enervision:enervision@localhost:5432/enervision_test"
+        "DATABASE_URL", "postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test"
     )
     get_settings.cache_clear()
     yield
     get_settings.cache_clear()
 
 
+# Piege : get_engine est lru_cache et pytest-asyncio ouvre une boucle par test. Sans ce
+# recyclage, le 2e test touchant vraiment la base heriterait d une boucle morte.
+@pytest.fixture(autouse=True)
+async def engine_per_test() -> AsyncIterator[None]:
+    yield
+    if get_engine.cache_info().currsize:
+        await get_engine().dispose()
+    get_engine.cache_clear()
+    get_session_factory.cache_clear()
+
+
 @pytest.fixture
 def app() -> FastAPI:
     return create_app()
@@ -30,3 +54,21 @@ async def client(app: FastAPI) -> AsyncIterator[AsyncClient]:
     transport = ASGITransport(app=app)
     async with AsyncClient(transport=transport, base_url="http://test") as async_client:
         yield async_client
+
+
+@pytest.fixture
+def fake_session(app: FastAPI) -> Callable[..., None]:
+    def install(result: object = None, failure: Exception | None = None) -> None:
+        async def override() -> AsyncIterator[FakeSession]:
+            yield FakeSession(result=result, failure=failure)
+
+        app.dependency_overrides[get_session] = override
+
+    return install
+
+
+# Contrainte : ouvre une vraie connexion, donc reservee aux tests `integration`.
+@pytest.fixture
+async def session() -> AsyncIterator[AsyncSession]:
+    async with get_session_factory()() as async_session:
+        yield async_session

apps/backend/tests/factories.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from app.core.config import Settings
+
+SETTINGS_DE_TEST: dict[str, Any] = {
+    "env": "local",
+    "debug": False,
+    "log_level": "WARNING",
+    "cors_origins": "",
+    "secret_key": "secret-de-test",
+    "database_url": "postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test",
+}
+
+
+class FakeSession:
+    """Session factice : renvoie `result`, ou leve `failure` si elle est fournie."""
+
+    def __init__(self, result: object = None, failure: Exception | None = None) -> None:
+        self._result = result
+        self._failure = failure
+
+    async def scalar(self, *_: object, **__: object) -> object:
+        return self._repondre()
+
+    async def execute(self, *_: object, **__: object) -> object:
+        return self._repondre()
+
+    def _repondre(self) -> object:
+        if self._failure is not None:
+            raise self._failure
+        return self._result
+
+
+# Piege : les arguments nommes priment sur l'environnement et sur .env, contrairement
+# aux variables posees par la fixture `environment`, qui restent surchargeables.
+def make_settings(**overrides: Any) -> Settings:
+    return Settings(**{**SETTINGS_DE_TEST, **overrides})

apps/frontend/README.md

@@ -72,7 +72,8 @@ Points à vérifier après toute regénération :
 
 1. Pointer l'API dans `src/environments/` sur `http://localhost:8000/api/v1`.
 2. Ajouter le proxy de développement (`proxy.conf.json`) vers le backend.
-3. Vérifier que `npm start` sert bien sur le port 4200 attendu par `docker-compose.yml`.
+3. Vérifier que `npm start` sert bien sur le port 4200, valeur par défaut d'`APP_CORS_ORIGINS`
+   côté backend. Le `docker-compose.yml` n'a aucun service frontend.
 4. Ajouter le `Dockerfile` multi-stage (build Angular puis service statique nginx).
 
 ## Additional Resources

apps/frontend/TESTING.md

@@ -0,0 +1,85 @@
+# Conventions de tests unitaires — Frontend
+
+## Outil
+Vitest (intégré nativement à Angular CLI, pas d'installation à faire).
+
+## Où écrire les tests
+Un fichier `*.spec.ts` à côté de chaque fichier testé (convention Angular CLI
+par défaut, respectée automatiquement par `ng generate`).
+
+## Structure attendue (Arrange / Act / Assert)
+```typescript
+it('devrait faire X quand Y', () => {
+  // Arrange : préparer les données et les mocks
+  const input = { valeur: 42 };
+
+  // Act : exécuter le code testé
+  const result = service.doSomething(input);
+
+  // Assert : vérifier le résultat
+  expect(result).toBe(true);
+});
+```
+
+## Ce qui doit être testé en priorité
+- Services (`core/services/`) : logique métier, gestion des erreurs
+- Guards et interceptors (`core/guards/`, `core/interceptors/`) : chaque branche de décision
+- Composants avec logique (formulaires, conditions d'affichage) — pas nécessaire pour
+  un composant 100% template, sans logique
+
+`core/services/`, `core/guards/` et `core/interceptors/` n'existent pas encore : c'est
+l'arborescence cible, décrite dans
+[docs/architecture/30-frontend.md](../../docs/architecture/30-frontend.md).
+
+## Gabarit — tester un service avec appel HTTP
+```typescript
+import { TestBed } from '@angular/core/testing';
+import { provideHttpClient } from '@angular/common/http';
+import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
+import { MonService } from './mon.service';
+
+describe('MonService', () => {
+  let service: MonService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [MonService, provideHttpClient(), provideHttpClientTesting()],
+    });
+    service = TestBed.inject(MonService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => httpMock.verify());
+
+  it('devrait récupérer les données', () => {
+    service.getData().subscribe();
+    const req = httpMock.expectOne('/api/v1/...');
+    expect(req.request.method).toBe('GET');
+    req.flush({ /* réponse simulée */ });
+  });
+});
+```
+
+## Gabarit — tester un composant standalone
+```typescript
+import { TestBed } from '@angular/core/testing';
+import { MonComposant } from './mon-composant';
+
+describe('MonComposant', () => {
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [MonComposant],
+    }).compileComponents();
+  });
+
+  it('devrait se créer', () => {
+    const fixture = TestBed.createComponent(MonComposant);
+    expect(fixture.componentInstance).toBeTruthy();
+  });
+});
+```
+
+## Lancer les tests
+- Développement (mode watch) : `npm test`
+- Rapport de couverture (CI) : `npm run test:ci -- --coverage`, puis ouvrir `coverage/index.html`

apps/frontend/angular.json

@@ -77,7 +77,24 @@
           "defaultConfiguration": "development"
         },
         "test": {
-          "builder": "@angular/build:unit-test"
+          "builder": "@angular/build:unit-test",
+          "options": {
+            "coverage": true,
+            "coverageReporters": [
+              "text-summary",
+              "lcov",
+              "html"
+            ],
+            "reporters": [
+              "default",
+              [
+                "junit",
+                {
+                  "outputFile": "test-results/junit.xml"
+                }
+              ]
+            ]
+          }
         }
       }
     }

apps/frontend/package-lock.json

@@ -21,6 +21,7 @@
         "@angular/build": "^22.1.8",
         "@angular/cli": "^22.1.8",
         "@angular/compiler-cli": "^22.1.0",
+        "@vitest/coverage-v8": "^4.1.11",
         "jsdom": "^28.0.0",
         "prettier": "^3.8.1",
         "typescript": "~6.0.2",
@@ -733,6 +734,16 @@
         "node": "^22.18.0 || >=24.11.0"
       }
     },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+      "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@bramus/specificity": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
@@ -3692,6 +3703,37 @@
         "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/@vitest/coverage-v8": {
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.11.tgz",
+      "integrity": "sha512-8MVGEFnJIcdGjcbfKmeq8z0pZHH0JlVtoVZH9Q/qwUp6wyFnEJUBMrw9DCaj+ra3vShGmhavjalMIhPNxZAUcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@bcoe/v8-coverage": "^1.0.2",
+        "@vitest/utils": "4.1.11",
+        "ast-v8-to-istanbul": "^1.0.0",
+        "istanbul-lib-coverage": "^3.2.2",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.2.0",
+        "magicast": "^0.5.2",
+        "obug": "^2.1.1",
+        "std-env": "^4.0.0-rc.1",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@vitest/browser": "4.1.11",
+        "vitest": "4.1.11"
+      },
+      "peerDependenciesMeta": {
+        "@vitest/browser": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@vitest/expect": {
       "version": "4.1.11",
       "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.11.tgz",
@@ -3943,6 +3985,18 @@
         "node": ">=12"
       }
     },
+    "node_modules/ast-v8-to-istanbul": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.6.tgz",
+      "integrity": "sha512-fvpl29helSO2w/z7utIbrkNXILdrLwDwAMH2I/zPKlGf5244+gf+B4cyS1sANcrPY2h+hWCGSgC8N61s/+AF9A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "estree-walker": "^3.0.3",
+        "js-tokens": "^10.0.0"
+      }
+    },
     "node_modules/baseline-browser-mapping": {
       "version": "2.11.23",
       "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.23.tgz",
@@ -5077,6 +5131,16 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/has-symbols": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
@@ -5139,6 +5203,13 @@
         "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/htmlparser2": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
@@ -5382,6 +5453,45 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/jose": {
       "version": "6.2.12",
       "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.12.tgz",
@@ -5886,6 +5996,84 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/magicast": {
+      "version": "0.5.5",
+      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.5.tgz",
+      "integrity": "sha512-UicdXN8zQ3JHlxVq+28afMXPr1z7WNY6+7EJnzTdQWkTAlMLF5fNCCKxJHBQwGaNGR11581EiQmQzx73+MvszA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/magicast/node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/magicast/node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/magicast/node_modules/@babel/parser": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz",
+      "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.8"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/magicast/node_modules/@babel/types": {
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
+      "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -7088,6 +7276,19 @@
         "url": "https://github.com/chalk/strip-ansi?sponsor=1"
       }
     },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/symbol-tree": {
       "version": "3.2.4",
       "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",

apps/frontend/package.json

@@ -6,7 +6,8 @@
     "start": "ng serve",
     "build": "ng build",
     "watch": "ng build --watch --configuration development",
-    "test": "ng test"
+    "test": "ng test",
+    "test:ci": "ng test --watch=false"
   },
   "private": true,
   "packageManager": "npm@11.19.0",
@@ -24,6 +25,7 @@
     "@angular/build": "^22.1.8",
     "@angular/cli": "^22.1.8",
     "@angular/compiler-cli": "^22.1.0",
+    "@vitest/coverage-v8": "^4.1.11",
     "jsdom": "^28.0.0",
     "prettier": "^3.8.1",
     "typescript": "~6.0.2",

apps/frontend/test-results/junit.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<testsuites name="vitest tests" tests="2" failures="0" errors="0" time="0.0699261">
+    <testsuite name="src/app/app.spec.ts" timestamp="2026-09-14T14:27:28.895Z" hostname="76SE37-GL5HHZ3" tests="2" failures="0" errors="0" skipped="0" time="0.0699261">
+        <testcase classname="src/app/app.spec.ts" name="App &gt; should create the app" time="0.0527847">
+        </testcase>
+        <testcase classname="src/app/app.spec.ts" name="App &gt; should render title" time="0.015831">
+        </testcase>
+    </testsuite>
+</testsuites>

db/README.md

@@ -1,6 +1,7 @@
 # Base de donnees
 
-PostgreSQL avec l'extension TimescaleDB. Non initialise, voir le ticket dedie.
+PostgreSQL 17 avec l'extension TimescaleDB, servie en local par le service `db` du
+`docker-compose.yml` racine (image `timescale/timescaledb-ha:pg17`).
 
 - `init` : scripts de bootstrap joues au premier demarrage du conteneur.
 - `migrations` : migrations SQL versionnees.
@@ -8,3 +9,31 @@ PostgreSQL avec l'extension TimescaleDB. Non initialise, voir le ticket dedie.
 
 Les migrations du schema applicatif expose par l'API vivent dans
 `apps/backend/alembic`, pas ici.
+
+## `init` ne rejoue jamais
+
+Ces scripts sont montes sur `/docker-entrypoint-initdb.d`, dont PostgreSQL ne joue le
+contenu qu'a la toute premiere initialisation, quand `PGDATA` est vide. Modifier ou
+ajouter un script ensuite reste sans effet sur une base existante : il faut detruire
+le volume, ce que fait `make db-reset`.
+
+L'image apporte ses propres scripts dans ce dossier, et ils comptent :
+
+| Script | Origine | Role |
+|---|---|---|
+| `000_install_timescaledb.sh` | image | Cree l'extension dans `postgres`, `template1` et la base applicative, et fixe `timescaledb.telemetry_level`. |
+| `001_timescaledb_tune.sh` | image | Lance `timescaledb-tune` sur la memoire et les CPU vus par le conteneur. |
+| `010_install_timescaledb_toolkit.sh` | image | Ajoute `timescaledb_toolkit`. |
+| `100-extensions.sql` | ce depot | Declare explicitement les extensions attendues. |
+| `110-test-database.sql` | ce depot | Cree `enervision_test`, attendue par la suite de tests du backend. |
+
+D'ou deux contraintes dans `docker-compose.yml`. Nos fichiers sont **montes un par un**,
+et non par leur dossier : un montage de `./db/init` sur `/docker-entrypoint-initdb.d`
+remplacerait le dossier de l'image au lieu de s'y ajouter, et ferait disparaitre les trois
+scripts ci-dessus sans le moindre message. Ajouter un fichier ici impose donc d'ajouter
+une ligne la-bas. Et leur numerotation commence a `100` pour passer apres `010`, y compris
+en locale C ou un prefixe a deux chiffres se trierait avant.
+
+Comme un bootstrap peut toujours avoir ete saute, deux gardes le rattrapent :
+`/api/v1/health/ready` repond 503 si l'extension n'est pas chargee, et la premiere
+revision Alembic refuse de s'appliquer.

db/init/100-extensions.sql

@@ -0,0 +1,4 @@
+-- Piege : ce script ne rejoue qu'a la premiere initialisation, quand PGDATA est vide.
+-- Le modifier ensuite reste sans effet tant que le volume n'est pas detruit.
+
+CREATE EXTENSION IF NOT EXISTS timescaledb;

db/init/110-test-database.sql

@@ -0,0 +1,8 @@
+-- Contrainte : le nom de cette base est code en dur dans apps/backend/tests/conftest.py.
+-- Elle sert la suite de tests de la stack locale, pas un deploiement.
+
+CREATE DATABASE enervision_test;
+
+\connect enervision_test
+
+CREATE EXTENSION IF NOT EXISTS timescaledb;

docker-compose.yml

@@ -0,0 +1,47 @@
+# Piege : PGDATA de l'image timescaledb-ha vaut /home/postgres/pgdata/data, pas le chemin
+# habituel de l'image postgres. Monte ailleurs, le volume ne retient rien, sans erreur.
+# Piege : db/init est monte fichier par fichier. Monter le dossier masquerait les scripts
+# d'init de l'image, dont timescaledb-tune. Ajouter un fichier impose une ligne ici.
+
+name: enervision
+
+services:
+  db:
+    image: timescale/timescaledb-ha:pg17
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:?}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?}
+      POSTGRES_DB: ${POSTGRES_DB:?}
+      TIMESCALEDB_TELEMETRY: ${TIMESCALEDB_TELEMETRY:-off}
+    ports:
+      - "${POSTGRES_PORT:-5433}:5432"
+    volumes:
+      - pgdata:/home/postgres/pgdata/data
+      - ./db/init/100-extensions.sql:/docker-entrypoint-initdb.d/100-extensions.sql:ro
+      - ./db/init/110-test-database.sql:/docker-entrypoint-initdb.d/110-test-database.sql:ro
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
+      interval: 10s
+      timeout: 5s
+      retries: 12
+      start_period: 40s
+    restart: unless-stopped
+
+  backend:
+    build: ./apps/backend
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      APP_ENV: ${APP_ENV:-local}
+      APP_DEBUG: ${APP_DEBUG:-false}
+      APP_LOG_LEVEL: ${APP_LOG_LEVEL:-INFO}
+      APP_SECRET_KEY: ${APP_SECRET_KEY:?}
+      APP_CORS_ORIGINS: ${APP_CORS_ORIGINS:-http://localhost:4200}
+      DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
+    ports:
+      - "${BACKEND_PORT:-8000}:8000"
+    restart: unless-stopped
+
+volumes:
+  pgdata:

docs/README.md

@@ -1,4 +1,4 @@
 # Documentation
 
 - `adr` : decisions d'architecture, une par fichier, numerotees et immuables.
-- `architecture` : schemas et vues d'ensemble.
+- `architecture` : les vues du systeme. Point d'entree : [architecture/README.md](architecture/README.md).

docs/adr/0001-postgresql-timescaledb.md

@@ -0,0 +1,66 @@
+# 0001 - PostgreSQL avec l'extension TimescaleDB
+
+- Statut : accepte
+- Date : 2026-09-14
+
+## Contexte
+
+EnerVision collecte, stocke et restitue des series temporelles energetiques sur une machine
+on-premise. La charge est dominee par des insertions horodatees en flux et par des lectures
+agregees sur des fenetres de temps. Airflow produira des agregations continues, Grafana lira
+les memes donnees, et l'API FastAPI les exposera.
+
+Un SGBD relationnel generaliste sait faire, mais degrade a mesure que la table de mesures
+grossit : les index se fragmentent, les balayages de fenetre deviennent couteux, et il faut
+ecrire a la main le partitionnement, la retention et les agregats pre-calcules.
+
+## Decision
+
+PostgreSQL 17 avec l'extension TimescaleDB, servie en local par l'image
+`timescale/timescaledb-ha:pg17`.
+
+PostgreSQL reste une base relationnelle standard : un seul SGBD pour les donnees metier et
+les mesures, un seul dialecte SQL, un seul pilote (`asyncpg`), et l'outillage habituel.
+TimescaleDB ajoute le partitionnement automatique, les agregations continues et les
+politiques de retention sans changer de moteur.
+
+L'image `-ha` plutot que l'image alpine : elle embarque `timescaledb_toolkit`, `postgis` et
+`pgvector`. Le toolkit porte les fonctions de comblement de trous et d'analyse de series dont
+l'ETL aura besoin, et changer d'image plus tard imposerait une reinitialisation du volume.
+
+PG17 plutot que PG18 : c'est la version la mieux couverte par Airflow et Grafana a ce jour.
+
+## Frontiere entre `db/` et `apps/backend/alembic/`
+
+C'est la regle que ce document existe surtout pour fixer.
+
+- `db/init/` : bootstrap joue **une seule fois**, a la premiere initialisation du conteneur.
+  Extensions, bases annexes. Ne rejoue jamais sur un volume existant.
+- `db/migrations/` : SQL versionne qui ne decoule pas du schema applicatif, typiquement les
+  politiques de retention et de compression TimescaleDB.
+- `apps/backend/alembic/` : le schema expose par l'API, et lui seul. C'est `Base.metadata`
+  qui fait foi.
+
+Une hypertable relevera des deux : Alembic cree la table, et le `create_hypertable()` vit
+dans la meme revision Alembic, parce que separer les deux rendrait le schema irreproductible
+depuis un seul `alembic upgrade head`.
+
+## Consequences
+
+- Le projet se lie a une extension, donc a un hebergement qui l'autorise. C'est acquis
+  puisque le deploiement est on-premise.
+- `CREATE EXTENSION` demande le superutilisateur : cela reste un acte de bootstrap, pas une
+  migration applicative.
+- Un bootstrap saute ne se voit pas au demarrage de l'API. Deux gardes couvrent ce cas :
+  `/api/v1/health/ready` repond 503 si l'extension est absente, et la premiere revision
+  Alembic refuse de s'appliquer.
+- L'image `-ha` pese environ 1 Go, a telecharger une fois par poste.
+
+## Alternatives ecartees
+
+- **PostgreSQL nu, partitionnement manuel** : faisable, mais il faudrait reecrire ce que
+  TimescaleDB fournit, et le maintenir.
+- **InfluxDB** : tres bon sur la serie temporelle, mais imposerait un second SGBD pour le
+  relationnel, donc deux dialectes, deux sauvegardes et des jointures applicatives.
+- **ClickHouse** : taille pour un volume analytique que le projet n'atteindra pas, et moins
+  a l'aise sur les ecritures unitaires frequentes du flux d'ingestion.

docs/architecture/00-vue-ensemble.md

@@ -0,0 +1,137 @@
+# Vue d'ensemble
+
+EnerVision collecte, stocke, analyse et restitue des séries temporelles énergétiques, sur une
+machine on-premise.
+
+## Cadre du projet
+
+Quatre jalons ont été posés à l'ouverture du projet. Ils ont disparu du `README.md` lors de la
+réécriture de l'arborescence (`2670483`) et ne subsistaient que sur `main`. Ils sont repris ici
+parce qu'ils disent ce que le projet doit prouver, et donc à quoi sert chaque décision technique.
+
+| Jalon | Intitulé | Ce que la documentation apporte |
+|---|---|---|
+| J1 | Valider la préparation de l'environnement et du repo | `10-infra.md` décrit la stack du poste de développement et la commande qui la démarre |
+| J2 | Valider le périmètre retenu et les choix technologiques | Les ADR (`../adr/`) portent les choix ; `40-data.md` liste les questions de périmètre encore ouvertes |
+| J3 | Ingestion & backend | `20-backend.md` |
+| J4 | Architecture, sécurité & frontend | Les cinq vues, et la section « Sécurité » ci-dessous qui consolide les surfaces exposées |
+| J5 | Valider la robustesse et assurer les livrables | `20-backend.md` et `30-frontend.md` renvoient aux conventions de tests de chaque application |
+
+## Contexte
+
+Statut : `Cible`. Les acteurs et les sources de mesures ne sont pas arrêtés, c'est l'objet du
+jalon J2.
+
+```mermaid
+flowchart LR
+  exploitant["Exploitant<br/>consulte les courbes"]
+  admin["Administrateur<br/>exploite la plateforme"]
+  sources["Sources de mesures<br/>à définir en J2"]
+
+  subgraph systeme["EnerVision"]
+    plateforme["Collecte, stockage,<br/>analyse et restitution<br/>de séries temporelles"]
+  end
+
+  sources -.-> plateforme
+  exploitant -.-> plateforme
+  admin -.-> plateforme
+```
+
+## Conteneurs
+
+Trait plein pour ce qui tourne, pointillé pour ce qui est cible.
+
+```mermaid
+flowchart TB
+  navigateur["Navigateur"]
+
+  subgraph machine["Machine on-premise"]
+    front["Frontend Angular 22<br/>apps/frontend"]
+    api["API FastAPI<br/>apps/backend"]
+    db[("PostgreSQL 17<br/>TimescaleDB")]
+    airflow["Airflow<br/>etl/airflow"]
+    prom["Prometheus"]
+    grafana["Grafana"]
+  end
+
+  navigateur --> front
+  front -.-> api
+  api --> db
+  airflow -.-> db
+  prom -.-> api
+  grafana -.-> db
+  grafana -.-> prom
+```
+
+Le lien `front -.-> api` est en pointillé à dessein : le frontend n'appelle aujourd'hui aucune
+API, `provideHttpClient` n'est pas encore installé. Voir [30-frontend.md](30-frontend.md).
+
+Le lien `prom -.-> api` de même : l'API expose bien `/metrics` au format Prometheus, mais aucun
+collecteur ne vient le lire.
+
+## État de la stack
+
+| Domaine | Technologie | Emplacement | Statut | Ce qui existe réellement |
+|---|---|---|---|---|
+| Backend | FastAPI, Python 3.14 | `apps/backend` | `En cours` | Factory, configuration, journalisation, 2 sondes de santé, `/metrics`. Aucune couche métier |
+| Frontend | Angular 22, Node 24 | `apps/frontend` | `En cours` | Squelette `ng new` standalone, routes vides, aucun service HTTP |
+| Base | PostgreSQL 17 + TimescaleDB | `db` | `Fait` | Bootstrap de l'extension, base de test, chaîne Alembic. Aucune table applicative |
+| Infra | Terraform, k3s single-node | `infra/terraform` | `En cours` | Module d'installation du cluster. 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` | `Cible` | Rien |
+| CI/CD | GitHub Actions | `.github/workflows` | `Cible` | Rien |
+
+## Flux bout en bout
+
+Statut : `Cible`. Aucun maillon de cette chaîne n'existe aujourd'hui, à l'exception de la base.
+
+```mermaid
+sequenceDiagram
+  participant S as Source de mesures
+  participant A as Airflow
+  participant T as TimescaleDB
+  participant API as FastAPI
+  participant U as Angular
+
+  S->>A: mesures horodatées
+  A->>T: insertion dans l'hypertable
+  T->>T: rafraîchissement de l'agrégat continu
+  U->>API: GET /api/v1/...
+  API->>T: agrégation sur la fenêtre demandée
+  T-->>API: lignes
+  API-->>U: JSON
+```
+
+## Sécurité
+
+Section rattachée au jalon J3. Le détail par brique est dans chaque document ; voici la vue
+consolidée.
+
+### En place
+
+- **Les secrets n'ont pas de valeur par défaut.** `APP_SECRET_KEY` et `DATABASE_URL` sont requis
+  sans repli : l'application refuse de démarrer si l'un manque, plutôt que de tourner avec une
+  valeur de démonstration. `.env` reste hors dépôt, `.env.example` est versionné.
+- **CORS conditionnel** : le middleware n'est ajouté que si `APP_CORS_ORIGINS` est renseigné.
+- **Documentation interactive fermée en production** : `/docs`, `/redoc` et `/openapi.json` sont
+  désactivés dès que `APP_ENV=prod`.
+- **Conteneur backend non-root**, déclaré dans `apps/backend/Dockerfile`.
+- **Côté infrastructure** : la clé SSH est marquée `sensitive`, le kubeconfig reste en `600/root`
+  sur la machine cible et n'est lu que par `sudo`, `*.tfvars` est ignoré par git sauf les
+  `.example`.
+
+### Absent
+
+- **Aucune authentification ni autorisation.** Les deux endpoints exposés sont publics. Rien
+  n'est encore décidé sur ce point.
+- Pas de TLS, pas de limitation de débit, pas de journalisation des accès, pas de rotation des
+  secrets.
+- Aucune analyse de dépendances ni de conteneur, faute de CI.
+
+## Décisions structurantes
+
+Elles vivent dans `../adr/`, pas ici.
+
+| ADR | Objet |
+|---|---|
+| [0001](../adr/0001-postgresql-timescaledb.md) | PostgreSQL 17 avec l'extension TimescaleDB, et la frontière `db/` vs `alembic/` |

docs/architecture/10-infra.md

@@ -0,0 +1,132 @@
+# Infrastructure
+
+Deux topologies coexistent et ne servent pas la même chose. Ce document dit laquelle vaut dans
+quel contexte, quelles décisions sont arrêtées, et ce qui manque encore entre les deux.
+
+| Topologie | Sert à | Statut |
+|---|---|---|
+| Docker Compose | Développer et recetter sur le poste | `Fait` |
+| k3s single-node | Déployer sur le serveur on-premise | `En cours` |
+
+## Poste de développement
+
+Statut : `Fait`. Défini par `docker-compose.yml`, projet `enervision`.
+
+```mermaid
+flowchart TB
+  subgraph poste["Poste de développement"]
+    ng["ng serve<br/>:4200"]
+    api["uvicorn --reload<br/>:8000"]
+  end
+
+  subgraph compose["docker compose"]
+    back["service backend<br/>image construite depuis apps/backend"]
+    db[("service db<br/>timescale/timescaledb-ha:pg17")]
+  end
+
+  ng -.->|"proxy /api"| api
+  api -->|"hôte :5433 vers conteneur :5432"| db
+  back -->|"réseau interne, db:5432"| db
+```
+
+| Service | Image | Points notables |
+|---|---|---|
+| `db` | `timescale/timescaledb-ha:pg17` | Publié sur **5433** côté hôte, 5432 souvent déjà pris. `healthcheck` `pg_isready`, 12 tentatives, `start_period` 40s |
+| `backend` | Construite depuis `apps/backend` | `depends_on: db, condition: service_healthy`. **N'embarque pas le source** : toute modification impose `docker compose up -d --build backend` |
+
+**La boucle de développement n'utilise pas le service `backend`.** `make db-up` puis `make dev` :
+seule la base tourne en conteneur, l'API tourne sur le poste avec le rechargement à chaud. Le
+service `backend` sert la stack complète et la recette. Les deux occupent le port 8000, ils ne se
+lancent donc pas ensemble.
+
+Deux pièges sont documentés en tête du `docker-compose.yml`, ils ne se devinent pas :
+
+- `PGDATA` vaut `/home/postgres/pgdata/data` pour l'image `-ha`, et non le chemin habituel de
+  l'image `postgres`. Monté ailleurs, le volume ne retient rien, sans le moindre message.
+- `db/init` est monté **fichier par fichier**. Monter le dossier masquerait les scripts d'init de
+  l'image, dont `timescaledb-tune`. Ajouter un fichier dans `db/init/` impose donc une ligne dans
+  le compose. Voir [`db/README.md`](../../db/README.md).
+
+## Cible de déploiement
+
+Statut : `En cours`. Le module `infra/terraform/modules/k3s/` installe le cluster. Il n'a jamais
+été appliqué.
+
+```mermaid
+flowchart LR
+  poste["Poste<br/>terraform apply"]
+  kube["kubeconfig local"]
+
+  subgraph serveur["Serveur on-premise"]
+    k3s["k3s server single-node<br/>Traefik désactivé"]
+    charges["Charges de travail<br/>aucune déclarée"]
+  end
+
+  poste -->|"SSH, get.k3s.io"| k3s
+  k3s -->|"cat /etc/rancher/k3s/k3s.yaml"| kube
+  k3s -.-> charges
+```
+
+### Ce que le Terraform fait
+
+```mermaid
+sequenceDiagram
+  participant TF as terraform apply
+  participant SRV as Serveur on-premise
+  participant L as Poste local
+
+  TF->>SRV: SSH, curl get.k3s.io puis install server
+  TF->>SRV: attend /etc/rancher/k3s/k3s.yaml
+  TF->>SRV: ssh cat k3s.yaml
+  SRV-->>L: kubeconfig, 127.0.0.1 réécrit en ssh_host
+```
+
+### Ce que le Terraform ne fait pas
+
+Il déclare le provider `null` et **lui seul** : ni `kubernetes`, ni `helm`. Aucun namespace,
+aucun déploiement, aucun service, aucun ingress. À l'issue d'un `apply`, on dispose d'un cluster
+vide et d'un kubeconfig, rien de plus.
+
+## Décisions figées
+
+Ces arbitrages sont pris. Ils ne vivaient jusqu'ici que dans des commentaires de code et des
+`description` de variables, c'est-à-dire qu'ils ne survivaient pas au premier remaniement.
+
+| Décision | Raison | Où elle est appliquée |
+|---|---|---|
+| k3s single-node plutôt que Kubernetes complet | Une seule machine on-premise, pas de plan de contrôle à répartir | `modules/k3s/main.tf` |
+| `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` |
+| `.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/` |
+
+## Ports et noms
+
+| Quoi | Valeur | Remarque |
+|---|---|---|
+| PostgreSQL, côté hôte | `5433` | Redirigé vers 5432 dans le conteneur. 5432 est souvent déjà pris |
+| PostgreSQL, côté réseau Compose | `db:5432` | Nom de service, utilisé par `DATABASE_URL` du service `backend` |
+| API | `8000` | Identique en conteneur et hors conteneur |
+| Frontend, `ng serve` | `4200` | Valeur par défaut d'`APP_CORS_ORIGINS`. Le compose n'a aucun service frontend |
+| SSH du serveur | `22` par défaut | `ssh_port`, redéfinissable |
+| Base applicative | `enervision` | Variable `POSTGRES_DB` |
+| Base de test | `enervision_test` | Créée par `db/init/110-test-database.sql`, nom attendu en dur par `apps/backend/tests/conftest.py` |
+
+## Le trou entre les deux topologies
+
+Rien ne relie aujourd'hui ce qui est construit par Compose et ce qui tournerait sur k3s. Compose
+construit une image backend localement ; k3s ne saurait pas où la trouver. C'est la première
+question à trancher, avant toute ressource Kubernetes.
+
+## Questions ouvertes
+
+- **Quel ingress** remplace Traefik, et qui termine le TLS.
+- **Quel registre d'images**, et comment il est alimenté sans CI.
+- **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`.

docs/architecture/20-backend.md

@@ -0,0 +1,163 @@
+# Backend
+
+API FastAPI, Python 3.14, SQLAlchemy asynchrone sur `asyncpg`. Source dans `apps/backend`.
+
+## Couches
+
+La doctrine est posée dans [`apps/backend/README.md`](../../apps/backend/README.md) et
+[`TESTING.md`](../../apps/backend/TESTING.md) : `endpoints` appelle `services`, qui appelle
+`repositories`, qui seuls touchent les `models`. Le sens de dépendance ne s'inverse jamais.
+
+Dans les faits, trois de ces couches sont des dossiers vides.
+
+```mermaid
+flowchart TB
+  ep["endpoints<br/>2 routes"]
+  sc["schemas<br/>2 modèles Pydantic"]
+  sv["services<br/>vide"]
+  rp["repositories<br/>vide"]
+  md["models<br/>vide"]
+  db[("PostgreSQL")]
+
+  ep --> sc
+  ep -.-> sv
+  sv -.-> rp
+  rp -.-> md
+  ep -->|"SQL brut, état actuel"| db
+  rp -.-> db
+```
+
+Le trait plein de `endpoints` vers la base n'est pas une erreur de dessin : `/health/ready`
+exécute aujourd'hui son `SELECT` directement, sans repository. C'est acceptable pour une sonde
+d'infrastructure, qui vérifie la base elle-même et non une donnée métier. Ce raccourci ne doit
+pas servir de modèle au premier endpoint métier.
+
+`app/models/__init__.py` ne contient qu'un avertissement, qui mérite d'être connu avant la
+première migration : tout modèle absent de ce module reste invisible d'un
+`alembic revision --autogenerate`, qui produirait alors un `drop` de sa table.
+
+## Démarrage
+
+Point d'entrée : **une factory**, `uvicorn app.main:create_app --factory`. Aucune configuration
+n'est lue à l'import du module, ce qui rend l'application testable et les migrations
+indépendantes de l'environnement d'exécution.
+
+```mermaid
+sequenceDiagram
+  participant U as uvicorn --factory
+  participant F as create_app
+  participant S as get_settings
+  participant A as FastAPI
+
+  U->>F: create_app()
+  F->>S: Settings depuis .env et variables APP_*
+  S-->>F: resolved
+  F->>F: configure_logging(resolved)
+  F->>A: FastAPI, docs fermés si prod
+  F->>A: CORSMiddleware, seulement si allowed_origins
+  F->>A: Instrumentator, expose /metrics
+  F->>A: include_router, préfixe /api/v1
+  A-->>U: application
+```
+
+**Le `lifespan` n'ouvre aucune connexion.** Au démarrage il journalise le nom, la version et
+l'environnement ; à l'arrêt il libère l'engine. L'engine lui-même est construit paresseusement au
+premier appel de `get_engine()`, mis en cache par `lru_cache`. Conséquence directe : une API qui
+démarre ne prouve rien sur la base, la première connexion réelle a lieu au premier
+`GET /api/v1/health/ready`. C'est ce qui rend cette sonde indispensable.
+
+## Configuration
+
+`Settings` est un `BaseSettings` Pydantic, lu depuis `.env` avec le préfixe `APP_`.
+
+| Variable | Défaut | Rôle |
+|---|---|---|
+| `APP_SECRET_KEY` | **aucun** | Secret applicatif, `SecretStr` |
+| `DATABASE_URL` | **aucun** | Chaîne de connexion, `postgresql+asyncpg://...` |
+| `APP_ENV` | `local` | `local`, `dev`, `staging` ou `prod` |
+| `APP_DEBUG` | `false` | Active aussi l'écho SQL de l'engine |
+| `APP_LOG_LEVEL` | `INFO` | |
+| `APP_CORS_ORIGINS` | `""` | Liste séparée par des virgules. Vide, aucun middleware CORS n'est posé |
+| `APP_API_PREFIX` | `/api/v1` | |
+| `APP_DATABASE_POOL_SIZE` | `5` | |
+| `APP_DATABASE_MAX_OVERFLOW` | `10` | |
+
+Deux pièges :
+
+- **`DATABASE_URL` ne prend pas le préfixe `APP_`.** C'est le seul réglage dans ce cas, par
+  `validation_alias`, pour rester compatible avec la convention d'Alembic et des hébergeurs.
+- **`APP_SECRET_KEY` et `DATABASE_URL` n'ont pas de valeur par défaut.** L'application refuse de
+  démarrer si l'un manque. C'est délibéré : mieux vaut un échec au démarrage qu'un service qui
+  tourne avec un secret de démonstration.
+
+Deux fichiers d'environnement, deux usages : `.env` à la racine alimente `docker-compose.yml`,
+`apps/backend/.env` alimente l'API lancée sur le poste.
+
+## Routes exposées
+
+| Méthode | Chemin | Dans l'OpenAPI | Rôle |
+|---|---|---|---|
+| GET | `/api/v1/health/live` | oui | Le processus répond. Ne touche pas la base |
+| GET | `/api/v1/health/ready` | oui | La base répond **et** l'extension TimescaleDB est chargée |
+| GET | `/metrics` | non | Format Prometheus, exposé par l'instrumentator |
+| GET | `/docs`, `/redoc`, `/openapi.json` | non | Désactivés quand `APP_ENV=prod` |
+
+Aucune route métier n'existe à ce jour.
+
+### `/health/ready`
+
+Cette sonde porte une garde décrite dans l'[ADR 0001](../adr/0001-postgresql-timescaledb.md) : un
+bootstrap de base sauté ne se voit pas au démarrage de l'API, elle le rend visible.
+
+```mermaid
+sequenceDiagram
+  participant C as Client
+  participant R as readiness
+  participant E as get_engine
+  participant D as PostgreSQL
+
+  C->>R: GET /api/v1/health/ready
+  R->>E: session, engine créé au premier appel
+  R->>D: SELECT extversion FROM pg_extension WHERE extname = 'timescaledb'
+  alt base injoignable
+    D--xR: SQLAlchemyError ou OSError
+    R-->>C: 503 Base de donnees injoignable
+  else extension absente
+    D-->>R: NULL
+    R-->>C: 503 Extension TimescaleDB absente
+  else
+    D-->>R: version de l'extension
+    R-->>C: 200 status ready
+  end
+```
+
+## Sécurité
+
+Voir la vue consolidée dans [00-vue-ensemble.md](00-vue-ensemble.md). Côté backend :
+
+- **Aucune authentification, aucune autorisation.** Les deux routes sont publiques. Le premier
+  endpoint métier imposera de trancher ce point.
+- Le CORS n'autorise que les origines listées, et n'existe pas si la liste est vide.
+- `/docs`, `/redoc` et `/openapi.json` disparaissent en production.
+- Le conteneur tourne en utilisateur non-root, avec un `HEALTHCHECK` sur `/api/v1/health/live`.
+- Ni limitation de débit, ni journalisation des accès, ni en-têtes de sécurité.
+
+## Observabilité
+
+- Journalisation par `dictConfig` : format console en développement, JSON dès `APP_ENV=prod`.
+  `sqlalchemy.engine` est forcé à `WARNING` pour ne pas noyer les journaux.
+- `/metrics` au format Prometheus. **Aucun collecteur ne le lit** : `monitoring/` est vide.
+
+## Tests
+
+Conventions, gabarits et arborescence : [`apps/backend/TESTING.md`](../../apps/backend/TESTING.md).
+Deux points structurants y sont fixés : les doubles passent par `app.dependency_overrides` et
+jamais par `unittest.mock`, et les tests qui touchent la vraie base portent le marqueur
+`integration`, exclu par défaut.
+
+## Questions ouvertes
+
+- **Authentification et autorisation** : quel mécanisme, quelle granularité.
+- **Pagination et fenêtrage** des lectures de séries temporelles, qui conditionnent la forme des
+  endpoints métier.
+- **Politique de versionnement de l'API** au-delà du préfixe `/api/v1`.

docs/architecture/30-frontend.md

@@ -0,0 +1,114 @@
+# Frontend
+
+Application Angular 22, 100 % standalone, testée avec Vitest. Source dans `apps/frontend`.
+
+## État actuel
+
+Statut : `En cours`. Le projet est un `ng new` intact. Le tableau de la
+[vue d'ensemble](00-vue-ensemble.md) le classe désormais correctement, le `README.md` racine le
+disait encore « à initialiser » alors que le squelette existe depuis `49f4697`.
+
+Ce qui est en place :
+
+- Bootstrap par `bootstrapApplication(App, appConfig)`, **aucun `NgModule`** dans le dépôt.
+- `app.config.ts` fournit `provideBrowserGlobalErrorListeners()` et `provideRouter(routes)`.
+- Vitest via le builder `@angular/build:unit-test`, couverture activée, un fichier de test.
+- Prettier configuré, parser `angular` pour les gabarits HTML.
+
+Ce qui n'existe pas encore :
+
+- `routes` est un tableau vide. Aucune page, aucune navigation.
+- **`provideHttpClient` n'est pas fourni** et `@angular/common/http` n'est importé nulle part :
+  l'application n'appelle aucune API.
+- `app.html` est la page d'accueil Angular par défaut, commentaires de remplacement compris.
+- Aucune bibliothèque de graphiques, aucun kit d'interface, aucune gestion d'état.
+- Aucun lint : ESLint n'est pas installé.
+
+## Arborescence cible
+
+Statut : `Cible`. Elle n'est pas inventée ici : [`TESTING.md`](../../apps/frontend/TESTING.md) la
+prescrit déjà dans ses gabarits de tests.
+
+```mermaid
+flowchart TB
+  subgraph src["src/app"]
+    core["core/<br/>services, guards, interceptors"]
+    features["features/<br/>un dossier par domaine"]
+    shared["shared/<br/>composants réutilisables"]
+  end
+
+  features -.-> core
+  features -.-> shared
+  core -.-> env["environments/<br/>apiUrl"]
+```
+
+Un service HTTP par domaine dans `core/services`, les composants de page dans `features`, et rien
+d'autre que du réutilisable dans `shared`. Les composants n'appellent jamais `HttpClient`
+directement : ils passent par un service, ce qui rend le double de test trivial.
+
+## Flux HTTP
+
+Statut : `Cible`. Le chemin est câblé, rien ne l'emprunte encore.
+
+```mermaid
+sequenceDiagram
+  participant C as Composant
+  participant S as Service Angular
+  participant P as ng serve, proxy
+  participant A as FastAPI
+
+  C->>S: appel de méthode
+  S->>P: GET /api/v1/...
+  P->>A: http://localhost:8000/api/v1/...
+  A-->>S: JSON
+  S-->>C: modèle typé
+```
+
+En développement, `proxy.conf.json` redirige tout `/api` vers `http://localhost:8000`. C'est ce
+qui évite le CORS sur le poste, et c'est pourquoi `environment.development.ts` se contente d'un
+`apiUrl` relatif, `/api/v1`.
+
+En production, il n'y a pas de proxy : `environment.ts` porte une URL absolue. Angular substitue
+le fichier via `fileReplacements`, et la configuration `production` est celle par défaut.
+
+**Dette connue.** `src/environments/environment.ts`, qui est la configuration de production,
+pointe `http://localhost:8000/api/v1` en dur. La valeur est celle du poste de développement :
+telle quelle, un build de production ne joindra jamais l'API. À corriger avant le premier
+déploiement, en même temps que sera tranchée la question de l'ingress dans
+[10-infra.md](10-infra.md).
+
+## Exécution
+
+| Commande | Effet |
+|---|---|
+| `npm ci` | Installe les dépendances. `node_modules/` n'est pas présent par défaut |
+| `npm start` | `ng serve` sur le port 4200, proxy actif |
+| `npm run build` | Build de production |
+| `npm run test` | Vitest en mode observateur |
+| `npm run test:ci` | Vitest en une passe |
+
+Le frontend **n'a pas de cible dans le `Makefile` racine** et **aucun service dans
+`docker-compose.yml`** : il se pilote uniquement par `npm`, depuis `apps/frontend`. Le port 4200
+n'apparaît dans le compose que comme valeur par défaut d'`APP_CORS_ORIGINS`, côté backend.
+
+Un `Dockerfile` frontend existe sur la branche `feat/pipeline-cd`, mais il est mono-étage et sans
+`CMD` : il construit sans rien servir. Le `README.md` de l'application demande un multi-étage
+avec un service statique, il reste à écrire.
+
+## Sécurité
+
+- Le frontend ne détient aucun secret : `environment.ts` ne porte qu'une URL.
+- L'authentification n'existe pas côté API, donc pas de garde ni d'intercepteur de jeton à ce
+  stade. `core/guards` et `core/interceptors` sont prévus pour cela.
+
+## Tests
+
+Conventions et gabarits : [`apps/frontend/TESTING.md`](../../apps/frontend/TESTING.md).
+
+## Questions ouvertes
+
+- **Quelle bibliothèque de graphiques** pour les séries temporelles, et si Grafana en couvre déjà
+  une partie du besoin.
+- **Gestion d'état** : signaux seuls, ou une bibliothèque dédiée.
+- **Comment `apiUrl` est injecté en production** : build par environnement, ou configuration lue
+  au démarrage.

docs/architecture/40-data.md

@@ -0,0 +1,186 @@
+# Données
+
+PostgreSQL 17 avec l'extension TimescaleDB. Le choix, ses alternatives et ses conséquences sont
+dans l'[ADR 0001](../adr/0001-postgresql-timescaledb.md), qui fait foi. Ce document décrit le
+système qui en découle.
+
+## Avertissement
+
+**Aucune table applicative n'existe à ce jour.** `Base.metadata` est vide, `app/models/` ne
+contient qu'un commentaire, l'unique révision Alembic ne crée aucune table, et aucune hypertable
+n'a été déclarée. Tout ce qui suit sous le statut `Cible` est une proposition de structure, pas un
+relevé du code. Le modèle sera arrêté au jalon J2.
+
+## Trois emplacements, trois rôles
+
+C'est la règle que l'ADR 0001 existe surtout pour fixer. La confondre coûte cher : un script placé
+au mauvais endroit ne s'exécute jamais, ou s'exécute deux fois.
+
+| Emplacement | Contenu | Quand ça s'exécute |
+|---|---|---|
+| `db/init/` | Extensions, bases annexes | **Une seule fois**, à la première initialisation du conteneur, quand `PGDATA` est vide. Ne rejoue jamais |
+| `db/migrations/` | SQL versionné qui ne découle pas du schéma applicatif : rétention, compression | À la main, aujourd'hui vide |
+| `apps/backend/alembic/` | Le schéma exposé par l'API, et lui seul | `alembic upgrade head`, c'est `Base.metadata` qui fait foi |
+
+Une hypertable relève des deux derniers : **Alembic crée la table, et le `create_hypertable()`
+vit dans la même révision**. Les séparer rendrait le schéma irreproductible depuis un seul
+`alembic upgrade head`.
+
+Détail de `db/init/` et du piège de montage : [`db/README.md`](../../db/README.md).
+
+## Ce qui existe
+
+Statut : `Fait`.
+
+- `db/init/100-extensions.sql` crée l'extension `timescaledb`.
+- `db/init/110-test-database.sql` crée `enervision_test`, dont le nom est attendu en dur par
+  `apps/backend/tests/conftest.py`.
+- Une révision Alembic, `5353c0e4f094`, qui **ne crée aucune table**. Elle établit
+  `alembic_version` et refuse de s'appliquer si l'extension manque :
+
+```sql
+IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') THEN
+    RAISE EXCEPTION 'extension timescaledb absente, voir db/init et db/README.md';
+END IF;
+```
+
+Cette garde forme paire avec le 503 de `/api/v1/health/ready`. Un bootstrap sauté ne se voit pas
+au démarrage de l'API : ces deux gardes le rendent visible tôt, des deux côtés.
+
+## Cycle de vie d'une mesure
+
+Statut : `Cible`. Aucun de ces maillons n'existe.
+
+```mermaid
+flowchart LR
+  src["Source de mesures"] -.-> ing["Ingestion Airflow"]
+  ing -.-> hy[("Hypertable mesure")]
+  hy -.-> agg[("Agrégat continu")]
+  hy -.-> comp["Compression"]
+  hy -.-> ret["Rétention"]
+  agg -.-> api["API FastAPI"]
+  agg -.-> graf["Grafana"]
+```
+
+Les lectures de l'API et de Grafana visent l'agrégat continu, pas la table brute : c'est tout
+l'intérêt de TimescaleDB, et cela doit rester vrai quand les volumes augmenteront.
+
+## Modèle
+
+Statut : `Cible`. Les entités ci-dessous sont des **candidates**, à valider en J2. Elles
+s'appuient sur les gabarits de [`apps/backend/TESTING.md`](../../apps/backend/TESTING.md), qui
+évoquent déjà un modèle `Site`, un `SiteRepository` et un `ConsumptionService` exposant un
+`total_kwh(site_id)`.
+
+```mermaid
+erDiagram
+  SITE ||--o{ POINT_DE_MESURE : porte
+  POINT_DE_MESURE ||--o{ MESURE : produit
+
+  SITE {
+    int id PK
+    string nom
+  }
+  POINT_DE_MESURE {
+    int id PK
+    int site_id FK
+    string libelle
+    string unite
+  }
+  MESURE {
+    timestamptz horodatage PK
+    int point_id PK
+    double valeur
+  }
+```
+
+`MESURE` est la table destinée à devenir une hypertable, partitionnée sur `horodatage`. Sa clé
+primaire doit inclure la colonne de temps : TimescaleDB l'exige, une clé sur le seul identifiant
+de point serait refusée.
+
+## Gabarit de révision créant une hypertable
+
+Conforme à la règle de l'ADR 0001 : table et hypertable dans la même révision.
+
+```python
+def upgrade() -> None:
+    op.create_table(
+        "mesure",
+        sa.Column("horodatage", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("point_id", sa.Integer(), sa.ForeignKey("point_de_mesure.id"), nullable=False),
+        sa.Column("valeur", sa.Float(), nullable=False),
+        sa.PrimaryKeyConstraint("horodatage", "point_id"),
+    )
+    op.execute("SELECT create_hypertable('mesure', by_range('horodatage'))")
+
+
+def downgrade() -> None:
+    op.drop_table("mesure")
+```
+
+`drop_table` suffit au retour arrière : supprimer la table supprime l'hypertable et ses partitions.
+
+## Conventions
+
+- **Noms au singulier**, en minuscules, sans préfixe de table.
+- **Toute colonne de temps en `timestamptz`.** Jamais de `timestamp` nu : une mesure sans fuseau
+  devient ininterprétable dès le premier changement d'heure.
+- **La colonne de partitionnement s'appelle `horodatage`** et entre dans la clé primaire.
+- **Les politiques de rétention et de compression** vont dans `db/migrations/`, pas dans Alembic :
+  elles ne découlent pas du schéma applicatif.
+- **Tout modèle doit être importé dans `app/models/__init__.py`**, sans quoi
+  `alembic revision --autogenerate` ne le voit pas et génère un `drop` de sa table.
+
+## Questions ouvertes
+
+Elles relèvent du jalon J2, « valider le périmètre retenu », et bloquent le modèle définitif.
+
+- **Quelles sources de mesures**, et selon quel protocole elles sont collectées.
+- **Quelle granularité** à l'ingestion : la seconde, la minute, le quart d'heure.
+- **Quels agrégats continus**, et sur quelles fenêtres.
+- **Quelle profondeur de rétention** en données brutes, et à partir de quand on compresse.
+- **Quelles unités** sont manipulées, et si une même table les mélange.
+- **Multi-tenant ou non** : un site appartient-il à un client, et faut-il cloisonner les lectures.
+
+## Modélisation détaillée des données
+
+Cette modélisation prend en compte les fichiers CSV historiques,
+leurs métadonnées JSON et les données de l’API Mock.
+Elle comprend six tables, depuis le stockage des mesures
+jusqu’aux recommandations proposées à l’utilisateur.
+
+### Schéma de données
+
+Le diagramme ci-dessous présente les tables et leurs relations.
+Il décrit une structure de conception ; les migrations correspondantes
+restent à implémenter.
+
+![Schéma de données EnerVision](images/EnerVision-schema-donnees.png)
+
+*Figure — Modélisation des données EnerVision.*
+
+### Description des tables
+
+Chaque table remplit un rôle précis dans le traitement et l’exploitation
+des données.
+
+| Table | Rôle | Origine des informations |
+|---|---|---|
+| `datasets` | Identifier les jeux historiques, retrouver leurs fichiers et conserver leurs métadonnées | Archive CSV/JSON et informations ajoutées lors de l’import |
+| `sites` | Regrouper les informations des sites : identifiant, nom, type et caractéristiques disponibles | CSV et API Mock `/api/v1/sites` |
+| `readings` | Stocker les mesures, leur provenance, leur qualité et les éventuelles valeurs imputées | CSV et API Mock `/current` et `/readings` |
+| `predictions` | Conserver les prévisions, leur période cible et la référence du modèle utilisé | Traitements ML d’EnerVision |
+| `alerts` | Enregistrer les alertes, leur type, leur gravité et leur message | API Mock `/alerts` et détections EnerVision |
+| `recommendations` | Proposer des actions et expliquer la règle qui les motive | Règles métier d’EnerVision |
+
+Les anomalies historiques décrites dans les JSON sont conservées
+dans `datasets.metadata`. Elles servent à l’analyse des données
+et ne sont pas considérées comme des alertes actuelles.
+
+### Relations entre les tables
+
+- Un site possède plusieurs mesures, prévisions et alertes.
+- Un jeu de données historique contient plusieurs mesures CSV.
+- Les mesures API ne sont pas rattachées à un dataset historique.
+- Une alerte peut être associée à une prévision du même site.
+- Une alerte peut donner lieu à plusieurs recommandations.

docs/architecture/README.md

@@ -0,0 +1,58 @@
+# Architecture
+
+Les vues d'architecture d'EnerVision. Un ADR (`../adr/`) **décide** et date une décision
+structurante ; une vue d'architecture **décrit** le système qui en résulte. Quand les deux se
+contredisent, c'est l'ADR qui fait foi et la vue qui est en retard.
+
+## Les documents
+
+| Document | Ce qu'il couvre |
+|---|---|
+| [00-vue-ensemble.md](00-vue-ensemble.md) | Jalons du projet, contexte, conteneurs, sécurité, flux bout en bout |
+| [10-infra.md](10-infra.md) | Poste de développement, cible k3s, décisions figées, ports et noms |
+| [20-backend.md](20-backend.md) | Couches FastAPI, séquence de démarrage, routes, configuration |
+| [30-frontend.md](30-frontend.md) | Angular, arborescence cible, flux HTTP |
+| [40-data.md](40-data.md) | Frontières `db/` et `alembic/`, cycle de vie d'une mesure, modèle |
+
+L'observabilité, la sécurité et la CI/CD n'ont pas de document propre : ce sont des sections des
+cinq ci-dessus, tant que `monitoring/`, `.github/workflows/` et `etl/airflow/` ne contiennent que
+des `.gitkeep`. Elles en sortiront le jour où elles auront de la matière. Un fichier vide de plus
+n'aide personne.
+
+## Conventions
+
+### Mermaid, et rien d'autre
+
+GitHub rend Mermaid nativement dans les fichiers `.md`. Un diagramme est donc du texte : il se
+relit en revue, il se diffe, et il ne se périme pas dans un binaire que plus personne ne sait
+rouvrir six mois plus tard. Aucune image exportée, aucun `.drawio`, aucun `.png`.
+
+### Chaque section porte son statut
+
+Une large part de la stack n'est pas écrite. Une vue qui mélange l'existant et la cible sans le
+dire devient fausse sans prévenir.
+
+| Statut | Sens |
+|---|---|
+| `Fait` | Le code existe et tourne |
+| `En cours` | Commencé, incomplet |
+| `Cible` | Décidé, pas encore écrit |
+
+### Légende des diagrammes
+
+Trait plein pour ce qui tourne, trait pointillé pour ce qui est cible.
+
+```mermaid
+flowchart LR
+  A[Composant en place] --> B[Composant en place]
+  B -.-> C[Composant cible]
+```
+
+## Maintenance
+
+**Toute PR qui change un composant met à jour sa vue dans la même PR.** Une vue qu'on promet de
+mettre à jour plus tard ne l'est jamais.
+
+Une documentation fausse coûte plus cher qu'une documentation absente : on la lit, on la croit, et
+on construit dessus. Si une section ne peut plus être tenue à jour, elle est supprimée plutôt que
+laissée à dériver.

infra/README.md

@@ -1,6 +1,22 @@
 # Infrastructure
 
-Provisionnement Terraform de la machine on-premise. Non initialise, voir le ticket dedie.
+Provisionnement Terraform de la machine on-premise (serveur physique, accessible en SSH).
 
 - `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.
+  - `dev` : instancie le module `k3s` sur le serveur de l'ecole.
+  - `prod` : non initialise, voir le ticket dedie.
+
+## Usage (environments/dev)
+
+```bash
+cd infra/terraform/environments/dev
+cp terraform.tfvars.example terraform.tfvars   # renseigner ssh_host / ssh_private_key_path
+terraform init
+terraform apply
+```
+
+Le kubeconfig est ecrit localement au chemin defini par `kubeconfig_output_path`
+(par defaut `./kubeconfig`, ignore par git).

infra/terraform/environments/dev/main.tf

@@ -0,0 +1,11 @@
+module "k3s" {
+  source = "../../modules/k3s"
+
+  ssh_host               = var.ssh_host
+  ssh_port               = var.ssh_port
+  ssh_user               = var.ssh_user
+  ssh_private_key_path   = var.ssh_private_key_path
+  k3s_version            = var.k3s_version
+  k3s_disable_components = var.k3s_disable_components
+  kubeconfig_output_path = var.kubeconfig_output_path
+}

infra/terraform/environments/dev/outputs.tf

@@ -0,0 +1,9 @@
+output "kubeconfig_path" {
+  description = "Chemin local du kubeconfig recupere apres installation."
+  value       = module.k3s.kubeconfig_path
+}
+
+output "node_host" {
+  description = "Adresse du serveur sur lequel k3s est installe."
+  value       = module.k3s.node_host
+}

infra/terraform/environments/dev/terraform.tfvars.example

@@ -0,0 +1,8 @@
+ssh_host                = "10.0.0.10"
+ssh_port                = 22
+ssh_user                = "root"
+ssh_private_key_path    = "~/.ssh/id_ed25519_enervision"
+# Epingler une version reelle avant apply : https://github.com/k3s-io/k3s/releases
+k3s_version             = "v1.31.5+k3s1"
+k3s_disable_components  = ["traefik"]
+kubeconfig_output_path  = "./kubeconfig"

infra/terraform/environments/dev/variables.tf

@@ -0,0 +1,39 @@
+variable "ssh_host" {
+  type        = string
+  description = "Adresse IP ou nom d'hote du serveur on-premise de l'ecole."
+}
+
+variable "ssh_port" {
+  type        = number
+  description = "Port SSH du serveur."
+  default     = 22
+}
+
+variable "ssh_user" {
+  type        = string
+  description = "Utilisateur SSH utilise pour l'installation."
+  default     = "root"
+}
+
+variable "ssh_private_key_path" {
+  type        = string
+  description = "Chemin local vers la cle privee SSH."
+  sensitive   = true
+}
+
+variable "k3s_version" {
+  type        = string
+  description = "Version k3s a epingler pour un deploiement reproductible (ex: v1.31.5+k3s1). Voir https://github.com/k3s-io/k3s/releases."
+}
+
+variable "k3s_disable_components" {
+  type        = list(string)
+  description = "Composants embarques k3s a desactiver."
+  default     = ["traefik"]
+}
+
+variable "kubeconfig_output_path" {
+  type        = string
+  description = "Chemin local ou ecrire le kubeconfig recupere apres installation."
+  default     = "./kubeconfig"
+}

infra/terraform/environments/dev/versions.tf

@@ -0,0 +1,14 @@
+terraform {
+  required_version = ">= 1.7"
+
+  required_providers {
+    null = {
+      source  = "hashicorp/null"
+      version = "~> 3.2"
+    }
+  }
+
+  backend "local" {
+    path = "terraform.tfstate"
+  }
+}

infra/terraform/modules/k3s/main.tf

@@ -0,0 +1,55 @@
+locals {
+  sudo_prefix    = var.ssh_user == "root" ? "" : "sudo "
+  install_env    = "INSTALL_K3S_VERSION=${var.k3s_version} "
+  disable_flags  = join(" ", [for c in var.k3s_disable_components : "--disable=${c}"])
+  kubeconfig_cmd = "${local.sudo_prefix}cat /etc/rancher/k3s/k3s.yaml"
+}
+
+resource "null_resource" "k3s_install" {
+  triggers = {
+    ssh_host            = var.ssh_host
+    k3s_version         = var.k3s_version
+    disable_components  = join(",", var.k3s_disable_components)
+  }
+
+  connection {
+    type        = "ssh"
+    host        = var.ssh_host
+    port        = var.ssh_port
+    user        = var.ssh_user
+    private_key = file(var.ssh_private_key_path)
+  }
+
+  provisioner "remote-exec" {
+    inline = [
+      "${local.sudo_prefix}sh -c 'curl -sfL https://get.k3s.io | ${local.install_env}sh -s - server ${local.disable_flags}'",
+      "until ${local.sudo_prefix}test -f /etc/rancher/k3s/k3s.yaml; do sleep 2; done",
+    ]
+  }
+
+  # Le kubeconfig est lu via sudo (fetch_kubeconfig), pas besoin de --write-kubeconfig-mode :
+  # il reste 600/root par defaut, ce qui evite d'exposer les droits cluster-admin a tout utilisateur local.
+  provisioner "remote-exec" {
+    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'",
+    ]
+  }
+}
+
+resource "null_resource" "fetch_kubeconfig" {
+  depends_on = [null_resource.k3s_install]
+
+  triggers = {
+    install_id = null_resource.k3s_install.id
+  }
+
+  provisioner "local-exec" {
+    interpreter = ["bash", "-c"]
+    command     = <<-EOT
+      ssh -i "${var.ssh_private_key_path}" -p ${var.ssh_port} -o StrictHostKeyChecking=accept-new ${var.ssh_user}@${var.ssh_host} '${local.kubeconfig_cmd}' \
+        | sed 's/127.0.0.1/${var.ssh_host}/' > "${var.kubeconfig_output_path}"
+    EOT
+  }
+}

infra/terraform/modules/k3s/outputs.tf

@@ -0,0 +1,9 @@
+output "kubeconfig_path" {
+  description = "Chemin local du kubeconfig recupere apres installation."
+  value       = var.kubeconfig_output_path
+}
+
+output "node_host" {
+  description = "Adresse de la machine sur laquelle k3s est installe."
+  value       = var.ssh_host
+}

infra/terraform/modules/k3s/variables.tf

@@ -0,0 +1,43 @@
+variable "ssh_host" {
+  type        = string
+  description = "Adresse IP ou nom d'hote de la machine on-premise cible."
+}
+
+variable "ssh_port" {
+  type        = number
+  description = "Port SSH de la machine cible."
+  default     = 22
+}
+
+variable "ssh_user" {
+  type        = string
+  description = "Utilisateur SSH. Si different de root, les commandes d'installation sont prefixees par sudo."
+  default     = "root"
+}
+
+variable "ssh_private_key_path" {
+  type        = string
+  description = "Chemin local vers la cle privee SSH utilisee pour se connecter a la machine cible."
+  sensitive   = true
+}
+
+variable "k3s_version" {
+  type        = string
+  description = "Version k3s a epingler pour un deploiement reproductible (ex: v1.31.5+k3s1). Voir https://github.com/k3s-io/k3s/releases."
+
+  validation {
+    condition     = length(trimspace(var.k3s_version)) > 0
+    error_message = "k3s_version doit etre epinglee explicitement, pas de valeur vide (sinon k3s.io installerait la derniere version a chaque run, non reproductible)."
+  }
+}
+
+variable "k3s_disable_components" {
+  type        = list(string)
+  description = "Composants embarques a desactiver a l'installation (ex: traefik, servicelb)."
+  default     = ["traefik"]
+}
+
+variable "kubeconfig_output_path" {
+  type        = string
+  description = "Chemin local ou ecrire le kubeconfig recupere apres installation."
+}

infra/terraform/modules/k3s/versions.tf

@@ -0,0 +1,10 @@
+terraform {
+  required_version = ">= 1.7"
+
+  required_providers {
+    null = {
+      source  = "hashicorp/null"
+      version = "~> 3.2"
+    }
+  }
+}

test.txt

@@ -1 +0,0 @@
-coucou