Shulou(Shulou.com)05/31 Report--

What this article shares with you is about the principle and practice of registration discovery and load balancing based on gRPC. The editor thinks it is very practical, so I share it with you. I hope you can get something after reading this article. Without saying much, let's take a look at it.

GRPC is a modern, high-performance, open source and language-independent general RPC framework, designed based on HTTP2 protocol, serialization uses PB (Protocol Buffer), PB is a language-independent high-performance serialization framework, based on the high performance guaranteed by HTTP2+PB. Go-zero is an open source micro-service framework that supports http and rpc protocols, in which the bottom layer of rpc depends on gRPC. This paper will analyze the implementation principles of service registration and discovery and load balancing from the perspective of practice, combining gRPC and go-zero source code.

Basic principles

The principle flow chart is as follows:

You can see from the figure that go-zero implements the resolver and balancer interfaces of gRPC, and then registers to gRPC through the gprc.Register method. The resolver module provides the function of service registration, and the balancer module provides the function of load balancing. When client initiates a service call, it selects a service to initiate the request based on the list of services registered by resolver, using the registered balancer. If the gRPC is not registered, the default resolver and balancer are used. Changes in service addresses are synchronized to etcd, and go-zero listens for changes in etcd to update the list of services through resolver

Resolver module

You can register a custom Resolver,Register method definition through the resolver.Register method as follows, where Builder is of type interface, so custom resolver needs to implement this interface. Builder is defined as follows.

/ / Register register custom resolverfunc Register (b Builder) {m [b.Scheme ()] = b} / / Builder definition resolver buildertype Builder interface {Build (target Target, cc ClientConn, opts BuildOptions) (Resolver, error) Scheme () string}

The type of the first parameter target of the Build method is defined as Target. The second parameter of creating ClientConn to call grpc.DialContext, target, needs to conform to this structure definition after parsing. The target definition format is: scheme://authority/endpoint_name.

Type Target struct {Scheme string / / indicates the name system to be used Authority string / / indicates some scheme-specific boot information Endpoint string / / indicates a specific name}

The Resolver returned by the Build method is also an interface type. The definition is as follows

Type Resolver interface {ResolveNow (ResolveNowOptions) Close ()}

The following diagram of flow chart

Therefore, you can see that custom Resolver needs to implement the following steps:

Define target

Implement resolver.Builder

Implement resolver.Resolver

Call resolver.Register to register the custom Resolver, where name is the scheme in target

Implement service discovery logic (etcd, consul, zookeeper)

Update the service address through resolver.ClientConn

The definition of target in go-zero is as follows, and the default name is discov

/ / BuildDiscovTarget build targetfunc BuildDiscovTarget (endpoints [] string, key string) string {return fmt.Sprintf ("% s://%s/%s", resolver.DiscovScheme, strings.Join (endpoints, resolver.EndpointSep), key)} / / RegisterResolver register custom Resolverfunc RegisterResolver () {resolver.Register (& dirBuilder) resolver.Register (& disBuilder)}

The implementation of the Build method is as follows

Func (d * discovBuilder) Build (target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {hosts: = strings.FieldsFunc (target.Authority, func (r rune) bool {return r = = EndpointSepChar}) / / get service list sub, err: = discov.NewSubscriber (hosts, target.Endpoint) if err! = nil {return nil Err} update: = func () {var addrs [] resolver.Address for _, val: = range subset (sub.Values (), subsetSize) {addrs = append (addrs, resolver.Address {Addr: val })} / / call the UpdateState method to update cc.UpdateState (resolver.State {Addresses: addrs,})} / / add snooping Update sub.AddListener (update) / / update service list update () return & nopResolver {cc: cc}, nil} when the service address changes

So where is the registered resolver used? When you call the DialContext method to create a ClientConn when creating a client, do the following

Interceptor processing

Processing of various configuration items

Parsing target

Get resolver

Create ccResolverWrapper

When you create a clientConn, parse the scheme according to target, and then find the registered resolver according to scheme. If not, use the default resolver.

The process of ccResolverWrapper is shown in the figure below, where resolver is associated with balancer, and balancer is handled in a similar way to resolver, which is encapsulated through wrapper.

A link to htt2 will be created based on the obtained address.

At this point, the ClientConn creation process is basically over. Let's sort out the whole process together. First, we get the resolver, where ccResolverWrapper implements the resovler.ClientConn interface, which is triggered by the UpdateState method of Resolver to obtain Balancer and Balancer, where ccBalancerWrapper implements the balancer.ClientConn interface, triggers the creation of SubConn through the UpdateClientConnState method of Balnacer, and finally creates the HTTP2 Client.

Balancer module

The balancer module is used for load balancing when the client initiates a request. If no custom balancer is registered, gRPC will use the default load balancing algorithm. The flow chart is as follows

The custom balancer in go-zero mainly implements the following steps:

Implement the PickerBuilder,Build method to return balancer.Picker

Implementing balancer.Picker,Pick method to realize load balancing algorithm Logic

Call balancer.Registet to register a custom Balancer

Using baseBuilder registration, the framework has provided baseBuilder and baseBalancer to implement Builer and Balancer

The implementation of the Build method is as follows

Func (b * p2cPickerBuilder) Build (readySCs map [uplover.Address] balancer.SubConn) balancer.Picker {if len (readySCs) = 0 {return base.NewErrPicker (balancer.ErrNoSubConnAvailable)} var conns [] * subConn for addr, conn: = range readySCs {conns = append (conns, & subConn {addr: addr Conn: conn, success: initSuccess,})} return & p2cPicker {conns: conns, r: rand.New (rand.NewSource (time.Now (). UnixNano ()), stamp: syncx.NewAtomicDuration (),}}

The P2P load balancing algorithm is implemented by default in go-zero. The advantage of this algorithm is that it can flexibly handle the requests of each node. The implementation of Pick is as follows

Func (p * p2cPicker) Pick (ctx context.Context, info balancer.PickInfo) (conn balancer.SubConn, done func (balancer.DoneInfo), err error) {p.lock.Lock () defer p.lock.Unlock () var chosen * subConn switch len (p.conns) {case 0: return nil, nil Balancer.ErrNoSubConnAvailable / / there is no available link case 1: chosen = p.choose (p.conns [0], nil) / / only one link case 2: chosen = p.choose (p.conns [0], p.conns [1]) default: / / Select a healthy node var node1 Node2 * subConn for i: = 0 I

= a {baked +} node1 = p.conns [a] node2 = p.conns [b] if node1.healthy () & & node2.healthy () {break }} chosen = p.choose (node1 Node2)} atomic.AddInt64 (& chosen.inflight, 1) atomic.AddInt64 (& chosen.requests, 1) return chosen.conn, p.buildDoneFunc (chosen), nil}

The process for the client to initiate the call is as follows. The pick method is called to obtain a transport for processing.

The above is based on the principle and practice of gRPC registration discovery and load balancing. The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.