CryptoCluster

Toute la documentation détaillée est maintenant dans docs/.

Consulte en priorité:

• docs/README.md - vue d'ensemble, installation, démarrage, scripts utiles

• docs/verification_redis_timeseries.md - vérification RedisTimeSeries via redis-cli

Configuration actuelle

• Nœud de stockage : node8.lan (RedisTimeSeries + InfluxDB)

• Nœud master : node13.lan (scheduler Dispy)

• Workers : node6.lan à node14.lan (9 workers pour collecte et calculs)

• Exchanges : Binance (1 seul pour commencer)

• Paires :

• Paires USDT : BTC, ETH, BNB, SOL, XRP, ADA, DOT, MATIC, LINK, AVAX, UNI, LTC, ATOM

• Paires EUR : BTC, ETH, XRP, BNB, SOL, ADA, DOT, MATIC, LINK, AVAX

• Paires croisées : BTC/ETH, ETH/XRP, BTC/XRP, etc. (pour arbitrage triangulaire)

Installation rapide

# Windows / PowerShell

conda create -n cryptocluster python=3.9 -y

conda activate cryptocluster

pip install -r requirements.txt

Configuration

1. RedisTimeSeries : doit être installé et démarré sur node8.lan

2. InfluxDB 1.8 : doit être installé et démarré sur node8.lan

3. Variables d'environnement : optionnel, voir config/storage_config.py

Fichiers de configuration

• config/storage_config.py : Configuration Redis et InfluxDB

• config/exchanges_config.py : Configuration des exchanges

• inventory/nodes.yaml : Configuration des nœuds du cluster

Déploiement et démarrage

1. Découvrir les paires disponibles (recommandé)

Avant de lancer la collecte, découvre les paires disponibles sur l'exchange et les cycles d'arbitrage :

conda activate cryptocluster

python scripts/discover_pairs.py

Ce script va :

• Se connecter à Binance

• Lister toutes les paires disponibles

• Filtrer les paires désirées (PRIORITY_SYMBOLS)

• Trouver les cycles d'arbitrage (EUR → BTC → ETH → XRP → EUR, etc.)

• Afficher les paires recommandées pour la collecte

2. Lancer le collector

# 1) Déployer le code sur les nœuds (ignore node10 si hors ligne)

conda activate cryptocluster

scripts\dispy\deploy_project_code.ps1 -Force



# 2) Lancer le collector (détecte automatiquement les paires disponibles)

python start_collector.py

Le collector va automatiquement :

• Détecter les paires disponibles sur l'exchange

• Filtrer les paires désirées

• Trouver les cycles d'arbitrage

• Répartir les paires sur les workers

• Lancer la collecte

Le script lance automatiquement :

• Collecte continue des tickers (toutes les secondes)

• Synchronisation RedisTimeSeries → InfluxDB (toutes les 60 secondes)

• Calcul des bougies

• Calcul des stratégies (RSI)

Appuyez sur Ctrl+C pour arrêter proprement.

Tests rapides Dispy

conda activate cryptocluster

# Ping simple du scheduler

python scripts/tools/test_dispy_simple.py

# Vérifier tous les nœuds

python scripts/tools/test_all_dispy_nodes.py

# Vérifier connexion collector -> scheduler et assignations

python scripts/tools/test_collector_scheduler.py

# Distribution de jobs sur plusieurs nœuds

python scripts/tools/test_multiple_nodes.py --jobs 20

# Test complet scheduler + workers

python scripts/tools/test_scheduler_workers.py

# Vérifier les imports côté workers

python scripts/tools/test_import_worker.py

Méthodes alternatives

Pipeline complet manuel

from exchanges.distributed_collector import DistributedCollector



collector = DistributedCollector()



# Pipeline automatique : collecte → sync → bougies → stratégies

collector.run_full_pipeline(collect_interval=1, sync_interval=60)

Collecte seule

from exchanges.distributed_collector import DistributedCollector



with DistributedCollector() as collector:

    # Collecte continue

    collector.collect_tickers_continuous(interval_seconds=1)

