Plateforme télécom distribuée de nouvelle génération pour le traitement unifié des Call Detail Records multi-pays
ORION unifie l'ingestion, le traitement et l'analyse des CDR télécom de multiples pays dans une architecture moderne, performante et sécurisée.
[CDR Multi-pays] → [Kafka] → [Pipeline Rust] → [ML Fraud] → [ScyllaDB/Ceph] → [APIs & Analytics]
Résultats :
- ⚡ < 1 seconde : latence end-to-end
- 📈 > 1M CDR/min : ingestion par pays
- 🤖 < 10ms : inférence ML fraude
- 💰 -65% : réduction coûts infrastructure
- 🌍 Multi-pays : schéma unifié groupe
- Introduction — Comprendre ORION en 5 minutes
- Vision stratégique — Objectifs et impact attendu
- Guide de reprise — Pour les développeurs rejoignant le projet
- 00 - Vue d'ensemble — Introduction, vision, glossaire
- 01 - Cadrage — Cahier des charges, roadmap, objectifs
- 02 - Architecture — Architecture globale et détaillée
- 03 - Données — Schéma CDR unifié, modèle ScyllaDB
- 04 - Machine Learning — Agent fraud, features, modèle
- 05 - Déploiement — Docker, RHEL, Kubernetes, monitoring
- 06 - Démonstration — Scénarios et scripts de démo
📍 Index complet de la documentation
┌─────────────────────────────────────────────────────────────┐
│ ORION Pipeline │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Kafka │ → │ Rust │ → │ ML │ │
│ │Multi-pays│ │ Pipeline │ │ Fraud │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ ↓ │
│ ┌───────────┴────────────┐ │
│ ↓ ↓ │
│ ┌──────────┐ ┌──────────┐ │
│ │ScyllaDB │ │ Ceph │ │
│ │Hot Store │ │Cold Store│ │
│ └──────────┘ └──────────┘ │
│ ↓ ↓ │
│ ┌──────────────────────────────────┐ │
│ │ APIs & Analytics & Billing │ │
│ └──────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
- orion-ingestion — Ingestion Kafka multi-pays
- orion-validation — Validation et contrôles métier
- orion-normalization — Application du schéma unifié
- orion-enrichment — Enrichissement réseau & client
- orion-ml-fraud-agent — Détection fraude temps réel
- orion-storage-hot — Écriture ScyllaDB
- orion-storage-cold — Archivage Ceph/MinIO
- orion-api — API REST interne
- orion-observability — Métriques & santé
- Kafka — Bus d'ingestion distribué
- ScyllaDB — Hot storage (requêtes < 10ms)
- Ceph/MinIO — Cold storage (Parquet compressé)
- Prometheus — Métriques temps réel
- Grafana — Dashboards visuels
- Docker & Docker Compose 2.20+
- Rust 1.75+ (pour développement)
- 16 GB RAM, 8 CPU cores
# 1. Cloner le repo
git clone <repo-url>
cd ORION_Unified_CDR_Engine
# 2. Générer des CDR de test
.\arborescences\create_orion_generate_cdr.ps1 -CountPerCountry 10000
# 3. Démarrer la stack complète
docker compose up -d
# 4. Vérifier la santé des services
curl http://localhost:8080/health # API
curl http://localhost:8081/health # Ingestion
curl http://localhost:8085/health # ML Fraud Agent
# 5. Accéder aux interfaces
# Grafana : http://localhost:3000 (admin/orion123)
# Prometheus : http://localhost:9090
# MinIO : http://localhost:9001 (orion/orion_secret_123)📘 Guide détaillé : docker-local.md
Accès rapide aux CDR par abonné pour facturation, litiges, vérification consommation.
Scoring ML temps réel sur chaque CDR, alertes instantanées, analyse comportementale.
Analyse QoS par cellule, identification zones à problème, dimensionnement capacité.
Suivi CDR roaming, réconciliation inter-opérateurs, facturation wholesale.
Datasets consolidés multi-pays, exports vers data lakes, dashboards exécutifs.
Rétention réglementaire, traçabilité complète, exports pour autorités.
| Catégorie | Technologie | Rôle |
|---|---|---|
| Langage | Rust 1.75+ | Pipeline complet |
| Async Runtime | Tokio | Concurrence |
| Web Framework | Axum | HTTP endpoints |
| Messaging | Apache Kafka | Ingestion distribuée |
| Hot Storage | ScyllaDB 5.4 | Base NoSQL temps réel |
| Cold Storage | Ceph / MinIO | Stockage objet S3 |
| ML Inference | ONNX Runtime | Modèles embarqués |
| Monitoring | Prometheus + Grafana | Observabilité |
| Orchestration | Docker Compose / K8s | Déploiement |
| CI/CD | GitHub Actions | Automatisation |
| Métrique | Objectif V1 | Objectif V3 |
|---|---|---|
| Latence end-to-end | < 1 sec | < 500 ms |
| Ingestion CDR/min/pays | > 1M | > 10M |
| Latence requête hot | < 10 ms | < 5 ms |
| Latence ML inference | < 10 ms | < 5 ms |
| Disponibilité | > 99.9% | > 99.99% |
- Pipeline Rust complet
- Schéma CDR unifié
- ML fraud agent basique
- ScyllaDB + MinIO
- Démo end-to-end
- Go pour I/O-bound services
- Kubernetes natif
- Feature store ML
- Multi-datacenter
- TAP/NRTRDE natif
- SLA 99.99%
- Haute disponibilité
- Sécurité avancée
- GitOps complet
- Déploiement tous pays
ORION_Unified_CDR_Engine/
├── docs/ # Documentation complète
├── orion-*/ # Microservices Rust (crates)
├── arborescences/ # Scripts PowerShell d'automatisation
├── configs/ # Configurations (Kafka, Scylla, Prometheus...)
├── datasets/ # CDR de test multi-pays
├── docker-compose.yml # Orchestration Docker
├── Cargo.toml # Workspace Rust
└── Makefile # Commandes utiles
# Build workspace complet
cargo build --workspace
# Run un microservice
cargo run --bin orion-ingestion
# Tests
cargo test --workspace
# Linter
cargo clippy --workspace --all-targets
# Format
cargo fmt --all- Rust : respecter les conventions du guide_de_reprise.md
- Git : commits atomiques, messages clairs
- Documentation : Markdown, diagrammes, exemples
- Tests : coverage minimum 70%
- Index docs complètes
- FAQ — Glossaire technique
Propriétaire — Tous droits réservés © 2026
"Un seul pipeline, un seul schéma, une seule vérité"
ORION simplifie radicalement le traitement des CDR télécom en unifiant :
- 🎯 Un schéma pour tout le groupe
- 🦀 Un langage (Rust) pour cohérence
- 📊 Une observabilité (Prometheus/Grafana)
- 🗄️ Un storage (ScyllaDB/Ceph)
- 🤖 Un ML intégré natif
Résultat : maintenance facilitée, coûts réduits, innovation accélérée.
ORION Unified CDR Engine
Unifying Telecom Data at Scale