Classements en temps réel : architecture technique

Le classement Real Time est un ensemble de services qui transforme des millions d'événements de jeu en positions mises à jour en des centaines de millisecondes, tout en préservant l'honnêteté, l'audit et la gestion économique. Ci-dessous est un constructeur pratique des exigences à l'exploitation.

1) Exigences et objectifs

Latence jusqu'à UI : ≤ 200-300 ms p95 de l'arrivée de l'événement à la mise à jour de la position.

Précision : score correct des « meilleurs N « /divisions/tie-break à la charge et aux pannes.

Disponibilité : ≥ 99. 9 % pour la période du tournoi ; dégradation sans perte d'intégrité.

Idempotence : « une fois exactement » au niveau des charges, « au moins une fois » dans les transports.

Échelle : croissance horizontale par région/division/équipe (top-K sur le ballon).

Audit : logiques immuables des règles, des événements, des évaluations et des émissions.

2) Schéma système (niveau 10 000 ft)

Клиент → Event Ingest → Scoring Engine → Stream Aggregator (Top-K/Top-M) → Write-Optimized Store → Hot Cache/Edge → UI/Comms → Rewards/Claim

Фоново: Snapshotter, Anti-Fraud/RG, Analytics & A/B, Audit/Observability.

3) Accueil des événements (Event Ingest)

Défis : protection contre les prises, les surtensions, les pertes de réseau.

Idempotence : chaque événement a « event _ uuid » ; vérification « vu/nettoyé ».

La sémantique de la livraison : le transport est at-least-once, l'enregistrement des lunettes est exactly-once.

Backpressure : files d'attente avec lots dynamiques ; en cas de surcharge, la priorité des tours « actifs ».

Fenêtres temporelles : nous admettons les événements late (par exemple, jusqu'à 90 secondes) - nous les acheminons vers la « fenêtre de recalculation ».

Temps : serveur UTC, sur le client - affichage local uniquement.

4) Score de points (Scoring Engine)

Principes : Règles versionnables, anti-pay-to-win, retour facile.

Versioning : 'rule _ set _ id' + feature-flags per-region/division.

Modèles : multiplier ('Score = round (100log2 (Win/Bet + 1))'), win-based avec courbe de log, wager-based (uniquement comme méta de fond).

Score "meilleur N' : nous gardons la structure top-N pour le joueur/jour/tournée ; sommation/médiane par format.

Exceptions : bonus 'coef _ bonus ≤ 0. 5 'ou « 0 » ; kap per spin/day ; quotas pour le fournisseur.

Tie-break : 1) réalisation antérieure de la pente finale ; 2) plus de diversité ; 3) seed déterministe.

5) Stream-agrégation et top K

Objectif : recalculer rapidement les positions sans scanner l'ensemble.

Chardonnage : 'shard _ id = hash (division_id	region	tournament_id)`; volume fixe du top K dans la charpente.
Algorithmes : Min-heap pour le top K, arbre d'ordre statistique ou « counted B-tree » ; pour les équipes - Sum Top-M contributions.
Incrémentalité : nous ne renouvelons que les positions changeantes ; diff-abonnements (push-player-centric).
Fusion : le top K local sur la écharpe → le top mondial via k-way merge (régulier).
Événements tardifs : recalculation « shadow » et mise à jour sécurisée avec le versioning de l'état.

6) Stockage : write vs read

Write-optimized store : journal de calcul, états "best-n', tie-break, métadonnées (entrée/update uniquement).

Read-optimized store (Query) : « vitrines » dénormalisées pour l'UI : top 100, « ma position », « top day/division », contribution à l'équipe.

Photos (Snapshotter) : heures « snepshots » du leader ; rollback/replay rapide, rapports et audit.

Cohérence : eventual pour les grandes listes, read-your-writes pour « ma position ».

7) Cache et Edge

Cache chaud : dernières positions et score des joueurs sur le ballon ; TTL 1-5 secondes ; invalidité par événement.

Couche Edge/CDN : blocs statiques, pages de résultats « froides », mais pas la logique de calcul.

Fallback : en cas de dégradation - « mode bronze » : mise à jour de l'UI toutes les X secondes + bloc de widgets lourds.

8) Temps, fenêtres et temporisations

Temps « vrai » unique : UTC sur les services ; les deblines en UTC.

Localisation : conversion du temps sur le client (fuseau horaire de l'utilisateur).

Limites : « fenêtre molle » de fermeture 1-3 min pour les lagunes de réseau (en T&C).

Nous allons en classe word : surveillance clock-skew, alertes NTP, mesure de la dérive.

9) Lutte contre les événements tardifs et en double

Événements de late : nous tenons la « fenêtre de reconnaissance » ; recalculer localement + calmement les positions de la bande de notification.

Doublets : 'event _ uuid' + (player, game, bet, ts) dans une fenêtre étroite ; le magazine « seen ».

Idempotence de facturation : transaction « événement → modification » avec statut de applied/rolled_back.

10) Anti-froid et RG (intégré dans le pipline)

