Starting to resolve the issue on prediction2

This commit is contained in:
Your Name 2026-10-26 10:05:49 +02:00
parent 2da5f16d4b
commit 20a26c88df
6 changed files with 138 additions and 91 deletions

View File

@ -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

View File

@ -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.

View File

@ -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

View File

@ -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

View File

@ -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**)

View File

@ -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 <autre_conteneur_redis>
docker rm <autre_conteneur_redis>
# 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`)