史上最细gRPC(Go)入门教程(十二)---客户端负载均衡

golang工程组件篇:高性能RPC框架gRPC之Client连接池的实现 然后当我们需要发送一个GetUser请求时,从连接池中获取一个可用的连接,创建UserServiceClient客户端,发送请求,并将连接放回到池子中。它可以帮助我们复用已经建立好的TCP连接,并且避免频繁地创建和关闭连接。通过使用Client连接池,我们可以有效地降低系统的开销,并且提高系统对并发请求的处理能力。通过使用Client连接池,我们可以有效地复用已经建立好的TCP连接,并且避免频繁地创建和关闭连接。在本文中,我将重点介绍如何实现gRPC框架中的Client连接池,以提高系统的可靠性和性能。 阅读详情

来自:指月 https://lixueduan.com

原文:https://www.lixueduan.com/post/grpc/12-client-side-loadbalance/
本文主要介绍了 gRPC 内置的负载均衡策略及其配置与使用,包括 Name Resolver、ServiceConfig 等。


如果你对云原生技术充满好奇,想要深入了解更多相关的文章和资讯,欢迎关注微信公众号。

扫描下方二维码或搜索公众号【探索云原生】即可订阅


gRPC 系列相关代码见 Github

1. 概述

gRPC 负载均衡包括客户端负载均衡和服务端负载均衡两种方向。本文主要介绍的是客户端负载均衡。

gRPC 的客户端负载均衡主要分为两个部分:

  • 1)Name Resolver
  • 2)Load Balancing Policy

1. NameResolver

具体可以参考官方文档-Name Resolver或者gRPC系列教程(十一)—NameResolver 实战及原理分析

gRPC 中的默认 name-system 是DNS,同时在客户端以插件形式提供了自定义 name-system 的机制。

gRPC NameResolver 会根据 name-system 选择对应的解析器,用以解析用户提供的服务器名,最后返回具体地址列表(IP+端口号)。

例如:默认使用 DNS name-system,我们只需要提供服务器的域名即端口号,NameResolver 就会使用 DNS 解析出域名对应的IP列表并返回。

在本例中我们会自定义一个 NameResolver。

1.2 Load Balancing Policy

具体可以参考官方文档-Load Balancing Policy

常见的 gRPC 库都内置了几个负载均衡算法,比如 gRPC-Go 中内置了pick_first和round_robin两种算法。

  • pick_first:尝试连接到第一个地址,如果连接成功,则将其用于所有RPC,如果连接失败,则尝试下一个地址(并继续这样做,直到一个连接成功)。
  • round_robin:连接到它看到的所有地址,并依次向每个后端发送一个RPC。例如,第一个RPC将发送到backend-1,第二个RPC将发送到backend-2,第三个RPC将再次发送到backend-1。

本例中我们会分别测试两种负载均衡策略的效果。

2. Demo

2.1 Server

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"sync"

	"google.golang.org/grpc"

	pb "github.com/lixd/grpc-go-example/features/proto/echo"
)

var (
	addrs = []string{":50051", ":50052"}
)

type ecServer struct {
	pb.UnimplementedEchoServer
	addr string
}

func (s *ecServer) UnaryEcho(ctx context.Context, req *pb.EchoRequest) (*pb.EchoResponse, error) {
	return &pb.EchoResponse{Message: fmt.Sprintf("%s (from %s)", req.Message, s.addr)}, nil
}

func startServer(addr string) {
	lis, err := net.Listen("tcp", addr)
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterEchoServer(s, &ecServer{addr: addr})
	log.Printf("serving on 0.0.0.0%s\n", addr)
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

func main() {
	var wg sync.WaitGroup
	for _, addr := range addrs {
		wg.Add(1)
		go func(addr string) {
			defer wg.Done()
			startServer(addr)
		}(addr)
	}
	wg.Wait()
}

主要通过一个 for 循环,在 50051 和 50052 这两个端口上启动了服务。

2.2 Client

package main

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

	pb "github.com/lixd/grpc-go-example/features/proto/echo"
	"google.golang.org/grpc"
	"google.golang.org/grpc/resolver"
)

const (
	exampleScheme      = "example"
	exampleServiceName = "lb.example.grpc.lixueduan.com"
)

var addrs = []string{"localhost:50051", "localhost:50052"}

func callUnaryEcho(c pb.EchoClient, message string) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	r, err := c.UnaryEcho(ctx, &pb.EchoRequest{Message: message})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	fmt.Println(r.Message)
}

