Barrel
EN GitHub

Écrire sur chaque nœud

Faites tourner une copie de la base sur chaque site, appareil ou région. Chaque copie accepte les écritures pendant que son lien est coupé, et la réplication ramène toutes les copies au même état sans perdre une modification.

Active-active : ni leader, ni base primaire. Construit avec les tâches de réplication de barrel_docdb et le canal _sync servi par barrel_server.

Le problème

Sites, appareils et régions ont chacun besoin de leurs données en local, plus une copie centrale, sur des liens qui vont et viennent. Une base primaire fait attendre le réseau à chaque site, et une synchronisation où la dernière écriture gagne perd en silence un côté de chaque modification concurrente.

Comment les pièces s’assemblent

  1. Site A (votre release Erlang)

    • Votre application lit et écrit en local
    • inventory barrel_docdb, sur disque local
  2. tâche continue, dans les deux sens
  3. Hub (barrel_server)

    • /db/inventory/_sync le canal de réplication
    • inventory la copie centrale
  4. tâche continue, dans les deux sens
  5. Site B et les autres

    • Votre application lit et écrit en local
    • inventory sa propre copie

Chaque copie accepte les écritures. Chaque nœud fait tourner une tâche vers le hub ; le hub transmet les changements aux autres nœuds. Filtres et canaux décident des documents que reçoit un nœud.

Deux sites modifient la même tâche

Coupez la liaison, modifiez des deux côtés, synchronisez. Aucune modification n’est perdue : les deux copies choisissent la même gagnante et gardent l’autre modification comme conflit jusqu’à ce que quelqu’un le résolve.

L’appel derrière votre dernière actionDémonstration dans votre navigateur, selon les règles de barrel

 

Le construire

Cinq étapes : un hub, puis les mêmes quelques appels sur chaque nœud.

  1. Lancer un hub

    Un barrel_server avec un jeton partagé par les nœuds. La réplication ne crée pas de base : créez-la d’abord.

    %% sys.config of the hub
    [{barrel_server, [
       {http_port, 8080},
       {auth, #{tokens => [<<"sync-token">>]}}
     ]}].
  2. Intégrer Barrel sur chaque nœud

    Créez la même base en local. Donnez le jeton par origine dans l’environnement de l’application, pour que la configuration des tâches ne contienne aucun secret.

    Erlang, sur chaque nœud
    {ok, _} = application:ensure_all_started(barrel_docdb),
    {ok, _} = barrel_docdb:create_db(<<"inventory">>),
    application:set_env(barrel_docdb, sync_auth,
        #{<<"http://hub.example:8080">> => <<"sync-token">>}).
  3. Lancer une tâche continue dans les deux sens

    Les tâches survivent aux redémarrages. Une source locale réveille la tâche à chaque changement ; le côté distant est interrogé périodiquement, 500 ms après des données et jusqu’à 15 s quand il est inactif.

    Erlang, sur chaque nœud
    {ok, TaskId} = barrel_rep_tasks:start_task(#{
        source    => <<"inventory">>,
        target    => <<"http://hub.example:8080/db/inventory">>,
        mode      => continuous,
        direction => both}).
  4. Écrire en local, connecté ou non

    Les écritures n’attendent jamais le hub. Quand le lien tombe, la tâche espace ses tentatives de 1 s à 60 s, enregistre last_error et reste running ; elle rattrape son retard depuis son point de reprise quand le lien revient.

    Erlang
    {ok, _} = barrel_docdb:put_doc(<<"inventory">>,
        #{<<"id">> => <<"sku:42">>, <<"qty">> => 7}),
    {ok, #{status := running}} =
        barrel_rep_tasks:get_task(TaskId).
  5. Résoudre les conflits qui vous importent

    Deux sites qui modifient le même document pendant qu’ils sont séparés gardent chacun leur modification : chaque copie choisit le même gagnant et garde l’autre comme conflit. Résolvez-le en écrivant une version qui remplace les versions observées. Un conflict_resolver passé à create_db peut le faire pour vous.

    Erlang
    {ok, #{<<"_observed">> := Seen}} =
        barrel_docdb:get_doc(<<"inventory">>, <<"sku:42">>,
                             #{conflicts => true}),
    {ok, _} = barrel_docdb:resolve_conflict(<<"inventory">>,
        <<"sku:42">>, Seen, {merge, #{<<"qty">> => 5}}).
    Forme du résultat, d’après une exécution enregistrée (autres noms)
    {ok,#{id => <<"task:1">>,
          rev => <<"000001a1b879d59500000000@w7bcb971434496877">>,
          conflicts_resolved => 1}}

Ce que fait Barrel

  • Ordonne les écritures avec une horloge logique hybride et des vecteurs de versions
  • Choisit le même gagnant sur chaque copie, et garde les modifications concurrentes comme conflits
  • Enregistre un point de reprise à chaque lot et reprend après une panne
  • Déplace les pièces jointes avec leurs documents, adressées par leur contenu
  • Filtre à la source par chemin, requête ou canal

Ce que fait votre application

  • Choisit la topologie : un hub, plusieurs, ou un maillage
  • Décide quelles données vont où, avec des filtres ou des canaux
  • Remet à chaque nœud son jeton via sync_auth
  • Résout les conflits, ou définit un conflict_resolver
  • Surveille l’état des tâches et last_error

Limites

  • Les index vectoriels ne sont pas répliqués. En mode enregistrement, les documents voyagent et chaque nœud reconstruit son index.
  • La provenance (acteur, session, source) reste sur le nœud qui a reçu l’écriture ; les arrivées sont marquées comme répliquées.
  • Un document qui quitte un canal reste sur les répliques qui l’ont déjà.
  • La façade barrel n’expose pas la réplication : appelez barrel_rep_tasks sur le nom docdb.
  • Un pair dont l’horloge est trop en avance est refusé avec clock_skew. Les listeners HTTP/3 ne vérifient pas encore les certificats clients.

Aller plus loin

Haut et bas pour se déplacerEntrée pour ouvrir