gRPC进阶——Metadata机制

什么是Metadata

gRPC让我们可以像本地调用一样实现远程调用，对于每一次的RPC调用中都可能会有一些有用的数据，而这些数据就可以通过metadata来传递。metadata是以key-value的形式存储数据的，其中key是string类型，而value是[]string,即一个字符串数组类型。metadata使得client和server能够为对方提供关于本次调用的一些信息，就像一次http请求的RequestHeader和 ResponseHeader一样。http中header的生命周周期是一次http请求，那么 metadata的生命周期就是一次RPC调用。

Metadata的结构

Metadata是由键值对组成的，每个键名都是字符串，值可以是字符串或二进制数据。为了兼容性和标准化，键名通常使用小写字母和连字符，避免使用大写字母。

Metadata的使用场景

1. 身份验证：
   • 传递访问令牌（如JWT、OAuth令牌）或API密钥进行身份验证。
   • 在每个请求中包含身份验证信息，以便服务器进行认证和授权。
2. 追踪和日志：
   • 传递追踪ID、请求ID或会话ID，用于分布式系统中的请求跟踪。
   • 方便在复杂的微服务架构中跟踪和调试请求链路。
3. 自定义指令：
   • 传递压缩指令，指示服务器使用特定的压缩算法返回数据。
   • 传递自定义头信息，以实现特定业务逻辑需求。

Go中的Metadata

源码：源码

文档：文档

1. 新建Metadata

MD类型实际上是map，key是string，value是string类型的slice。

// MD is a mapping from metadata keys to values. Users should use the following
// two convenience functions New and Pairs to generate MD.
type MD map[string][]string

Metadata创建的时候可以像普通的map类型一样使用new关键字进行创建：

// 方式一，使用metadata.New()
md := metadata.New(map[string]string{"key1": "value1", "key2": "value2"})

// 方式二：使用metadata.Pairs()
md := metadata.Pairs(
    "key1": "value1",
    "key1": "value1-2", // "key1" will have map value []string{"value1", "value1-2"}
    "key2": "value2"
)

2. 发送Metadata

md := metadata.Pairs("key","value")

//新建一个有metadata的context
ctx := metadata.NewOutgoingContext(context.Background(), md)

//单向RPC
response, err := client.SomeRPC(ctx, someRequest)

3. 接收metadata

func (s *Server) SomeRPC(ctx context.Context,in *pb.SomeRequest)(*pb.SomeResponse, error) {
    md,ok := metadata.FromIncomingContext(ctx)
	//do something with metadata
}

GO使用gRPC Metadata

0. 目录树如下

.
├── client
│   └── client.go
├── proto
│   ├── meta_grpc.pb.go
│   ├── meta.pb.go
│   └── meta.proto
└── server
    └── server.go

1. 建立proto/meta.proto文件

syntax = "proto3";

option go_package = ".;proto";

import "google/protobuf/empty.proto";

service GetMeta {
  rpc GetMeta(google.protobuf.Empty) returns (google.protobuf.Empty);
}

利用命令生成对应的go文件

cd proto/
protoc meta.proto --go_out=. --go-grpc_out=.

2. 建立server/server.go文件

package main

import (
	"context"
	"fmt"
	"net"

	"github.com/golang/protobuf/ptypes/empty"
	"google.golang.org/grpc"
	"google.golang.org/grpc/metadata"

	"go-try/metadata/proto"
)

type MetaServer struct {
	proto.UnimplementedGetMetaServer
}

func (s *MetaServer) GetMeta(ctx context.Context, empty2 *empty.Empty) (*empty.Empty, error) {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		fmt.Println("get metadata err")
	}
	if tokenSlice, ok := md["token"]; ok {
		fmt.Println("token: ", tokenSlice[0])
	}
	return nil, nil
}

func main() {
	server := grpc.NewServer()
	proto.RegisterGetMetaServer(server, &MetaServer{})
	listen, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
		panic("faild to listen : " + err.Error())
	}
	err = server.Serve(listen)
	if err != nil {
		panic("faild to start grpc : " + err.Error())
	}
}

3. 建立client/client.go文件

package main

import (
	"context"
	"google.golang.org/grpc/metadata"

	"github.com/golang/protobuf/ptypes/empty"
	"google.golang.org/grpc"

	"go-try/metadata/proto"
)

func main() {
	conn, err := grpc.NewClient("0.0.0.0:8080", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	md := metadata.Pairs("token", "xxxxxxxxxxxxxxxxxxx")
	//md := metadata.New(map[string]string{
	//	"token": "xxxxxxxxxxxxxxxxxxx",
	//})
	ctx := metadata.NewOutgoingContext(context.Background(), md)

	cli := proto.NewGetMetaClient(conn)
	if _, err := cli.GetMeta(ctx, &empty.Empty{}); err != nil {
		panic(err)
	}
}

4. 分别运行server.go和client.go

运行结果如下：

token:  xxxxxxxxxxxxxxxxxxx

总结

通过Metadata机制，可以在不改变接口定义的情况下传递额外的信息，增强服务的灵活性和功能性。在实际应用中，根据具体需求合理设计和使用Metadata，可以实现高效、安全的gRPC通信。