Skip to main content

🏗️ Architecture de FreeTrade

FreeTrade utilise une architecture microservices moderne conçue pour la scalabilité, la résilience et la maintenabilité.

🎯 Principes architecturaux​

Design Patterns utilisés​

  • API Gateway Pattern : Point d'entrée unique
  • Microservices Pattern : Services découplés et autonomes
  • CQRS : Séparation commande/requête
  • Event-Driven Architecture : Communication asynchrone
  • Circuit Breaker : Résilience aux pannes

Avantages de l'architecture​

  • ✅ Scalabilité horizontale : Chaque service peut être répliqué
  • ✅ Résilience : Panne d'un service n'affecte pas les autres
  • ✅ Développement parallèle : Équipes indépendantes
  • ✅ Technologies hétérogènes : Chaque service peut utiliser sa stack
  • ✅ Déploiement indépendant : Mises à jour sans interruption

🌐 Vue d'ensemble du système​

graph TB
    Client[Client Web/Mobile] --> Gateway[API Gateway :3004]
    
    Gateway --> Auth[Auth Service]
    Gateway --> Admin[Admin Service]
    Gateway --> Trade[Trade Service]
    Gateway --> Org[Organization Service]
    Gateway --> Storage[Storage Service]
    
    Auth --> NATS[NATS Cluster]
    Admin --> NATS
    Trade --> NATS
    Org --> NATS
    Storage --> NATS
    
    NATS --> DB[(MySQL Database)]
    Storage --> Files[(File Storage)]
    
    Gateway --> Cache[(Redis Cache)]

🔧 Composants principaux​

🌐 API Gateway (Port 3004)​

Rôle : Point d'entrée unique et orchestrateur

Responsabilités :

  • Routage des requêtes vers les microservices
  • Authentification et autorisation centralisées
  • Gestion des erreurs et logging
  • Rate limiting et throttling
  • Transformation des réponses

Technologies :

  • NestJS avec TypeScript
  • Cache Redis pour l'authentification
  • Communication NATS avec les services

🔐 Auth Service​

Rôle : Gestion de l'authentification et autorisation

Fonctionnalités :

  • Authentification JWT avec cache intelligent
  • Gestion des sessions utilisateurs
  • Validation des permissions
  • Audit des connexions

Optimisations :

  • Cache Redis avec TTL de 5 minutes
  • AuthGuard avec enrichissement automatique
  • Gestion granulaire des erreurs

👨‍💼 Admin Service​

Rôle : Administration du système

Modules (8 modules, 115 endpoints) :

  • Actors : Gestion des acteurs (Admins, Agents, Customers)
  • Users : Gestion des utilisateurs et sessions
  • Organizations : Gestion des organisations
  • Complaints : Système de gestion des plaintes
  • Transports : Gestion des transports et véhicules
  • Forum : Modération du forum
  • Configurations : Gestion centralisée des configurations
  • Announcements : Gestion des annonces

🚀 Trade Service​

Rôle : Interface utilisateur pour les opérations métier

Modules (5 modules, 46 endpoints) :

  • Complaints : Plaintes côté utilisateur
  • Transports : Création et gestion des transports
  • Forum : Forum communautaire complet
  • Announcements : Annonces utilisateur
  • Tutorials : Tutoriels et guides

🏢 Organization Service​

Rôle : Gestion des structures organisationnelles

Fonctionnalités :

  • Hiérarchie des organisations
  • Gestion des relations parent-enfant
  • Types d'organisations multiples
  • Intégration avec les autres services

📦 Storage Service​

Rôle : Gestion des fichiers et documents

Capacités :

  • Upload de fichiers avec validation
  • Stockage sécurisé avec UUID
  • Gestion des types MIME
  • Intégration avec les plaintes et transports

📡 Communication inter-services​

NATS Message Broker​

Architecture : Cluster 3 serveurs pour haute disponibilité

  • Server 1 : Port 4232
  • Server 2 : Port 4233
  • Server 3 : Port 4234

Patterns de communication :

// Request-Response Pattern
const response = await this.natsClient.send('auth.checkToken', { token });

// Publish-Subscribe Pattern
this.natsClient.emit('user.created', userData);

// Queue Groups pour load balancing
@MessagePattern('process.transport', { queue: 'transport_queue' })

Queues NATS utilisées​

  • auth_queue : Authentification
  • admin-service : Administration
  • trade_queue : Commerce
  • organization_queue : Organisations
  • storage_queue : Stockage

🗄️ Couche de données​

MySQL Database (Port 3340)​

Configuration :

  • MySQL 8.0 avec optimisations InnoDB
  • Connexions poolées via Prisma
  • Transactions ACID pour la cohérence
  • Backup automatique configuré

Structure :

  • Users & Auth : Utilisateurs, rôles, sessions
  • Business : Transports, plaintes, organisations
  • Content : Forum, annonces, tutoriels
  • Config : Configurations système, types, catégories

Redis Cache (Intégré)​

Utilisation :

  • Cache des tokens d'authentification (TTL: 5 min)
  • Sessions utilisateurs actives
  • Données fréquemment consultées
  • Rate limiting et throttling

🔒 Sécurité multicouche​

Niveau 1 : API Gateway​

  • Validation des requêtes entrantes
  • Rate limiting par IP/utilisateur
  • Headers de sécurité (CORS, CSP)
  • Logging des tentatives d'accès

Niveau 2 : Authentification​

  • JWT avec signature HMAC-SHA256
  • Refresh tokens pour sessions longues
  • Cache intelligent des tokens valides
  • Audit trail complet

Niveau 3 : Autorisation​

  • RBAC (Role-Based Access Control)
  • Permissions granulaires par endpoint
  • Validation des ressources propriétaires
  • Isolation des données par organisation

Niveau 4 : Données​

  • Chiffrement des mots de passe (bcrypt)
  • Validation stricte des entrées (DTOs)
  • Requêtes préparées (protection SQL injection)
  • Audit des modifications sensibles

📊 Monitoring et observabilité​

Logging centralisé​

// Exemple de logging structuré
this.logger.log({
  action: 'user.login',
  userId: user.id,
  ip: request.ip,
  userAgent: request.headers['user-agent'],
  timestamp: new Date().toISOString()
});

Métriques de performance​

  • Temps de réponse par endpoint
  • Taux d'erreur par service
  • Utilisation des ressources
  • Santé des connexions NATS

Health Checks​

# Santé globale
GET /health

# Santé détaillée
GET /health/detailed

🚀 Scalabilité et performance​

Scalabilité horizontale​

  • Chaque microservice peut être répliqué
  • Load balancing automatique via NATS
  • Base de données centralisée pour cohérence
  • Cache distribué avec Redis Cluster

Optimisations appliquées​

  • Cache intelligent : Réduction 80% des appels DB
  • Connection pooling : Réutilisation des connexions
  • Lazy loading : Chargement à la demande
  • Pagination : Limitation des résultats
  • Compression : Réduction de la bande passante

Métriques de performance​

  • ⚡ Temps de réponse : < 100ms pour endpoints cachés
  • 🔄 Throughput : 1000+ requêtes/seconde
  • 📈 Cache hit ratio : > 90% pour l'authentification
  • 🛡️ Disponibilité : 99.9% avec cluster NATS

Prochaine section : Communication entre microservices