# Story 6.2: Docker Compose Production

Status: done

<!-- Note: Validation is optional. Run validate-create-story for quality check before dev-story. -->

## Story

As a **DevOps**,
I want **a production Docker Compose setup**,
so that **I can deploy to VPS**.

## Acceptance Criteria

1. **Given** docker-compose.yml exists  
   **When** I deploy to VPS  
   **Then** all services run in production mode  
   **And** containers restart automatically on failure  
   **And** health checks are configured  
   **And** secrets are loaded from environment  

## Tasks / Subtasks

- [x] Task 1 (AC: #1) — Fichier docker-compose.yml dédié production
  - [x] 1.1 Définir les services backend, frontend, postgres, redis (sans mounts de code, images buildées).
  - [x] 1.2 Documenter la commande de déploiement : `docker compose up -d` (ou `docker-compose -f docker-compose.yml up -d`).
- [x] Task 2 (AC: #1) — Mode production et redémarrage
  - [x] 2.1 Backend et frontend exécutés sans --reload / sans hot reload ; build d’images pour la prod.
  - [x] 2.2 Politique restart: `restart: unless-stopped` (ou `always`) pour tous les services applicatifs et dépendances.
- [x] Task 3 (AC: #1) — Health checks
  - [x] 3.1 Healthchecks configurés pour backend (ex. GET /health), postgres, redis.
  - [x] 3.2 depends_on avec condition: service_healthy pour les services qui dépendent de postgres/redis/backend.
- [x] Task 4 (AC: #1) — Secrets depuis l’environnement
  - [x] 4.1 Aucun secret en dur ; usage de env_file et/ou variables d’environnement (NFR10).
  - [x] 4.2 Documenter dans .env.example (section Production) les variables requises pour la prod (DATABASE_URL, REDIS_URL, SECRET_KEY, API keys, etc.).

## Dev Notes

- **Contexte** : La story 6-1 a livré `docker-compose.dev.yml` (dev avec hot reload, volumes de code, PostgreSQL, Redis). La story 6-2 vise un **fichier prod** `docker-compose.yml` (ou équivalent) pour déploiement VPS : pas de mount de code, images buildées, restart policy, healthchecks, secrets via env.
- **Architecture** : [Source: _bmad-output/planning-artifacts/architecture.md] — Infrastructure & Deployment : Docker Compose (Backend + Frontend + Redis + DB), VPS, reverse proxy (Traefik/Nginx) pour HTTPS. Health check format documenté (status, database, redis, providers).
- **NFR10** : Secrets et configuration via variables d’environnement uniquement.
- **Fichiers à toucher** : `docker-compose.yml` (prod), `.env.example` (section Production), éventuellement `docker/backend/Dockerfile` et `docker/frontend/Dockerfile` si un stage "prod" ou "production" est nécessaire.

### Project Structure Notes

- Racine : `office_translator/` avec `docker-compose.yml` (prod), `docker-compose.dev.yml` (dev). Rester cohérent avec l’arbre dans architecture.md.
- En prod : pas de volumes montant le code source ; build d’images et exécution des binaires (uvicorn sans --reload, frontend build npm run build + serve).

### References

- [Source: _bmad-output/planning-artifacts/architecture.md] — Infrastructure & Deployment, Development Workflow, Complete Project Directory Structure.
- [Source: _bmad-output/planning-artifacts/epics.md] — Epic 6, Story 6.2, AC BDD.
- [Source: _bmad-output/implementation-artifacts/6-1-docker-compose-development.md] — Patterns dev (services, healthchecks, env_file) à réutiliser en prod sans hot reload.

### Technical Requirements (Architecture Compliance)

- **Backend** : Python 3.11+, FastAPI, uvicorn **sans** --reload. Port 8000. Connexion PostgreSQL (asyncpg) et Redis via variables d’environnement. Image construite depuis docker/backend/Dockerfile (stage prod).
- **Frontend** : Node 20, Next.js 15, build `npm run build`, exécution en prod (ex. `npm run start` ou serveur statique). NEXT_PUBLIC_API_URL doit pointer vers l’URL du backend en prod (ex. https://api.domaine.fr).
- **PostgreSQL** : Image postgres:16-alpine. Healthcheck `pg_isready`. Volume persistant pour les données.
- **Redis** : Image redis:7-alpine. Healthcheck `redis-cli ping`. Volume persistant si besoin (persistance prod).
- **Réseau** : Même réseau Compose pour backend ↔ postgres, backend ↔ redis. Exposition des ports selon besoin (ex. 8000 backend, 3000 frontend ou derrière reverse proxy uniquement).
- **Secrets** : Aucun secret en dur ; env_file et/ou variables injectées par l’orchestrateur (NFR10).

### Architecture Compliance

- Alignement avec architecture.md : Docker Compose pour orchestration, VPS, reverse proxy (Traefik/Nginx) pour HTTPS — config reverse proxy hors scope de cette story (story 6.5).
- Health check format attendu (documenté dans architecture) : JSON avec status, database, redis, providers.
- Respect de la structure projet : backend/, frontend/, docker/, scripts/.

### Library / Framework Requirements

- Docker Compose (Compose Spec v2/v3) : utiliser la syntaxe supportée par le moteur cible (Docker Engine 20.10+, Compose V2 recommandé).
- Aucune librairie applicative supplémentaire ; stack inchangée (FastAPI, Next.js, PostgreSQL, Redis).

### File Structure Requirements

- `docker-compose.yml` à la racine du projet (prod). Ne pas écraser ou fusionner avec `docker-compose.dev.yml` ; garder deux fichiers distincts (dev vs prod).
- Fichiers Dockerfile : `docker/backend/Dockerfile`, `docker/frontend/Dockerfile` — utiliser un stage "prod" ou "production" pour build sans outils de dev si pertinent.
- `.env.example` : section « Production / VPS » listant toutes les variables requises (DATABASE_URL, REDIS_URL, SECRET_KEY, GOOGLE_API_KEY, DEEPL_API_KEY, OPENAI_API_KEY, OLLAMA_BASE_URL, etc.) sans valeurs réelles.

### Testing Requirements

- Vérifier que `docker compose up -d` (ou équivalent) démarre tous les services en mode prod sans erreur.
- Vérifier que les healthchecks passent (backend /health, postgres, redis).
- Vérifier qu’un arrêt brutal d’un conteneur déclenche bien un redémarrage (restart policy).
- Vérifier qu’aucun secret n’apparaît en clair dans les fichiers versionnés.

### Previous Story Intelligence (6-1 Docker Compose Development)

- **Fichiers créés/modifiés** : `docker-compose.dev.yml` (4 services : postgres, redis, backend, frontend), `.env.example` (section Docker Compose dev), `scripts/verify-dev-compose.sh`.
- **Patterns établis** : healthchecks avec `condition: service_healthy` pour depends_on ; env_file pour variables ; volumes dédiés pour données postgres/redis et pour éviter d’écraser venv/node_modules en dev.
- **Différence clé pour 6-2** : en prod, pas de volumes montant le code ; pas de `--reload` ni `npm run dev` ; images buildées une fois ; restart policy explicite ; mêmes services (backend, frontend, postgres, redis) mais configuration orientée stabilité et secrets externes.

### Git Intelligence Summary

- Derniers commits : correctifs sécurité (path traversal, validation UUID), revue de code, évolutions Docker/Kubernetes et PostgreSQL, améliorations production (sécurité, Redis sessions, retry). Pour 6-2 : s’appuyer sur l’infra Docker/PostgreSQL existante et ne pas introduire de régression sur la sécurité (pas de secrets en clair, bonnes pratiques de build).

### Latest Tech Information

- Docker Compose V2 (`docker compose`) est le standard ; privilégier la Compose Specification pour compatibilité. Pour production : utiliser des images multi-stage pour réduire la taille et éviter les outils de dev dans l’image finale.

### Project Context Reference

- Aucun fichier `project-context.md` trouvé à la racine ou dans docs/. Pour contexte métier et stack, s’appuyer sur architecture.md et epics.md.

## Dev Agent Record

### Agent Model Used

(dev-story workflow)

### Debug Log References

-

### Completion Notes List

- docker-compose.yml : en-tête mis à jour (usage `docker compose up -d`), backend/frontend avec `target: production` et `env_file: [.env]`, healthcheck Redis avec `start_period: 5s`. Restart policy et healthchecks déjà en place pour tous les services.
- .env.example : section « Production / VPS » ajoutée en tête listant les variables requises (POSTGRES_*, JWT_SECRET_KEY, ADMIN_*, DATABASE_URL, REDIS_URL, CORS_ORIGINS, NEXT_PUBLIC_API_URL, clés API optionnelles). Aucun secret en dur (NFR10).
- Validation : `docker compose config` non exécuté (Docker indisponible dans l’environnement). À vérifier manuellement : `docker compose up -d`, healthchecks, restart policy.

- Code review fixes : docker-compose.yml — POSTGRES_PASSWORD sans défaut (NFR10), JWT_SECRET_KEY dans environment ; .env.example — section Production précisée ; scripts/verify-prod-compose.sh ajouté.

### File List

- docker-compose.yml (modifié — usage doc, target production, env_file, redis healthcheck ; post-review : POSTGRES_PASSWORD sans défaut, JWT_SECRET_KEY)
- .env.example (modifié — section Production / VPS, précision variables sensibles)
- scripts/verify-prod-compose.sh (créé — validation YAML et services prod)
- _bmad-output/implementation-artifacts/6-2-docker-compose-production.md (modifié — statut, tâches, Dev Agent Record)
- _bmad-output/implementation-artifacts/sprint-status.yaml (modifié — 6-2 in-progress puis review)
