Grpc-go实践

Grpc-go实践

上手

项目文件目录

── client
│ └── grpc_client.go
├── pb
│ └── hello.pb.go
├── proto
│ └── hello.proto
└── server
├── greeter
│ └── grpc_server.go
└── main.go

1、编写proto文件

(对大小写不敏感，会自动转换)

syntax = "proto3";
package trip;
option go_package="github.com/bob/codelab/golang/grpc_example/pb;hellopb";
message helloRequest {
    string name=1;
    int64 id=2;
}

message helloResponse {
    string res=1;
}

service helloService{
    rpc sayHello(helloRequest)returns(helloResponse){}
}

2、编译

在proto文件的桶目录下

protoc -I=.  --go_out=plugins=grpc,paths=source_relative:../pb hello.proto

或者：

protoc -I=.  --go_out=plugins=grpc:. hello.proto

这样的命令会将生成的文件，option go_package=指定的目录下，并且生成的目录是相对proto文件的位置

4、编写grpc客户端

package main

import (
	"context"
	"fmt"
	"log"

	hellopb "github.com/bob/codelab/golang/grpc_example/pb"
	"google.golang.org/grpc"
)

func main() {
	conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	client := hellopb.NewHelloServiceClient(conn)
	res, err := client.SayHello(context.Background(), &hellopb.HelloRequest{Name: "bob123", Id: 1})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(res)
}

5、服务端

本质上就是实现hello.pb.go中的HelloServiceServer接口

type HelloServiceServer interface {

​ SayHello(context.Context, *HelloRequest) (*HelloResponse, error)

}

package greeter

import (
	"context"
	"fmt"

	hellopb "github.com/bob/codelab/golang/grpc_example/pb"
)

// Server implements greeter service
type Service struct{}

func (*Service) SayHello(c context.Context, req *hellopb.HelloRequest) (*hellopb.HelloResponse, error) {
	fmt.Println(req.Name,req.Id)
	return &hellopb.HelloResponse{
		Res: req.Name,
	}, nil
}

Main.go

package main

import (
	"fmt"
	"net"

	pb "github.com/bob/codelab/golang/grpc_example/pb"
	"github.com/bob/codelab/golang/grpc_example/server/greeter"
	"google.golang.org/grpc"
)

const PORT = ":50052"

func main() {
	fmt.Println("grpc server starting")
	//监听端口
	lis, err := net.Listen("tcp", PORT)
	if err != nil {
		panic(err)
	}
	//创建一个grpc 服务器
	s := grpc.NewServer()
	//注册事件
	pb.RegisterHelloServiceServer(s,&greeter.Service{})
	//处理链接
	err = s.Serve(lis)
	if err != nil {
		panic(err)
	}
}

grpc的一元拦截器

1、server端的拦截器实现

package main

import (
	"context"
	"fmt"
	"net"
	"time"

	pb "github.com/bob/codelab/golang/grpc_example/pb"
	"github.com/bob/codelab/golang/grpc_example/server/greeter"
	"google.golang.org/grpc"
)

const PORT = ":50052"

func main() {
	fmt.Println("grpc server starting")
	//监听端口
	lis, err := net.Listen("tcp", PORT)
	if err != nil {
		panic(err)
	}
	// 创建一个拦截器
	// }
	interceptor1 := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error){
		fmt.Println("统计时间")
		start :=time.Now()
		res,err :=handler(ctx,req)// hander 函数表示原始运行逻辑
		end:=time.Since(start)
		fmt.Println("耗时：",end)
		return res,err 
	}
	opt1 :=grpc.UnaryInterceptor(interceptor1) //一元调用的拦截器

	//创建一个grpc 服务器
	s := grpc.NewServer(opt1)
	//注册事件
	pb.RegisterHelloServiceServer(s,&greeter.Service{})
	//处理链接
	err = s.Serve(lis)
	if err != nil {
		panic(err)
	}
}

2、客户端实现拦截器

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	hellopb "github.com/bob/codelab/golang/grpc_example/pb"
	"google.golang.org/grpc"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/types/known/emptypb"
)

func main() {
	myInterceptor :=func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error{
		fmt.Println("client的拦截器")

		err := invoker(ctx,method,req,reply,cc,opts...)
		return err
	}
	opt:=grpc.WithUnaryInterceptor(myInterceptor)
	conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure(),opt)
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	client := hellopb.NewHelloServiceClient(conn)

	res, err := client.SayHello(context.Background(), &hellopb.HelloRequest{Name: "bob123", Id: 1})

	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(res)
	pong, err := client.Ping(context.Background(), &emptypb.Empty{})
	if err != nil {
		panic(err)
	}
	fmt.Println(pong)
}

说明

