实战 Go:如何实现一个简单分布式系统

标签: go 分布 系统 | 发表时间:2022-10-26 13:19 | 作者:MarvinZhang
出处:https://juejin.cn/tag/%E6%9E%B6%E6%9E%84

引子

如今很多云原生系统、分布式系统,例如 Kubernetes,都是用 Go 语言写的,这是因为 Go 语言天然支持异步编程,而且静态语言能保证应用系统的稳定性。笔者的开源项目 Crawlab 作为爬虫管理平台,也应用到了分布式系统。本篇文章将介绍如何用 Go 语言编写一个简单的分布式系统。

思路

在开始写代码之前,我们先思考一下需要实现些什么。

  • 主节点(Master Node):中控系统,相当于军队中的指挥官,派发任务命令
  • 工作节点(Worker Node):执行者,相当于军队中的士兵,执行任务

除了上面的概念以外,我们需要实现一些简单功能。

  • 上报运行状态(Report Status):工作节点向主节点上报当前状态
  • 分派任务(Assign Task):通过 API 向主节点发起请求,主节点再向工作节点分派任务
  • 运行脚本(Execute Script):工作节点执行任务中的脚本

整个流程示意图如下。

Main Process Diagram

实战

节点通信

节点之间的通信在分布式系统中非常重要,毕竟每个节点或机器如果孤立运行,就失去了分布式系统的意义。因此,节点通信在分布式系统中是核心模块。

gRPC 协议

首先,我们来想一下,如何让节点之间进行相互通信。最常用的通信方式就是 API,不过这个通信方式有个缺点,就是需要将各个节点的 IP 地址及端口显示暴露给其他节点,这在公网中是不太安全的。因此,我们选择了 gRPC,一种流行的 远程过程调用(Remote Procedure Call,RPC)框架。这里我们不过多的解释 RPC 或 gRPC 的原理,简而言之,就是能让调用者在远程机器上执行命令的协议方式。

为了使用 gRPC 框架,我们先创建 go.mod 并输入以下内容,并执行 go mod download。注意:对于国内的朋友,或许需要添加代理才能正常下载,可以先执行 export GOPROXY=goproxy.cn,direct 后再执行下载命令。

  module go-distributed-system
​
go 1.17
​
require (
  github.com/golang/protobuf v1.5.0
  google.golang.org/grpc v1.27.0
  google.golang.org/protobuf v1.27.1
)

然后,我们创建 Protocol Buffers 文件 node.proto(表示节点对应的 gRPC 协议文件),并输入以下内容。

  syntax = "proto3";
​
package core;
option go_package = ".;core";
​
message Request {
  string action = 1;
}
​
message Response {
  string data = 1;
}
​
service NodeService {
  rpc ReportStatus(Request) returns (Response){};       // Simple RPC
  rpc AssignTask(Request) returns (stream Response){};  // Server-Side RPC
}

在这里我们创建了两个 RPC 服务,分别是负责上报状态的 Simple RPC ReportStatus 以及 Server-Side RPC AssignTask。Simple RPC 和 Server-Side RPC 的区别如下图所示,主要区别在于 Server-Side RPC 可以从通过流(Stream)向客户端(Client)主动发送数据,而 Simple RPC 只能从客户端向服务端(Server)发请求。

RPC Diagram

创建好 .proto 文件后,我们需要将这个 gRPC 协议文件转化为 .go 代码文件,从而能被 Go 程序引用。在命令行窗口中执行如下命令。注意:编译工具 protoc 不是自带的,需要单独下载,具体可以参考文档 https://grpc.io/docs/protoc-installation/

  mkdir core
protoc --go_out=./core \
    --go-grpc_out=./core \
    node.proto

执行完后,可以在 core 目录下看到两个 Go 代码文件, node.pb.gonode_grpc.pb.go,这相当于 Go 程序中对应的 gRPC 库。

gRPC 服务端

现在开始编写服务端逻辑。

咱们先创建一个新文件 core/node_service_server.go,输入以下内容。主要逻辑就是实现了之前创建好的 gRPC 协议中的两个调用方法。其中,暴露了 CmdChannel 这个通道(Channel)来获取需要发送到工作节点的命令。

  package core