Exemples détaillés

Voir exchanges/example_distributed_usage.py pour plus d'exemples :

python exchanges/example_distributed_usage.py pipeline  # Pipeline complet

python exchanges/example_distributed_usage.py collect    # Collecte seule

python exchanges/example_distributed_usage.py sync      # Sync seule

python exchanges/example_distributed_usage.py strategies # Calcul stratégies

Structure du projet

CryptoCluster/

├── config/              # Configuration centralisée

│   ├── storage_config.py      # Redis + InfluxDB

│   ├── exchanges_config.py    # Exchanges CCXT

│   └── dispy_config.py        # Dispy

├── exchanges/           # Code des exchanges

│   ├── distributed_collector.py   # Orchestrateur principal

│   ├── dispy_storage_workers.py   # Workers collecte/stockage

│   ├── dispy_strategy_workers.py   # Workers stratégies

│   └── ...

├── inventory/           # Configuration des nœuds

│   ├── nodes.yaml      # Fichier YAML

│   └── nodes.py        # Utilitaires de chargement

└── docs/               # Documentation

Architecture des données

RedisTimeSeries

• Séries : tick:{exchange}:{symbol}:price, tick:{exchange}:{symbol}:volume

• Rétention : 3 jours

InfluxDB

• Measurement ticks : ticks individuels

• Measurement candles : bougies OHLCV

• Rétention : 15 jours pour ticks, 90 jours pour bougies

Raccourcis utiles:

conda activate cryptocluster

python scripts/monitoring/monitor_system.py

python scripts/monitoring/health_check.py

Scripts de diagnostic

• scripts/monitoring/check_redis.py : Vérifie Redis et RedisTimeSeries

• scripts/monitoring/check_influxdb.py : Vérifie InfluxDB

• scripts/diagnose_dispy_nodes.ps1 : Diagnostic des nœuds Dispy

• scripts/monitoring/monitor_system.py : Vue d'ensemble du système

• scripts/monitoring/health_check.py : Health checks rapides (retour de code, pour CI/cron)

Outils Dispy

• scripts/dispy/deploy_project_code.ps1 : Copier le code sous /opt/cryptocluster et mettre à jour PYTHONPATH

• scripts/dispy/deploy_dispy_worker.ps1 : Déployer/mettre à jour le worker systemd sur les nœuds

• scripts/dispy/update_dispy_worker_ips.ps1 : Mettre à jour les IPs dans le service sur chaque nœud

• scripts/dispy/diagnose_dispy_nodes.ps1 : Diagnostiquer les nœuds qui ne se connectent pas

• scripts/dispy/dispy_worker.py : Script Python exécuté sur les nœuds (service)

• scripts/dispy/dispy_worker.service : Unité systemd du worker

Astuce: un script unifié scripts/dispy/manage_dispy.ps1 est fourni pour déployer et redémarrer rapidement (voir section Scripts).

Outils SSH

• scripts/ssh/setup_ssh_keys.ps1 : Configurer l'authentification SSH par clés sur tous les nœuds

• scripts/ssh/fix_ssh_permissions.ps1 : Corriger les permissions .ssh et authorized_keys

• scripts/ssh/replace_ssh_keys.ps1 : Remplacer complètement authorized_keys par la clé locale

• scripts/ssh/fix_home_permissions.ps1 : Remettre /home/pi en 755 et réparer les clés

• scripts/ssh/configure_ssh_for_samba.ps1 : Mettre StrictModes no pour compatibilité Samba

Rappels utiles

• Windows 10 / PowerShell: évite les pipes ou chaînages | et &&. Exécute les commandes une par une.

• Toujours activer l'environnement conda cryptocluster avant de lancer les scripts Python.

• Si un nœud est hors-ligne (ex: node10.lan), laisse-le de côté, le cluster fonctionne avec les autres.

Prochaines étapes

1. Ajouter plus d'exchanges (Coinbase, Kraken, etc.)

2. Ajouter plus de cryptos

3. Configurer les agrégations continues dans InfluxDB

4. Développer plus de stratégies de trading