// 拦截器的实现：关键函数grpc.WithUnaryInterceptor(opts...)
myInterceptor :=func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error{
		fmt.Println("client的拦截器")

		err := invoker(ctx,method,req,reply,cc,opts...)
		return err
	}

/*
invoker()：函数表示之后的逻辑继续执行
g
*/

grpc的metadata

说明、

metadata类似语言中的map的使用，起到的作用跟http中的请求头head 类似，可以作为token之类的信息传递

1、客户端设置metadata

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	hellopb "github.com/bob/codelab/golang/grpc_example/pb"
	"google.golang.org/grpc"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/types/known/emptypb"
)

func main() {
	myInterceptor :=func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error{
		fmt.Println("client的拦截器")

		err := invoker(ctx,method,req,reply,cc,opts...)
		return err
	}
	opt:=grpc.WithUnaryInterceptor(myInterceptor)
	conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure(),opt)
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	client := hellopb.NewHelloServiceClient(conn)
	// metadata的使用，类似map，key-value储存
	// md :=metadata.Pairs("timeStamp",time.Now().Format("2006-01-02 15:04:05")) //
	// 使用new 创建md
	md:=metadata.New(map[string]string{
		"Name":"bob",
		"timeStamp":time.Now().Format("2006-01-02 15:04:05"),
	})
	ctx:=metadata.NewOutgoingContext(context.Background(),md)
	res, err := client.SayHello(ctx, &hellopb.HelloRequest{Name: "bob123", Id: 1})

	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(res)
	pong, err := client.Ping(context.Background(), &emptypb.Empty{})
	if err != nil {
		panic(err)
	}
	fmt.Println(pong)
}

关键代码：

md:=metadata.Pairs("timeStamp",time.Now().Format("2006-01-02 15:04:05"))
// or
md:=metadata.New(map[string]string{
		"Name":"bob",
		"timeStamp":time.Now().Format("2006-01-02 15:04:05"),
	})
	ctx:=metadata.NewOutgoingContext(context.Background(),md)
/*
metadata的新建可以使用Pairs和New，在使用习惯上，个人推荐使用New。
*/

2、服务端接受处理metadata

/*
1、服务端接收到的的metadata会将客户端传来的大写转小写；

2、获取metadata中的信息的方法跟map雷曦
*/
package greeter

import (
	"context"
	"fmt"

	hellopb "github.com/bob/codelab/golang/grpc_example/pb"
	emptypb "github.com/golang/protobuf/ptypes/empty"
	"google.golang.org/grpc/metadata"
)

// Server implements greeter service
type Service struct{}

func (*Service) SayHello(c context.Context, req *hellopb.HelloRequest) (*hellopb.HelloResponse, error) {
	fmt.Println(req.Name, req.Id)
	md,ok :=metadata.FromIncomingContext(c)
	if ok{
		for k,v:=range md{  // md中的信息不只有客户端传入的k,v，还包含另外的一些系统信息
			fmt.Println(k,v)
		}
	}
  /*
  遍历得到的所有信息：其中只有timestamp和name是客户端传来的
  timestamp [2021-09-06 21:44:09]
  :authority [localhost:50052]
  content-type [application/grpc]
  user-agent [grpc-go/1.26.0]
  name [bob]
  */
	if timeSlice,ok := md["timeStamp"];ok{ // 取不到timeStamp的值，此处的key应该为全小写
		fmt.Println(timeSlice)// 取出的value为一个切片：[]string
		for i,v :=range timeSlice{
			fmt.Println(i,v)
		}
	}
	return &hellopb.HelloResponse{
		Res: req.Name,
	}, nil
}
func (*Service) Ping(context.Context, *emptypb.Empty) (*hellopb.Pong, error) {
	return &hellopb.Pong{
		Id: 111,
	}, nil
}

grpc负载均衡

1、开源项目

https://github.com/mbobakov/grpc-consul-resolver

2、service_config的官方配置文档

https://github.com/grpc/grpc-proto/blob/master/grpc/service_config/service_config.proto

grpc中间件实现重试机制

重试机制

依赖包：grpcRetry "github.com/grpc-ecosystem/go-grpc-middleware/retry"

客户端使用

// grpc重试机制·
	retryOpt := []grpcRetry.CallOption{
		// grpcRetry.WithBackoff(grpcRetry.BackoffLinear(100 * time.Millisecond)),
		// grpcRetry.WithCodes(codes.NotFound, codes.Aborted),
		grpcRetry.WithMax(3), //重试次数
		grpcRetry.WithPerRetryTimeout(time.Second), //多久时间重试
		grpcRetry.WithCodes(codes.Unknown, codes.Unavailable, codes.DeadlineExceeded), //重试状态码
	}
	opts = append(opts, grpc.WithUnaryInterceptor(grpcRetry.UnaryClientInterceptor(retryOpt...))) 
	conn, err := grpc.Dial("localhost:50052", opts...)