Scoring comportemental : intervalles uniformes, super-vitesse, « pas de bruit » - drapeaux.

Graphique des liens : devis/IP/paiements communs → clusters ; holds de récompenses, vérification manuelle.

Quotas et caps : N meilleurs essais/jour, quotas par fente/fournisseur, caps points par spin/jour.

Bonus : ratios/exclusion.

RG : les points ne sont accumulés que dans les limites volontaires (temps/dépôts/pertes) ; rappels des pauses.

11) Multi-région et tolérance aux pannes

Actif-actif par région : Chardes régionales + ensemble mondial ; routage par proximité.

RTO/RPO : RTO <15 min (folback sur les snepshots), RPO = 0 pour les charges (repliement idempotent de la loge).

Partition-tolerance : en cas de rupture du réseau, un leader local, une consolidation ultérieure et une correction douce des positions.

FX et devises : si les prix sont dans différentes monnaies - nous fixons le moment de la conversion, le tampon FX est de 1-3 %.

12) Sécurité et vie privée

Données : minimisation (alias, sans PII dans l'agrégateur), cryptage « en vol » et « au repos ».

Accès : principe du moindre privilège, secrets dans KMS, audit d'accès.

T & S/juridictions : logs de règles/versions, blocs géographiques, limites d'âge.

13) Observabilité et pratiques SRE

SLO : Lag UI ≤ 300 ms p95, temps de Claim ≤ 10 min p95, aptyme ≥ 99. 9%.

Métriques : events/sec, proportion de prises/rejetées, taux de late, croissance heap du top K, strim, erreurs de calcul, taux de claim.

Tracing : de bout en bout (ingest → scoring → cache → UI).

Alert : bouton stop (disable lourd expérimentation/réduire N meilleur), auto-dégradation.

Post-mortem : RCA en 24-48 h, liste des éléments d'action, politique error-budget.

14) Rewards & Claim

Prix automatique : lors d'un événement de fermeture - calcul des positions, émission, reçus.

Claim-fenêtre : ≤ 72 heures, retraits de livraison, ordre de paiement déterministe.

Transparence : historique des récompenses dans le profil : règle, temps, montant, source.

Holds : pour les prix rares/précieux jusqu'à KYC/AML.

15) Expériences A/B et évolution des schémas

Que tester : N meilleur (10/20), kap per spin (on/off), bonus de diversité (0/50/100), type d'agrégation (somme/médiane).

Randomisation : par région/canal/cluster - on évite les débordements.

Guardrails : RTP, plaintes/10k, signaux RG - ne se détériore pas.

Migration : compatibilité des schémas de stockage, double écriture (dual-write) pendant la durée de la migration.

16) Modèles UX de notations real-time

Centre de classement : règle de victoire, minuteur, votre compte, les tentatives restantes, next reward.

« + 40 points pour x3 », « il reste 2 essais sur 20 », « tu es monté de 3 places ».

Vitrines : top 100 général, « ma position », « top jour/division », contribution à l'équipe.

A11y : contraste, grands nombres, focus states, voix du progrès.

Localisation : deadlines/minuteries en TZ local, multilinguisme.

17) Défaillances fréquentes et scénarios de dégradation

Échec	Un symptôme	Action
Pic de charge sur Ingest	Augmentation des files d'attente	Réduction temporaire des N meilleurs, hiérarchisation des tours actifs
Chute du processeur de stream	Stagnation du top K	Feilover workers, repliement de la loge, affichage du snepshot
Taux-late surestimé	Ajustements massifs	Agrandir la « fenêtre molle », mettre clairement en surbrillance les rebonds dans l'interface utilisateur
Doublages d'événements	« Double lunettes »	Plus stricte déduplication, bloc de sources suspectes
Lag cache	« Sauts » de positions	Invalidité par événement, limitation des demandes lourdes

18) Chéquiste de lancement des classements temps réel

Règles/Économie

Formule, N des meilleurs, tie-break, divisions
RewardRate, largeurs de paiement, Wajers, claim ≤ 72 h

Technique

Idempotent Ingest, Late Window, Chardonnage
Stream-Aggregator (топ-K/Top-M), Snapshotter
Hot Cache/Edge, API Santé/État, bouton stop

Sécurité/RG

Scoring comportemental, graphe des liens, kaps/quotas
Limites RG, rappels, KYC/AML pour les grands prix

Données/A/B

Dashboards : late-rate, doublons, métriques fairness
Plan d'expérimentation et de guardrails, dual-write sur les migrations

UX

Centre de notation, micro-fidbek, A11y, localisation
Règles brèves en 1 écran + plein T&C

Un classement en temps réel fiable n'est pas un seul service, mais un écosystème discipliné : une réception idempotente, un scoring versionable, une agrégation de top K, un cache rapide, des instantanés d'état et des mécanismes anti-frod/RG intégrés. Ajoutez un SLO/SLA rigoureux, un UX compréhensible et une vérification des changements via A/B - et vous obtiendrez des leaders auxquels les joueurs ont confiance, et le produit obtient une croissance prévisible de Retentation, Stick....et LTV.