Performances et scalabilité

📊 Performances et scalabilité

État actuel des performances

Métriques clés

Métrique	Valeur actuelle	Objectif
Temps de réponse API (p50)	45ms	< 100ms
Temps de réponse API (p95)	180ms	< 500ms
Génération IA (moyenne)	8s	< 15s
Uptime	99.2%	99.9%
Utilisateurs simultanés	100 testés	10 000 cible

Benchmarks

API Backend
Génération IA

Endpoint: GET /api/v1/collections
Concurrence: 50 utilisateurs
Durée: 60 secondes

xychart-beta
    title "Résultats du benchmark API"
    x-axis ["Req/s", "Latence moy (ms)", "P95 (ms)", "P99 (ms)"]
    y-axis "Valeur" 0 --> 500
    bar [450, 42, 156, 312]

Métrique	Valeur
Requêtes/sec	450
Latence moyenne	42ms
P95 latence	156ms
P99 latence	312ms
Erreurs	0% ✅

Opération: Générer 10 cartes depuis un document
Taille document: 5000 mots
Modèle: GPT-4

pie showData
    title "Répartition du temps de génération"
    "Durée moyenne (8.2s)" : 82
    "Overhead (1.8s)" : 18

Métrique	Valeur
Durée moyenne	8.2s
Tokens utilisés	~3500
Coût par génération	~$0.12
Taux de succès	98% ✅

Architecture cloud

flowchart LR
 subgraph Client["Client"]
        RN["React Native"]
  end
 subgraph DNS["DNS"]
        API_DNS["api.mindlet.app"]
        WS_DNS["ws.mindlet.app"]
  end
 subgraph Ingress["Nginx Ingress Controller"]
        LB["Load Balancer"]
        RT["Router"]
  end
 subgraph API["API Deployment"]
        OCT["Laravel Octane"]
        POD_API1["POD"]
        POD_API2["POD"]
        POD_API3["POD"]
  end
 subgraph WS["WS Deployment"]
        REV["Laravel Reverb"]
        POD_WS["POD"]
  end
 subgraph REDIS["Redis Service"]
        REDIS_APP["Redis"]
        POD_REDIS["POD"]
  end
 subgraph WORKERS["Worker supervisors"]
        HZ["Laravel Horizon"]
        POD_W1["POD"]
        POD_W2["POD"]
        POD_W3["POD"]
  end
 subgraph K8S["OVH Cloud Kubernetes Cluster"]
        Ingress
        API_SVC(("api-service"))
        WS_SVC(("ws-service"))
        API
        WS
        REDIS
        WORKERS
  end
 subgraph Neon["Neon"]
        PG[("PostgreSQL")]
  end
 subgraph Qdrant["Qdrant Cloud"]
        VDB[("Vector DB")]
  end
 subgraph LangGraph["LangGraph Cloud"]
        CARD["Card generation"]
        EMB["Embeddings"]
  end
    RN --> API_DNS & WS_DNS
    LB --> RT
    API_DNS --> LB
    WS_DNS --> LB
    RT --> API_SVC & WS_SVC
    OCT --> POD_API1 & POD_API2 & POD_API3
    REV --> POD_WS
    REDIS_APP --> POD_REDIS
    HZ --> POD_W1 & POD_W2 & POD_W3
    API_SVC --> API
    WS_SVC --> WS
    API <--> REDIS
    WS <--> REDIS
    WORKERS <--> REDIS
    API --> PG & VDB & CARD & EMB

Infrastructure actuelle

Composant	Configuration	Fournisseur
API (Kubernetes)	2 pods, 1 CPU, 2GB RAM	OVHcloud
PostgreSQL	Managed, 2 vCPU, 4GB RAM	OVHcloud
Redis	Managed, 1GB RAM	OVHcloud
Qdrant	1 instance, 2GB RAM	Hetzner
MinIO	Object storage, 50GB	OVHcloud

Stratégies de scalabilité

Scalabilité horizontale

Kubernetes HPA

Auto-scaling des pods API basé sur CPU/mémoire

