games_app/docs/DEPLOY-VPS.md
2026-07-25 22:48:54 +02:00

730 lines
22 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Guide de déploiement Prediqo sur VPS
Ce guide décrit comment lancer Prediqo sur un serveur Linux (VPS) **sans perturber** les autres applications (ports dédiés **9080** / **9443**).
**Démarrage sur base vierge (VPS + local) :** voir la [section 4](#4-démarrage-sur-base-de-données-vierge-vps-et-local).
---
## 1. Prérequis sur le VPS
| Outil | Vérification |
|-------|----------------|
| **Docker** | `docker --version` |
| **Docker Compose** | `docker compose version` |
| **Git** | `git --version` |
| **PostgreSQL** | installé sur l’hôte (port 5432) |
| **Node.js** | optionnel (uniquement pour `npm run …` à la racine) |
Si Node n’est pas installé, vous pouvez utiliser directement `docker compose` à la place des scripts `npm run`.
### Ouvrir les ports Prediqo (pare-feu)
```bash
sudo ufw allow 9080/tcp # HTTP (redirection)
sudo ufw allow 9443/tcp # HTTPS
sudo ufw reload
```
### DNS
Le domaine **`prediqo.redirectme.net`** doit pointer vers l’IP du VPS (enregistrement **A**).
---
## 2. Récupérer le projet
```bash
cd ~
git clone https://github.com/japhni/games-project.git games_app
cd games_app
```
*(Adaptez le chemin si vous avez déjà copié le projet.)*
---
## 3. Configurer l’environnement
**Fichier à utiliser sur le VPS : `.env` à la racine du projet** (`games_app/.env`).
```bash
cp .env.example .env
nano .env # ou vim
```
### Variables essentielles à personnaliser
| Variable | Description |
|----------|-------------|
| `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Compte PostgreSQL sur l’hôte |
| `JWT_SECRET` | Secret JWT (32+ caractères aléatoires) |
| `ENCRYPTION_KEY` | 64 caractères hex (32 octets AES-256) |
| `PLATFORM_MNEMONIC` | Phrase BIP39 24 mots (générer une fois, garder secrète) |
| `INITIAL_SETUP_TOKEN` | Jeton pour créer le 1er admin (`/setup`) |
| `APP_PUBLIC_URL` | `https://prediqo.redirectme.net:9443` |
| `VITE_API_BASE_URL` | même URL de base (sans `/api`) |
| `VITE_WS_URL` | `wss://prediqo.redirectme.net:9443/ws/v1/games/candle-predict` |
| `CERTBOT_EMAIL` | Email pour Let’s Encrypt |
| `CERTBOT_DOMAIN1` | `prediqo.redirectme.net` |
| `SMTP_*` / `EMAIL_FROM` | Envoi d’emails (vérification compte, reset mot de passe) |
### Configuration SMTP (Gmail)
L’erreur `535-5.7.8 Username and Password not accepted` signifie que **Gmail refuse le mot de passe SMTP**. Le mot de passe normal du compte Gmail **ne fonctionne pas** : il faut un **mot de passe d’application**.
1. Activer la **validation en 2 étapes** sur le compte Gmail expéditeur.
2. Créer un mot de passe d’application : [https://myaccount.google.com/apppasswords](https://myaccount.google.com/apppasswords) → application « Mail », appareil « Prediqo VPS ».
3. Copier les **16 caractères** (sans espaces) dans `.env` :
```env
EMAIL_TRANSPORT=smtp
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=votre-compte@gmail.com
SMTP_PASS=xxxxxxxxxxxxxxxx
EMAIL_FROM="Prediqo" <votre-compte@gmail.com>
APP_PUBLIC_URL=https://prediqo.redirectme.net:9443
RESET_PASSWORD_PATH=/reset-password
```
`SMTP_USER` doit être **le même compte Gmail** que celui qui a généré le mot de passe d’application.
**Tester la connexion SMTP (après `git pull`) :**
```bash
sudo npm run phase-b:verify-smtp
```
Puis redémarrer le backend :
```bash
sudo npm run phase-b:up
```
> **Ne pas committer `.env`** — il est ignoré par Git.
### Base de données PostgreSQL (sur l’hôte) — **obligatoire avant le 1er démarrage**
Créez la base si nécessaire :
```bash
sudo -u postgres psql -c "CREATE DATABASE crypto_wallet;"
```
Si votre utilisateur PostgreSQL n’est pas `postgres`, adaptez :
```bash
sudo -u postgres psql -c "CREATE USER votre_user WITH PASSWORD 'votre_mot_de_passe';"
sudo -u postgres psql -c "CREATE DATABASE crypto_wallet OWNER votre_user;"
```
Vérifiez la connexion :
```bash
psql -U postgres -h localhost -d crypto_wallet -c "SELECT 1;"
```
Les identifiants doivent correspondre à `POSTGRES_USER`, `POSTGRES_PASSWORD` et `POSTGRES_DB` dans `.env`.
**URL base de données pour Docker (important) :**
```env
POSTGRES_DB=games_platform_db
POSTGRES_USER=postgres
POSTGRES_PASSWORD=votre_mot_de_passe
# Les conteneurs ne peuvent PAS utiliser localhost — utiliser host.docker.internal :
DATABASE_URL=postgresql://postgres:votre_mot_de_passe@host.docker.internal:5432/games_platform_db
```
`psql` sur l’hôte utilise `localhost` ; les **conteneurs** utilisent `host.docker.internal`.
### PostgreSQL : autoriser les connexions depuis Docker (Linux)
Si `psql` fonctionne sur l’hôte mais le backend Docker redémarre en boucle (`password authentication failed` ou `ECONNREFUSED`), PostgreSQL refuse souvent les connexions venant du réseau Docker.
Éditez `pg_hba.conf` (ex. `/etc/postgresql/16/main/pg_hba.conf`) et ajoutez **avant** les règles « reject » :
```
host all all 172.16.0.0/12 scram-sha-256
```
Dans `postgresql.conf`, vérifiez :
```
listen_addresses = 'localhost'
```
(suffit en général avec `host.docker.internal` + port forwarding Docker)
Puis :
```bash
sudo systemctl reload postgresql
```
**Test depuis un conteneur :**
```bash
sudo docker compose run --rm --no-deps backend node -e "
const { Client } = require('pg');
const c = new Client({ connectionString: process.env.DATABASE_URL });
c.connect().then(() => { console.log('DB OK'); return c.end(); }).catch(e => { console.error(e.message); process.exit(1); });
"
```
Les conteneurs Docker se connectent via `host.docker.internal` (configuré dans `docker-compose.yml`). Au démarrage, le backend exécute les **migrations** automatiquement.
**Erreur typique si cette étape est oubliée :**
```
error: database "crypto_wallet" does not exist
```
→ le backend et nginx redémarrent en boucle, le port **9080** ne répond pas.
---
## 4. Démarrage sur base de données vierge (VPS et local)
Cette section regroupe les commandes à exécuter lorsque PostgreSQL est **vide** (base créée, mais **sans schéma**). L’ordre est toujours le même :
1. **Créer la base** PostgreSQL (voir section 3).
2. **Configurer** les secrets et `INITIAL_SETUP_TOKEN` dans le fichier d’environnement.
3. **Appliquer les migrations** (création des tables).
4. **Démarrer la stack** (API, frontend, Redis, workers…).
5. **Configurer la plateforme** via la page **`/setup`** (premier super administrateur).
> Les scripts `*:init` enchaînent automatiquement **migrations + démarrage** en une seule commande.
### Prérequis communs
| Étape | Détail |
|-------|--------|
| Base PostgreSQL | Base vide créée (`games_platform_db` ou `crypto_wallet` selon `.env`) |
| Jeton setup | `INITIAL_SETUP_TOKEN` — min. 16 caractères, **32+ aléatoires recommandés** |
| Fichier env | VPS → `.env` · Local Docker → `.env.docker` |
| Connexion Docker → Postgres | `DATABASE_URL` avec **`host.docker.internal`**, pas `localhost` |
Vérifier que l’API répond avant `/setup` :
```bash
curl -s http://127.0.0.1:9080/api/v1/setup/status
# attendu : {"needsSetup":true,"setupEnabled":true}
```
### Sur le VPS
À la racine du projet (`games_app/`) :
```bash
cp .env.example .env
# Éditer .env : PostgreSQL, secrets, INITIAL_SETUP_TOKEN, URLs publiques
```
**Premier déploiement (base vierge) — migrations + stack :**
```bash
# HTTP (test rapide)
npm run phase-b:init
# HTTPS (production — certificat DNS requis une fois avant)
npm run ssl:dns-init
npm run phase-b:init:https
```
Équivalents Docker directs (sans Node.js sur le VPS) :
```bash
# Migrations seules
docker compose run --rm --no-deps --build backend node dist/db/migrate.js
# Puis démarrage
docker compose --profile http up -d --build # HTTP
docker compose --profile https-dns up -d --build # HTTPS
```
**Démarrages suivants** (base déjà migrée, pas de changement de schéma) :
```bash
npm run phase-b:up # HTTP
npm run phase-b:up:https # HTTPS
```
**Configuration initiale (navigateur) :**
| Mode | URL setup |
|------|-----------|
| HTTP | `http://prediqo.redirectme.net:9080/setup` |
| HTTPS | `https://prediqo.redirectme.net:9443/setup` |
1. Saisir le **`INITIAL_SETUP_TOKEN`** (valeur de `.env` sur le serveur).
2. Créer le premier administrateur **ou** promouvoir un compte existant.
3. Un **code de parrainage racine** est généré automatiquement pour ce super admin ; les inscriptions sans code y seront rattachées.
4. Se connecter sur **`/login`**.
### En local — Docker (même stack que le VPS)
Fichier d’environnement dédié : **`.env.docker`** (non versionné).
```bash
cp .env.docker.example .env.docker
# Éditer .env.docker : POSTGRES_PASSWORD, JWT_SECRET, ENCRYPTION_KEY,
# PLATFORM_MNEMONIC, INITIAL_SETUP_TOKEN
# Garder NODE_ENV=development + Shasta (production + testnet = crash au boot).
# Créer la base vide sur PostgreSQL local, ex. games_platform_db
```
**Premier démarrage (base vierge) :**
```bash
npm run docker:local:init
```
Équivalent :
```bash
docker compose --env-file .env.docker run --rm --no-deps --build backend node dist/db/migrate.js
docker compose --env-file .env.docker --profile http up -d --build
```
**Configuration initiale :** [http://localhost:9080/setup](http://localhost:9080/setup)
**Démarrages suivants :**
```bash
npm run docker:local:up
```
**Migrations seules** (après `git pull` avec changement de schéma) :
```bash
npm run docker:local:migrate
# ou : npm run db:migrate (utilise .env racine, pas .env.docker)
```
Autres commandes locales utiles : `npm run docker:local:status` · `docker:local:logs` · `docker:local:down`
### En local — sans Docker (backend Node + Postgres sur la machine)
Utile pour le développement backend pur :
```bash
cd backend
cp .env.example .env
# DATABASE_URL=postgresql://user:pass@localhost:5432/crypto_wallet
npm run migrate
npm run dev
```
Frontend en dev (autre terminal) :
```bash
cd prediqo_web
cp .env.example .env
# VITE_API_BASE_URL=http://localhost:4000
npm install
npm run dev
```
Page setup : **`http://localhost:5173/setup`** (ou le port Vite affiché), l’API étant sur le port configuré dans `VITE_API_BASE_URL`.
### Table récapitulative
| Contexte | Fichier env | 1er démarrage (base vierge) | Page setup |
|----------|-------------|-----------------------------|------------|
| **VPS HTTP** | `.env` | `npm run phase-b:init` | `:9080/setup` |
| **VPS HTTPS** | `.env` | `npm run phase-b:init:https` | `:9443/setup` |
| **Local Docker** | `.env.docker` | `npm run docker:local:init` | `http://localhost:9080/setup` |
| **Local sans Docker** | `backend/.env` | `cd backend && npm run migrate` puis `npm run dev` | frontend dev + `/setup` |
| Action | VPS | Local Docker |
|--------|-----|--------------|
| Migrations seules | `npm run db:migrate` | `npm run docker:local:migrate` |
| État conteneurs | `npm run phase-b:status` | `npm run docker:local:status` |
| Logs | `npm run phase-b:logs` | `npm run docker:local:logs` |
---
## 5. Lancer l’application
Deux parcours : **HTTP rapide** (test) ou **HTTPS recommandé** (production).
### Parcours A — HTTP (test rapide)
**Important :** les URLs `VITE_*` et `APP_PUBLIC_URL` doivent utiliser **http** et le port **9080** (pas https/9443).
```env
APP_PUBLIC_URL=http://prediqo.redirectme.net:9080
VITE_API_BASE_URL=http://prediqo.redirectme.net:9080
VITE_WS_URL=ws://prediqo.redirectme.net:9080/ws/v1/games/candle-predict
```
```bash
# 1er déploiement (migrations + démarrage en une commande)
npm run phase-b:init
# équivalent : migrate puis docker compose --profile http up -d --build
# démarrages suivants ou après git pull (sans changement de schéma)
npm run phase-b:up
```
Accès : **http://prediqo.redirectme.net:9080** (avec le port, en **http**)
### Parcours B — HTTPS avec Let’s Encrypt (recommandé)
Let’s Encrypt est **gratuit**. La validation **DNS** n’utilise pas les ports 80/443 du VPS.
#### Étape 1 — Certificat DNS (une fois, interactif)
```bash
npm run ssl:dns-init
```
Certbot affiche un enregistrement **TXT** à créer chez redirectme.net :
```
_acme-challenge.prediqo.redirectme.net → <valeur affichée>
```
Attendez 1–5 min (propagation DNS), puis validez dans le terminal.
#### Étape 2 — Démarrer la stack HTTPS
```bash
# 1er déploiement HTTPS (migrations + stack)
npm run phase-b:init:https
# équivalent : migrate puis docker compose --profile https-dns up -d --build
# démarrages suivants
npm run phase-b:up:https
```
Accès : **https://prediqo.redirectme.net:9443**
Le port **9080** redirige automatiquement vers **9443**.
---
## 6. Premier administrateur
> Résumé des commandes de démarrage : [section 4](#4-démarrage-sur-base-de-données-vierge-vps-et-local).
1. Ouvrez la page **setup** (voir URLs ci-dessous).
2. Saisissez le **`INITIAL_SETUP_TOKEN`** (valeur de `.env` ou `.env.docker` — **identique** à celle du serveur, min. 16 caractères).
3. **Créez** le compte administrateur **ou** **promouvez** un utilisateur déjà inscrit via Register.
4. Le système génère automatiquement un **code de parrainage racine** pour ce super administrateur ; les nouveaux utilisateurs sans code de parrainage y seront rattachés.
5. Connectez-vous sur **`/login`**.
| Contexte | URL setup |
|----------|-----------|
| VPS HTTPS | `https://prediqo.redirectme.net:9443/setup` |
| VPS HTTP | `http://prediqo.redirectme.net:9080/setup` |
| Local Docker | `http://localhost:9080/setup` |
Ensuite, gérez les rôles depuis **Admin → Users**.
Si `setupEnabled` est `false` dans `/api/v1/setup/status`, vérifiez que `INITIAL_SETUP_TOKEN` est défini (32+ caractères recommandés) et redémarrez le backend :
```bash
docker compose restart backend
```
---
## 7. Commandes utiles
| Action | Commande |
|--------|----------|
| **1er déploiement HTTP (VPS)** | `npm run phase-b:init` |
| **1er déploiement HTTPS (VPS)** | `npm run phase-b:init:https` |
| **1er démarrage local Docker** | `npm run docker:local:init` |
| Démarrer / rebuild (HTTP VPS) | `npm run phase-b:up` |
| Démarrer local Docker | `npm run docker:local:up` |
| Migrations seules (VPS) | `npm run db:migrate` |
| Migrations seules (local Docker) | `npm run docker:local:migrate` |
| État des conteneurs | `npm run phase-b:status` |
| Logs en direct | `npm run phase-b:logs` |
| Redémarrer | `npm run phase-b:restart` |
| Arrêter | `npm run phase-b:down` |
| Reconstruire après changement `VITE_*` | `npm run phase-b:up:https` |
Logs d’un service précis :
```bash
docker compose logs -f backend
docker compose logs -f nginx-https-dns
```
---
## 8. Mise à jour après `git pull`
```bash
cd ~/games_app
git pull
npm run phase-b:up:https
```
Si seul le backend a changé (pas le frontend) :
```bash
docker compose build backend backend-engine backend-ws backend-worker-bets
docker compose --profile https-dns up -d
```
---
## 9. Renouveler le certificat SSL (~tous les 90 jours)
```bash
npm run ssl:dns-renew
```
Même procédure TXT DNS que lors de la création initiale.
---
## 10. Architecture des conteneurs
| Conteneur | Rôle |
|-----------|------|
| `prediqo_nginx_https` | Entrée web (9080 → 9443 HTTPS) |
| `prediqo_web` | Frontend React (build Vite) |
| `crypto_wallet_api` | API REST `/api/v1` |
| `crypto_wallet_ws` | WebSocket `/ws/…` |
| `crypto_wallet_engine` | Moteur de jeux (Candle Predict) |
| `crypto_wallet_worker_bets` | Traitement async des paris |
| `crypto_wallet_redis` | Cache / files Redis |
PostgreSQL tourne **sur l’hôte**, pas dans Docker (sauf profil `docker-db` optionnel).
---
## 11. Dépannage
### `database "crypto_wallet" does not exist`
La base PostgreSQL n’a pas été créée sur l’hôte.
```bash
sudo -u postgres psql -c "CREATE DATABASE crypto_wallet;"
sudo docker compose --profile http up -d
sudo docker compose logs backend --tail 20
curl http://127.0.0.1:9080/api/v1/setup/status
```
### Migration échoue : `relation "users" does not exist`
Sur une **base vierge**, une version antérieure de `schema.sql` créait `user_roles` avant la table `users`. Mettez à jour le dépôt puis relancez :
```bash
cd ~/projects_repository/games-project
git pull
npm run phase-b:init
```
Si des objets partiels existent (migration interrompue manuellement), repartir d’une base vide est le plus simple :
```bash
sudo -u postgres psql -c "DROP DATABASE IF EXISTS games_platform_db;"
sudo -u postgres psql -c "CREATE DATABASE games_platform_db;"
npm run phase-b:init
```
*(Adaptez le nom de la base à `POSTGRES_DB` dans `.env`.)*
### Tables manquantes (`parserOpenTable` / relation does not exist)
La base existe mais les **migrations** n’ont pas été appliquées.
```bash
sudo npm run db:migrate
# ou : sudo docker compose run --rm --no-deps backend node dist/db/migrate.js
sudo docker compose --profile http up -d
curl http://127.0.0.1:9080/api/v1/setup/status
```
### nginx : `host not found in upstream "backend"`
nginx démarre avant que le backend soit visible dans le DNS Docker. Mettez à jour le projet (`git pull`) — les templates nginx utilisent le résolveur Docker `127.0.0.11`. Puis :
```bash
sudo docker compose --profile http up -d --force-recreate nginx
```
### Backend redémarre en boucle (DB OK avec psql sur l’hôte)
1. Vérifiez l’erreur exacte :
```bash
sudo docker compose logs backend --tail 20
```
2. `DATABASE_URL` dans `.env` doit utiliser **`host.docker.internal`**, pas `localhost` :
```env
DATABASE_URL=postgresql://postgres:VOTRE_MDP@host.docker.internal:5432/games_platform_db
```
3. `POSTGRES_PASSWORD` doit être **identique** au mot de passe postgres (caractères spéciaux → encoder en URL si besoin).
4. Autorisez le réseau Docker dans `pg_hba.conf` (voir section PostgreSQL ci-dessus).
5. Logs nginx si le port 9080 ne répond toujours pas :
```bash
sudo docker compose logs nginx --tail 20
sudo ss -tlnp | grep 9080
```
### Page s’affiche mais connexion / API échoue
Le frontend est compilé avec les URLs `VITE_*` du `.env`. Si vous lancez en **HTTP :9080** mais que `.env` contient `https://...:9443`, le navigateur appelle le mauvais serveur.
Corrigez `.env`, puis **rebuild** :
```env
APP_PUBLIC_URL=http://prediqo.redirectme.net:9080
VITE_API_BASE_URL=http://prediqo.redirectme.net:9080
VITE_WS_URL=ws://prediqo.redirectme.net:9080/ws/v1/games/candle-predict
```
```bash
sudo npm run phase-b:up
```
Vérifiez l’API depuis le VPS :
```bash
curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:9080/api/v1/setup/status
# attendu : 200
```
### `permission denied` sur `docker.sock`
L’utilisateur Linux n’a pas le droit d’utiliser Docker.
**Correctif durable (recommandé) :**
```bash
sudo usermod -aG docker $USER
# Puis se déconnecter et reconnecter au VPS (ou : newgrp docker)
docker ps # doit fonctionner sans sudo
```
**Contournement immédiat :**
```bash
sudo npm run ssl:dns-init
sudo npm run phase-b:up:https
```
> Ne mettez pas à jour npm global (`npm install -g npm`) — ce n’est pas lié à l’erreur Docker et nécessite les droits root.
### Le site ne répond pas
```bash
npm run phase-b:status
docker compose logs nginx-https-dns --tail 50
```
Vérifiez le pare-feu (`9443/tcp`) et le DNS.
### Erreur base de données
```bash
docker compose logs backend --tail 100
```
Vérifiez `POSTGRES_*` dans `.env` et que PostgreSQL accepte les connexions depuis Docker (`host.docker.internal`).
### Certificat SSL / nginx ne démarre pas
Le certificat doit exister avant `phase-b:up:https` :
```bash
docker volume ls | grep letsencrypt
npm run ssl:dns-init # si pas encore fait
```
### Page blanche ou API inaccessible
Les URLs `VITE_*` sont figées au **build** du frontend. Après modification :
```bash
npm run phase-b:up:https
```
### `INITIAL_SETUP_TOKEN` refusé
Vérifiez la variable dans `.env` racine et redémarrez l’API :
```bash
docker compose restart backend
```
### Prédiction single-candle échoue (auto / multi OK)
Le pari manuel **single** passe par une file Redis (`BET_ASYNC=true`) traitée par **`backend-worker-bets`**, puis une confirmation WebSocket. L’auto et le multi contournent ce flux (exécution directe ou synchrone).
**Cause fréquente (VPS)** : l’interface affichait encore « fenêtre ouverte » via WebSocket/Redis alors que le serveur avait déjà fermé la fenêtre → le pari manuel était rejeté (`Prediction window is closed`) sans message clair. L’auto (déclenchée par le moteur) et le multi (réponse HTTP immédiate) continuaient de fonctionner.
**Correctifs** : publication WS à la fermeture de fenêtre, statut UI basé sur l’horloge serveur, cache Redis n’écrase plus le statut, `BET_ASYNC` lu depuis `.env`.
**Vérifications sur le VPS :**
```bash
sudo docker compose ps backend-worker-bets backend-ws redis
sudo docker compose logs backend-worker-bets --tail 80
sudo docker compose logs backend-ws --tail 40
```
Le conteneur `crypto_wallet_worker_bets` doit être **Up** et les logs doivent afficher `[worker-bets] Consumer worker-1 ready`.
**Test rapide** — désactiver temporairement la file async (pari synchrone comme le multi) :
```bash
# Dans .env racine (docker-compose lit cette variable) :
BET_ASYNC=false
sudo docker compose up -d --build backend backend-worker-bets
```
Si le single fonctionne avec `BET_ASYNC=false`, le problème vient du worker ou du WebSocket.
**WebSocket** — le frontend doit être buildé avec la bonne URL (rebuild obligatoire après changement) :
```env
VITE_WS_URL=ws://prediqo.redirectme.net:9080/ws/v1/games/candle-predict
VITE_WS_ENABLED=true
```
Puis : `sudo npm run phase-b:up` (rebuild `prediqo-web`).
**Depuis la version récente**, le frontend interroge aussi l’API `GET /api/v1/games/candle-predict/bets/outcome/:idempotencyKey` en secours si le WebSocket ne confirme pas le pari à temps.
---
## 12. Migration vers un VPS dédié (futur)
Quand Prediqo aura son propre serveur :
1. Dans `.env` : `PREDIQO_HTTP_PORT=80`, `PREDIQO_HTTPS_PORT=443`
2. URLs sans port : `https://prediqo.redirectme.net`
3. `npm run ssl:init && npm run phase-b:up:ssl`
Aucune modification des autres projets n’est nécessaire.
---
## 13. Fichiers `.env` — rappel
| Fichier | Usage |
|---------|--------|
| **`.env` (racine)** | **VPS Docker** — fichier principal |
| **`.env.docker`** | **Local Docker** — copie de `.env.docker.example`, gitignored |
| `backend/.env` | Dev local Node seulement (sans Docker) |
| `prediqo_web/.env` | Dev frontend Vite seulement ; en Docker, `VITE_*` vient du `.env` racine |