Skip to content

kaligautier/tinder-match-engine

BranchesTags

Repository files navigation

Système de Recommandation de Profils

Description

Ce projet implémente un système de recommandation de profils utilisateur utilisant une architecture microservices. Le système permet aux utilisateurs de consulter des profils recommandés et d'interagir avec eux (like, dislike, superlike).

Architecture

Le système est composé de plusieurs services interconnectés :

  • API Gateway : Point d'entrée unique pour toutes les requêtes
  • Redis : Cache et stockage des templates (port 6380)
  • Dragonfly : Cache haute performance Redis-compatible (port 6379, mode host)
  • Kafka : Messagerie asynchrone pour les événements
  • PostgreSQL : Base de données principale
  • OpenSearch : Moteur de recherche et indexation
  • Gemini : Service de traitement et analyse

Architecture Réseau

L'environnement de développement utilise une segmentation réseau logique pour une meilleure organisation et sécurité :

Réseaux Docker

  • tinder-data : Services de stockage et données

    • postgres + postgres-mcp : Base de données principale et interface MCP
    • redis : Cache Redis sur port 6380
    • opensearch : Moteur de recherche et indexation

  • tinder-messaging : Écosystème de messagerie asynchrone

    • zookeeper : Coordination et configuration Kafka
    • kafka : Broker de messages pour les événements

  • tinder-monitoring : Interfaces de monitoring et administration

    • opensearch-dashboards : Interface de gestion OpenSearch
    • kafka-ui : Interface de gestion Kafka

Services Multi-Réseaux

  • opensearch-dashboards : Connecté à tinder-data et tinder-monitoring
  • kafka-ui : Connecté à tinder-messaging et tinder-monitoring

Configuration Spéciale

  • Dragonfly : Utilise le mode host pour des performances optimales
    • Accès direct au réseau de l'hôte (pas de NAT Docker)
    • Port 6379 accessible directement sur localhost
    • Recommandé pour les workloads haute performance

Fonctionnalités

Gestion des Profils

  • Demande et récupération de profils utilisateur
  • Stockage et mise en cache des données de profil
  • Recherche et filtrage de profils

Système de Recommandation

  • Calcul des prochains profils à présenter
  • Prise en compte des interactions précédentes
  • Mise à jour en temps réel des recommandations

Interactions Utilisateur

  • Like : Marquer un profil comme apprécié
  • Dislike : Marquer un profil comme non apprécié
  • Superlike : Interaction premium pour montrer un intérêt particulier

Matching

  • Détection automatique des matches mutuels
  • Notification en temps réel via Kafka
  • Sauvegarde des matches dans PostgreSQL

Flux de Données

1. Consultation de Profils

User → API → Redis (Template) → Kafka → PostgreSQL → OpenSearch → Gemini

2. Interaction avec un Profil

User → API → Redis (Cache) → Kafka (Async) → PostgreSQL (Match Detection)

3. Calcul de Score et Sauvegarde

Kafka → PostgreSQL → Score Calculation → Database Update

Technologies Utilisées

  • Backend : API REST
  • Cache : Redis pour le stockage temporaire et les templates
  • Message Queue : Apache Kafka pour les événements asynchrones
  • Base de données : PostgreSQL pour la persistance
  • Recherche : OpenSearch pour l'indexation et la recherche
  • IA/ML : Gemini pour l'analyse et les recommandations

Installation et Configuration

Prérequis

  • Docker et Docker Compose
  • Redis
  • PostgreSQL
  • Apache Kafka
  • OpenSearch
  • Accès à l'API Gemini

Variables d'Environnement

REDIS_URL=redis://localhost:6379
POSTGRES_URL=postgresql://user:password@localhost:5432/dbname
KAFKA_BROKERS=localhost:9092
OPENSEARCH_URL=https://localhost:9200
GEMINI_API_KEY=your_api_key

Lancement

1. Démarrage des Services Infrastructure

# Cloner le repository
git clone [repository-url]
cd tinder-match-engine

# Lancer tous les services de développement
docker-compose -f dev/docker-compose.yml up -d

# Ou lancer seulement certains services par réseau
docker-compose -f dev/docker-compose.yml up -d postgres redis opensearch  # tinder-data
docker-compose -f dev/docker-compose.yml up -d zookeeper kafka            # tinder-messaging
docker-compose -f dev/docker-compose.yml up -d dragonfly                  # cache haute performance

2. Vérification des Services

# Vérifier que tous les conteneurs sont démarrés
docker-compose -f dev/docker-compose.yml ps

# Vérifier les logs si nécessaire
docker-compose -f dev/docker-compose.yml logs dragonfly
docker-compose -f dev/docker-compose.yml logs kafka

3. Accès aux Interfaces

  • Application Tinder : http://localhost:8083
  • PostgreSQL : localhost:5432
  • Redis : localhost:6380
  • Dragonfly : localhost:6379 (mode host)
  • Kafka : localhost:9092
  • OpenSearch : localhost:9200
  • Kafka UI : http://localhost:8080
  • OpenSearch Dashboards : http://localhost:5601
  • PostgreSQL MCP : http://localhost:8000

4. Démarrage de l'Application Spring Boot

Option A : Avec Docker Compose (Recommandé pour développement complet)
# Copier le fichier d'exemple des variables d'environnement
cp .env.example .env

# Éditer .env et renseigner vos clés API (Supabase, Gemini)
nano .env  # ou vim, code, etc.

# Démarrer TOUS les services (infrastructure + application)
docker-compose -f dev/docker-compose.yml up -d

# Vérifier les logs de l'application
docker-compose -f dev/docker-compose.yml logs -f tinder-app

