一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第4天，点击查看活动详情。
本文大部分都是实际代码例子, 如果您对 grpc 感兴趣, 可以作为基础参考的一部分.
- 介绍了 proto 生成 pb 文件常用命令
- 如何构造 grpc 服务, header头传递、拦截器一些基本操作.
- 如何使用 protoc-gen-grpc-gateway 插件生成同时支持 grpc和http 访问请求.
声明 proto
定义proto文件, 返回Msg
syntax = "proto3";
package server;
option go_package = ".;testServer";
service testServer {
rpc SayHello (Request) returns(Response){
}
}
message Request {
}
message Response {
string Msg = 1;
}
生成pb message结构文件
protoc -I pb/ --go_out=./pb server.proto
生成grpc服务文件
protoc -I pb/ --go-grpc_out=./pb server.proto
-I 表示指定proto的目录 *_out 表示指定输出的目录 *.proto表示源proto的文件名
执行完成后, 我们将会看到 server.pb.go 和 server_grpc.pb.go 两个文件
grpc 服务实现
grpc server服务实现
业务逻辑部分(pb rpc中定义的接口实现)
type Server struct {
testServer.UnimplementedTestServerServer
}
func (s *Server) SayHello(ctx context.Context, t *testServer.Request) (*testServer.Response, error) {
//获取传递的metadata
md, _ := metadata.FromIncomingContext(ctx)
log.Println("xxxx", md)
return &testServer.Response{Msg: "Hello world"}, nil
}
UnimplementedTestServerServer 的作用是将源pb文件 rpc 方法全部生成为默认实现, 这么做的目的在我们在变更 rpc 接口时, 不会因为未全部实现 导致 register 失败而无法运行, 而是将会执行 UnimplementedTestServerServer 的方法， 例如:
func (UnimplementedTestServerServer) SayHello(context.Context, *Request) (*Response, error) {
return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}
metadata.FromIncomingContext 是获取 grpc 请求的头部参数,
http1传递参数通过header头, 而对应的 http2 传递 header 参数主要依赖metadata, grpc底层依赖 http2, 所以也是依赖 metadata 获取header头参数的.
metadata 在实现上是比较简单的, 底层就是一个 map 的结构.
type MD map[string][]string
func FromIncomingContext(ctx context.Context) (MD, bool) {
md, ok := ctx.Value(mdIncomingKey{}).(MD)
if !ok {
return nil, false
}
out := MD{}
for k, v := range md {
// We need to manually convert all keys to lower case, because MD is a
// map, and there's no guarantee that the MD attached to the context is
// created using our helper functions.
key := strings.ToLower(k)
out[key] = v
}
return out, true
}
grpc server 服务
grpc.UnaryServerInterceptor 是我们的拦截器, 通过实现 unaryServerInterceptor 方法, 我们将会在入口拦截请求参数进行处理, 比如验证鉴权操作
Server对象就是我们上面 rpc 接口的实现, 我们通过 RegisterTestServerServer 注册到 srv上
//拦截器
ints := []grpc.UnaryServerInterceptor{
unaryServerInterceptor(),
}
grpcOpts := []grpc.ServerOption{
grpc.ChainUnaryInterceptor(ints...),
}
//new grpc server
srv := grpc.NewServer(grpcOpts...)
//grpc server 注册server服务
server := &Server{}
testServer.RegisterTestServerServer(srv, server)
//grpc server绑定端口
listener, err := net.Listen("tcp", ":12345")
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
err = srv.Serve(listener)
if err != nil {
log.Fatalf("failed to serve: %v", err)
}
unaryServerInterceptor 拦截器实现
func unaryServerInterceptor() grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
//获取md参数并打印
md, _ := metadata.FromIncomingContext(ctx)
log.Println(md)
replyHeader := metadata.MD{}
//todo
h := func(ctx context.Context, req interface{}) (interface{}, error) {
return handler(ctx, req)
}
reply, err := h(ctx, req)
//设置响应头
if len(replyHeader) > 0 {
_ = grpc.SetHeader(ctx, replyHeader)
}
return reply, err
}
}
grpc client 调用
conn, err := grpc.Dial(":12345", grpc.WithInsecure())
if err != nil {
panic(err)
}
client := testServer.NewTestServerClient(conn)
ctx := context.Background()
md := metadata.New(map[string]string{"key1": "小文文", "key2": "小方方"})
ctx = metadata.NewOutgoingContext(ctx, md)
response, err := client.SayHello(ctx, &testServer.Request{})
log.Println(response, err, ctx)
HTTP1 和 GRPC 共同提供服务
如何使用一套proto协议可以同时支持 http1 和 grpc 调用呢?
这里我们使用一个proto的插件 protoc-gen-grpc-gateway, 来实现这个功能.
//安装插件
go get github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway
http需要指定访问路径, 我们需要稍微改造下上面的 proto 协议
//...
import "google/api/annotations.proto";
//...
service testServer {
rpc SayHello (Request) returns(Response){
option (google.api.http) = {
get: "/hello",
};
}
}
message Request {
}
message Response {
string Msg = 1;
}
这里我们使用option命令声明了一个 get 请求 /hello
protoc -I pb/ --proto_path=./ --go_out=./pb --go-grpc_out=./pb --grpc-gateway_out=./pb server.proto
我们新增加了一个插件 --grpc-gateway_out , 生成 pb.gw.go文件, 提供 RegisterTestServerHandler 方法进行路由注册.
//register server (http->SayHello)
func RegisterTestServerHandlerServer(ctx context.Context, mux *runtime.ServeMux, server TestServerServer) error {
mux.Handle("GET", pattern_TestServer_SayHello_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
//...
//调用的本地
resp, md, err := local_request_TestServer_SayHello_0(rctx, inboundMarshaler, server, req, pathParams)
//...
})
return nil
}
//register client (http -> grpc -> SayHello)
func RegisterTestServerHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TestServerClient) error {
mux.Handle("GET", pattern_TestServer_SayHello_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
//...
//调用的grpc服务
resp, md, err := request_TestServer_SayHello_0(rctx, inboundMarshaler, client, req, pathParams)
//...
})
return nil
}
这里可以看到两种 register 是不一样的, 一种是本地直接调用 pb rpc 声明的方法, 另一种是 http 再调用 grpc 服务, 下面我们看下示例
RegisterTestServerHandlerServer 注册示例
gwmux := runtime.NewServeMux(
runtime.WithIncomingHeaderMatcher(func(key string) (string, bool) { //自定义header头过滤规则
//todo 此处需要返回header key, 才能在 md 中获取到header头信息
return key, true
}),
)
err = testServer.RegisterTestServerHandlerServer(context.Background(), gwmux, server)
if err != nil {
log.Fatalln("Failed to register gateway:", err)
}
gwServer := &http.Server{
Addr: ":8888",
Handler: gwmux,
}
log.Fatalln(gwServer.ListenAndServe())
RegisterTestServerHandlerClient注册示例
//首先链接grpc服务地址
conn, err := grpc.Dial(
":12345",
grpc.WithInsecure(),
)
if err != nil {
log.Fatalln("Failed to dial server:", err)
}
client := testServer.NewTestServerClient(conn)
gwmux := runtime.NewServeMux(
runtime.WithIncomingHeaderMatcher(func(key string) (string, bool) { //自定义header头过滤规则
//todo 此处需要返回header key, 才能在 md 中获取到header头信息
return key, true
}),
)
err = testServer.RegisterTestServerHandlerClient(context.Background(), gwmux, client)
if err != nil {
log.Fatalln("Failed to register gateway:", err)
}
gwServer := &http.Server{
Addr: ":8888",
Handler: gwmux,
}
log.Fatalln(gwServer.ListenAndServe())
