gRPC 的测试
文章目录
- 简介
-
- 测试 gRPC 服务器端
- 测试 gRPC 客户端
- 负载测试
- 负载测试程序示例
简介
gRPC 应用程序始终会与网络交互，测试应该涵盖服务器端和客户端 gRPC 应用程序的网络方面。
测试 gRPC 服务器端
gRPC 服务的测试通常使用 gRPC 客户端应用程序来完成，该客户端应用程序是测试用例的一部分。服务器端的测试包括使用所需的服务启动 gRPC 服务器，并使用实现测试用例的客户端应用程序连接到服务器。
在 Go 语言中，gRPC 测试用例应该是使用 testing 包的 Go 通用测试用例来实现的，例如以下的关键的程序使用 Go 语言编写的测试用例，它对 ProductInfo 服务进行了测试。
// 常规测试，启动 gRPC 客户端和服务端
func TestServer_AddProduct(t *testing.T) {
// 在 HTTP/2 之上启动常规的 gRPC 服务器
grpcServer := initGRPCServerHTTP2()
conn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
grpcServer.Stop()
t.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewProductInfoClient(conn)
name := "Sumsung S10"
description := "Samsung Galaxy S10 is the latest smart phone, launched in February 2019"
price := float32(700.0)
ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel()
r, err := c.AddProduct(ctx, &pb.Product{Name: name, Description: description, Price: price})
if err != nil {
t.Fatalf("Could not add product: %v", err)
}
if r.Value == "" {
t.Errorf("Invalid Product ID %s", r.Value)
}
log.Printf("Res %s", r.Value)
grpcServer.Stop()
}
测试 gRPC 客户端
测试客户端的逻辑却不想要连接真正的服务器端所带来的开销，可以使用 mock 框架。对 gRPC 服务器端进行 mock，能够让开发人员在客户端编写轻量级单元测试，来对功能进行检查，避免对服务器进行 RPC。
若使用 Go 语言开发 gRPC 客户端应用程序，则可以（借助生成的代码）使用 Gomock 来模拟客户端接口，并通过编码的方式设置方法以接收和返回预先确定的值。在使用 Gomock 时，可以通过如下命令为 gRPC 客户端应用程序生成 mock 接口：
mockgen grpc-docker/go/proto \ ProductInfoClient > mock_prodinfo/prodinfo_mock.go
这里指定 ProductInfoClient 是要模拟的接口，然后，所编写的测试代码可以导入 mockgen 生成的包以及 gomock 包，从而为客户端逻辑编写单元测试例如以下的的程序创建了一个 mock 对象，预期对它的方法进行调用并返回一个响应。
func TestAddProduct(t *testing.T) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
// 创建 mock 对象，预期对远程方法进行调用
mocklProdInfoClient := NewMockProductInfoClient(ctrl)
...
req := &pb.Product{Name: name, Description: description, Price: price}
// 对 mock 对象进行编码
mocklProdInfoClient.EXPECT().AddProduct(gomock.Any(), &rpcMsg{msg: req},). Return(&wrapper.StringValue{Value: "ABC123" + name}, nil)
// 调用实际的测试方法，它会调用客户端存根的远程方法
testAddProduct(t, mocklProdInfoClient)
}
func testAddProduct(t *testing.T, client pb.ProductInfoClient) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second) defer cancel()
...
r, err := client.AddProduct(ctx, &pb.Product{Name: name, Description: description, Price: price})
// 测试并校验响应
}
mock gRPC 服务器不会带来与真实的 gRPC 服务器端完全相同的行为。因此，特定的功能可能无法通过测试来校验，除非重新实现 gRPC 服务器端可能出现的所有错误逻辑。在实践中，可以通过 mock 校验一组选定的功能，而其他的功能则需要通过真正的 gRPC 服务器实现来验证。
负载测试
使用常规的工具很难对 gRPC 应用程序进行负载测试和基准测量，这是因为这些应用程序都或多或少是与特定协议（如 HTTP）绑定的。对于 gRPC 来说，需要定制的负载测试工具，这些工具能够生成对服务器端的虚拟 RPC 负载，从而实现对 gRPC 服务器端的负载测试。
ghz 就是这样的负载测试工具，它是使用 Go 语言实现的命令行工具。它能够在本地对服务进行测试和调试，也能用在自动化持续集成环境中，实现性能回归测试。
ghz 的安装与配置参考以下两种方式：
- 离线包方式
可以直接在 Release 页面下载二进制文件并依次执行以下命令：
# 下载
wget https://github.com/bojand/ghz/releases/download/v0.114.0/ghz-linux-x86_64.tar.gz
# 解压
tar -zxvf ghz-linux-x86_64.tar.gz
# 解压后的文件
ghz ghz-linux-x86_64.tar.gz ghz-web LICENSE
# 添加到环境变量（export PATH=$PATH:/user/local）
sudo vim /etc/profile
# 使环境变量生效
source /etc/profile
- 源码编译方式
参考 ghz 官网的教程，依次执行如下的命令：
# 克隆仓库
git clone https://github.com/bojand/ghz
# 进入 ghz 目录
cd ghz
# Build using make
make build
# Build using go
cd cmd/ghz
go build .
# Install using go
go install github.com/bojand/ghz/cmd/ghz@latest
ghz 工具有如下两种使用方法：
-
二进制文件方式，通过命令行参数或者配置文件指定配置信息；
-
ghz/runner 编程方式，通过代码指定配置信息。
ghz 命令参数说明：
参数可以查看 官方文档 或者查阅帮助命令 ghz -h ，大致可以分为基本参数，负载参数（主要控制 ghz 每秒发起的请求数（RPS）），并发参数。具体的参数参考如下表：
| 基本参数 | 说明 |
|---|---|
| –config | 指定配置文件位置 |
| –proto | 指定 proto 文件位置，会从 proto 文件中获取相关信息 |
| –call | 指定调用的方法，具体格式：包名.服务名.方法名 |
| -c | 并发请求数 |
| -n | 最大请求数，达到后则结束测试 |
| -d | 请求参数，JSON格式，如 -d ‘{“name”:“cqupthao”}’ |
| -D | 以文件方式指定请求参数，JSON文件位置，如 -D ./file.json |
| -o | 输出路径，默认输出到 stdout |
| -O/–format | 输出格式，有多种格式可选（csv、json、pretty、html、influx-summary、influx-details、满足 InfluxDB line-protocol 格式的输出） |
| 负载参数 | 说明 |
|---|---|
| -r/–rps | 指定RPS，ghz 以恒定的 RPS 进行测试 |
| –load-schedule | 负载调度算法，取值有（const：恒定RPS，也是默认调用算法；step：步进增长RPS，需要配合 load-start、load-step、load-end、load-step-duration 和 load-max-duration 等参数；line：线性增长RPS，需要配合 load-start、load-step、load-end 和 load-max-duration 等参数，其实 line 就是 step 算法将 load-step-duration 时间固定为一秒了） |
| –load-start | step、line 的起始 RPS |
| –load-step | step、line 的步进值或斜率值 |
| –load-end | step、line 的负载结束值 |
| –load-max-suration | 最大持续时间，到达则结束 |
使用方法如下所示：
# 从 50 RPS 开始，每 5 秒钟增加 10 RPS ，一直到完成 10000 请求为止
-n 10000 -c 10 --load-schedule=step --load-start=50 --load-step=10 --load-step-duration=5s
# 从 50 RPS 开始，每 5 秒钟增加 10 RPS ，最多增加到 150 RPS ，一直到完成 10000 请求为止
-n 10000 -c 10 --load-schedule=step --load-start=50 --load-end=150 --load-step=10 --load-step-duration=5s
# 从 200 RPS 开始，每 1 秒钟降低 2RPS ，一直降低到 50 RPS ，一直到完成 10000 请求为止
# line 其实就是 step ，只不过是把 –load-step-duration 固定为 1 秒了
-n 10000 -c 10 --load-schedule=line --load-start=200 --load-step=-2 --load-end=50
| 并发参数 | 说明 |
|---|---|
| -c | 并发 woker 数，非并发请求数 |
| –concurrency-schedule | 并发调度算法，和–load-schedule类似（const：恒定并发数，默认值；step：步进增加并发数；line：线性增加并发数） |
| –concurrency-start | 起始并发数 |
| –concurrency-end | 结束并发数 |
| –concurrency-step | 并发数步进值 |
| –concurrency-step-duration | 在每个梯段需要持续的时间 |
| –concurrency-max-duration | 最大持续时间 |
使用方法如下所示：
# 固定 RPS 200 ，worker 数从 5 开始，每 5 秒增加 5 ，最大增加到 50
# 5 个 worker 时也要完成 200 RPS （即每个 worker 需要完成 40 RPS ，到 50 个 worker 时只需要每个 worker 完成 4 RPS 即可达到 200 RPS）
-n 100000 --rps 200 --concurrency-schedule=step --concurrency-start=5 --concurrency-step=5 --concurrency-end=50 --concurrency-step-duration=5s
所有参数都可以通过配置文件来指定，例如如下内容的文件：
{
"proto": "/path/to/greeter.proto",
"call": "helloworld.Greeter.SayHello",
"total": 2000,
"concurrency": 50,
"data": {
"name": "Joe"
},
"metadata": {
"foo": "bar",
"trace_id": "{{.RequestNumber}}",
"timestamp": "{{.TimestampUnix}}"
},
"import-paths": [
"/path/to/protos"
],
"max-duration": "10s",
"host": "0.0.0.0:50051"
}
负载测试程序示例
（1）在任意目录下创建 server 和 client 项目文件，在服务端和客户端的项目目录下分别创建 proto 目录，用于存放 helloworld.proto 文件，具体的文件结构和 helloworld.proto 文件内容如下所示：
Tesing
├── client
│ └── proto
│ └── helloworld.proto
└── server
└── proto
└── helloworld.proto
syntax = "proto3";
option go_package = "../proto";
package helloworld;
// The greeting service definition.
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
// Sends another greeting
rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}}
// The request message containing the user's name.
message HelloRequest {
string name = 1;
}
// The response message containing the greetings
message HelloReply {
string message = 1;
}
根据 helloworld.proto 文件分别在 server 和 client 项目下生成 gRPC 代码文件，进入 proto 目录执行以下的命令：
protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative *.proto
成功生成后的源码文件会保存在 proto 文件夹下，具体目录结构如下所示：
Testing
├── client
│ └── proto
│ ├── helloworld_grpc.pb.go
│ ├── helloworld.pb.go
│ └── helloworld.proto
└── server
└── proto
├── helloworld_grpc.pb.go
├── helloworld.pb.go
└── helloworld.proto
（2）在服务端需要实现该服务定义并运行 gRPC 服务器来处理客户端的调用，编写服务端程序重载服务基类（实现所生成的服务器骨架的逻辑），创建 gRPC 服务器，注册服务并指定端口监听传入的消息，该程序的具体代码如下：
package main
import (
"context"
"flag"
"fmt"
"log"
"net"
"google.golang.org/grpc"
pb "server/proto"
)
var (
port = flag.Int("port", 50051, "The server port")
)
// server is used to implement helloworld.GreeterServer.
type server struct {
pb.UnimplementedGreeterServer
}
// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
log.Printf("Received: %v", in.GetName())
return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}
func (s *server) SayHelloAgain(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
return &pb.HelloReply{Message: "Hello again " + in.Name}, nil
}
func main() {
flag.Parse()
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterGreeterServer(s, &server{})
log.Printf("server listening at %v", lis.Addr())
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}
（3）在 client 项目下编写一个调用 server 提供的 RPC 服务的程序，该程序的具体代码如下：
package main
import (
"context"
"flag"
"log"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
pb "client/proto"
)
const (
defaultName = "world"
)
var (
addr = flag.String("addr", "localhost:50051", "the address to connect to")
name = flag.String("name", defaultName, "Name to greet")
)
func main() {
flag.Parse()
// Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewGreeterClient(conn)
// Contact the server and print out its response.
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
r, err := c.SayHello(ctx, &pb.HelloRequest{Name: *name})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.GetMessage())
r, err = c.SayHelloAgain(ctx, &pb.HelloRequest{Name: *name})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.Message)
}
（4）分别在 server 和 client 项目下编译并执行程序，输出如下的结果：
2023/02/28 22:09:16 Greeting: Hello world
2023/02/28 22:09:16 Greeting: Hello again world
（5）启动服务端程序，重新打开一个终端。
- 进行基本参数测试，进入 client 项目目录下执行如下的命令：
ghz -c 10 -n 1000 --insecure --proto proto/helloworld.proto --call helloworld.Greeter.SayHelloAgain localhost:50051
成功执行后输出如下的结果：
Summary:
Count: 1000
Total: 235.00 ms
Slowest: 6.81 ms
Fastest: 0.22 ms
Average: 1.18 ms
Requests/sec: 4255.23
Response time histogram:
0.219 [1] |
0.879 [475] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
1.538 [283] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
2.197 [137] |∎∎∎∎∎∎∎∎∎∎∎∎
2.857 [63] |∎∎∎∎∎
3.516 [21] |∎∎
4.176 [10] |∎
4.835 [6] |∎
5.495 [3] |
6.154 [0] |
6.813 [1] |
Latency distribution:
10 % in 0.45 ms
25 % in 0.62 ms
50 % in 0.91 ms
75 % in 1.51 ms
90 % in 2.21 ms
95 % in 2.68 ms
99 % in 4.10 ms
Status code distribution:
[OK] 1000 responses
--call helloworld.Greeter.SayHelloAgain 参数说明，包名为 helloworld、 service 名为 Greeter ，方法名为 SayHelloAgain ，对应的 proto 文件关键内容如下：
// 省略其它代码...
package helloworld;
service Greeter {
rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
}
- 进行负载参数测试，进入 server 项目目录下执行如下的命令：
ghz -c 10 -n 1000 --insecure --proto proto/helloworld.proto --call helloworld.Greeter.SayHelloAgain --load-schedule=step --load-start=50 --load-step=10 --load-step-duration=5s localhost:50051
成功执行后输出如下的结果：
Summary:
Count: 1000
Total: 16.25 s
Slowest: 2.89 ms
Fastest: 0.39 ms
Average: 0.62 ms
Requests/sec: 61.53
Response time histogram:
0.392 [1] |
0.642 [775] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
0.892 [182] |∎∎∎∎∎∎∎∎∎
1.142 [13] |∎
1.392 [8] |
1.642 [2] |
1.892 [3] |
2.142 [0] |
2.392 [3] |
2.642 [8] |
2.893 [5] |
Latency distribution:
10 % in 0.47 ms
25 % in 0.50 ms
50 % in 0.55 ms
75 % in 0.63 ms
90 % in 0.76 ms
95 % in 0.85 ms
99 % in 2.46 ms
Status code distribution:
[OK] 1000 responses
若要指定使用 HTML 格式输出结果，执行以下的命令后可以在当前目录看到输出的 HTML 文件：
ghz -c 10 -n 1000 --insecure --proto proto/helloworld.proto --call helloworld.Greeter.SayHelloAgain --load-schedule=step --load-start=50 --load-step=10 --load-step-duration=5s -o report.html -O html localhost:50051
- 进行并发参数测试，进入 server 项目目录下执行如下的命令：
ghz -c 10 -n 1000 --insecure --proto proto/helloworld.proto --call helloworld.Greeter.SayHelloAgain --rps 200 --concurrency-schedule=step --concurrency-start=5 --concurrency-step=5 --concurrency-end=50 --concurrency-step-duration=5s localhost:50051
成功执行后输出如下的结果：
Summary:
Count: 1000
Total: 5.00 s
Slowest: 3.69 ms
Fastest: 0.32 ms
Average: 0.49 ms
Requests/sec: 199.96
Response time histogram:
0.324 [1] |
0.661 [922] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
0.998 [50] |∎∎
1.335 [6] |
1.673 [3] |
2.010 [3] |
2.347 [5] |
2.684 [5] |
3.021 [1] |
3.358 [2] |
3.695 [2] |
Latency distribution:
10 % in 0.37 ms
25 % in 0.39 ms
50 % in 0.42 ms
75 % in 0.47 ms
90 % in 0.62 ms
95 % in 0.74 ms
99 % in 2.25 ms
Status code distribution:
[OK] 1000 responses
若要指定使用 JSON 格式输出结果，执行以下的命令后可以在当前目录看到输出的 JSON 文件：
ghz -c 10 -n 1000 --insecure --proto proto/helloworld.proto --call helloworld.Greeter.SayHelloAgain --rps 200 --concurrency-schedule=step --concurrency-start=5 --concurrency-step=5 --concurrency-end=50 --concurrency-step-duration=5s -o report.json -O json localhost:50051
（6） ghz/runner 编程实现参数，在 server 项目目录下编写一个程序实现测试，该程序的具体代码如下：
package main
import (
"log"
"os"
"github.com/bojand/ghz/printer"
"github.com/bojand/ghz/runner"
"github.com/golang/protobuf/proto"
pb "server/proto"
)
// 官方文档 https://ghz.sh/docs/intro.html
func main() {
// 组装 BinaryData
item := pb.HelloRequest{Name: "lixd"}
buf := proto.Buffer{}
err := buf.EncodeMessage(&item)
if err != nil {
log.Fatal(err)
return
}
report, err := runner.Run(
// 基本配置 call host proto 文件 data
"helloworld.Greeter.SayHello", // 'package.Service/method' or 'package.Service.Method'
"localhost:50051",
runner.WithProtoFile("proto/helloworld.proto", []string{}),
runner.WithBinaryData(buf.Bytes()),
runner.WithInsecure(true),
runner.WithTotalRequests(10000),
// 并发参数
runner.WithConcurrencySchedule(runner.ScheduleLine),
runner.WithConcurrencyStep(10),
runner.WithConcurrencyStart(5),
runner.WithConcurrencyEnd(100),
)
if err != nil {
log.Fatal(err)
return
}
// 指定输出路径
file, err := os.Create("report.html")
if err != nil {
log.Fatal(err)
return
}
rp := printer.ReportPrinter{
Out: file,
Report: report,
}
// 指定输出格式
_ = rp.Print("html")
}
成功执行程序后会在当前目录下生成指定格式的文件，推荐使用 ghz/runner 编程方式 + HTML 格式输出结果。
-
ghz/runner 编程方式相比二进制方式更加灵活；
-
HTML 格式输出结果更加直观。
-
参考链接：gRPC 官网
-
参考书籍：《gRPC与云原生应用开发：以Go和Java为例》（[斯里兰卡] 卡山 • 因德拉西里 丹尼什 • 库鲁普 著）