200 行代码实现基于 Paxos 的 KV 存储

Paxos&Quorum 注: 这里谈论的2PC不同于事务中的2PC,而是专门为了同步和高可用改过的2PC协议 问题: 寻求一种能够保证,在给定多台计算机,并且他们之间由网络相互连通,中间的数据没有拜占庭将军问题(数据不会被伪造)的前提下,能够做到以下两个特性的方法: 1)数据每次成功的写入,数据不会丢失,并且按照写入的顺序排列 2)给定安全级别,保证服务可用性,并尽可能减少机器的消 阅读详情

前言

写完【paxos 的直观解释】之后,网友都说疗效甚好,但是也会对这篇教程中一些环节提出疑问(有疑问说明真的看懂了 ),例如怎么把只能确定一个值的 paxos 应用到实际场景中。

既然 Talk is cheap,那么就 Show me the code,这次我们把教程中描述的内容直接用代码实现出来,希望能覆盖到教程中的涉及的每个细节。帮助大家理解 paxos 的运行机制。

这是一个基于 paxos,200 行代码的 kv 存储系统的简单实现,作为【paxos 的直观解释】这篇教程中的代码示例部分。Paxos 的原理本文不再介绍了,本文提到的数据结构使用【protobuf】定义,网络部分使用【grpc】定义。另外 200 行 go 代码实现 paxos 存储。

文中的代码可能做了简化, 完整代码实现在【paxoskv】这个项目中(naive 分支)。

运行和使用

跑一下:

git clone https://github.com/openacid/paxoskv.git
cd paxoskv
go test -v ./...

这个项目中除了 paxos 实现,用 3 个 test case 描述了 3 个 paxos 运行的例子,

  • 【TestCase1SingleProposer】:无冲突运行。
  • 【TestCase2DoubleProposer】:有冲突运行。
  • 【Example_setAndGetByKeyVer】作为 key-val 使用。

测试代码描述了几个 paxos 运行例子的行为,运行测试可以确认 paxos 的实现符合预期。

本文中 protobuf 的数据结构定义如下:

service PaxosKV {
    rpc Prepare (Proposer) returns (Acceptor) {}
    rpc Accept (Proposer) returns (Acceptor) {}
}
message BallotNum {
    int64 N          = 1;
    int64 ProposerId = 2;
}
message Value {
    int64 Vi64 = 1;

以及主要的函数实现:

// struct KVServer
Storage : map[string]Versions
func Accept(c context.Context, r *Proposer) (*Acceptor, error)
func Prepare(c context.Context, r *Proposer) (*Acceptor, error)
func getLockedVersion(id *PaxosInstanceId) *Version

// struct Proposer
func Phase1(acceptorIds []int64, quorum int) (*Value, *BallotNum, error)
func Phase2(acceptorIds []int64, quorum int) (*BallotNum, error)
func RunPaxos(acceptorIds []int64, val *Value) *Value
func rpcToAll(acceptorIds []int64, action string) []*Acceptor

func ServeAcceptors(acceptorIds []int64) []*grpc.Server

从头实现 Paxoskv

Paxos 相关的数据结构

在这个例子中我们的数据结构和服务框架使用【protobuf】和【grpc】实现,首先是最底层的 paxos 数据结构:Proposer 和 Acceptor在【slide-27】中我们介绍了 1 个 Acceptor 所需的字段:

在存储端(Acceptor)也有几个概念:
  • last_rnd 是 Acceptor 记住的最后一次进行写前读取的 Proposer(客户端)是谁,以此来决定谁可以在后面真正把一个值写到存储中。
  • v 是最后被写入的值。
  • vrnd 跟 v 是一对, 它记录了在哪个 Round 中 v 被写入了。

原文中这些名词是参考了【paxos made simple】中的名称,但在【Leslie Lamport】后面的几篇 paper 中都换了名称,为了后续方便,在【paxoskv】的代码实现中也做了相应的替换:

rnd      ==> Bal   // 每一轮paxos的编号, BallotNum
vrnd     ==> VBal  // 在哪个Ballot中v被Acceptor 接受(voted)
last_rnd ==> LastBal

Proposer 的字段也很简单,它需要记录:

  • 当前的 ballot number:Bal,
  • 以及它选择在 Phase2 运行的值:Val(【slide-29】)。

于是在这个项目中用 protobuf 定义这两个角色的数据结构,如代码【paxoskv.proto】中的声明,如下:

message Acceptor {
  BallotNum LastBal = 1;
  Value     Val = 2;
  BallotNum VBal = 3;
}

message Proposer {
  PaxosInstanceId Id = 1;

  BallotNum Bal = 2;
  Value     Val = 3;
}

其中 Proposer 还需要一个 PaxosInstanceId,来标识当前的 paxos 实例为哪个 key 的哪个 version 在做决定,【paxos made simple】中只描述了一个 paxos 实例的算法(对应一个 key 的一次修改),要实现多次修改,就需要增加这个字段来区分不同的 paxos 实例:

message PaxosInstanceId {
  string Key = 1;
  int64  Ver = 2;
}

【paxoskv.proto】还定义了一个 BallotNum,因为要保证全系统内的 BallotNum 都有序且不重复,一般的做法就是用一个本地单调递增的整数,和一个全局唯一的 id 组合起来实现:

message BallotNum {
    int64 N = 1;
    int64 ProposerId = 2;
}

定义 RPC 消息结构

RPC 消息定义了 Proposer 和 Acceptor 之间的通讯。

在一个 paxos 系统中,至少要有 4 个消息:

  • Phase 1 的 Prepare-request,Prepare-reply
  • Phase 2 的 Accept-request,Accept-reply

如【slide-28】所描述的(原文中使用 rnd,这里使用 Bal,都是同一个概念):

Phase- 1(Prepare): request:
Bal: int

reply:
LastBal: int
Val: string
VBal: int
Phase- 2(Accept):
request:
Bal: int
Val: string

reply:
LastBal: int

在 Prepare-request 或 Accept-request 中,发送的是一部分或全部的 Proposer 的字段,因此我们在代码中:

  • 直接把 Proposer 的结构体作为 request 的结构体
  • 同样把 Acceptor 的结构体作为 reply 的结构体

在使用的时候只使用其中几个字段,对应我们的 RPC 服务【PaxosKV】定义如下:

service PaxosKV {
    rpc Prepare (Proposer) returns (Acceptor) {}
    rpc Accept (Proposer) returns (Acceptor) {}
}

使用 Protobuf 和 Grpc 生成服务框架

protobuf 可以将【paxoskv.proto】直接生成 go 代码(代码库中已经包含了生成好的代码:【paxoskv.pb.go】,只有修改【paxoskv.proto】之后才需要重新生成)

  • 首先安装 protobuf 的编译器 protoc,可以根据【install-protoc】中的步骤安装, 一般简单的一行命令就可以了:安装好之后通过 protoc--version 确认版本,至少应该是 3.x: libprotoc 3.13.0
    • Linux:apt install-y protobuf-compiler
    • Mac:brew install protobuf
  • 安装 protoc 的 go 语言生成插件 protoc-gen-go:go get -u http://github.com/golang/protobuf/protoc-gen-go
  • 重新编译 protokv.proto 文件:直接 make gen 或:
  protoc \
      --proto_path=proto \
      --go_out=plugins=grpc:paxoskv \
      paxoskv.proto

生成后的【paxoskv.pb.go】代码中可以看到,其中主要的数据结构例如 Acceptor 的定义:

type Acceptor struct {
  LastBal *BallotNum ...
  Val     *Value ...
  VBal    *BallotNum ...
        ...
}

以及 KV 服务的 client 端和 server 端的代码,client 端是实现好的,server 端只有一个 interface,后面我们需要来完成它的实现:

type paxosKVClient struct {
  cc *grpc.ClientConn
}
type PaxosKVClient interface {
  Prepare(
    ctx context.Context,
    in *Proposer,
    opts ...grpc.CallOption
  ) (*Acceptor, error)

  Accept(
    ctx context.Context,
    in *Proposer,
    opts ...grpc.CallOption
  ) (*Acceptor, error)
}

type PaxosKVServer interface {
  Prepare(context.Context,
          *Proposer) (*Acceptor, error)
  Accept(context.Context,
         *Proposer) (*Acceptor, error)
}

实现存储的服务器端

【impl.go】是所有实现部分,我们定义一个 KVServer 结构体,用来实现 grpc 服务的 interface PaxosKVServer;其中使用一个内存里的 map 结构模拟数据的存储:

type Version struct {
  mu       sync.Mutex
  acceptor Acceptor
}
type Versions map[int64]*Version
type KVServer struct {
  mu      sync.Mutex
  Storage map[string]Versions
}

其中 Version 对应一个 key 的一次变化,也就是对应一个 paxos 实例,Versions 对应一个 key 的一系列变化,Storage 就是所有 key 的所有变化。

实现 Acceptor 的 grpc 服务 handler

Acceptor,是这个系统里的 server 端,监听一个端口,等待 Proposer 发来的请求并处理,然后给出应答。

根据 paxos 的定义,Acceptor 的逻辑很简单:在【slide-28】中描述:

根据教程里的描述,为 KVServer 定义 handle Prepare-request 的代码:

func (s *KVServer) Prepare(
    c context.Context,
    r *Proposer) (*Acceptor, error) {

  v := s.getLockedVersion(r.Id)
  defer v.mu.Unlock()

  reply := v.acceptor

  if r.Bal.GE(v.acceptor.LastBal) {
    v.acceptor.LastBal = r.Bal
  }

  return &reply, nil
}

这段代码分 3 步:

  • 取得 paxos 实例,
  • 生成应答:Acceptor 总是返回 LastBal,Val,VBal 这 3 个字段,所以直接把 Acceptor 赋值给 reply。
  • 最后更新 Acceptor 的状态:然后按照 paxos 算法描述,如果请求中的 ballot number 更大,则记录下来,表示不在接受更小 ballot number 的 Proposer。

其中 getLockedVersion() 从 KVServer.Storage 中根据 request 发来的PaxosInstanceId 中的字段 key 和 ver 获取一个指定 Acceptor 的实例:

func (s *KVServer) getLockedVersion(
    id *PaxosInstanceId) *Version {

  s.mu.Lock()
  defer s.mu.Unlock()

  key := id.Key
  ver := id.Ver
  rec, found := s.Storage[key]
  if !found {
    rec = Versions{}
    s.Storage[key] = rec
  }

  v, found := rec[ver]
  if !found {
    // initialize an empty paxos instance
    rec[ver] = &Version{
      acceptor: Acceptor{
        LastBal: &BallotNum{},
        VBal:    &BallotNum{},
      },
    }
    v = rec[ver]
  }

  v.mu.Lock()
  return v
}

handle Accept-request 的处理类似,在【slide-31】中描述:

Accept() 要记录 3 个值,

  • LastBal:Acceptor 看到的最大的 ballot number;
  • Val:Proposer 选择的值,
  • 以及 VBal:Proposer 的 ballot number:
func (s *KVServer) Accept(
    c context.Context,
    r *Proposer) (*Acceptor, error) {

  v := s.getLockedVersion(r.Id)
  defer v.mu.Unlock()

  reply := Acceptor{
    LastBal: &*v.acceptor.LastBal,
  }

  if r.Bal.GE(v.acceptor.LastBal) {
    v.acceptor.LastBal = r.Bal
    v.acceptor.Val = r.Val
    v.acceptor.VBal = r.Bal
  }

  return &reply, nil
}

Acceptor 的逻辑到此完整了,再看 Proposer:

实现 Proposer 逻辑

Proposer 的运行分 2 个阶段,Phase1 和 Phase2,与 Prepare 和 Accept 对应。

Phase1

在【impl.go】的实现中,Proposer.Phase1() 函数负责 Phase1 的逻辑:

func (p *Proposer) Phase1(
    acceptorIds []int64,
    quorum int) (*Value, *BallotNum, error) {

  replies := p.rpcToAll(acceptorIds, "Prepare")

  ok := 0
  higherBal := *p.Bal
  maxVoted := &Acceptor{VBal: &BallotNum{}}

  for _, r := range replies {
    if !p.Bal.GE(r.LastBal) {
      higherBal = *r.LastBal
      continue
    }

    if r.VBal.GE(maxVoted.VBal) {
      maxVoted = r
    }

    ok += 1
    if ok == quorum {
      return maxVoted.Val, nil, nil
    }
  }

  return nil, &higherBal, NotEnoughQuorum
}

这段代码首先通过 rpcToAll() 向所有 Acceptor 发送 Prepare-request 请求, 然后找出所有的成功的 reply:

  • 如果发现一个更大的 ballot number,表示一个 Prepare 失败:有更新的Proposer 存在;
  • 否则,它是一个成功的应答,再看它有没有返回一个已经被 Acceptor 接受(voted)的值。

最后,成功应答如果达到多数派(quorum),则认为 Phase1 完成,返回最后一个被 voted 的值,也就是 VBal 最大的那个。让上层调用者继续 Phase2;如果没有达到 quorum,这时可能是有多个 Proposer 并发运行而造成冲突,有更大的 ballot number,这时则把见到的最大 ballot number 返回,由上层调用者提升 ballot number 再重试。

client 与 server 端的连接

上面用到的 rpcToAll 在这个项目中的实现 client 端(Proposer)到 server 端(Acceptor)的通讯,它是一个十分 简洁美观 简陋的 grpc 客户端实现:

func (p *Proposer) rpcToAll(
    acceptorIds []int64,
    action string) []*Acceptor {

  replies := []*Acceptor{}

  for _, aid := range acceptorIds {
    var err error
    address := fmt.Sprintf("127.0.0.1:%d",
        AcceptorBasePort+int64(aid))

    conn, err := grpc.Dial(
        address, grpc.WithInsecure())
    if err != nil {
      log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()

    c := NewPaxosKVClient(conn)

    ctx, cancel := context.WithTimeout(
        context.Background(), time.Second)
    defer cancel()

    var reply *Acceptor
    if action == "Prepare" {
      reply, err = c.Prepare(ctx, p)
    } else if action == "Accept" {
      reply, err = c.Accept(ctx, p)
    }
    if err != nil {
      continue
    }
    replies = append(replies, reply)
  }
  return replies
}

Phase2

Proposer 运行的 Phase2 在【slide-30】中描述,比 Phase1 更简单:

在第 2 阶段 phase-2,Proposer X 将它选定的值写入到 Acceptor 中,这个值可能是它自己要写入的值,或者是它从某个 Acceptor 上读到的 v(修复)。
func (p *Proposer) Phase2(
    acceptorIds []int64,
    quorum int) (*BallotNum, error) {

  replies := p.rpcToAll(acceptorIds, "Accept")

  ok := 0
  higherBal := *p.Bal
  for _, r := range replies {
    if !p.Bal.GE(r.LastBal) {
      higherBal = *r.LastBal
      continue
    }
    ok += 1
    if ok == quorum {
      return nil, nil
    }
  }

  return &higherBal, NotEnoughQuorum
}

我们看到,它只需要确认成 Phase2 的功应答数量达到 quorum 就可以了。另外同样它也有责任在 Phase2 失败时返回看到的更大的 ballot number,因为在 Phase1 和 Phase2 之间可能有其他 Proposer 使用更大的 ballot number 打断了当前 Proposer 的执行,就像【slide-33】的冲突解决的例子中描述的那样。

完整的 Paxos 逻辑

完整的 paxos 由 Proposer 负责,包括:如何选择一个值,使得一致性得以保证。如【slide-29】中描述的:

Proposer X 收到多数(quorum)个应答,就认为是可以继续运行的。如果没有联系到多于半数的 acceptor,整个系统就 hang 住了,这也是 paxos 声称的只能运行少于半数的节点失效。这时 Proposer 面临 2 种情况:

所有应答中都没有任何非空的 v,这表示系统之前是干净的,没有任何值已经被其他 paxos 客户端完成了写入(因为一个多数派读一定会看到一个多数派写的结果),这时 Proposer X 继续将它要写的值在 phase-2 中真正写入到多于半数的 Acceptor 中。

如果收到了某个应答包含被写入的 v 和 vrnd,这时,Proposer X 必须假设有其他客户端(Proposer)正在运行,虽然 X 不知道对方是否已经成功结束,但任何已经写入的值都不能被修改!所以 X 必须保持原有的值。于是 X 将看到的最大 vrnd 对应的 v 作为 X 的 phase-2 将要写入的值。

这时实际上可以认为 X 执行了一次(不知是否已经中断的)其他客户端(Proposer)的修复。

基于 Acceptor 的服务端和 Proposer 2 个 Phase 的实现,最后把这些环节组合到一起组成一个完整的 paxos,在我们的代码【RunPaxos】这个函数中完成这些事情:

func (p *Proposer) RunPaxos(
    acceptorIds []int64,
    val *Value) *Value {

  quorum := len(acceptorIds)/2 + 1

  for {
    p.Val = val

    maxVotedVal, higherBal, err := p.Phase1(
        acceptorIds, quorum)

    if err != nil {
      p.Bal.N = higherBal.N + 1
      continue
    }

    if maxVotedVal != nil {
      p.Val = maxVotedVal
    }

    // val == nil 是一个读操作,
    // 没有读到voted值不需要Phase2
    if p.Val == nil {
      return nil
    }

    higherBal, err = p.Phase2(
        acceptorIds, quorum)

    if err != nil {
      p.Bal.N = higherBal.N + 1
      continue
    }

    return p.Val
  }
}

这段代码完成了几件事:运行 Phase1,有 voted 的值就选它,没有就选自己要写的值 val,然后运行 Phase2。

就像 Phase1 Phase2 中描述的一样,任何一个阶段,如果没达到 quorum,就需要提升遇到的更大的 ballot number,重试去解决遇到的 ballot number 冲突。这个函数接受 2 个参数:

  • 所有 Acceptor 的列表(用一个整数的 id 表示一个 Acceptor),
  • 以及要提交的值。

其中,按照 paxos 的描述,这个值 val 不一定能提交:如果 paxos 在 Phase1 完成后看到了其他已经接受的值(voted value),那就要选择已接收的值,放弃 val。遇到这种情况,在我们的系统中,例如要写入 key=foo,ver=3 的值为 bar,如果没能选择 bar,就要选择下一个版本 key=foo,ver=4 再尝试写入。

这样不断的重试循环, 写操作最终都能成功写入一个值(voted value)。

实现读操作

在我们这个 NB(naive and basic)的系统中,读和写一样都要通过一次 paxos 算法来完成。因为写入过程就是一次 paxos 执行,而 paxos 只保证在一个 quorum 中写入确定的值,不保证所有节点都有这个值。因此一次读操作如果要读到最后写入的值,至少要进行一次多数派读。

但多数派读还不够:它可能读到一个未完成的 paxos 写入,如【slide-11】中描述的脏读问题,读取到的最大 VBal 的值,可能不是确定的值(写入到多数派)。

例如下面的状态:

Val=foo    Val=bar    ?
VBal=3     VBal=2     ?
-------    -------    --
A0         A1         A2

如果 Proposer 试图读,在 Phase1 联系到 A0 A1 这 2 个 Acceptor,那么 foo 和 bar 这 2 个值哪个是确定下来的,要取决于 A2 的状态。所以这时要再把最大VBal 的值跑完一次 Phase2,让它被确定下来,然后才能把结果返回给上层(否则另一个 Proposer 可能联系到 A1 和 A2,然后认为 Val=bar 是被确定的值)。

当然如果 Proposer 在读取流程的 Phase1 成功后没有看到任何已经 voted 的值(例如没有看到 foo 或 bar), 就不用跑 Phase2 了。

所以在这个版本的实现中,读操作也是一次【RunPaxos】函数的调用,除了它并不 propose 任何新的值,为了支持读操作,所以在上面的代码中 Phase2 之前加入一个判断,如果传入的 val 和已 voted 的值都为空,则直接返回:

if p.Val == nil {
  return nil
}

【Example_setAndGetByKeyVer】这个测试用例展示了如何使用 paxos 实现一个 kv 存储,实现读和写的代码大概这样:

prop := Proposer{
  Id: &PaxosInstanceId{
    Key: "foo",
    Ver: 0,
  },
  Bal: &BallotNum{N: 0, ProposerId: 2},
}

// 写:
v := prop.RunPaxos(acceptorIds, &Value{Vi64: 5})

// 读:
v := prop.RunPaxos(acceptorIds, nil)

到现在为止,本文中涉及到的功能都实现完了,完整实现在【impl.go】中。

接着我们用测试用例实现 1 下【paxos的直观解释】中列出的 2 个例子, 从代码看 poxos 的运行:

文中例子

第1个例子是 paxos 无冲突的运行【slide-32】:

把它写成 test case,确认教程中每步操作之后的结果都如预期

【TestCase1SingleProposer】:

func TestCase1SingleProposer(t *testing.T) {
  ta := require.New(t)

  acceptorIds := []int64{0, 1, 2}
  quorum := 2

  // 启动3个Acceptor的服务
  servers := ServeAcceptors(acceptorIds)
  defer func() {
    for _, s := range servers {
      s.Stop()
    }
  }()

  // 用要更新的key和version定义paxos 实例的id
  paxosId := &PaxosInstanceId{
    Key: "i",
    Ver: 0,
  }

  var val int64 = 10

  // 定义Proposer, 随便选个Proposer id 10.
  var pidx int64 = 10
  px := Proposer{
    Id:  paxosId,
    Bal: &BallotNum{N: 0, ProposerId: pidx},
  }

  // 用左边2个Acceptor运行Phase1,
  // 成功, 没有看到其他的ballot number
  latestVal, higherBal, err := px.Phase1(
      []int64{0, 1}, quorum)

  ta.Nil(err, "constitued a quorum")
  ta.Nil(higherBal, "no other proposer is seen")
  ta.Nil(latestVal, "no voted value")

  // Phase1成功后, 因为没有看到其他voted的值,
  // Proposer选择它自己的值进行后面的Phase2
  px.Val = &Value{Vi64: val}

  // Phase 2
  higherBal, err = px.Phase2(
      []int64{0, 1}, quorum)

  ta.Nil(err, "constitued a quorum")
  ta.Nil(higherBal, "no other proposer is seen")
}

第 2 个例子对应 2 个 Proposer 遇到冲突并解决冲突的例子,略长不贴在文中了,代码可以在 【TestCase2DoubleProposer】看到。

工程

Paxos 的出色之处在于它将分布式一致性问题简化到最核心的部分,没有任何多余的设计。

工程实现上我们多数时候会用一个 paxos 的变体,它需要对 paxos 中的实例扩展为一系列多值的操作日志,支持完整的状态机,以及对运维提供支持成员变更,所以 raft 在工程上更受欢迎:

https://github.com/datafuselabs/openraft创建 openraft 这个项目的目的是:

  • 优化和改良 raft 算法本身的问题:
    • 例如一个 term 内无法选出多个 leader,造成选举冲突过多的问题,
    • 例如不必要的 pre-vote 阶段的引入,
    • 例如 raft 作为一个一致性算法对外部时钟的依赖,
    • 例如强制的 leader/candidate 阶段的拆分使得换 leader 要经历一个无法服务的 candidate-state 的阶段。

openraft 正在解决的这些问题,使之不仅仅是一个为了性能和安全用 rust 重写的项目。

  • 其次在用户接口上,提供一组语义明确的 async API。

参考链接

本文用到的代码在 paxoskv 项目的 naive 分支上:

【https://github.com/openacid/paxoskv/tree/naive】

关于 Databend

Databend 是一款开源、弹性、低成本,基于对象存储也可以做实时分析的新式数仓。期待您的关注,一起探索云原生数仓解决方案,打造新一代开源 Data Cloud。

文章首发于公众号:Databend

分布式数据库,基于Paxos多副本的两地三中心架构 本篇文章是对云栖大会所分享内容的一个技术补充,期望从数据库架构设计的视角,分享下在大型银行落地PolarDB-X的经验,介绍Paxos多副本 + 传统两地三中心上的技术思考。 阅读详情

相关推荐

FoundationDB:解耦架构如何重塑分布式事务型KV存储的可靠性与性能边界

本文深入解析FoundationDB的架构解耦设计如何提升分布式事务型KV存储的可靠性与性能。通过将系统拆分为事务管理、日志和存储三个独立子系统,FoundationDB实现了线性扩展和高吞吐量。文章详细介绍了其优化的事务处理机制、秒级故障恢复能力以及强大的模拟测试框架,为分布式系统设计提供了新思路。

weixin_28702105的博客 339

Paxos 算法详解

Paxos 算法是一种用于解决分布式系统中一致性问题的经典算法。它通过准备阶段和接受阶段来确保提案在多数派接受者之间达成一致。虽然 Paxos 算法在原理上相对简单,但在实际应用中可能需要进行一些优化和变种以适应不同的场景和需求。通过深入理解 Paxos 算法的原理和变种,我们可以更好地设计和实现分布式系统的一致性解决方案。

Weirdo的博客 2169

paxoskv:基于paxos的kv存储的天真的和基本的印象; 对于https

paxoskv: a Naive and Basic paxos kv storage 这个repo 目前仅是用于学习的实例代码. 这是一个基于paxos, 只有200行代码的kv存储系统的简单实现, 以最简洁的形式展示paxos如何运行, 作为 这篇教程中的代码示例部分. 因为有不少网友跟我问起这篇教程中的实现问题, 例如怎么把只能确定一个值的paxos应用到实际场景中. 既然Talk is cheap, 那么就Show me the code, 把教程中描述的内容直接用代码实现出来, 希望能覆盖到教程中的每个细节. 帮助大家理解paxos的运行机制. NB-paxoskv 通过classic paxos建立一个简单的kv存储, 这个版本只支持指定key-version的写入和读取: 写入操作通过一次2轮的paxos实现. 读取操作也通过一次1轮或2轮的paxos实现. 虽然每个key

一文读懂 Paxos 算法

一文读懂 Paxos 算法

激流丶的博客 3252

paxosKV:使用paxos算法实现的键值存储

paxosKV 采用一致性哈希算法计算键所在的节点,每个节点都有一个唯一的ID用作标识,同时这个id也作为paxos的groupID,通过paxos在主备服务器之间进行同步数据。 KV存储的数据类型:int,字符串,列表,set,map。 客户端整合的是SDK,因此客户端与服务端要分开,但是Paxos相关的是整合在服务端的。 paxos组件应该是作为通信与同步相关的组件,而KV负责提供心跳检测,容错,分配令牌等操作。 为了减少程序占用,paxos组件与KV组件应该共享网络服务。 也就是说网络服务相关部分也需要独立成一个组件,并且可以嵌入到KV与paxos相关逻辑当中。 KV储存相关的所有数据备份之间组成一个paxos。 组件之间通过eventBus来通信,而不是直接调用函数方法。

paxos:Paxos的实现

帕克索斯 使用 Akka 实现单实例 Paxos。

basic paxos,multi paxos

basic paxos:集群内所有节点如何就一个值达成共识 角色: 1.提议者:提出提议(proposal). 2.接受者:对于提议要给出自己的回答. 3.学习者:接受达成共识的值,不参与投票和提议. 注意 1.除了学习者节点.每个节点都可以生成提议(proposal)和接受提议 2.共识的达成需要两阶段协议 3.不需要所有节点同意,过半同意即可. 流程: 1.提议一般是节点生成的.生成的提议可有使用p(id,value).其中id是提议编号. 2.一个节点生成提议后...

小小李的博客 611

SimMechanics二连杆仿真避坑指南:Solid模块坐标系设置与Rigid Transform常见错误

本文详细解析了SimMechanics中二连杆平面臂仿真的常见问题,重点探讨Solid模块坐标系设置与Rigid Transform模块的配置陷阱。通过实战案例和MATLAB代码示例,揭示多体系统仿真中的关键错误点,包括坐标系方向定义、参数匹配、端口连接规则等,帮助工程师有效规避仿真风险,提升建模效率。

weixin_29309213的博客 414

200行代码实现基于paxos的kv存储

本文链接: https://blog.openacid.com/algo/paxoskv/ 前言 写完 paxos的直观解释 之后, 网友都说疗效甚好, 但是也会对这篇教程中一些环节提出疑问(有疑问说明真的看懂了 ???? ) , 例如怎么把只能确定一个值的paxos应用到实际场景中. 既然Talk is cheap, 那么就Show me the code, 这次我们把教程中描述的内容直接用代码实现出来, 希望能覆盖到教程中的涉及的每个细节. 帮助大家理解paxos的运行机制. 这是一个基于paxos,

weixin_40147959的博客 335

别再到处找教程了!Windows下用FFmpeg+Mediamtx+VLC搭建本地RTSP流媒体服务器,保姆级配置流程

本文详细介绍了在Windows系统下使用FFmpeg、Mediamtx和VLC搭建本地RTSP流媒体服务器的完整流程。从环境准备到核心配置,再到推流和拉流的实战技巧,提供了保姆级的避坑指南和优化建议,帮助开发者快速实现稳定的流媒体服务部署。

weixin_42614269的博客 213

HSPICE用户必看:用Sigrity Broadband SPICE解决复杂封装建模的3个技巧

本文为HSPICE用户分享了三个使用Sigrity Broadband SPICE解决复杂封装建模难题的实战技巧。通过将宽频带S参数高效转换为时域SPICE模型,能显著提升仿真速度、保障收敛性,并精准分析谐振、返回路径不连续及超多端口PDN等关键问题,助力实现高效稳定的系统级信号与电源完整性分析。

metal的博客 601

完整mes代码(含客户端和server端_200行代码实现基于paxos的kv存储

本文链接: https://blog.openacid.com/algo/paxoskv/前言写完 paxos的直观解释 之后, 网友都说疗效甚好, 但是也会对这篇教程中一些环节提出疑问(有疑问说明真的看懂了 ) , 例如怎么把只能确定一个值的paxos应用到实际场景中.既然Talk is cheap, 那么就Show me the code, 这次我们把教程中描述的内容直接用代码实现出来, ...

weixin_39929377的博客 412

鸿蒙开发实战:如何用DevEco Studio 4.0一键迁移安卓Java项目(附避坑清单)

本文详细介绍了如何使用DevEco Studio 4.0将安卓Java项目一键迁移到鸿蒙系统,包括环境准备、代码适配、UI转换及常见问题解决方案。通过实战指南和避坑清单,帮助开发者高效完成项目移植,充分利用鸿蒙生态优势。

weixin_29214199的博客 385

只运行一部分代码_200行代码实现基于paxos的kv存储

本文链接: https://blog.openacid.com/algo/paxoskv/前言写完 paxos的直观解释 之后, 网友都说疗效甚好, 但是也会对这篇教程中一些环节提出疑问(有疑问说明真的看懂了 ) , 例如怎么把只能确定一个值的paxos应用到实际场景中.既然Talk is cheap, 那么就Show me the code, 这次我们把教程中描述的内容直接用代码实现出来, ...

weixin_30082367的博客 140

从网格剖分到结果外推:一文拆解HFSS快速扫频(Fast Sweep)的底层逻辑与性能调优

本文深入解析了HFSS快速扫频(Fast Sweep)技术的底层逻辑与性能调优方法。通过ALPS算法实现频带外推,快速扫频相比离散扫频和插值扫频能提升3-5倍计算效率,特别适用于天线阵列、微波滤波器等宽频带分析场景。文章详细介绍了算法架构、参数优化策略及工程实践中的精度保障机制,帮助工程师高效完成电磁仿真。

weixin_28693447的博客 95

企业如何开展BI建设--指标体系建设

很多企业的数字化转型工作都是从做BI项目开始的,很多企业认为,BI就是做指标大屏,所以做了很多的驾驶舱,也做了很多指标,有从系统取的,有手工填报的,甚至手工填报的比例占到了70%,最终BI沦为了填报系统,业务认为BI就是把从线下的微信沟通转到了线上录入展示,并没有给业务代来任何提升,久而久之,BI大屏就没人关心,公司高层也认为数据都是填报的,都经过了加工处理,这种数据不可信,不能反映业务开展的实际。其实在BI系统建设之前,我们首先要做的就是要梳理企业的指标,到底我们要展示哪些指标?

265

Multi-Master-Paxos-3

转存失败重新上传取消 200 行代码实现 paxos-kv 中介绍了一款非常简洁的分布式 kv 存储实现,它是基于 classic-paxos 实现分布式一致性。在 paxos 的直观解释 中我们提到,每次写入,也就是每个 paxos 实例需要 2 轮 RPC 完成,效率低。一个常见的优化就是 mutli-paxos(或 raft),用一次 RPC 对多个实例运行 phase-1;再对每个实例分别运行 phase-2,这样均摊开销是一次 RPC 完成一次写入。 它通过 phase-1 在集群中确定了一个唯一

Databend的博客 256

YOLOv8改进目录一览 | 涉及卷积层、轻量化、注意力、损失函数、Backbone、SPPF、Neck、检测头等全方位改进

1️⃣本专栏已更新150多种不同的改进方法,所使用并改进的每一个模块均包含详细的模块分析、原理讲解、个人总结、多种改进方式以及完整的修改流程,所有改进100%可直接运行。2️⃣所有改进点均为近三年顶会,顶刊提出的先进算法,将其融入到中,紧跟学术热点,适应不同的任务场景。3️⃣团队内发表数篇SCI论文,熟悉完整的发表流程,订阅专栏即可进群享受模型训练、模型改进、论文写作、投稿选刊,从入门到论文的各种答疑内容。4️⃣专栏内容会持续更新,最近更新时间:2024-12-24。项目介绍在大家购买专栏后,加入学

Limiiiing的博客 1万+

异地多活paxos实现:Multi-Master-Paxos-3

Background200行代码实现paxos-kv中介绍了一款非常简洁的分布式kv存储实现, 它是基于classic-paxos实现分布式一致性. 在paxos的直观解释中我们...

weixin_45583158的博客 493

Python计算时间差的方法

使用datetime模块是Python内置的方法,使用timedelta对象可以更精确地计算时间差,而使用dateutil库则提供了更为灵活和方便的操作方式。我们可以使用datetime模块中的datetime类来表示一个具体的日期和时间,并进行相应的运算。在Python中,我们经常需要计算日期和时间之间的差异,例如计算两个日期之间的天数、小时数、分钟数等。Python提供了多种方法来计算时间差,下面我们将介绍其中的几种常用方法,并附上相应的源代码。在上面的代码中,我们使用了dateutil库中的。

学习使你进步。 2086

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

小学生也可以轻松掌握的Paxos/Raft算法奥秘

Paxos 解决的是分布式系统中达成共识的一个最简单的问题,即多个节点如何在可能发生故障的情况下就某个值达成一致。一致性(Agreement): 所有的节点必须对同一个值达成一致,且达成一致后不会再改变合法性(Validity): 这个达成一致的值只能来自于某个节点的提议。终止性(Termination): 最终所有节点会达成一致。以上条件也被称为 Safety + Liveness,这是典型的既要又要,既要正确又要可行。

canonical的博客 1472

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

分布式KV缓存优化:多智能体系统性能提升方案

键值缓存(KV Cache)作为分布式系统中的核心组件,通过内存级数据存储显著提升访问效率。其技术原理基于分层缓存架构和智能数据同步机制,在无人机协同、仓储机器人等物联网场景中能有效降低网络延迟。KVCOMM方案创新性地融合RDMA零拷贝传输和向量时钟算法,实现亚毫秒级数据同步的同时保障一致性,实测显示可降低42%任务耗时。该技术特别适用于智能体间需要高频数据交换的分布式系统,其中缓存亲和性调度和热点键检测等关键技术能进一步提升L2命中率。

weixin_33720956的博客 427

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

分布式存储架构核心解析:从CAP理论到Ceph、Redis集群实战

分布式存储是解决海量数据管理挑战的核心技术,其核心思想是将数据分散到多台互联的服务器上,通过软件定义的方式实现统一服务。其基本原理围绕数据分片、多副本与一致性协议展开,旨在突破单机存储的容量、性能与可用性瓶颈。该技术的核心价值在于能以线性扩展的方式,用廉价硬件构建出高可靠、高可用的数据服务层,支撑起互联网、大数据与AI等场景的海量数据需求。在实际应用中,面对不同的业务场景,演化出了中心化索引、无中心对等(P2P)及混合架构等多种模式。例如,Ceph采用基于CRUSH算法的无中心架构实现统一存储,而Redis

weixin_30613433的博客 407

Consul(注册中心)部署

Consul是HashiCorp公司推出的开源工具,consul包含很多组件,但总体来说,consul是用于实现分布式系统的服务发现、服务配置的方案

小杨博客 学习交流 3931

国产数据库核心技术对比与选型指南

数据库作为信息系统的核心组件,其架构设计直接影响系统性能和可靠性。主流数据库通常采用共享存储、分布式或云原生架构,通过事务处理、查询优化等核心技术实现数据高效管理。在国产化替代背景下,达梦、PolarDB、TiDB等国产数据库在TPC-C测试中展现出强劲性能,其中OceanBase更以每分钟450万次交易刷新纪录。这些产品在政务、金融、互联网等场景各具优势:达梦适合传统OLTP系统,PolarDB的弹性扩展满足业务波动需求,TiDB的HTAP架构实现实时分析。技术选型需综合评估性能指标、功能特性和总体拥有成

weixin_28358083的博客 248

使用Consul提供的DNS服务

使用Consul提供的DNS服务前言服务发现软件以及特性对比Consul 介绍Consul 的优势特性Consul 角色FQAconsul UI访问地址127.0.0.1改为0.0.0.0 本文部分内容摘自: 原文:https://www.cnblogs.com/ityouknow/p/9340591.html 前言 最早DNS服务器,使用的是bind应用,后面诞生了各种的服务发现的应用zoo...

白开水的博客 9146
上一篇: 解密云原生数据库|Data Infra 研究社第一期
下一篇: 如何为开源项目撰写 RFC
Databend
博客等级 码龄5年 1458粉丝 362原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值