# Vérifier la santé de l'application
curl http://localhost:8083/health

L'application sera accessible sur http://localhost:8083

Option B : En local avec Maven (pour développement Java)
# Démarrer uniquement l'infrastructure (sans l'app)
docker-compose -f dev/docker-compose.yml up -d postgres redis kafka opensearch

# Installer les dépendances Maven
./mvnw clean install

# Démarrer l'application avec profil dev
./mvnw spring-boot:run -Dspring-boot.run.profiles=dev

# Ou avec Maven wrapper pour tests
./mvnw test

L'application sera accessible sur http://localhost:8083

Peuplement des Données de Test

Script de Localisation OpenSearch

Pour tester les fonctionnalités de géolocalisation, un script simple permet de peupler OpenSearch avec les coordonnées GPS des utilisateurs de test.

# Installer requests si nécessaire
pip3 install requests

# Lancer le script (application Spring Boot doit être démarrée)
python3 scripts/simple_populate_locations.py

Les 6 utilisateurs de test seront positionnés dans les grandes villes françaises :

  • Alice Martin (Paris), Julien Dubois (Lyon), Marie Bernard (Marseille)
  • Pierre Garcia (Bordeaux), Sophie Petit (Nice), Thomas Robert (Toulouse)

API Endpoints

Match (Interactions)

Base URL: /api/v1/match/users

  • POST /{userId}/like/{targetUserId} - Liker un profil
  • POST /{userId}/superlike/{targetUserId} - SuperLike un profil
  • POST /{userId}/dislike/{targetUserId} - Dislike un profil

Géolocalisation

Base URL: /api/user-location

  • POST / - Sauvegarder une localisation utilisateur
  • GET /{userId} - Récupérer les localisations d'un utilisateur
  • GET / - Récupérer toutes les localisations
  • GET /{userId}/last - Récupérer la dernière localisation
  • GET /{userId}/nearby?radiusKm={radius} - Trouver les utilisateurs à proximité

Profils

Base URL: /api/v1/profiles

  • GET /users/{userId}/profiles/{viewerUserId}/view - Obtenir les détails d'un profil

Découverte de Profils

Base URL: /api/v1/profiles/discovery

  • GET /users/{userId}/next - Obtenir le prochain profil à découvrir
  • POST /users/{userId}/queue/refresh - Rafraîchir la file d'attente
  • POST /users/{userId}/profiles/{profileId}/viewed - Marquer un profil comme vu
  • GET /users/{userId}/queue/status - Obtenir le statut de la file d'attente

Gestion Utilisateurs

Base URL: /api/user

  • GET /{uuid} - Récupérer un utilisateur par UUID
  • GET / - Récupérer tous les utilisateurs
  • POST / - Créer un nouvel utilisateur
  • PUT /{uuid} - Mettre à jour un utilisateur
  • DELETE /{uuid} - Supprimer un utilisateur
  • DELETE / - Supprimer tous les utilisateurs

Système de Boost

Base URL: /api/v1/boost/users

  • POST /{userId}/activate - Activer un boost pour un utilisateur
  • POST /{userId}/deactivate/{boostId} - Désactiver un boost spécifique
  • GET /{userId}/status - Récupérer le statut des boosts actifs
  • GET /{userId}/history - Récupérer l'historique complet des boosts

Types de Boost disponibles:

  • VISIBILITY - Augmente la visibilité du profil
  • SUPER_LIKES - Boost pour les super likes
  • PROFILE_PRIORITY - Priorité d'affichage du profil

Exemple de requête d'activation:

{
  "type": "VISIBILITY",
  "durationMinutes": 60,
  "purchasePrice": 9.99
}

Monitoring et Logs

Le système utilise une approche événementielle avec Kafka pour tracer toutes les interactions. Les logs sont centralisés et permettent un monitoring en temps réel des performances du système de recommandation.

Architecture Docker

Services Containerisés

L'application complète peut tourner entièrement dans Docker :

┌─────────────────────────────────────────────────────────────┐
│                    TINDER MATCH ENGINE                       │
├─────────────────────────────────────────────────────────────┤
│  tinder-app (Spring Boot)  ←→  Port 8083                   │
│       ↓                ↓               ↓                     │
│  [tinder-data]   [tinder-messaging]   [host network]        │
│       ↓                ↓               ↓                     │
│  PostgreSQL        Kafka           Dragonfly                 │
│  Redis             Zookeeper       (port 6379)               │
│  OpenSearch                                                  │
└─────────────────────────────────────────────────────────────┘

Avantages de la Containerisation

  1. Environnement Reproductible : Même configuration dev/staging/prod
  2. Isolation : Chaque service dans son propre conteneur
  3. Déploiement Simplifié : Un seul docker-compose up
  4. Scalabilité : Facile de scaler horizontalement avec Kubernetes
  5. CI/CD Ready : Image Docker buildée et pushée automatiquement

Variables d'Environnement

Toutes les variables sensibles sont externalisées dans .env :

  • Clés API (Supabase, Gemini, OpenAI)
  • Credentials de base de données (si overriding)
  • Configuration réseau custom

Contribution

  1. Fork le projet
  2. Créer une branche feature (git checkout -b feature/nouvelle-fonctionnalite)
  3. Commit les changements (git commit -am 'Ajout nouvelle fonctionnalité')
  4. Push sur la branche (git push origin feature/nouvelle-fonctionnalite)
  5. Créer une Pull Request

License

[Spécifier la license du projet]

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases 1

Release pour la publication de mon article. Latest
Oct 21, 2025

Packages

 
 
 

Contributors

Languages