rpc

Compare gRPC services with HTTP APIs

Use Binary Encoding Instead of JSON

高效的数据压缩编码方式 Protobuf

HTTP/2 and gRPC — The Next Generation of Microservices Interactions

Compare gRPC services with HTTP APIs

Comparing API Architectural Styles: SOAP vs REST vs GraphQL vs RPC

RPC vs REST

RPC

protobuf教程(二)—核心编码原理

Encoding

Schema evolution in Avro, Protocol Buffers and Thrift

Protobuf vs JSON

gRPC Name Resolution

Load Balancing in gRPC

what: remote procedure call, used for communicate. between process

basic component:

1. serilization
2. transport: tcp

rpc框架比较:

use

what: 依赖于protoc 文件；

server: grpc server, handler client: grpc connect

code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// server

// 1. rpc server
grpcSrv = grpc.NewServer();
grpcSrv.Listen(tcpListen);


// 2. addRpcServer  
potocol.register(grpcSrv , handlerSrv)


// client
conn = grpc.dial()

client  = proto.newClientWithConn(conn)
client.callSomeFunc 

grpc.methods:

1
2
3
4

methodsTable:
	server: ....
	rpc methodname: ...
	handler: ....

restful vs rpc

same:

1. client-side
2. based on http, tcp

differ:

1. function vs resouce: 抽象方式

   1. rpc: action(function)-oriented: operatioon= call local funtion 处理各种类型操作；
   2. http: resouce-oriented: operaiton= curd resource, 不擅长处理非crud操作

2. data-format:

   1. rpc: binaryformat
   2. rest: text-format

3. advanced：

   1. 服务注册发现
   2. 负载均衡
   3. streaming

why use rpc in microserve:

1. fast: binary foramt, less size.
2. more safe: schema, type safety
3. more advanced:
   1. code generation
   2. service discovery
   3. load balance
   4. streaming

protobuf

what:

1. one of date format，like json,xml
2. 跨语言

vs json

differ:

1. encode:
   1. text-eoncode(serilazion)
   2. binray-econde : lesss size
2. type safety: 基于 schema实现type check, avoid unexpected behavior

how

1. variant int
2. Tag value to represent key value.

variant int

what: 使用最高位表示是否有更多byte 1: continue 0: end

pros: use less space when int is small;

example: 1

tag value

how： tagnumber -> key, length(optional), value

1
2
3
4
5
6
7

message Person {
required string user_name        = 1;
optional int64  favourite_number = 2;
repeated string interests        = 3;
}

person.name=martion -> 01  02 06 martin

the used of tag number： identify the key

can grpc number duplicate: no, key is represent in a unique key number during encoding and decoding

protobuf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

syntax = "proto3";

package hello_123;

  

option go_package ="xgit.molica.com.cn/backend/hello;hello";

  

service HelloWorldService {

rpc SayHello(HelloWorldRequest) returns (HelloWorldResponse) {}

}

  

message HelloWorldRequest {}

  

message HelloWorldResponse {

string message = 1;

}

package: use in internal space,

how to use it

define

structure package: namespace service: a set of methods

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package aa


message xx {

}

service  xxx  {

}

convention:

1. PascalCase for message name:
2. snake case name file file
3. PascalCase for service name and method

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

message HelloReq {
	string song_name = 1;
}



message  HelloRes  {
	string  age int32 = 1;
}


service Greeter {
	rpc  SayHello (HelloReq) returns (HelloRes)
}

command

plugins:

1. protoc-gen-go: how to encode/decode;
2. protoc-gen-go-grpc: grpc client/server

command:

simple:

1

protoc  --go_out   xx.proto 

1
2
3
4

protoc --go_out=paths=source_relative:.  --go-grpc_out=paths=source_relative:. -Iapi  hello/v1/hello.proto

protoc --proto_path=api  --go_out=. --go_opt=paths=source_relative    --go-grpc_out=. \
--go-grpc_opt=paths=source_relative  hello/v1/hello.proto

protoc –go_out=paths=source_relative:api api/hello/hello.proto

arguments:

–go_out=PATH: output direcotry; –go_out=pahts=source_relative/import:. the output directory is:

1. import: import directroy
2. source_relative: the proto file relative directory

grpc and http server

server: bind grpc service and protocServer

1
2
3
4
5
6

grpcSer := grpc.NewServer();

helloProtco.Register(grpcSer, protocServer)

grpcServer.Serve(tcpConnect)

client: bind serverClient

1
2
3

serverClient.Register(tcpConnect)

load balancer

default methods for grpc

how:

1. resolver: 解析URL, URL -> ip
2. balancer: pick from subConnect

balance strategy:
1. round-robin 2. pick-first 3. custom

resolver:

1
2
3

for  addrList :=  addressChannl{
	updateConnectionList(addlist)
}

balancer:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func Build(){
	var subConns []balancer.SubConn
	for sc := range info.ReadySCs {
		subConns = append(scs, sc)
	}
}

pickNext(){
	p.next = (p.next + 1) % len(subConns)
}

grpc advanced feature

stream;

1. what?

   send: —> [request message]; receive: <- [reponse message];

   send: [requestMsg1, reqMsg2]; response: [responseMsg, responMsg];

send mutiple reponse request/reponse at same time;

send:

1
2
3
4
5
6
7

func (s *server) SayHello1(in *pb.HelloRequest, gs pb.Greeter_SayHello1Server) error {
	name := in.Name
	for i := 0; i < 100; i++ {
		gs.Send(&pb.HelloReply{Message: "Hello " + name + strconv.Itoa(i)})
	}
	return nil
}

receive:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

for {
	reply, err := stream.Recv()
	if err == io.EOF {
		break
	}
	if err != nil {
		log.Printf("failed to recv: %v", err)
	}
	log.Printf("Greeting: %s", reply.Message)
}

2. 本质是什么？ 将一个大的请求/响应拆分成更小的请求/响应；

3. use case;

   1. 处理大量报表数据:报表数据；

grpc serverr

1. use protoc to generate the necesssary file
2. generate the server and client;

server:

1
2
3
4

grpc Server = grpc server

grpcSev.listen(tcp);
rpcHandler.register(grpcSev)

client: