安装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
}
