BASE (Basically Available, Soft state, Eventually consistent)

BASE est un modèle de cohérence pour les systèmes distribués qui contraste avec ACID en privilégiant la disponibilité sur la cohérence stricte. Conçu pour les architectures à grande échelle, BASE accepte que les données soient temporairement incohérentes entre les nœuds, garantissant qu'elles convergeront vers un état cohérent. Cette approche répond aux contraintes du théorème CAP en choisissant la disponibilité (Availability) et la tolérance au partitionnement (Partition tolerance) plutôt que la cohérence forte (Consistency).

Fondements du modèle BASE

• Basically Available : le système garantit la disponibilité des données même en cas de pannes partielles, quitte à retourner des données potentiellement obsolètes
• Soft state : l'état du système peut changer sans intervention externe à cause de la propagation asynchrone des modifications entre nœuds
• Eventually consistent : le système converge vers la cohérence après un délai, sans garantie de cohérence immédiate après une écriture
• Optimisation pour la scalabilité horizontale et les performances en lecture/écriture distribuées

Avantages du modèle BASE

• Haute disponibilité : les opérations continuent même lors de défaillances de nœuds ou de partitions réseau
• Scalabilité horizontale : ajout facile de nœuds sans impact sur les performances globales
• Latence réduite : les écritures ne nécessitent pas de consensus synchrone entre tous les nœuds
• Résilience accrue : tolérance aux pannes sans interruption complète du service
• Performances optimales pour les systèmes distribués à grande échelle (millions d'utilisateurs, milliards de transactions)

Exemple concret d'implémentation

Un système de recommandations e-commerce illustre parfaitement BASE. Lorsqu'un utilisateur achète un produit, cette information doit se propager à plusieurs services : inventaire, recommandations, analytics. Avec BASE, l'achat est confirmé immédiatement (disponibilité), mais les recommandations peuvent prendre quelques secondes à se mettre à jour (cohérence éventuelle).

// Système d'événements BASE avec cohérence éventuelle
interface PurchaseEvent {
  userId: string;
  productId: string;
  timestamp: number;
  version: number;
}

class BASEEventStore {
  private eventLog: PurchaseEvent[] = [];
  private replicas: Map<string, PurchaseEvent[]> = new Map();

  // Écriture disponible immédiatement (Basically Available)
  async recordPurchase(event: PurchaseEvent): Promise<void> {
    // Écriture locale sans attendre les répliques
    this.eventLog.push(event);
    
    // Propagation asynchrone (Eventually Consistent)
    this.propagateToReplicas(event).catch(err => {
      console.log('Propagation retardée, réessai planifié');
      this.scheduleRetry(event);
    });
  }

  // Propagation asynchrone vers les répliques
  private async propagateToReplicas(event: PurchaseEvent): Promise<void> {
    const replicaPromises = Array.from(this.replicas.keys()).map(replicaId => 
      this.sendToReplica(replicaId, event)
        .catch(() => ({ replicaId, success: false }))
    );
    
    // On n'attend pas toutes les répliques (Soft State)
    await Promise.race([...replicaPromises, this.timeout(100)]);
  }

  // Lecture avec détection de versions (résolution de conflits)
  async getUserPurchases(userId: string): Promise<PurchaseEvent[]> {
    const localEvents = this.eventLog.filter(e => e.userId === userId);
    
    // Réconciliation avec les répliques si disponibles
    const replicaEvents = await this.fetchFromReplicas(userId);
    
    return this.mergeWithVersioning(localEvents, replicaEvents);
  }

  // Résolution de conflits par versioning (Eventually Consistent)
  private mergeWithVersioning(
    local: PurchaseEvent[], 
    remote: PurchaseEvent[]
  ): PurchaseEvent[] {
    const merged = new Map<string, PurchaseEvent>();
    
    [...local, ...remote].forEach(event => {
      const key = `${event.userId}-${event.productId}`;
      const existing = merged.get(key);
      
      // Prendre la version la plus récente
      if (!existing || event.version > existing.version) {
        merged.set(key, event);
      }
    });
    
    return Array.from(merged.values());
  }

  private timeout(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  private async sendToReplica(replicaId: string, event: PurchaseEvent): Promise<void> {
    // Simulation d'envoi réseau
    await this.timeout(Math.random() * 50);
  }

  private async fetchFromReplicas(userId: string): Promise<PurchaseEvent[]> {
    return [];
  }

  private scheduleRetry(event: PurchaseEvent): void {
    setTimeout(() => this.propagateToReplicas(event), 5000);
  }
}

Mise en œuvre d'une architecture BASE

1. Identifier les cas d'usage tolérants à la cohérence éventuelle (réseaux sociaux, analytics, recommandations)
2. Choisir une base de données compatible BASE (Cassandra, DynamoDB, Riak, MongoDB avec réplication)
3. Implémenter un système de versioning ou de timestamps pour la résolution de conflits
4. Mettre en place un event sourcing ou un log d'événements pour la traçabilité
5. Configurer les niveaux de cohérence par opération (lecture/écriture quorum ajustable)
6. Développer des mécanismes de compensation pour gérer les incohérences temporaires
7. Monitorer les délais de convergence et ajuster les paramètres de réplication

Technologies et outils associés

• Apache Cassandra : base NoSQL distribuée avec cohérence configurable (eventual consistency par défaut)
• Amazon DynamoDB : base clé-valeur managée avec cohérence éventuelle et forte en option
• Riak : base de données distribuée conçue pour la haute disponibilité avec résolution de conflits
• CouchDB : base documentaire avec réplication multi-maître et cohérence éventuelle
• Redis Cluster : cache distribué avec réplication asynchrone
• Event Store : stockage d'événements pour event sourcing avec garanties BASE
• Kafka : plateforme de streaming pour la propagation asynchrone d'événements entre services

BASE représente un compromis architectural essentiel pour les systèmes modernes à grande échelle. En acceptant la cohérence éventuelle, les entreprises peuvent construire des plateformes capables de servir des millions d'utilisateurs simultanés avec une disponibilité de 99,99%. L'enjeu est de bien identifier où appliquer BASE (fonctionnalités non critiques, analytics, caches) versus ACID (transactions financières, inventaire), permettant ainsi d'optimiser coûts d'infrastructure et expérience utilisateur.