func makeRPCs(cc *grpc.ClientConn, n int) {
	hwc := pb.NewEchoClient(cc)
	for i := 0; i < n; i++ {
		callUnaryEcho(hwc, "this is examples/load_balancing")
	}
}

func main() {
	// "pick_first" is the default, so there's no need to set the load balancer.
	pickfirstConn, err := grpc.Dial(
		fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName),
		grpc.WithInsecure(),
		grpc.WithBlock(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer pickfirstConn.Close()

	fmt.Println("--- calling helloworld.Greeter/SayHello with pick_first ---")
	makeRPCs(pickfirstConn, 10)

	fmt.Println()

	// Make another ClientConn with round_robin policy.
	roundrobinConn, err := grpc.Dial(
		fmt.Sprintf("%s:///%s", exampleScheme, exampleServiceName),
		grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`), // This sets the initial balancing policy.
		grpc.WithInsecure(),
		grpc.WithBlock(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer roundrobinConn.Close()

	fmt.Println("--- calling helloworld.Greeter/SayHello with round_robin ---")
	makeRPCs(roundrobinConn, 10)
}

可以看到,在客户端是分别使用不同的负载均衡策略建立了两个连接,首先是默认的策略 pick_first,然后则是 round_robin,核心代码为:

grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`)

同时由于是本地测试,不方便使用内置的 dns Resolver 所以自定义了一个 Name Resolver,相关代码如下:

// Following is an example name resolver implementation. Read the name
// resolution example to learn more about it.

type exampleResolverBuilder struct{}

func (*exampleResolverBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
	r := &exampleResolver{
		target: target,
		cc:     cc,
		addrsStore: map[string][]string{
			exampleServiceName: addrs,
		},
	}
	r.start()
	return r, nil
}
func (*exampleResolverBuilder) Scheme() string { return exampleScheme }

type exampleResolver struct {
	target     resolver.Target
	cc         resolver.ClientConn
	addrsStore map[string][]string
}

func (r *exampleResolver) start() {
	addrStrs := r.addrsStore[r.target.Endpoint]
	addrs := make([]resolver.Address, len(addrStrs))
	for i, s := range addrStrs {
		addrs[i] = resolver.Address{Addr: s}
	}
	r.cc.UpdateState(resolver.State{Addresses: addrs})
}
func (*exampleResolver) ResolveNow(o resolver.ResolveNowOptions) {}
func (*exampleResolver) Close()                                  {}
func init() {
	// Register the example ResolverBuilder. This is usually done in a package's
	// init() function.
	resolver.Register(&exampleResolverBuilder{})
}

3. Test

分别运行服务端和客户端查看结果

lixd@17x:~/17x/projects/grpc-go-example/features/load_balancing/server$ go run main.go 
2021/05/23 09:47:59 serving on 0.0.0.0:50052
2021/05/23 09:47:59 serving on 0.0.0.0:50051
lixd@17x:~/17x/projects/grpc-go-example/features/load_balancing/client$ go run main.go 
--- calling helloworld.Greeter/SayHello with pick_first ---
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50051)

--- calling helloworld.Greeter/SayHello with round_robin ---
this is examples/load_balancing (from :50052)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50052)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50052)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50052)
this is examples/load_balancing (from :50051)
this is examples/load_balancing (from :50052)
this is examples/load_balancing (from :50051)

可以看到 pick_first 负载均衡策略时一直请求第一个服务 50051,round_robin 时则会交替请求,这也和负载均衡策略相符合。

3. 小结

本文介绍的 负载均衡属于 客户端负载均衡,需要在客户端做较大改动,因为 gRPC-go 中已经实现了对应的代码,所以使用起来还是很简单的。

gRPC 内置负载均衡实现:

  • 1)根据提供了服务名,使用对应 name resolver 解析获取到具体的 ip+端口号 列表
  • 2)根据具体服务列表,分别建立连接
    • gRPC 内部也维护了一个连接池
  • 3)根据负载均衡策略选取一个连接进行 rpc 请求

比如之前的例子,服务名为example:///lb.example.grpc.lixueduan.com,使用自定义的 name resolver 解析出来具体的服务列表为localhost:50051,localhost:50052.

然后调用 dial 建立连接时会分别与这两个服务建立连接。最后根据负载均衡策略选择一个连接来发起 rpc 请求。所以 pick_first会一直请求50051服务,而 round_robin 会交替请求 50051和50052。


