RPC框架Kitex入门

沐雨橙风24

已于 2023-02-07 10:16:02 修改

阅读量576

点赞数

分类专栏：青训营笔记文章标签： rpc golang Powered by 金山文档

于 2023-02-07 10:15:06 首次发布

本文链接：https://blog.csdn.net/weixin_57209831/article/details/128913767

版权

青训营笔记专栏收录该内容

17 篇文章 2 订阅

订阅专栏

这是我参与「第五届青训营」笔记创作活动的第 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

运行示例代码

直接启动

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 api

struct Request {
        1: string message
}

struct Response {
        1: string message
}

struct AddRequest {
  1: i64 first
  2: 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 工具将更新下述文件

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

更新 ./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，底层就需要两大功能：

Serialization 序列化

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 api

struct 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 main

import (
  "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 还是需要仔细研究官方文档。

引用

Kitex 官方文档 Kitex | CloudWeGo

沐雨橙风24

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
RPC框架Kitex入门

前一篇笔记介绍了字节跳动的开源 Golang 微服务 HTTP 框架 Hertz，本文将要介绍同样是字节跳动开源的 Golang 微服务 RPC 框架 Kitex。Kitex 字节跳动内部的 Golang 微服务 RPC 框架，具有高性能强可扩展的特点，在字节内部已广泛使用。如果对微服务性能有要求，又希望定制扩展融入自己的治理体系，Kitex 会是一个不错的选择。架构设计框架特点：高性能：使用自研的高性能网络库Netpoll，性能相较 go net 具有显著优势。扩展性。
复制链接

扫一扫