#当我们使用gRPC时,gRPC库关系的是连接,序列化,反序列化和超时执行。Deadlines允许gRPC客户端设置自己等待多长时间来完成rpc操作,直到出现这个错误 DEADLI
#
当我们使用gRPC时,gRPC库关系的是连接,序列化,反序列化和超时执行。Deadlines 允许gRPC客户端设置自己等待多长时间来完成rpc操作,直到出现这个错误 DEADLINE_EXCEEDED
。但是在正常情况下,这个DEADLINE_EXCEEDED默认设置是一个很大的数值。
一些语言的API用deadline,一些用 timeout。
在正常情况下,你没有设置deadline,那么所有的请求可能在最大请求时间过后才超时。这样你对于你的服务器资源,可能存在风险,比如内存,可能因为这个长期运行的服务而增长很快,从而耗尽资源。
为了避免这种情况,需要给你的客户端请求程序设置一个默认的超时时间,在这段时间内请求没有返回,那么就超时报错。
#
#
1.设置deadlines
Copy
2.检查deadlines
Copy
if ctx.Err() == context.Canceled {
return status.New(codes.Canceled, "Client cancelled, abandoning.")
}
#
1. 建立连接时超时控制:
客户端建立连接时,使用的Dial()函数,它位于
google.golang.org/grpc/clientconn.go 中,我们看看这个函数内容:
Copy
(*ClientConn, error) {
return DialContext(context.Background(), target, opts...)
}
它里面调用的 DialContext() 函数,这个函数非常长,他们在同一个文件中,它是实际执行的函数,这里面就有context的timeout和Done相关操作。你也可以到google.golang.org/grpc/clientconn.go
文件中去看看这个函数DialContext
具体是干嘛的。
使用的时候传入设置timeout的context,如下:
Copy
5)
defer cancel()
conn, err := grpc.DialContext(ctx, address, grpc.WithBlock(), grpc.WithInsecure())
- grpc.WithInsecure() ,这个参数啥意思?
gRPC是建立在HTTP/2上的,所以对TLS提供了很好的支持。如果在客户端建立连接过程中设置 grpc.WithInsecure()
就可以跳过对服务器证书的验证。写练习时可以用这个参数,但是在真实的环境中,不要这样做,因为有泄露信息的风险。
- grpc.WithBlock()
这个参数会阻塞等待握手成功。
因为用Dial连接时是异步连接,连接状态为正在连接,如果设置了这个参数就是同步连接,会阻塞等待握手成功。
这个还和超时设置有关,如果你没有设置这个参数,那么context超时控制将会失效。
2. 调用时超时:
函数的调用超时控制
Copy
5)
defer cancel()
result, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
#
用grpc官方的例子来练习下
目录结构:
Copy
grpc-tutorial
#
Copy
echo;message
EchoRequest {
string message = 1;
}
message EchoResponse {
string message = 1;
}
service Echo {
rpc UnaryEcho(EchoRequest) returns (EchoRequest) {}
rpc ServerStreamingEcho(EchoRequest) returns (stream EchoResponse) {}
rpc ClientStreamingEcho(stream EchoRequest) returns (EchoResponse) {}
rpc BidirectionalStreamingEcho(stream EchoRequest) returns (stream EchoResponse){}
}
进入到proto/echo目录,生成go文件,命令如下:
protoc -I . --go_out=plugins=grpc:. ./echo.proto
#
client\main.go
有2个主要的函数,2端都是stream和都不是stream,先看都不是stream的函数
都不是stream的函数
Copy
// unaryCall 不是stream的请求
func unaryCall(c pb.EchoClient, requestID int, message string, want codes.Code) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
上面的code设置在文件 grpc/codes/codes.go
Copy
uint32
const (
OK Code = 0
Canceled Code = 1
Unknown Code = 2
InvalidArgument Code = 3
DeadlineExceeded Code = 4
... ...
)
2端都是stream的函数:
Copy
// streamingCall,2端都是stream
func streamingCall(c pb.EchoClient, requestID int, message string, want codes.Code) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
main 执行函数
Copy
() {
flag.Parse()
conn, err := grpc.Dial(*addr, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Fatalf("did not connect : %v ", err)
}
defer conn.Close()
c :=pb.NewEchoClient(conn)
#
定义一个struct
Copy
struct {
pb.UnimplementedEchoServer
client pb.EchoClient
cc *grpc.ClientConn
}
2端不是stream的函数:
Copy
(*pb.EchoResponse, error) {
message := req.Message
if strings.HasPrefix(message, "[propagate me]") {
上面函数标注 <1> 这个地方比较有意思,当client端发送的字符串包含 [propagate me] 字符串时,先睡眠800毫秒,然后在重新执行客户端请求服务端的函数 s.client.UnaryEcho() , 在次运行到服务端的 UnaryEcho(),客户端已经超时了。
也就是说client/main.go 先请求了一次服务端,然后在server/main.go 的函数 func (s *server) UnaryEcho(ctx context.Context, req *pb.EchoRequest)
又执行了一次请求服务端,所以会导致超时。
2端设置stream的函数:
Copy
error {
for {
req, err := stream.Recv()
if err == io.EOF {
return status.Error(codes.InvalidArgument, "request message not received")
}
if err != nil {
return err
}
message := req.Message
if strings.HasPrefix(message, "[propagate me]") {
time.Sleep(800 * time.Millisecond)
message = strings.TrimPrefix(message, "[propagate me]")
res, err := s.client.UnaryEcho(stream.Context(), &pb.EchoRequest{Message:message})
main函数
Copy
() {
flag.Parse()
address := fmt.Sprintf(":%v", *port)
lis, err := net.Listen("tcp", address)
if err != nil {
log.Fatalf("failed to listen: %v ", err)
}
echoServer := newEchoServer()
defer echoServer.Close()
grpcServer := grpc.NewServer()
pb.RegisterEchoServer(grpcServer, echoServer)
if err := grpcServer.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v ", err)
}
}
#
先运行 /server/main.go , go run main.go
在运行 /client/main.go, go run main.go
执行结果:
Copy
go run main.go
[1] wanted = OK, got = OK
[2] wanted = DeadlineExceeded, got = DeadlineExceeded
[3] wanted = OK, got = Unavailable
[4] wanted = DeadlineExceeded, got = Unavailable
[5] wanted = OK, got = Unavailable
[6] wanted = DeadlineExceeded, got = Unavailable
#
-
01hello grpc helloworld
-
02fourinteractionmode grpc 四种传输方式
-
03customer grpc 一个小练习demo
-
04deadlines grpc 超时限制
#
- gRPC and Deadlines
- grpc-go deadline