​
import (
  "context"
)
​
type NodeServiceGrpcServer struct {
  UnimplementedNodeServiceServer
​
  // channel to receive command
  CmdChannel chan string
}
​
func (n NodeServiceGrpcServer) ReportStatus(ctx context.Context, request *Request) (*Response, error) {
  return &Response{Data: "ok"}, nil
}
​
func (n NodeServiceGrpcServer) AssignTask(request *Request, server NodeService_AssignTaskServer) error {
  for {
    select {
    case cmd := <-n.CmdChannel:
      // receive command and send to worker node (client)
      if err := server.Send(&Response{Data: cmd}); err != nil {
        return err
      }
    }
  }
}
​
var server *NodeServiceGrpcServer
​
// GetNodeServiceGrpcServer singleton service
func GetNodeServiceGrpcServer() *NodeServiceGrpcServer {
  if server == nil {
    server = &NodeServiceGrpcServer{
      CmdChannel: make(chan string),
    }
  }
  return server
}

gRPC 客户端

gRPC 客户端不需要具体实现,我们通常只需要调用 gRPC 客户端的方法,程序会自动发起向服务端的请求以及获取后续的响应。

主节点

编写好了节点通信的基础部分,现在我们需要实现主节点了,这是整个中心化分布式系统的核心。

咱们创建一个新的文件 node.go,输入以下内容。

  package core
​
import (
  "github.com/gin-gonic/gin"
  "google.golang.org/grpc"
  "net"
  "net/http"
)
​
// MasterNode is the node instance
type MasterNode struct {
  api     *gin.Engine            // api server
  ln      net.Listener           // listener
  svr     *grpc.Server           // grpc server
  nodeSvr *NodeServiceGrpcServer // node service
}
​
func (n *MasterNode) Init() (err error) {
  // TODO: implement me
  panic("implement me")
}
​
func (n *MasterNode) Start() {
  // TODO: implement me
  panic("implement me")
}
​
var node *MasterNode
​
// GetMasterNode returns the node instance
func GetMasterNode() *MasterNode {
  if node == nil {
    // node
    node = &MasterNode{}
​
    // initialize node
    if err := node.Init(); err != nil {
      panic(err)
    }
  }
​
  return node
}

其中,我们创建了两个占位方法 InitStart,我们分别实现。

在初始化方法 Init 中,我们需要做几件事情:

  • 注册 gRPC 服务
  • 注册 API 服务

现在,在 Init 方法中加入如下代码。

  func (n *MasterNode) Init() (err error) {
  // grpc server listener with port as 50051
  n.ln, err = net.Listen("tcp", ":50051")
  if err != nil {
    return err
  }
​
  // grpc server
  n.svr = grpc.NewServer()
​
  // node service
  n.nodeSvr = GetNodeServiceGrpcServer()
​
  // register node service to grpc server
  RegisterNodeServiceServer(node.svr, n.nodeSvr)
​
  // api
  n.api = gin.Default()
  n.api.POST("/tasks", func(c *gin.Context) {
    // parse payload
    var payload struct {
      Cmd string `json:"cmd"`
    }
    if err := c.ShouldBindJSON(&payload); err != nil {
      c.AbortWithStatus(http.StatusBadRequest)
      return
    }
​
    // send command to node service
    n.nodeSvr.CmdChannel <- payload.Cmd
​
    c.AbortWithStatus(http.StatusOK)
  })
​
  return nil
}

可以看到,我们新建了一个 gRPC Server,并将之前的 NodeServiceGrpcServer 注册了进去。另外,我们还用 gin 框架创建了一个简单的 API 服务,可以 POST 请求到 /tasksNodeServiceGrpcServer 中的命令通道 CmdChannel 传送命令。这样就将各个部件串接起来了!

启动方法 Start 很简单,就是启动 gRPC Server 以及 API Server。

  func (n *MasterNode) Start() {
  // start grpc server
  go n.svr.Serve(n.ln)
​
  // start api server
  _ = n.api.Run(":9092")
​
  // wait for exit
  n.svr.Stop()
}

下一步,我们就要实现实际做任务的工作节点了。

工作节点

现在,我们创建一个新文件 core/worker_node.go,输入以下内容。

  package core
