raft - Golang implementation of the Raft consensus protocol

We have collection of more than 1 Million open source products ranging from Enterprise product to small libraries in all platforms. We aggregate information from all open source repositories. Search and find the best for your needs. Check out projects section.

raft - Golang implementation of the Raft consensus protocol

raft is a Go library that manages a replicated log and can be used with an FSM to manage replicated state machines. It is a library for providing consensus.The use cases for such a library are far-reaching as replicated state machines are a key component of many distributed systems. They enable building Consistent, Partition Tolerant (CP) systems, with limited fault tolerance as well.

https://github.com/hashicorp/raft

Tags	raft consensus raft-consensus state-machine finite-state-machine fsm
Implementation	Go
License	Mozilla
Platform	Windows MacOS Linux

Related Projects

hraftd - A reference use of Hashicorp's Raft implementation

For background on this project check out this blog post. hraftd is a reference example use of the Hashicorp Raft implementation v1.0. Raft is a distributed consensus protocol, meaning its purpose is to ensure that a set of nodes -- a cluster -- agree on the state of some arbitrary state machine, even when nodes are vulnerable to failure and network partitions. Distributed consensus is a fundamental concept when it comes to building fault-tolerant systems.

distributed-systems raft hashicorp-raft key-value consensus

Copycat - A novel implementation of the Raft consensus algorithm

Java

Copycat is a fault-tolerant state machine replication framework. Built on the Raft consensus algorithm, it handles replication and persistence and enforces strict ordering of inputs and outputs, allowing developers to focus on single-threaded application logic. Its event-driven model allows for efficient client communication with replicated state machines, from simple key-value stores to wait-free locks and leader elections. You supply the state machine and Copycat takes care of the rest, making it easy to build robust, safe distributed systems.

raft distributed-systems consensus raft-consensus-algorithm state-machine consensus-algorithm replication database

braft - An industrial-grade C++ implementation of RAFT consensus algorithm based on brpc, widely used inside Baidu to build highly-available distributed systems

An industrial-grade C++ implementation of RAFT consensus algorithm and replicated state machine based on brpc. braft is designed and implemented for scenarios demanding for high workload and low overhead of latency, with the consideration for easy-to-understand concepts so that engineers inside Baidu can build their own distributed systems individually and correctly. Build brpc which is the main dependency of braft.

raft-consensus-algorithm raft raft-protocol raft-cpp raft-cxx distributed-storage distributed-consensus state-machine-replication

raft - UNMAINTAINED: A Go implementation of the Raft distributed consensus protocol.

NOTE: This project is unmaintained. If you are using goraft in a project and want to carry the project forward please file an issue with your ideas and intentions. The original project authors have created new raft implementations now used in etcd and InfluxDB.This is a Go implementation of the Raft distributed consensus protocol. Raft is a protocol by which a cluster of nodes can maintain a replicated state machine. The state machine is kept in sync through the use of a replicated log.

raft raft-consensus

raft-rs - Raft distributed consensus algorithm implemented in Rust.

Rust

When building a distributed system one principal goal is often to build in fault-tolerance. That is, if one particular node in a network goes down, or if there is a network partition, the entire cluster does not fall over. The cluster of nodes taking part in a distributed consensus protocol must come to agreement regarding values, and once that decision is reached, that choice is final. Distributed Consensus Algorithms often take the form of a replicated state machine and log. Each state machine accepts inputs from its log, and represents the value(s) to be replicated, for example, a hash table. They allow a collection of machines to work as a coherent group that can survive the failures of some of its members.

distributed-consensus-algorithms distributed-systems raft

Atomix - Scalable, fault-tolerant distributed systems protocols and primitives for the JVM

Java

Atomix is an event-driven framework for coordinating fault-tolerant distributed systems built on the Raft consensus algorithm. It provides the building blocks that solve many common distributed systems problems including group membership, leader election, distributed concurrency control, partitioning, and replication.

raft consensus consensus-algorithm raft-protocol raft-consensus-algorithm distributed-systems leader-election distributed-lock data-structures

dragonboat - A feature complete and high performance multi-group Raft library in Go.

Dragonboat is a high performance multi-group Raft consensus library in Go with C++11 binding support. Consensus algorithms such as Raft provides fault-tolerance by alllowing a system continue to operate as long as the majority member servers are available. For example, a Raft cluster of 5 servers can make progress even if 2 servers fail. It also appears to clients as a single node with strong data consistency always provided. All running servers can be used to initiate read requests for aggregated read throughput.

raft paxos distributed-systems raft-protocol raft-algorithm consensus replicated-state-machines raft-cpp raft-cxx distributed-storage

raft - C implementation of the Raft Consensus protocol, BSD licensed

C implementation of the Raft consensus protocol, BSD licensed. Networking is out of scope for this project. The implementor will need to do all the plumbing. The library doesn't assume a network layer with ordering or duplicate detection. This means you could use UDP for transmission.

raft-consensus-algorithm raft consensus protocol raft-consensus

