diff --git a/.env.docker.example b/.env.docker.example index f4899905..5d833cad 100644 --- a/.env.docker.example +++ b/.env.docker.example @@ -33,7 +33,8 @@ RUN_MIGRATE_ON_START=0 BACKEND_PORT=4000 WS_PORT=4001 -REDIS_PORT=6379 +# Redis stays internal to Docker (no host port). Password required by compose. +REDIS_PASSWORD=local-dev-redis-password-change-me-32chars WORKER_ID=worker-1 JWT_SECRET=local-dev-jwt-secret-min-32-chars-change-me @@ -72,6 +73,7 @@ VITE_API_BASE_URL=http://localhost:9080 VITE_WS_ENABLED=true VITE_WS_URL=ws://localhost:9080/ws/v1/games/candle-predict +# Compose builds REDIS_URL with REDIS_PASSWORD for containers REDIS_ENABLED=true REDIS_ROUND_CACHE=true BET_ASYNC=true diff --git a/.env.example b/.env.example index 46c101aa..ac7f2cf2 100644 --- a/.env.example +++ b/.env.example @@ -43,8 +43,11 @@ RUN_MIGRATE_ON_START=0 # Phase B ports BACKEND_PORT=4000 WS_PORT=4001 -REDIS_PORT=6379 +# Redis is NOT published on the host (Docker network only). Optional debug map only: +# REDIS_PORT=6379 WORKER_ID=worker-1 +# Required by docker-compose redis + REDIS_URL auth (hex/alphanumeric recommended) +REDIS_PASSWORD=change-me-to-a-long-random-hex-secret # Backend secrets JWT_SECRET=your-super-secret-jwt-key-min-32-chars @@ -122,6 +125,9 @@ VITE_WS_URL=ws://prediqo.redirectme.net:9080/ws/v1/games/candle-predict # VITE_WS_URL=wss://prediqo.redirectme.net:9443/ws/v1/games/candle-predict # Phase B feature flags (used by Docker services) +# Compose injects redis://:${REDIS_PASSWORD}@redis:6379 into containers. +# Local backend outside Docker (only if you temporarily publish Redis): +# REDIS_URL=redis://:YOUR_REDIS_PASSWORD@localhost:6379 REDIS_ENABLED=true REDIS_ROUND_CACHE=true # BET_ASYNC=true enables async bet queue for WebSocket place_bet only. diff --git a/backend/.env.example b/backend/.env.example index ec7e953f..c65bea56 100644 --- a/backend/.env.example +++ b/backend/.env.example @@ -84,7 +84,9 @@ PASSWORD_RESET_EXPIRY_HOURS=1 # CANDLE_PREDICT_BACKFILL_SEED_MAX=15 # initial chart history per interval # Phase B — Redis + realtime (optional in local dev) -REDIS_URL=redis://localhost:6379 +# Prefer password auth. Docker Compose injects redis://:${REDIS_PASSWORD}@redis:6379. +# Local (only if Redis is published on the host): +REDIS_URL=redis://:change-me-to-a-long-random-hex-secret@localhost:6379 REDIS_ENABLED=true REDIS_ROUND_CACHE=true BET_ASYNC=true diff --git a/docker-compose.yml b/docker-compose.yml index c5e626b8..6b5b22ac 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -25,7 +25,8 @@ x-backend-common: &backend-common DATABASE_PASSWORD: ${DATABASE_PASSWORD:-} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_USER: ${POSTGRES_USER:-postgres} - REDIS_URL: redis://redis:6379 + # Auth URL — password from .env (REDIS_PASSWORD). Never publish Redis on the host. + REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379 REDIS_ENABLED: ${REDIS_ENABLED:-true} REDIS_ROUND_CACHE: ${REDIS_ROUND_CACHE:-true} BET_ASYNC: ${BET_ASYNC:-true} @@ -141,13 +142,44 @@ services: image: redis:7-alpine container_name: crypto_wallet_redis restart: unless-stopped - command: redis-server --appendonly yes - ports: - - "${REDIS_PORT:-6379}:6379" + # Hardened: requirepass, no host port (Docker network only), dangerous cmds disabled. + # Set REDIS_PASSWORD in .env (required). Do not map 6379 to the host on a VPS. + environment: + REDIS_PASSWORD: ${REDIS_PASSWORD:?Set REDIS_PASSWORD in .env} + command: + - redis-server + - --appendonly + - yes + - --requirepass + - ${REDIS_PASSWORD} + - --protected-mode + - "yes" + - --rename-command + - FLUSHALL + - "" + - --rename-command + - FLUSHDB + - "" + - --rename-command + - CONFIG + - "" + - --rename-command + - KEYS + - "" + - --rename-command + - DEBUG + - "" + - --rename-command + - REPLICAOF + - "" + - --rename-command + - SLAVEOF + - "" + # Intentionally no `ports:` — Redis stays on prediqo-net only. volumes: - redis_data:/data healthcheck: - test: ["CMD", "redis-cli", "ping"] + test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "--no-auth-warning", "ping"] interval: 5s timeout: 3s retries: 5 @@ -254,7 +286,7 @@ services: "CMD", "node", "-e", - "const Redis=require('ioredis');const r=new Redis(process.env.REDIS_URL||'redis://redis:6379');r.ping().then(()=>process.exit(0)).catch(()=>process.exit(1)).finally(()=>r.quit());", + "const Redis=require('ioredis');const r=new Redis(process.env.REDIS_URL||'');if(!process.env.REDIS_URL)process.exit(1);r.ping().then(()=>process.exit(0)).catch(()=>process.exit(1)).finally(()=>r.quit());", ] interval: 15s timeout: 5s diff --git a/docs/DEPLOY-VPS.md b/docs/DEPLOY-VPS.md index 5315cc78..cc3bb67e 100644 --- a/docs/DEPLOY-VPS.md +++ b/docs/DEPLOY-VPS.md @@ -62,6 +62,7 @@ nano .env # ou vim | `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Compte PostgreSQL sur l’hôte (défaut DB : `games_platform_db`) | | `DATABASE_URL` / `DATABASE_PASSWORD` | Connexion Docker via `host.docker.internal` (mot de passe encodé si caractères spéciaux) | | `JWT_SECRET` | Secret JWT (32+ caractères aléatoires) | +| `REDIS_PASSWORD` | Mot de passe Redis (obligatoire) — Redis **non** publié sur l’hôte ; URL conteneurs `redis://:…@redis:6379` | | `ENCRYPTION_KEY` | 64 caractères hex (32 octets AES-256) — **générer une fois**, backup hors git | | `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`) | @@ -784,7 +785,7 @@ npm run phase-b:init npm run phase-b:up ``` -Si `phase-b:up` échoue avec `6379/tcp: address already in use`, ou si la prédiction / le Support affichent `Stream isn't writeable…` / `Connection is closed` : voir **[TROUBLESHOOTING-REDIS-PORT.md](./TROUBLESHOOTING-REDIS-PORT.md)**. +Redis est **interne Docker uniquement** (pas de port 6379 sur l’hôte) et protégé par `REDIS_PASSWORD` dans `.env` (obligatoire). Si la prédiction / le Support affichent `Stream isn't writeable…` / `Connection is closed`, ou en cas de `READONLY` réplica : voir **[TROUBLESHOOTING-REDIS-PORT.md](./TROUBLESHOOTING-REDIS-PORT.md)**. Accès : **http://prediqo.redirectme.net:9080** (avec le port, en **http**) diff --git a/docs/TROUBLESHOOTING-REDIS-PORT.md b/docs/TROUBLESHOOTING-REDIS-PORT.md index 9cd6ac40..0d87a412 100644 --- a/docs/TROUBLESHOOTING-REDIS-PORT.md +++ b/docs/TROUBLESHOOTING-REDIS-PORT.md @@ -1,8 +1,25 @@ -# Dépannage : Redis port 6379 déjà utilisé +# Dépannage Redis (port / auth / READONLY) -## Symptômes +## Sécurité (état attendu) -Lors de `npm run phase-b:up` (ou `docker compose --profile http up -d --build`) : +Redis Prediqo est **durci** dans `docker-compose.yml` : + +| Mesure | Détail | +|--------|--------| +| Pas de port hôte | Aucun `ports:` sur le service `redis` — accessible uniquement via `prediqo-net` | +| Mot de passe | `requirepass` = `REDIS_PASSWORD` (obligatoire dans `.env`) | +| URL app | Conteneurs : `redis://:${REDIS_PASSWORD}@redis:6379` | +| Commandes dangereuses | `FLUSHALL`, `FLUSHDB`, `CONFIG`, `KEYS`, `DEBUG`, `REPLICAOF`, `SLAVEOF` désactivées | + +Sans `REDIS_PASSWORD` dans `.env`, `docker compose` refuse de démarrer. + +**Ne jamais** republier `6379:6379` sur un VPS public. C’est la cause typique d’un Redis forcé en esclave (`READONLY You can't write against a read only replica`). + +--- + +## Symptômes : conflit de port (legacy) + +Si une ancienne version du compose publiait encore 6379, lors de `npm run phase-b:up` : ```text Error response from daemon: failed to set up container networking: @@ -10,114 +27,101 @@ Error response from daemon: failed to set up container networking: failed to bind host port 0.0.0.0:6379/tcp: address already in use ``` -Sur l’app (page prédiction Candle Predict, Tloto Support, realtime) : +Avec le compose actuel (sans `ports:`), ce conflit **ne devrait plus** se produire pour Prediqo. Si 6379 est encore ouvert sur l’hôte, c’est un **autre** Redis (système ou autre projet) — à arrêter, pas à réutiliser. + +Sur l’app (Candle Predict / Support) si Redis est down : - `Stream isn't writeable and enableOfflineQueue options is false` - `Connection is closed` -**Ce n’est pas un bug marketing / Live Activity.** C’est Redis indisponible : le backend Redis client utilise `enableOfflineQueue: false` et échoue immédiatement si Redis est down. +--- -Un simple « rebuild » peut parfois « marcher » parce qu’il arrête/recrée des conteneurs et libère temporairement le port — le conflit peut revenir au prochain `up`. +## Symptômes : READONLY / réplica -## Cause +```text +READONLY You can't write against a read only replica +``` -Le conteneur Redis (`crypto_wallet_redis`) publie le port hôte **6379**. Si un autre process ou un autre conteneur Redis l’occupe déjà, le démarrage échoue. Les services API / WS / workers démarrent parfois sans Redis → erreurs realtime ci-dessus. +Souvent après exposition publique de 6379 : un bot a envoyé `SLAVEOF` / `REPLICAOF` vers une IP distante. -## Diagnostic - -Sur le VPS (dans le dépôt du projet) : +### Diagnostic + +```bash +docker exec crypto_wallet_redis redis-cli -a "$REDIS_PASSWORD" --no-auth-warning INFO replication +# role:master → OK +# role:slave → compromis / mauvais état +``` + +### Remise en master (compose durci) + +Avec `REPLICAOF` désactivé, le plus sûr est de **recréer** Redis (le cache se reconstruit ; Postgres reste la source de vérité) : + +```bash +cd /path/to/games_app +# Assurez-vous que .env contient REDIS_PASSWORD (fort, alphanumérique) +docker compose stop redis +docker compose rm -f redis +# Optionnel si l’état volume est douteux après attaque : +# docker volume rm games_app_redis_data # adapter le nom: docker volume ls | grep redis +docker compose up -d redis +docker exec crypto_wallet_redis redis-cli -a "$REDIS_PASSWORD" --no-auth-warning INFO replication +# puis redémarrer API / workers / WS +docker compose up -d backend backend-ws backend-worker-bets backend-worker-engine +``` + +Vérifier qu’**aucun** process n’écoute 6379 sur l’hôte : + +```bash +sudo ss -tlnp | grep 6379 || echo "OK: 6379 non publié" +``` + +--- + +## Diagnostic général ```bash -# Qui écoute sur 6379 ? sudo ss -tlnp | grep 6379 -# ou -sudo lsof -i :6379 - -# Conteneurs Redis (y compris arrêtés) docker ps -a --filter name=redis -docker ps -a | grep -i redis - -# État de la stack sudo npm run phase-b:status # ou docker compose ps ``` -Interpréter : - | Observation | Interprétation | |-------------|----------------| -| Conteneur `crypto_wallet_redis` Exit / Created | Échec de bind ; Redis de la stack n’est pas up | -| Autre conteneur Redis « Up » sur 6379 | Deux stacks Docker se disputent le port | -| Process `redis-server` hors Docker | Redis système qui occupe 6379 | +| Conteneur `crypto_wallet_redis` Exit | Mot de passe manquant, healthcheck, ou volume | +| `ss` montre 6379 sur l’hôte | Fuite / autre Redis — **fermer** | +| `role:slave` | Voir section READONLY ci-dessus | +| App : Stream isn't writeable | Redis down ou mauvais `REDIS_URL` / mot de passe | -## Résolution - -### 1. Libérer le port (cas le plus fréquent) +Ping interne : ```bash -# Ancien conteneur Redis de cette stack -docker stop crypto_wallet_redis 2>/dev/null -docker rm crypto_wallet_redis 2>/dev/null - -# Autre Redis Docker (adapter le nom si besoin) -docker ps -a | grep -i redis -docker stop -docker rm - -# Redis installé sur l’hôte (si ss/lsof le montre) -sudo systemctl stop redis -# ou -sudo systemctl stop redis-server +docker exec crypto_wallet_redis redis-cli -a "$REDIS_PASSWORD" --no-auth-warning ping +# PONG ``` -Puis relancer : +--- -```bash -sudo npm run phase-b:up -# HTTPS : -# sudo npm run phase-b:up:https -``` +## Déploiement VPS (checklist sécurité) -Vérifier : +1. Copier / générer `REDIS_PASSWORD` dans le `.env` du VPS (même valeur que celle utilisée par compose). +2. Déployer le `docker-compose.yml` **sans** mapping de port Redis. +3. `docker compose up -d` (ou `npm run phase-b:up` / `phase-b:up:https`). +4. Confirmer : pas de 6379 public + `INFO replication` → `role:master`. +5. Firewall : n’ouvrir que 9080/9443 (ou 80/443), **jamais** 6379. -```bash -docker ps --filter name=crypto_wallet_redis -# doit être "Up" -sudo ss -tlnp | grep 6379 -# doit être le conteneur Docker Redis de la stack -``` - -### 2. Éviter deux stacks en parallèle - -Ne pas laisser tourner en même temps : - -- `phase-b` (prod VPS) **et** -- une autre compose qui mappe aussi `6379:6379` (ex. ancien projet, `docker:local` sur la même machine) - -Garder **une seule** stack qui expose 6379, ou changer le mapping de l’autre (ex. `"6380:6379"`) dans son `docker-compose` — **sans** changer Redis côté app tant que l’URL interne Docker reste `redis:6379`. - -### 3. Confirmer que les erreurs app disparaissent - -Après Redis up : - -1. Recharger la page prédiction et le Support. -2. Les messages `Stream isn't writeable…` / `Connection is closed` ne doivent plus apparaître. -3. Logs utiles : - ```bash - docker logs crypto_wallet_redis --tail 50 - docker logs crypto_wallet_api --tail 80 - docker logs crypto_wallet_ws --tail 80 - ``` +--- ## Prévention -- Avant un `phase-b:up`, vérifier : `sudo ss -tlnp | grep 6379`. -- Après un déploiement raté, ne pas enchaîner des rebuilds sans regarder Redis : corriger le port d’abord. -- Sur un VPS partagé, ne pas installer Redis système **et** Redis Docker sur le même `6379`. +- Redis **uniquement** sur le réseau Docker interne. +- Mot de passe long (ex. 64 hex) ; ne pas committer `.env`. +- Ne pas installer Redis système sur le même VPS « pour debug » en écoute `0.0.0.0:6379`. +- Après incident slave : recréer le service (+ volume si besoin), puis vérifier `role:master`. ## Références code -- Client Redis (échec rapide) : `backend/src/realtime/redis/client.ts` (`enableOfflineQueue: false`) -- Compose / service Redis : `docker-compose` (service redis, port hôte `6379`) -- Commandes stack : `docs/DEPLOY-VPS.md` (`phase-b:up`, `phase-b:status`, `phase-b:logs`) +- Client Redis : `backend/src/realtime/redis/client.ts` (`enableOfflineQueue: false`) +- Compose : service `redis` + `REDIS_URL` dans `x-backend-common` +- Stack : `docs/DEPLOY-VPS.md` (`phase-b:up`, `phase-b:status`, `phase-b:logs`)