这是我参与「第五届青训营 」笔记创作活动的第 13 天

前言

前一篇笔记介绍了字节跳动的开源 Golang 微服务 HTTP 框架 Hertz，本文将要介绍同样是字节跳动开源的 Golang 微服务 RPC 框架 Kitex。

重点内容

• Kitex 简介

• 快速开始

• 基础教程

知识点介绍

Kitex 简介

Kitex 字节跳动内部的 Golang 微服务 RPC 框架，具有高性能、强可扩展的特点，在字节内部已广泛使用。如果对微服务性能有要求，又希望定制扩展融入自己的治理体系，Kitex 会是一个不错的选择。

架构设计

框架特点：

• 高性能：使用自研的高性能网络库 Netpoll，性能相较 go net 具有显著优势。

• 扩展性：提供了较多的扩展接口以及默认扩展实现，使用者也可以根据需要自行定制扩展。

• 多消息协议：RPC 消息协议默认支持 Thrift、Kitex Protobuf、gRPC。Thrift 支持 Buffered 和 Framed 二进制协议；Kitex Protobuf 是 Kitex 自定义的 Protobuf 消息协议，协议格式类似 Thrift；gRPC 是对 gRPC 消息协议的支持，可以与 gRPC 互通。除此之外，使用者也可以扩展自己的消息协议。

• 多传输协议：传输协议封装消息协议进行 RPC 互通，传输协议可以额外透传元信息，用于服务治理，Kitex 支持的传输协议有 TTHeader、HTTP2。TTHeader 可以和 Thrift、Kitex Protobuf 结合使用；HTTP2 目前主要是结合 gRPC 协议使用，后续也会支持 Thrift。

• 多种消息类型：支持 PingPong、Oneway、双向 Streaming。其中 Oneway 目前只对 Thrift 协议支持，双向 Streaming 只对 gRPC 支持

• 服务治理：支持服务注册/发现、负载均衡、熔断、限流、重试、监控、链路跟踪、日志、诊断等服务治理模块，大部分均已提供默认扩展，使用者可选择集成。

• 代码生成：Kitex 内置代码生成工具，可支持生成 Thrift、Protobuf 以及脚手架代码。

快速开始

注意：kitex 暂时没有针对 Windows 做支持，如果本地开发环境是 Windows 建议使用 WSL2

• 安装代码生成工具

• 安装 kitex：go install github.com/cloudwego/kitex/tool/cmd/kitex@latest

• 安装 thriftgo：go install github.com/cloudwego/thriftgo@latest

• 获取示例代码

git clone https://github.com/cloudwego/kitex-examples.git

• 运行示例代码

• 直接启动

• 进入示例仓库的 hello 目录

cd kitex-examples/hello

• 运行 server

go run .

• 运行 client

另起一个终端后，go run ./client

• 使用 Docker 快速启动

• 进入示例仓库目录

cd kitex-examples

• 编译项目

docker build -t kitex-examples .

• 运行 server

docker run --network host kitex-examples ./hello-server

• 运行 client

另起一个终端后，docker run --network host kitex-examples ./hello-client

现在成功通过 Kitex 发起了 RPC 调用。

• 增加一个新方法

• 打开 hello.thrift，为新方法分别定义一个新的请求和响应，AddRequest 和 AddResponse，并在 service Hello 中增加 add 方法

namespace go apistruct Request {1: string message
}struct Response {1: string message
}struct AddRequest {1: i64 first2: i64 second
}struct AddResponse {1: i64 sum
}service Hello {Response echo(1: Request req)AddResponse add(1: AddRequest req)
}

• 重新生成代码

• 运行如下命令后，kitex 工具将根据 hello.thrift 更新代码文件

kitex -service a.b.c hello.thrift# 若当前目录不在 $GOPATH/src 下，需要加上 -module 参数，一般为 go.mod 下的名字
kitex -module "your_module_name" -service a.b.c hello.thrift

• 执行完上述命令后，kitex 工具将更新下述文件

1. 更新 ./handler.go，在里面增加一个 Add 方法的基本实现

1. 更新 ./kitex_gen，里面有框架运行所必须的代码文件

• 更新服务端处理逻辑

• 上述步骤完成后，./handler.go 中会自动补全一个 Add 方法的基本实现，类似如下代码：

// Add implements the HelloImpl interface.
func (s *HelloImpl) Add(ctx context.Context, req *api.AddRequest) (resp *api.AddResponse, err error) {// TODO: Your code here...return
}

• 在里面增加我们所需要的逻辑，类似如下代码：

// Add implements the HelloImpl interface.
func (s *HelloImpl) Add(ctx context.Context, req *api.AddRequest) (resp *api.AddResponse, err error) {// TODO: Your code here...resp = &api.AddResponse{Sum: req.First + req.Second}return
}

• 增加客户端调用

• 在 ./client/main.go 中你会看到类似如下的 for 循环：

for {req := &api.Request{Message: "my request"}resp, err := client.Echo(context.Background(), req)if err != nil {log.Fatal(err)}log.Println(resp)time.Sleep(time.Second)
}

在里面增加 Add 方法的调用：

for {req := &api.Request{Message: "my request"}resp, err := client.Echo(context.Background(), req)if err != nil {log.Fatal(err)}log.Println(resp)time.Sleep(time.Second)addReq := &api.AddRequest{First: 512, Second: 512}addResp, err := client.Add(context.Background(), addReq)if err != nil {log.Fatal(err)}log.Println(addResp)time.Sleep(time.Second)
}