如果你对云原生技术充满好奇,想要深入了解更多相关的文章和资讯,欢迎关注微信公众号。

扫描下方二维码或搜索公众号【探索云原生】即可订阅


4. 参考

https://github.com/grpc/grpc/blob/master/doc/naming.md

https://github.com/grpc/grpc/blob/master/doc/load-balancing.md

GoLang:gRPC协议的介绍以及详细教程,从Protocol开始 gRPC(Google Remote Procedure Call)是一个由Google开发的高性能、开源RPC(远程过程调用)框架。它基于HTTP/2进行数据传输,使用ProtoBuf(Protocol Buffers)作为接口描述语言,支持多种编程语言,如Java、Go、C#等,适用于不同语言环境。gRPC的显著特点包括其高效的通信性能,支持双向流、多路复用和二进制传输,以及集成的安全机制,如SSL/TLS。这些特性使gRPC特别适合用于构建高性能的分布式系统和微服务架构中的服务间通信,尤其在需要处理大 阅读详情

相关推荐

Go Grpc部署到 k8s【负载均衡】

网上关于grpc的服务发现和负载均衡很多是是用consul,我这里尝试用nacos来做试验吧,关于grpc的负载均衡 网上有很多说的 head less 【修改 Service 的 spec.clusterIP 为 ”None“】, 当然还有nginx-ingress-controller ,我实验过 都不怎么理想 索性自己从零开始. 项目结构如下: nacos 里面的nacos.go 如下: package nacos import ( "net" "github.com/naco.

dz45693的专栏 4238

Go语言使用GRPC由浅入深

使用各种实战方式来学习grpc,包括grpc基础与进阶,学grpc一篇就够了

陈c 6266

gRPC负载均衡方案

实现方案选择负载均衡处理方案有三种: - 负载均衡软件 HAProxy, LVS 等 - 客户端进程内负载均衡 - 客户端机器部署独立负载均衡进程 类似QConf-agent参考负载均衡方案: https://segmentfault.com/a/1190000008672912gRPC go client 实现gRPC go client 采用第二种方式,客户端进程内实现负载均衡。 其基

uxff的专栏 7703

go实现gRPC服务

定义服务接口、接收和响应的消息类型均在.proto文件中定义,以下代码中,定义了一个服务Greeter,服务中定义了一个rpc方法SayHello,该方法接收一个HelloRequest类型的消息,并返回一个HelloReply类型的响应。// 指定protoc版本// 指定自动生成go代码时的包名// 指定包名,防止命名冲突// 定义Greeter服务// 定义SayHello方法// 定义HelloRequest消息,消息中包括一个string类型的name字段。

Golang丨系统架构丨微服务丨物联网 1683

golang grpc 负载均衡

微服务架构里面,每个服务都会有很多节点,如果流量分配不均匀,会造成资源的浪费,甚至将一些机器压垮,这个时候就需要负载均衡,最简单的一种策略就是轮询,顺序依次选择不同的节点访问 grpc 在客户端提供了负载均衡的实现,并提供了服务地址解析和更新的接口(默认提供了 DNS 域名解析的支持),方便不同服务的集成 使用示例 conn, err := grpc.Dial( &quot;&quot;, ...

hatlonely的专栏 2759

golang grpc consul 服务注册、发现和负载均衡。

开发环境 grpc-go: v1.24 consul:1.6 设备: docker-compose、 mac 搭建一个单节点的consul环境

qq_35916684的博客 5650

史上最细gRPC(Go)入门教程(十三)---Kubernetes 环境下的 gRPC 负载均衡

本文主要介绍了 Kubernetes 环境中的 gRPC 负载均衡具体实现。 gRPC 系列相关代码见 Github 1. 概述 系统中多个服务间的调用用的是 gRPC 进行通信,最初没考虑到负载均衡的问题,因为用的是 Kubernetes,想的是直接用 K8s 的 Service 不就可以实现负载均衡吗。 但是真正测试的时

探索云原生 1440

Golang-GRPC概述及入门示例

RPC的全称是,远程过程调用。RPC是一种协议,它实际是提供了一套机制,使得应用程序之间可以进行通信,而且也遵从server/client模型。使用的时候客户端调用server端提供的接口就像是调用本地的函数一样。而gRPC又是什么呢?用官方的话来说:gRPC是一个高性能的、开源的通用的RPC框架。在gRPC中,我们称调用方为client,被调用方为server。跟其他的RPC框架一样,gRPC也是基于”服务定义“的思想。简单的来讲,就是我们通过某种方式来描述一个服务,这种描述方式是语言无关的。

匆匆过客 1042

gRPC之gRPC负载均衡(客户端负载均衡)(etcd)

gRPC之gRPC负载均衡(客户端负载均衡)(etcd)

YIYIYI 2889

grpc-go源码剖析十四之round_robin平衡器原理介绍

  本小节主要是介绍一下round_robin类型的平衡器的基本原理;其实,就是如何处理两个场景: 场景一:跟grpc服务器端链接的策略是什么,比方说同一个服务,可能是由多个grpc服务器端提供的;那么此时,grpc客户端的平衡器选择什么策略来连接grpc服务器端呢?这里的策略指的是,跟其中一个grpc服务器端相连接,还是全部连接,还是根据grpc服务器端的负载情况进行链接呢?等等 场景二:如果grpc客户端的平衡器(如round_robin平衡器)链接了多个grpc服务器地址,那么,在真正进行帧的传输时

码二哥的技术池 1016

Multisim实现555计时器模拟简易电子琴

一. 元器件介绍 这里用到的元器件有: DIgital power(VCC)数字电源 频率计数器(XFC) 示波器(XSC) ground 数字地 Capacitan 电容器 Resistor 电阻器 555_VIRTUAL 555计时器 触发按键(DIPSW)(DPST)(SPST)

是你呀星途的博客 2万+

Golang基础第五篇——golang的gRPC

此篇的组织架构,第一节简述golang的rpc,第二节讲主体golang/grpc,第三节简述grpc应用的结构和特性。本身grpc是个上限很高的框架,这里的博文只科普,尽量简单地告诉你它做了什么,有什么用;关于使用,部署,以及更深层的原理还要自己发掘。

lishinho的博客 9559

gRPC Go 服务发现与负载均衡

gRPC Go 服务发现与负载均衡 https://blog.cong.moe/post/2021-03-06-grpc-go-discovery-lb/ gRPC是 Google 开源的一款高性能, 支持多种语言的 RPC 框架. 已经被广泛用于集群内服务间调用. 为了大规模流量和避免单点故障, 所以服务往往是部署多实例的, 于是负载均衡就是硬需求了. 注意:本文所有内容均基于grpc/grpc-go, 不同语言实现会有不同, 后面不在说明. 基本介绍 由于 gRPC client ...

落羽的专栏 1204

ABAQUS单元刚度矩阵输出全攻略:从理论到实践(含MTX/DAT文件对比)

本文详细解析了ABAQUS中单元刚度矩阵的输出方法,涵盖理论原理、MTX与DAT文件格式对比及二次开发应用。通过具体操作步骤和性能优化建议,帮助用户高效获取并利用刚度矩阵数据,特别适合需要进行有限元分析验证和二次开发的工程师。

lg888的博客 1008

从电商平台到微信私域:构建合规跳转链路的技术实现

在互联网营销与用户增长领域,链接跳转是连接不同平台、引导用户流量的基础技术。其核心原理是通过服务器端路由与参数解析,实现用户请求的接收、处理与重定向。这项技术的价值在于能够突破平台间的生态壁垒,实现流量的合规、可控迁移,尤其适用于跨平台营销、私域沉淀等场景。在实际应用中,常需处理微信环境限制、参数传递与动态内容生成等挑战。本文聚焦于电商平台(如淘宝)到微信生态的跳转需求,详细阐述了如何利用Node.js、Express框架及二维码生成技术,构建一个包含环境检测、参数传递与动态落地页的完整跳转系统,以解决微信

weixin_33889665的博客 325

Go gRPC etcd实现服务注册发现与负载均衡

使用Go +grpc + etcd实现服务注册发现和负载均衡方案,可以监控服务上下线,客户端实现负载均衡

small_to_large的博客 2305

信创改造实战:SpringBoot项目迁移到宝兰德BES 9.5.5的完整避坑指南(附依赖配置)

本文详细介绍了将SpringBoot项目迁移到宝兰德BES 9.5.5中间件的完整流程,包括环境准备、依赖调整、Web.xml版本适配、部署配置优化及常见问题解决方案。特别针对信创改造需求,提供了排除Tomcat依赖、处理BES专用starter等实用技巧,帮助开发者顺利完成国产中间件迁移。

weixin_30825581的博客 1104

Golang 与 gRPC

首先通过.proto文件定义服务和数据结构。例如,一个简单的计算器服务:protobuf// 定义服务// Unary 调用:客户端发送单个请求,服务端返回单个响应// 服务端流式调用:客户端发一个请求,服务端返回多个响应// 定义消息类型// 生成斐波那契数列的个数Go 语言的简洁性、并发模型与 gRPC 的高性能、强类型特性完美契合,使其成为构建现代分布式系统的优选方案。

shao.bing的专栏 1246

基于单片机红外线遥控Proteus仿真电路发射接收

*单片机设计介绍,基于单片机红外线遥控Proteus仿真电路发射接收。

2201_75940997的博客 3943

基于模型上下文协议(MCP)的可插拔式临床AI工具链Clinical DS研究(下)

本研究深入探讨了医疗AI在临床落地中的核心矛盾,即如何从“模型能答”迈向“系统可信、可用、可追溯”。为解决此矛盾,我们创新性地提出并详细设计实现了一套基于模型上下文协议(MCP)的**“可插拔式临床AI工具链”**架构。通过将复杂的医疗AI系统解构为Host、MCP Server和标准协议三层,并将各类能力(临床决策、影像分析、合规审计)封装为标准的、可独立演进的Server,我们成功地构建了一个模块化、高内聚、低耦合的系统。

AllenLV的博客 1382

【gRPC Web 应用实战从入门到精通(三):实现简单的负载均衡服务】

本文介绍了如何通过gRPC实现客户端负载均衡,结合HTTP网关代理gRPC服务。主要内容包括:1)解析gRPC-Go中的Builder接口,说明如何自定义服务发现与地址解析逻辑;2)实现包含3个实例的gRPC服务端;3)客户端通过自定义resolver.Builder注入多个服务地址,并使用round_robin策略实现轮询访问。通过Gin框架搭建HTTP网关,将HTTP请求转发到gRPC服务,演示了简单的服务治理能力。该方案可在无服务注册中心的情况下,实现服务的横向扩展和负载均衡。