Load Balancer

Distribution de charge entre les instances

Stateless Design

Chaque pod peut traiter n’importe quelle requête

Queue Workers

Traitement asynchrone des tâches lourdes

Configuration Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mindlet-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mindlet-api
  template:
    spec:
      containers:
        - name: api
          image: mindlet/api:latest
          resources:
            requests:
              cpu: "500m"
              memory: "1Gi"
            limits:
              cpu: "1000m"
              memory: "2Gi"
          readinessProbe:
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 5
            periodSeconds: 10
---
# hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: mindlet-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: mindlet-api
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80

Traitement asynchrone

// Job de génération de cartes
class GenerateCardsJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;
    public int $timeout = 120;

    public function __construct(
        private Document $document,
        private User $user
    ) {
        $this->onQueue('high');
    }

    public function handle(AIService $aiService): void
    {
        $cards = $aiService->generateCards($this->document);

        event(new CardsGenerated($cards, $this->user));
    }

    public function failed(Throwable $exception): void
    {
        Log::error('Card generation failed', [
            'document_id' => $this->document->id,
            'error' => $exception->getMessage(),
        ]);

        $this->user->notify(new GenerationFailedNotification());
    }
}

Projections de montée en charge

Scénarios de croissance

Utilisateurs	API Pods	IA Workers	DB Size	Coût estimé/mois
100 (actuel)	2	1	5GB	50€
1 000	4	2	20GB	150€
10 000	8	4	100GB	500€
100 000	16+	8+	500GB	2 000€+

Points de friction identifiés

Composant	Risque	Solution prévue
Base de données	Connexions saturées	Connection pooling (PgBouncer)
Service IA	Coûts LLM	Cache des réponses, modèles locaux
Stockage	Croissance rapide	Politique de rétention, compression
Qdrant	Mémoire insuffisante	Sharding, clustering

Optimisations réalisées

Cache applicatif

class CollectionController extends Controller
{
    public function index(Request $request): JsonResponse
    {
        $userId = $request->user()->id;

        $collections = Cache::remember(
            "user:{$userId}:collections",
            now()->addMinutes(5),
            fn () => Collection::where('user_id', $userId)
                ->with('cards:id,collection_id')
                ->get()
        );

        return CollectionResource::collection($collections);
    }
}

Optimisation des requêtes

// Avant : N+1 queries
$collections = Collection::all();
foreach ($collections as $collection) {
    echo $collection->cards->count(); // Requête à chaque itération
}

// Après : Eager loading
$collections = Collection::withCount('cards')->get();
foreach ($collections as $collection) {
    echo $collection->cards_count; // Pas de requête supplémentaire
}

Indexation base de données

-- Index pour les requêtes fréquentes
CREATE INDEX idx_cards_collection_type ON cards(collection_id, type);
CREATE INDEX idx_cards_user_created ON cards(user_id, created_at DESC);
CREATE INDEX idx_collections_user ON collections(user_id);

-- Index pour la recherche full-text
CREATE INDEX idx_cards_question_gin ON cards
  USING gin(to_tsvector('french', question));

Monitoring et alertes

Stack de monitoring

Outil	Usage
Prometheus	Collecte de métriques
Grafana	Visualisation
Sentry	Error tracking
Laravel Telescope	Debug en développement

Métriques surveillées

// Middleware de métriques
class MetricsMiddleware
{
    public function handle($request, $next)
    {
        $start = microtime(true);

        $response = $next($request);

        $duration = microtime(true) - $start;

        Metrics::histogram('http_request_duration_seconds', $duration, [
            'method' => $request->method(),
            'path' => $request->path(),
            'status' => $response->status(),
        ]);

        return $response;
    }
}

Alertes configurées

Métrique	Seuil	Action
CPU > 80% pendant 5min	Warning	Notification Slack
Latency p95 > 1s	Critical	Alerte email + Slack
Error rate > 5%	Critical	Alerte immédiate
Disk usage > 85%	Warning	Notification

Prêt pour la croissance, conçu pour la performance.