Une base clé-valeur qui survit aux pannes.

Mbolo réplique chaque écriture sur 3 ou 5 nœuds avec Raft. Arrêtez un nœud, coupez le réseau : le cluster continue de répondre, sans perdre une donnée.

$ curl -fsSL https://mbolo.zaleo.dev/install.sh | sh

Linux et macOS, x86_64 et arm64v0.1.0Lire le script

Cluster de 5 nœuds, en direct
t = 0,00 s
N1suiveurmandat 0N2suiveurmandat 0N3suiveurmandat 0N4suiveurmandat 0N5suiveurmandat 0
N1
N2
N3
N4
N5
Élection du premier leader…

Cliquez un nœud pour l’arrêter ou l’isoler.

Pas une animation : le code Raft de Mbolo, compilé en WebAssembly, tourne ici dans le simulateur de ses tests. Les cases sont les entrées du journal, colorées par mandat ; en pointillé, pas encore validées.

Trois nœuds en deux minutes.

Après l’installation, tout se passe sur votre machine. Pas de root, pas de Docker.

1

Lancer trois nœuds

Chaque nœud écoute ses pairs sur le port 700x, les clients sur le 800x, et garde son journal dans mbolo/.

zsh
$ P=1=127.0.0.1:7001,2=127.0.0.1:7002,3=127.0.0.1:7003
$ for i in 1 2 3; do
    mbolo-node --id $i --peers $P --client 127.0.0.1:800$i --data mbolo/n$i 2>/dev/null &
  done
2

Écrire, lire

Le client trouve le leader tout seul. status montre qui dirige et où en est chaque journal.

$ mbolo-cli put ville Dakar
OK
$ mbolo-cli get ville
Dakar
$ mbolo-cli status | cut -c1-52
node 1: Leader    term 1    leader 1     commit 2
node 2: Follower  term 1    leader 1     commit 2
node 3: Follower  term 1    leader 1     commit 2
3

Tuer le leader

Un kill -9, sans prévenir. Les deux autres élisent un nouveau leader, et l’écriture suivante passe environ 268 ms après le crash.

# le leader est le nœud 1
$ pkill -9 -f 'mbolo-node --id 1'
$ mbolo-cli put ville Thiès
OK
$ mbolo-cli get ville
Thiès
$ mbolo-cli status | cut -c1-52
node 1: down (Connection refused (os error 111))
node 2: Leader    term 2    leader 2     commit 4
node 3: Follower  term 2    leader 2     commit 4
4

Le relancer

Il relit son journal sur disque, apprend qui dirige, et rattrape ce qu’il a manqué.

$ mbolo-node --id 1 --peers $P --client 127.0.0.1:8001 --data mbolo/n1 2>/dev/null &
$ mbolo-cli status | cut -c1-52
node 1: Follower  term 2    leader 2     commit 4
node 2: Leader    term 2    leader 2     commit 4
node 3: Follower  term 2    leader 2     commit 4
$ mbolo-cli get ville
Thiès

Cassé exprès, des milliers de fois.

Un bug de consensus n’apparaît qu’une fois sur mille. Alors Mbolo rejoue des milliers de pannes, et vérifie chaque réponse donnée aux clients.

30 000
simulations déterministes
0 échec

135 860 crashs, 89 031 coupures réseau, horloges qui dérivent. 25,2 millions d’opérations vérifiées linéarisables.

162 028
opérations façon Jepsen
0 anomalie

12 runs sur de vrais processus : 58 kill -9, 98 coupures de liens TCP, 7 changements de membres.

7 sur 8
bugs plantés, attrapés

Pour tester les tests, on casse Raft exprès. Le huitième bug (la figure 8 du papier) passe entre les mailles : voir les limites.

Rejouez une graine.

Une graine décide de tout : latences, pannes, clients. La même graine donne la même exécution, ici comme dans le terminal. À la fin, l’historique est vérifié et l’empreinte doit être identique.

$ mbolo-sim --seed 18
fingerprint: …
Graine 18, 12 s simulées
t = 0,00 s
N1suiveurmandat 0N2suiveurmandat 0N3suiveurmandat 0
N1
N2
N3
  1. Les pannes de cette graine s’afficheront ici.

Mesuré sur un portable.

Trois nœuds sur une seule machine, chaque écriture forcée sur disque (fsync) chez le leader et un suiveur. Un i7 de 2019 sous WSL2, pas un serveur.

2 295écritures/s

Avec 64 clients, médiane 26 ms. Un seul fsync couvre toutes les écritures en attente.

268 ms

Du kill -9 du leader à la première écriture acceptée par le suivant (médiane sur 40 essais).

Lectures linéarisables par seconde

3 nœuds, 64 clients. Trois façons de prouver qu’on lit la dernière valeur.

Bail du leader19 656/s · 3 ms

Aucun aller-retour, mais suppose des horloges à peu près justes.

ReadIndex12 011/s · 4,9 ms

Un battement de cœur confirme que le leader l’est toujours.

Par le journal1 972/s · 30 ms

La lecture passe par le consensus et le disque, comme une écriture.

Médianes de 3 runs. Les mesures complètes sont dans la doc.

Ce qui n’est pas fait.

Mbolo est un projet d’apprentissage sérieux, pas une base de production. Voici ses limites connues.

  • Le fsync bloque la boucle d’événements.Le leader n’écrit pas sur disque en parallèle de la réplication : une écriture attend deux fsync l’un après l’autre.
  • Un membre à la fois.Ajouts et retraits un par un, sans consensus conjoint (joint consensus) ni phase d’apprenti.
  • Pas de preuve formelle.La simulation aléatoire rate le bug de la figure 8. Un modèle TLA+ serait le bon outil pour ces recoins.
  • Jepsen sur une seule machine.Un kill -9 ne vide pas le cache disque ; c’est la simulation qui couvre les écritures coupées.
  • Lectures par bail : horloges supposées justes.Aucune lecture périmée à 30 et 50 % de dérive dans les tests : un échantillon, pas une preuve.
  • Petits volumes.Les instantanés partent en un seul message et tiennent en mémoire. Pas de transactions multi-clés.

Télécharger Mbolo 0.1.0.

Trois binaires : mbolo-node, mbolo-cli et mbolo-sim. Le script vérifie la somme SHA-256 et installe dans ~/.local/bin.

$ curl -fsSL https://mbolo.zaleo.dev/install.sh | sh
PlateformeArchiveSHA-256
Linux x86_64mbolo-0.1.0-linux-x86_64.tar.gz 1,5 Mo9d21b487806dda84b840f36601e5a70fd2f6b9df989243bcbcdd997599553a7d
Linux arm64 (aarch64)mbolo-0.1.0-linux-aarch64.tar.gz 1,5 Moa12dd54e0b799bec6a7c12ec0e66efd9e7772bfa4d179b23ae32064396012394
macOS Apple siliconmbolo-0.1.0-macos-arm64.tar.gz 1,2 Mo50ada0a1a57735e4e85c64cb3ece15a1c0cfb11f962cc7b359b17879335cb744
macOS Intelmbolo-0.1.0-macos-x86_64.tar.gz 1,3 Mof3d6cf786629555232109d065873cfbd71c895ad9327a9bef987d6a2e8f5a200

Toutes les commandes, les options des nœuds et du simulateur, et comment les tests sont faits.

Lire la documentation