• 重新运行示例代码，可以看到客户端在调用 Add 方法

基础教程

Kitex 是一个 RPC 框架，既然是 RPC，底层就需要两大功能：

1. Serialization 序列化

1. Transport 传输

Kitex 框架及命令行工具，默认支持 thrift 和 proto3 两种 IDL，对应的 Kitex 支持 thrift 和 protobuf 两种序列化协议。 传输上 Kitex 使用扩展的 thrift 作为底层的传输协议（注：thrift 既是 IDL 格式，同时也是序列化协议和传输协议）。IDL 全称是 Interface Definition Language，接口定义语言。

创建项目目录

在开始后续的步骤之前，先创建一个项目目录用于后续的教程。

$ mkdir example

然后进入项目目录

$ cd example

编写 IDL

首先创建一个名为 echo.thrift 的 thrift IDL 文件。

然后在里面定义服务

namespace go apistruct Request {1: string message
}struct Response {1: string message
}service Echo {Response echo(1: Request req)
}

生成 echo 服务代码

有了 IDL 以后便可以通过 kitex 工具生成项目代码了，执行如下命令：

$ kitex -module example -service example echo.thrift

上述命令中，-module 表示生成的该项目的 go module 名，-service 表明要生成一个服务端项目，后面紧跟的 example 为该服务的名字。最后一个参数则为该服务的 IDL 文件。

生成后的项目结构如下：

.
|-- build.sh
|-- echo.thrift
|-- handler.go
|-- kitex_gen
|   `-- api
|       |-- echo
|       |   |-- client.go
|       |   |-- echo.go
|       |   |-- invoker.go
|       |   `-- server.go
|       |-- echo.go
|       `-- k-echo.go
|-- main.go
`-- script|-- bootstrap.sh`-- settings.py

获取最新的 Kitex 框架

由于 kitex 要求使用 go mod 进行依赖管理，所以要升级 kitex 框架会很容易，只需要执行以下命令即可：

$ go get github.com/cloudwego/kitex@latest
$ go mod tidy

编写 echo 服务逻辑

需要编写的服务端逻辑都在 handler.go 这个文件中，现在这个文件应该如下所示：

package mainimport ("context""example/kitex_gen/api"
)// EchoImpl implements the last service interface defined in the IDL.
type EchoImpl struct{}// Echo implements the EchoImpl interface.
func (s *EchoImpl) Echo(ctx context.Context, req *api.Request) (resp *api.Response, err error) {// TODO: Your code here...return
}

这里的 Echo 函数就对应了之前在 IDL 中定义的 echo 方法。

修改 Echo 函数为下述代码：

func (s *EchoImpl) Echo(ctx context.Context, req *api.Request) (resp *api.Response, err error) {return &api.Response{Message: req.Message}, nil
}

编译运行

kitex 工具已经生成好了编译和运行所需的脚本：

编译：

$ sh build.sh

执行上述命令后，会生成一个 output 目录，里面含有编译产物。

运行：

$ sh output/bootstrap.sh

执行上述命令后，Echo 服务就开始运行啦！

编写客户端

有了服务端后，接下来编写一个客户端用于调用刚刚运行起来的服务端。

首先，同样的，先创建一个目录用于存放客户端代码：

$ mkdir client

进入目录：

$ cd client

创建一个 main.go 文件，然后就开始编写客户端代码了。

创建 client

import "example/kitex_gen/api/echo"
import "github.com/cloudwego/kitex/client"
...
c, err := echo.NewClient("example", client.WithHostPorts("0.0.0.0:8888"))
if err != nil {log.Fatal(err)
}

上述代码中，echo.NewClient 用于创建 client，其第一个参数为调用的 服务名，第二个参数为 options，用于传入参数， 此处的 client.WithHostPorts 用于指定服务端的地址。

发起调用

import "example/kitex_gen/api"
...
req := &api.Request{Message: "my request"}
resp, err := c.Echo(context.Background(), req, callopt.WithRPCTimeout(3*time.Second))
if err != nil {log.Fatal(err)
}
log.Println(resp)

上述代码中，首先创建了一个请求 req , 然后通过 c.Echo 发起了调用。

• 第一个参数为 context.Context，通过通常用其传递信息或者控制本次调用的一些行为。

• 第二个参数为本次调用的请求。

• 第三个参数为本次调用的 options ，Kitex 提供了一种 callopt 机制，顾名思义——调用参数 ，有别于创建 client 时传入的参数，这里传入的参数仅对此次生效。 此处的 callopt.WithRPCTimeout 用于指定此次调用的超时（通常不需要指定，此处仅作演示之用）

在编写完一个简单的客户端后，通过下述命令发起调用：

$ go run main.go

如果不出意外，可以看到类似如下输出：

2023/01/30 18:48:07 Response({Message:my request})

至此已经成功编写了一个 Kitex 的服务端和客户端，并完成了一次调用！

总结

本文主要介绍了Golang 微服务 RPC 框架 Kitex 的相关内容，并进行了一个简单的示例演示，本文介绍的都是最基础的入门知识，想更深入学习了解 Kitex 还是需要仔细研究官方文档。

引用

1. Kitex 官方文档 Kitex | CloudWeGo