​
import (
  "context"
  "google.golang.org/grpc"
  "os/exec"
)
​
type WorkerNode struct {
  conn *grpc.ClientConn  // grpc client connection
  c    NodeServiceClient // grpc client
}
​
func (n *WorkerNode) Init() (err error) {
  // connect to master node
  n.conn, err = grpc.Dial("localhost:50051", grpc.WithInsecure())
  if err != nil {
    return err
  }
​
  // grpc client
  n.c = NewNodeServiceClient(n.conn)
​
  return nil
}
​
func (n *WorkerNode) Start() {
  // log
  fmt.Println("worker node started")
​
  // report status
  _, _ = n.c.ReportStatus(context.Background(), &Request{})
​
  // assign task
  stream, _ := n.c.AssignTask(context.Background(), &Request{})
  for {
    // receive command from master node
    res, err := stream.Recv()
    if err != nil {
      return
    }
​
    // log command
    fmt.Println("received command: ", res.Data)
​
    // execute command
    parts := strings.Split(res.Data, " ")
    if err := exec.Command(parts[0], parts[1:]...).Run(); err != nil {
      fmt.Println(err)
    }
  }
}
​
var workerNode *WorkerNode
​
func GetWorkerNode() *WorkerNode {
  if workerNode == nil {
    // node
    workerNode = &WorkerNode{}
​
    // initialize node
    if err := workerNode.Init(); err != nil {
      panic(err)
    }
  }
​
  return workerNode
}

其中,我们在初始化方法 Init 中创建了gRPC 客户端,并连接了主节点的 gRPC 服务端。

在启动方法 Start 中做了几件事情:

  1. 调用上报状态(Report Status)的 Simple RPC 方法
  2. 调用分配任务(Assign Task)的 Server-Side RPC 方法,获取到了流(Stream)
  3. 通过循环不断接受流传输过来的来自服务端(也就是主节点)的信息,并执行命令

这样,整个包含主节点、工作节点的分布式系统核心逻辑就写好了!

将它们放在一起

最后,我们需要将这些核心逻辑用命令行工具封装一下,以便启用。

创建主程序文件 main.go,并输入以下内容。

  package main
​
import (
  "go-distributed-system/core"
  "os"
)
​
func main() {
  nodeType := os.Args[0]
  switch nodeType {
  case "master":
    core.GetMasterNode().Start()
  case "worker":
    core.GetWorkerNode().Start()
  default:
    panic("invalid node type")
  }
}

这样,整个简单的分布式系统就创建好了!

代码效果

下面我们来运行一下代码。

打开两个命令行窗口,其中一个输入 go run main.go master 启动主节点,另一个输入 go run main.go worker 启动工作节点。

如果主节点启动成功,将会看到如下日志信息。

  [GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
​
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)
​
[GIN-debug] POST   /tasks                    --> go-distributed-system/core.(*MasterNode).Init.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on :9092

如果工作节点启动成功,将会看到如下日志信息。

  worker node started

主节点、工作节点都启动成功后,我们在另外一个命令行窗口中输入如下命令来发起 API 请求。

  curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"cmd": "touch /tmp/hello-distributed-system"}' \
  http://localhost:9092/tasks

在工作节点窗口应该可以看到日志 received command: touch /tmp/hello-distributed-system

然后查看文件是否顺利生成,执行 ls -l /tmp/hello-distributed-system

  -rw-r--r--  1 marvzhang  wheel     0B Oct 26 12:22 /tmp/hello-distributed-system

文件成功生成,表示已经通过工作节点执行成功了!大功告成!

总结

本篇文章通过 RPC 框架 gRPC 以及 Go 语言自带的 Channel,将节点串接起来,开发出了一个简单的分布式系统。所用到的核心库和技术:

整个代码示例仓库在 GitHub 上: https://github.com/tikazyq/codao-code/tree/main/2022-10/go-distributed-system

社区

如果您对笔者的文章感兴趣,可以加笔者微信 tikazyq1 并注明 "码之道",笔者会将你拉入 "码之道" 交流群。

相关 [go 分布 系统] 推荐:

实战 Go:如何实现一个简单分布式系统

- - 掘金 架构
如今很多云原生系统、分布式系统,例如 Kubernetes,都是用 Go 语言写的,这是因为 Go 语言天然支持异步编程,而且静态语言能保证应用系统的稳定性. 笔者的开源项目 Crawlab 作为爬虫管理平台,也应用到了分布式系统. 本篇文章将介绍如何用 Go 语言编写一个简单的分布式系统. 在开始写代码之前,我们先思考一下需要实现些什么.

Go! ExtractIcons – 快速提取图标软件 | 小众软件 > 系统工具