写写代码做做饭 6846

YOLOv11改进策略【损失函数篇】| WIoU v3:针对低质量样本的边界框回归损失函数

是一种基于IoU的损失函数,旨在解决目标检测中边界框回归损失函数在处理低质量训练数据时的问题。论文链接:https://arxiv.org/pdf/2301.10051 源码链接:https://github.com/Instinct323/wiou此处需要查看的文件是中定义了模型的损失函数和计算方法,我们想要加入新的损失函数就只需要将代码放到这个文件内即可将下方的函数替换原本的函数即可: 用于计算各种损失。在内修改如下代码,使模型调用此损失函数。 tal.py中是一些损失函数的功能应用。在内修改如下代码,

Limiiiing的博客 3799

Kubernetes之gRPC 负载均衡

文章目录Kubernetes gRPC 负载均衡为什么要负载均衡?gRPC的负载均衡选项代理负载平衡客户端负载均衡与gRPC负载均衡相关的挑战创建服务端部署创建服务创建客户端部署使用无头服务的客户端负载平衡什么是无头服务?验证 DNS代码示例结语 Kubernetes gRPC 负载均衡 gRPC 是用于进程间通信的最流行的现代 RPC框架之一。是微服务架构的绝佳选择。而且,毫无疑问,部署微服务应用程序最流行的方式是 Kubernetes。 Kubernetes 部署可以具有相同的后端实例,为许多客户端请求

Kason_iWiki 1977

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

史上最细gRPC(Go)入门教程(十一)---NameResolver 实战及原理分析

本文主要介绍了 gRPC 的 NameResolver 及其简单使用,同时从源码层面对其核心原理进行了分析。 gRPC 系列相关代码见 Github 1. 概述 具体可以参考官方文档-Name Resolver gRPC 中的默认 name-system 是 DNS,同时在客户端以插件形式提供了自定义 name-system 的机制。 gRP

探索云原生 1827

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

grpc-go客户端源码分析

grpc-go客户端源码分析 代码讲解基于v1.37.0版本。 和grpc-go服务端源码分析一样,我们先看一段示例代码, const ( address = "localhost:50051" defaultName = "world" ) func main() { // Set up a connection to the server. conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())

inet_ygssoftware的博客 2万+

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

上一篇: 史上最细gRPC(Go)入门教程(十一)---NameResolver 实战及原理分析
下一篇: 史上最细gRPC(Go)入门教程(十三)---Kubernetes 环境下的 gRPC 负载均衡
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值