Finn - Fast Raft framework using the Redis protocol for Go

Finn is a fast and simple framework for building Raft implementations in Go. It uses Redcon for the network transport and Hashicorp Raft. There is also the option to use LevelDB, BoltDB or FastLog for log persistence.The reason for this project is to add Raft support to a future release of BuntDB and Tile38.

raft redis raft-consensus leader-election fault-tolerant

Raft - C implementation of the Raft consensus protocol

Fully asynchronous C implementation of the Raft consensus protocol. The library has modular design: its core part implements only the core Raft algorithm logic, in a fully platform independent way. On top of that, a pluggable interface defines the I/O implementation for networking (send/receive RPC messages) and disk persistence (store log entries and snapshots).

raft consensus-algorithm algorithm leader-election distributed distributed-systems

rafter - An Erlang library application which implements the Raft consensus protocol

Erlang

Rafter is not production ready. It hasn't been tested or run in any production environments. Furthermore, the log is entirely my own creation. It's possible that it isn't as safe or efficient as many other log structured backends like leveldb or rocksdb. The protocol is solid and well tested, and it works as expected in most cases. However, support is not fully guaranteed as I don't have a current use case for rafter and am not actively developing it. I will however do my best to respond to reports and fix bugs in an efficient manner.Rafter is more than just an erlang implementation of the raft consensus protocol. It aims to take the pain away from building Consistent(2F+1 CP) distributed systems, as well as act as a library for leader election and routing. A main goal is to keep a very small user api that automatically handles the problems of the everyday Erlang distributed systems developer. It is hopefully your libPaxos.dll for erlang.

raft raft-consensus

logcabin - LogCabin is a distributed storage system built on Raft that provides a small amount of highly replicated, consistent storage

LogCabin is a distributed system that provides a small amount of highly replicated, consistent storage. It is a reliable place for other distributed systems to store their core metadata and is helpful in solving cluster management issues. LogCabin uses the Raft consensus algorithm internally and is actually the very first implementation of Raft. It's released under the ISC license (equivalent to BSD).Information about releases is in RELEASES.md.

raft logcabin raft-consensus

etcd - Distributed reliable key-value store for the most critical data of a distributed system

Note: The master branch may be in an unstable or even broken state during development. Please use releases instead of the master branch in order to get stable binaries. etcd is written in Go and uses the Raft consensus algorithm to manage a highly-available replicated log.

etcd raft distributed-systems kubernetes database key-value consensus distributed-database

go-raft - A Go implementation of the Raft distributed consensus protocol.

A Go implementation of the Raft distributed consensus protocol.

SummitDB - In-memory NoSQL database with ACID transactions, Raft consensus, and Redis API

SummitDB is an in-memory, NoSQL key/value database. It persists to disk, uses the Raft consensus algorithm, is ACID compliant, and built on a transactional and strongly-consistent model. It supports custom indexes, geospatial data, JSON documents, and user-defined JS scripting.Under the hood it utilizes Finn, Redcon, BuntDB, GJSON, and Otto.

raft json nosql database in-memory geospatial

tikv - Distributed transactional key-value database, originally created to complement TiDB

Rust

TiKV is an open-source, distributed, and transactional key-value database. Unlike other traditional NoSQL systems, TiKV not only provides classical key-value APIs, but also transactional APIs with ACID compliance. Built in Rust and powered by Raft, TiKV was originally created to complement TiDB, a distributed HTAP database compatible with the MySQL protocol. The design of TiKV ('Ti' stands for titanium) is inspired by some great distributed systems from Google, such as BigTable, Spanner, and Percolator, and some of the latest achievements in academia in recent years, such as the Raft consensus algorithm.

distributed-transactions raft key-value tikv consensus rocksdb tidb cncf

Dqlite - High-availability SQLite

Dqlite is a fast, embedded, persistent SQL database with Raft consensus that is perfect for fault-tolerant IoT and Edge devices. Dqlite (“distributed SQLite”) extends SQLite across a cluster of machines, with automatic failover and high-availability to keep your application running. It uses C-Raft, an optimised Raft implementation in C, to gain high-performance transactional consensus and fault tolerance while preserving SQlite’s outstanding efficiency and tiny footprint.

sqlite database embedded-database distributed-database embedded distributed

Tendermint - Tendermint Core (BFT Consensus) in Go

Tendermint Core is Byzantine Fault Tolerant (BFT) middleware that takes a state transition machine - written in any programming language - and securely replicates it on many machines.

bft distributed-systems replication consistency db consensus blockchain cryptography state-machine fault-tolerent

tikv - Distributed transactional key value database powered by Rust and Raft

Rust

Geo-Replication TiKV uses Raft and Placement Driver to support Geo-Replication.Horizontal scalability With Placement Driver and carefully designed Raft groups, TiKV excels in horizontal scalability and can easily scale to 100+ TBs of data.

distributed-transactions raft key-value tikv consensus rocksdb tidb