- 翠 - 小众软件
ExtractIcons 是一款可以提取 DLL , EXE 等文件中图标的工具,同时 Go. ExtractIcons 还提供图标的编辑功能. ExtractIcons 最大的特点就是可以搜索文件夹下的所有文件的图标. 下载(326 KB): uudisc | 官方网站 | 来自小众软件. ©2011 socekin for 小众软件 | 原文链接 | 15 留言 | 加入我们 | 投稿 | 订阅指南.

Go和HTTPS

- - Tony Bai
近期在构思一个产品,考虑到安全性的原因,可能需要使用到 HTTPS协议以及双向数字证书校验. 之前只是粗浅接触过HTTP( 使用Golang开 发微信系列). 对HTTPS的了解则始于那次 自行搭建ngrok服务,在那个过程中照猫画虎地为服务端生成了一些私钥和证书,虽然结果是好 的:ngrok服务成功搭建起来了,但对HTTPS、数字证书等的基本原理并未求甚解.

Valve宣布CS: GO

- 小D - Solidot
此前媒体曾报告说Valv邀请CSS玩家和社区代表访问其总部,现在谜团已经解开:Valv宣布了团队射击游戏Counter-Strike: Global Offensive,它将在2012年初登陆Steam(PC和Mac)、PS3和Xbox360. CS: GO将是12年前发布的CS的真正扩展,而不是类似CS:Source的引擎更新,它提供了新的地图、角色、武器,经典CS地图(如de_dust),新的游戏模式,配对比赛和排名榜等.

Go 语言初步

- wei - 云风的 BLOG
所谓认真玩,就是拿 Go 写点程序,前后大约两千行吧. 据说 Go 的最佳开发平台是 Mac OS ,我没有. Windows 版还没全部搞定,但是也可以用了. 如果你用 google 搜索,很容易去到一个叫 go-windows 的开源项目上. 如果你用这个,很多库都没有,而且语法也是老的. 我在 Windows 下甚至不能正确链接自己写的多个 package.

Go 1.1 的性能提升

- - 博客 - 伯乐在线
伯乐在线注:今天上午在微博推荐了英文原文,感谢 @Codefor 的热心翻译. 如果其他朋友也有不错的原创或译文,可以尝试 推荐给我们. 这是Go1.1发布后性能提升分析系列的第一篇文章. Go官方文档( 这里和 这里)报告说,用Go1.1重新编译你的代码就可以获得30%-40%的性能提升.

采访:关于 Go 语言和《Go Web编程》

- - 开源中国社区最新新闻
最近,在网上出现了一本名为《Go Web编程》的书籍,里面详细地讲述了使用Go语言进行Web编程的各个方面. 很特别的是,这本书是在GitHub上以开源的方式撰写的. 日前,InfoQ采访了这本书的作者谢孟军先生,请他来和大家谈谈Go语言以及他撰写的开源书籍. InfoQ:请您先简单和大家介绍一下自己.

《学习Go语言》0.4 中文版

- way - python.cn(jobs, news)
鱼哥(https://twitter.com/#!/smallfishxy)上个月勒令我要完成 0.4 版的翻译. 之前公司重组的时候,没顾上看英文版本的更新,结果这老外不声不响的做了如此之多的改动……. 于是只好人工 diff,一条一条的对比 commit 内容. 总算是跟进到了 0.4 这个 tag.

Skype 被強制安裝 EasyBits Go

- MorrisC - 高登工作室
這是由網友 LuLu CHEN 所提供的資訊,我自己的Skype是沒有出現這樣子的訊息,如果你也是被強制安裝此一程式的話,請照著本篇的方法將它移除吧. Spype是大家最常用的語音IM即時通訊軟體,這個月初Skype還以85億美元的天價嫁給了微軟,但是怎麼送給大家的禮物卻是一個大家不想要的流氓軟體.

Opal :未曾发布的 7 寸 TouchPad Go

- SotongDJ - 爱范儿 · Beats of Bits
惠普的 TouchPad 是一部带有悲情色彩的平板电脑,它的降价策略和销量已经成为了漫画家和脱口秀主持人的好材料. 翻看过去的新闻,我们发现除了 9.7  寸的 TouchPad 之外,还存在一部代号为 Opal 的“迷你 TouchPad”,它真正的名字是 TouchPadGo , Go 在 TouchPad 的右上角形成一个特立独行的商标.