gRPC框架学习

安装Protobuf

下载安装：https://github.com/protocolbuffers/protobuf/releases
配置环境变量：$GOPATH/bin（解压后的程序文件放到goPath目录，否则会出现protoc命令不存在或者protoc-gen-go不存在等问题）

安装gRPC核心库

# 安装protocol编译器
go get google.golang.org/grpc
# 安装各语言的代码生成工具
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

编写proto文件

// 声明使用的是proto3语法
syntax = "proto3";

// 表示最后生成的go文件处于哪个目录哪个包中，【.】代表当前目录生成，service代表了生成的go文件的包名是service
option go_package = ".;service";

// 定义了一个服务，服务中需要一个方法，这个方法可以接收客户端的参数，再返回服务端的响应
// 这里定义了一个名为SayHello的service，这个服务中有一个rpc方法，名为SayHello，这个方法会发送一个HelloRequest，返回HelloResponse
service SayHello {
  rpc SayHello(HelloRequest) returns (HelloResponse) {}
}

message HelloRequest {
  string requestName = 1;
  int64 age = 2;
}

message HelloResponse {
  string responseMsg = 1;
}

生成对应文件

protoc --go_out=. test.proto # 对应文件名
protoc --go-grpc_out=. test.proto # 对应文件名

服务端编写

1. 创建gRPC Server对象，可以理解为它是Server端的抽象对象
2. 将server（其包含需要被调用的服务端接口）注册到gRPC Server的内部注册中心，这样可以在接受到请求时，通过内部的服务发现，发现该端口并转接进行逻辑处理
3. 创建Listen，监听TCP端口
4. gRPC Server开始lis.Accept，直到Stop

package main

import (
    "context"
    "fmt"
    "google.golang.org/grpc"
    pb "grpc/server/proto"
    "net"
)

// hello server
type server struct {
    pb.UnimplementedSayHelloServer
}

func (s *server) SayHello(ctx context.Context,req *pb.HelloRequest) (*pb.HelloResponse, error) {
    fmt.Println("打印：" + req.RequestName)
    return &pb.HelloResponse{ResponseMsg: "hello" + req.RequestName}, nil
}

func main() {
    // 开启端口
    listen,_  := net.Listen("tcp", ":9090")
    // 创建grpc服务
    grpcServer := grpc.NewServer()
    // 在grpc服务端中去注册我们自己编写的服务
    pb.RegisterSayHelloServer(grpcServer, &server{})

    // 启动服务
    err := grpcServer.Serve(listen)
    if err != nil {
        fmt.Printf("启动失败：%v", err)
        return
    }
}

客户端编写

package main

import (
    "context"
    "fmt"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    pb "grpc/server/proto"
)

func main() {
    conn, err := grpc.Dial("127.0.0.1:9090", grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        fmt.Printf("连接失败：%v", err)
        return
    }
    defer conn.Close()

    // 建立连接
    client := pb.NewSayHelloClient(conn)

    resp, _ := client.SayHello(context.Background(), &pb.HelloRequest{RequestName: "张三"})
    fmt.Println(resp.GetResponseMsg())
}

TLS认证

## 服务端
    // TLS认证
    creds, _ := credentials.NewServerTLSFromFile("pem file path","key file path")
    // 开启端口
    listen,_  := net.Listen("tcp", ":9090")
    // 创建grpc服务
    grpcServer := grpc.NewServer(grpc.Creds(creds))

## 客户端
    // TLS认证
    creds, _ := credentials.NewClientTLSFromFile("pem file path","*.test.com")
    conn, err := grpc.Dial("127.0.0.1:9090", grpc.WithTransportCredentials(creds))

Token认证

gRPC提供了一个接口，这个接口有2个方法，接口位于credentials包下，这个接口需要客户端来实现

type PerRPCCredentials interface {
    // 第一个方法用于获取元数据，也就是客户端提供的key-value对，context用于控制超时和取消，uri是请求入口处的uri
    GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error)
    // 第二个定义是否需要基于TLS认证进行安全传输，返回true则必须加上TLS验证，false则不用
    RequireTransportSecurity() bool
}

示例代码

## 客户端
type ClientTokenAuth struct {}

func (c ClientTokenAuth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
    return map[string]string{
        "appId":  "zhangsan",
        "appKey": "123123",
    }, nil
}

func (c ClientTokenAuth) RequireTransportSecurity() bool {
    return false
}

// 连接到server端代码，此处禁用安全传输，没有加密和验证
var opts []grpc.DialOption
opts = append(opts,grpc.WithTransportCredentials(insecure.NewCredentials()))
opts = append(opts,grpc.WithPerRPCCredentials(new(ClientTokenAuth)))

conn, err := grpc.Dial("127.0.0.1:9090", opts...)

#-------------------------------------------------------------------------------------#
## 服务端
func (s *server) SayHello(ctx context.Context,req *pb.HelloRequest) (*pb.HelloResponse, error) {
    // 获取元数据的信息
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        return nil,errors.New("未传输token")
    }
    
    var appId string
    var appKey string
    if val, ok := md["appId"];ok{
        appId = val[0]
    }
    if val, ok := md["appKey"];ok{
        appKey = val[0]
    }
    
    if appId != "zhangsan" || appKey != "123123" {
        return nil,errors.New("token异常")
    }
    
    return &pb.HelloResponse{ResponseMsg: "hello" + req.RequestName}, nil
}