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

golang工程组件篇:高性能RPC框架gRPC之Resolver服务名称解析器 在上述代码中,我们首先创建了一个名为myResolver的结构体,并实现了resolver.Resolver接口中的ResolveNow()和Close()方法。然后,我们创建了一个名为myResolverBuilder的结构体,并实现了resolver.Builder接口中的Build()和Scheme()方法。在gRPC中,我们可以通过resolver.Register()函数注册自定义Resolver实现,并将其与指定的目标地址相关联。在gRPC中,服务名称通常被用作客户端和服务器之间的地址标识符。 阅读详情

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

原文:https://lixueduan.com/post/grpc/11-name-resolver/

本文主要介绍了 gRPC 的 NameResolver 及其简单使用,同时从源码层面对其核心原理进行了分析。


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

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


gRPC 系列相关代码见 Github

1. 概述

具体可以参考官方文档-Name Resolver

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

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

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

2. Demo

首先用一个 Demo 来介绍一个 gRPC 的 NameResolver 如何使用。

2.1 Server

服务端代码比较简单,没有什么需要注意的地方。

package main

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

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

const addr = "localhost:50051"

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 main() {
	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 %s\n", addr)
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

2.2 Client

客户端需要注意的是,这里建立连接时使用我们自定义的 Scheme,而不是默认的 dns,所以需要有和这个自定义的 Scheme 对应的 Resolver 来解析才行。

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 (
	myScheme      = "17x"
	myServiceName = "resolver.17x.lixueduan.com"

	backendAddr = "localhost:50051"
)

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/name_resolving")
	}
}

func main() {
	passthroughConn, err := grpc.Dial(
		// passthrough 也是gRPC内置的一个scheme
		fmt.Sprintf("passthrough:///%s", backendAddr), // Dial to "passthrough:///localhost:50051"
		grpc.WithInsecure(),
		grpc.WithBlock(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer passthroughConn.Close()

	fmt.Printf("--- calling helloworld.Greeter/SayHello to \"passthrough:///%s\"\n", backendAddr)
	makeRPCs(passthroughConn, 10)

	fmt.Println()

	ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
	defer cancel()
	exampleConn, err := grpc.DialContext(
		ctx,
		fmt.Sprintf("%s:///%s", myScheme, myServiceName), // Dial to "17x:///resolver.17x.lixueduan.com"
		grpc.WithInsecure(),
		grpc.WithBlock(),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer exampleConn.Close()

	fmt.Printf("--- calling helloworld.Greeter/SayHello to \"%s:///%s\"\n", myScheme, myServiceName)
	makeRPCs(exampleConn, 10)
}

具体 Resolver 实现如下:

// Following is an example name resolver. It includes a
// ResolverBuilder(https://godoc.org/google.golang.org/grpc/resolver#Builder)
// and a Resolver(https://godoc.org/google.golang.org/grpc/resolver#Resolver).
//
// A ResolverBuilder is registered for a scheme (in this example, "example" is
// the scheme). When a ClientConn is created for this scheme, the
// ResolverBuilder will be picked to build a Resolver. Note that a new Resolver
// is built for each ClientConn. The Resolver will watch the updates for the
// target, and send updates to the ClientConn.

// exampleResolverBuilder is a
// ResolverBuilder(https://godoc.org/google.golang.org/grpc/resolver#Builder).
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{
			myServiceName: {backendAddr},
		},
	}
	r.ResolveNow(resolver.ResolveNowOptions{})
	return r, nil
}
func (*exampleResolverBuilder) Scheme() string { return myScheme }

// exampleResolver is a
// Resolver(https://godoc.org/google.golang.org/grpc/resolver#Resolver).
type exampleResolver struct {
	target     resolver.Target
	cc         resolver.ClientConn
	addrsStore map[string][]string
}

func (r *exampleResolver) ResolveNow(o resolver.ResolveNowOptions) {
	// 直接从map中取出对于的addrList
	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) Close() {}

func init() {
	// Register the example ResolverBuilder. This is usually done in a package's
	// init() function.
	resolver.Register(&exampleResolverBuilder{})
}

resolver 包括 ResolverBuilder 和 Resolver两个部分。

分别需要实现Builder和Resolver接口

type Builder interface {
	Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
	Scheme() string
}


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

Resolver 是整个功能最核心的代码,用于将服务名解析成对应实例。

Builder 则采用 Builder 模式在包初始化时创建并注册构造自定义 Resolver 实例。当客户端通过 Dial 方法对指定服务进行拨号时,grpc resolver 查找注册的 Builder 实例调用其 Build() 方法构建自定义 Resolver。

2.3 Test

分别启动服务端和客户端进行测试:

lixd@17x:~/17x/projects/grpc-go-example/features/name_resolving/server$ go run main.go 
2021/05/15 10:04:11 serving on localhost:50051
lixd@17x:~/17x/projects/grpc-go-example/features/name_resolving/client$ go run main.go 
--- calling helloworld.Greeter/SayHello to "passthrough:///localhost:50051"
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)

--- calling helloworld.Greeter/SayHello to "17x:///resolver.17x.lixueduan.com"
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)
this is examples/name_resolving (from localhost:50051)

一切正常,说明我们的自定义 Resolver 是可以运行的,那么接下来从源码层面来分析一下 gRPC 中 Resolver 具体是如何工作的。

3. 源码分析

以下分析基于 grpc-go v1.35.0 版本

首先客户端调用grpc.Dial()方法建立连接,会进入DialContext()方法。

// clientconn.go 103 行
func Dial(target string, opts ...DialOption) (*ClientConn, error) {
	return DialContext(context.Background(), target, opts...)
}

DialContext() 内容比较多,这里只关注 Resolver 相关的代码:

这一段是通过解析 target 获取 scheme,然后根据 scheme 找到对应的 resolverBuilder

// clientconn.go 249行
// 首先解析target
	cc.parsedTarget = grpcutil.ParseTarget(cc.target, cc.dopts.copts.Dialer != nil)
	channelz.Infof(logger, cc.channelzID, "parsed scheme: %q", cc.parsedTarget.Scheme)
// 然后根据scheme从全局Resolver列表中找到对应的resolverBuilder
	resolverBuilder := cc.getResolver(cc.parsedTarget.Scheme)
	if resolverBuilder == nil {
	// 如果指定的scheme找不到对应的resolverBuilder那就用defaultScheme
    // 默认协议为 `passthrough`,它会从用户解析的 target 中直接读取 endpoint 地址
		channelz.Infof(logger, cc.channelzID, "scheme %q not registered, fallback to default scheme", cc.parsedTarget.Scheme)
		cc.parsedTarget = resolver.Target{
			Scheme:   resolver.GetDefaultScheme(),
			Endpoint: target,
		}
		resolverBuilder = cc.getResolver(cc.parsedTarget.Scheme)
		if resolverBuilder == nil {
			return nil, fmt.Errorf("could not get resolver for default scheme: %q", cc.parsedTarget.Scheme)
		}
	}

具体获取 resolver 的逻辑如下:

// // clientconn.go 1577行
func (cc *ClientConn) getResolver(scheme string) resolver.Builder {
	for _, rb := range cc.dopts.resolvers {
		if scheme == rb.Scheme() {
			return rb
		}
	}
	return resolver.Get(scheme)
}
// resolver.go 54行
func Get(scheme string) Builder {
	if b, ok := m[scheme]; ok {
		return b
	}
	return nil
}

可以看到最终是去 m 这个 map 中获取的 resolverBuilder。

那么这个 map m 中的 resolverBuilder 是从哪儿来的呢?

这个 resolver 就是客户端代码中的 init 方法注册进去的,全局 resolverBuild 都存放一个 map 中,key 为 scheme,value 为对应的 resolverBuilder。

func init() {
	// Register the example ResolverBuilder. This is usually done in a package's
	// init() function.
	resolver.Register(&exampleResolverBuilder{})
}
func Register(b Builder) {
	m[b.Scheme()] = b
}

接下来就通过 resolverBuilder 构建一个 Resolver 实例。

// clientconn.go 312行
// Build the resolver.
	rWrapper, err := newCCResolverWrapper(cc, resolverBuilder)
	if err != nil {
		return nil, fmt.Errorf("failed to build resolver: %v", err)
	}

// resolver_conn_wapper.go 48行
// newCCResolverWrapper uses the resolver.Builder to build a Resolver and
// returns a ccResolverWrapper object which wraps the newly built resolver.
func newCCResolverWrapper(cc *ClientConn, rb resolver.Builder) (*ccResolverWrapper, error) {
	ccr := &ccResolverWrapper{
		cc:   cc,
		done: grpcsync.NewEvent(),
	}

	var credsClone credentials.TransportCredentials
	if creds := cc.dopts.copts.TransportCredentials; creds != nil {
		credsClone = creds.Clone()
	}
	rbo := resolver.BuildOptions{
		DisableServiceConfig: cc.dopts.disableServiceConfig,
		DialCreds:            credsClone,
		CredsBundle:          cc.dopts.copts.CredsBundle,
		Dialer:               cc.dopts.copts.Dialer,
	}

	var err error

	ccr.resolverMu.Lock()
	defer ccr.resolverMu.Unlock()
    // 调用resolverBuilder的Build方法构建Resolver
	ccr.resolver, err = rb.Build(cc.parsedTarget, ccr, rbo)
	if err != nil {
		return nil, err
	}
	return ccr, nil
}

接来下我们看一下 gRPC 内置的 ResolverBuilder 是 Build 方法是怎么实现的,就拿 DNSResolverBuilder 为例,代码如下:

// dns_resolver.go 109行
func (b *dnsBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
    // 首先依旧是解析target,获取格式化后的 host + port
	host, port, err := parseTarget(target.Endpoint, defaultPort)
	if err != nil {
		return nil, err
	}

	// 对host进行IP格式化处理 如果是IP地址则直接调用cc.UpdateState更新连接信息后返回 不走后续的dns解析逻辑了
	if ipAddr, ok := formatIP(host); ok {
		addr := []resolver.Address{{Addr: ipAddr + ":" + port}}
		cc.UpdateState(resolver.State{Addresses: addr})
		return deadResolver{}, nil
	}

	// 如果是域名则需要进行dns解析
	ctx, cancel := context.WithCancel(context.Background())
	d := &dnsResolver{
		host:                 host,
		port:                 port,
		ctx:                  ctx,
		cancel:               cancel,
		cc:                   cc,
		rn:                   make(chan struct{}, 1),
		disableServiceConfig: opts.DisableServiceConfig,
	}

    // 根据 Authority 判定使用默认Resolver还是自定义Resolver
	if target.Authority == "" {
		d.resolver = defaultResolver
	} else {
		d.resolver, err = customAuthorityResolver(target.Authority)
		if err != nil {
			return nil, err
		}
	}

	d.wg.Add(1)
    // 单独开一个 goroutine watcher 给定域名的 dns 信息变化
	go d.watcher()
    // 强制触发一次更新
	d.ResolveNow(resolver.ResolveNowOptions{})
	return d, nil
}

需要继续跟进 Resolver.watcher() 和 Resolver.ResolveNow() 方法。

// dns_resolver.go 189行
// ResolveNow 方法比较简单,只是往 d.rn 这个 channel 里传了一个消息,具体该消息怎么使用是在后续的 watcher 方法里
func (d *dnsResolver) ResolveNow(resolver.ResolveNowOptions) {
	select {
	case d.rn <- struct{}{}:
	default:
	}
}
// dns_resolver.go 202行
// watcher 方法也比较简单,通过一个for死循环不断更新
func (d *dnsResolver) watcher() {
	defer d.wg.Done()
	for {
        // 第一个select 只有d.rn这个channel里用消息了才能触发
        // 所以前面的ResolveNow方法实际上是写入了一个标记,让这个select能够退出 从而能够去执行后续逻辑
		select {
		case <-d.ctx.Done():
			return
		case <-d.rn:
		}
		// 进行dns解析 如果成功就调用UpdateState方法更新连接信息
		state, err := d.lookup()
		if err != nil {
			d.cc.ReportError(err)
		} else {
			d.cc.UpdateState(*state)
		}

	    // 第二个select 用一个 timer 来限制dns更新频率
		t := time.NewTimer(minDNSResRate)
		select {
		case <-t.C:
		case <-d.ctx.Done():
			t.Stop()
			return
		}
	}
}

所以这里虽然是死循环,但是会阻塞在第一个 select 处,直到 d.rn 有消息后才会执行一个 dns 更新。

至于什么地方会往 d.rn 里写消息相关代码比较复杂,等后续LB相关文章分析。

这里还需要继续跟进d.cc.UpdateState方法,看下具体是怎么更新的,代码如下:

// resolver_conn_wapper.go 139行
// grpc 底层 LB 组件对每个服务端实例创建一个 subConnection。并根据设定的 LB 策略,选择合适的 subConnection 处理某次 RPC 请求。
func (ccr *ccResolverWrapper) UpdateState(s resolver.State) {
	if ccr.done.HasFired() {
		return
	}
	channelz.Infof(logger, ccr.cc.channelzID, "ccResolverWrapper: sending update to cc: %v", s)
	if channelz.IsOn() {
		ccr.addChannelzTraceEvent(s)
	}
	ccr.curState = s
	ccr.poll(ccr.cc.updateResolverState(ccr.curState, nil))
}

此处代码比较复杂,后续在 LB 相关原理文章中再做概述。

4. 小结

![name-reslover][name-reslover]

  • 1)客户端启动时,注册自定义的 resolver 。

    • 一般在 init() 方法,构造自定义的 resolveBuilder,并将其注册到 grpc 内部的 resolveBuilder 表中(其实是一个全局 map,key 为协议名,value 为构造的 resolveBuilder)。
  • 2)客户端启动时通过自定义 Dail() 方法构造 grpc.ClientConn 单例

    • grpc.DialContext() 方法内部解析 URI,分析协议类型,并从 resolveBuilder 表中查找协议对应的 resolverBuilder。
    • 找到指定的 resolveBuilder 后,调用 resolveBuilder 的 Build() 方法,构建自定义 resolver,同时开启协程,通过此 resolver 更新被调服务实例列表。
    • Dial() 方法接收主调服务名和被调服务名,并根据自定义的协议名,基于这两个参数构造服务的 URI
    • Dial() 方法内部使用构造的 URI,调用 grpc.DialContext() 方法对指定服务进行拨号
  • 3)grpc 底层 LB 库对每个实例均创建一个 subConnection,最终根据相应的 LB 策略,选择合适的 subConnection 处理某次 RPC 请求。

到这里在回头看 Demo 中的自定义 Resolver 应该就没什么问题了。由于只是个 Demo 所以真的非常简单。直接在 Build 中通过 map 存储addr,然后 ResolveNow 时直接从 map 中取出来更新服务实例列表,连 watcher 都省略了。


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

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


5. 参考

https://github.com/grpc/grpc-go

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

https://blog.youkuaiyun.com/ra681t58cjxsgckj31/article/details/104079070

[name-reslover]:https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Fgithub.com%2Flixd%2Fblog%2Fraw%2Fmaster%2Fimages%2Fgrpc%2Fname-resolver.png&pos_id=img-8BxQF9zu-1703731349673)

4. 【gRPC系列学习】Resolver原理详解 Resolver原理 阅读详情

相关推荐

grpc-go源码剖析十五之grpc + LoadBalancer 实现负载均衡方案介绍

1、整体流程介绍 在介绍源码前,先把大体流程说一下,然后再详细介绍源码;也就是先整体介绍,后局部介绍; grpc客户端内部采用grpclb平衡器,采用自研的方式实现一个简单版本的负载均衡loadBalancer,架构图如下所示: 环境说明: 本次测试是在Mac环境下进行的测试: 启动一个grpc客户端,一个自研的loadBalancer, 三个grpc服务器; 主要流程说明: grpc服务器端启动时后依次向loadBalancer进行注册自己的信息 grpc客户端中的客户端连接器ClientConn,使

码二哥的技术池 1366

go微服务调用报错:last resolver error: produced zero addresses

情况一 服务端的配置文件中,ip地址设置成了0.0.0.0。然后注册到consul后,客户端发现的服务ip自然是0.0.0.0。此时当然调用不了服务端。 参考方案: 只需要检查配置文件,把ip改为正确地址就行了。 情况二 向consul注册中心发现服务时,consul匹配不到相同的服务,导致返回的地址为0.0.0.0。 参考方案: 此时通过consul检查服务端的健康状况,有问题及时纠正。 另外检查在配置文件中,检查consul的host和port是否配置正确。 ...

dorlolo的博客 4696

(3万字深度解析)Kaggle《房价预测:高级回归技巧》详解复现攻略

在这篇教程式文章中,我们从零开始完成了 Kaggle《房价预测:高级回归技巧》比赛的复现工作,涵盖了数据预处理、特征工程、模型训练、调优、解释和融合的完整流程。深入理解数据:阅读数据描述,结合常识对每个特征作出合理处理(如缺失值填充’None’表示无此设施 、异常值剔除 等)。对目标和偏态特征进行对数变换,使分布更平滑,从而更好满足模型假设并提升准确度。特征工程:我们创造了总面积、总浴室等新特征,整合信息提高模型可学习性。

qq_38334677的博客 1777

gRPC 使用自定义的 NameResolver

gRPC 使用自定义的 NameResolver 在使用注册中心时,gRPC 并未提供注册中心的服务发现,需要自己实现 NameResolverProvider 和 NameResolver NameResolver NameResolver 里面重写了 start 和 refresh 方法,这两个方法都调用一个 resolve 方法做服务发现; resovle 方法内部通过服务名从注册中心拉取服务实例列表,然后调用 Listener 的 onResult方法,将实例列表传递给 LoadBalancer

啦啦啦啦 la 3772

AI智能体评估基准AgentBench:从原理到实战的完整指南

在人工智能领域,智能体(AI Agent)的评估是衡量其实际应用能力的关键环节。评估基准通过设计标准化的测试任务,系统性地检验智能体的推理、规划和工具使用等核心能力。其技术价值在于为模型迭代和产品选型提供了客观、可复现的量化依据,能有效推动技术从演示走向工程落地。典型的应用场景包括模型能力评测、智能体框架对比以及具体应用(如自动化运维、智能客服)的性能验证。本文聚焦于清华团队推出的AgentBench,它作为一个多维度的综合评估套件,涵盖了从操作系统、数据库操作到网页浏览、数字卡牌游戏等八个贴近真实世界的任

weixin_27207591的博客 600

保姆级避坑指南:在Win10/Win11上搞定西门子博图V17完整安装(附注册表清理技巧)

本文提供了一份详细的西门子博图V17在Win10/Win11系统上的安装指南,涵盖从系统预检、注册表清理到分步安装的全过程。特别针对常见的安装失败问题,如PendingFileRenameOperations注册表残留和.NET Framework 3.5未启用等,提供了专业的解决方案和避坑技巧,帮助用户高效完成安装并优化性能。

weixin_29240711的博客 946

grpc NewClient 报错 name resolver error: produced zero addresses

grpc NewClient 报错 produced zero addresses

wanmei002的博客 1746

EtherCAT-7 从站代码移植-SPI

STM32F103 + AX58100,从站代码移植。

tianya_xuan的博客 3572

小米出品——gRPC Name Resolver 原理及实践

本文字数:5380 字精读时间:12分钟也可在 6分钟内完成速读作者郑伟,小米信息技术部架构组01前言gRPC Name Resolver(名称解析)是 gRPC 核心功能之一,目前...

Go中国 3278

猫耳语音下载(mediadown)

西宾猫耳语音下载工具,能够帮助你下载猫耳音频节目。如果你是会员,它还能帮你下载会员节目。

new_stranger的专栏 2492

【机械视觉】C#+VisionPro实战:位深图(CogImage8Grey)与Bitmap互转技巧及工业检测应用

本文详细介绍了在工业检测中如何使用C#和VisionPro实现位深图(CogImage8Grey)与Bitmap的高效互转技巧。通过实战代码示例和工业应用案例,帮助开发者解决图像处理中的常见问题,提升检测精度和系统性能,适用于半导体、汽车零部件等高精度检测场景。

weixin_29250573的博客 186

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

本文主要介绍了 gRPC 内置的负载均衡策略及其配置与使用,包括 Name Resolver、ServiceConfig 等。 gRPC 系列相关代码见 Github 1. 概述 gRPC 负载均衡包括客户端负载均衡和服务端负载均衡两种方向。本文主要介绍的是客户端负载均衡。 gRPC 的客户端负载均衡主要分为两个部...

探索云原生 3079

YOLOv11涨点改进| Kimi团队 2026 |独家创新首发、注意力改进篇|爆火AttnRes残差自注意力模块,含多种创新改进,借助残差思想,缓解细节信息在传播过程中被稀释,促进YOLOv11涨点

🔥本文提出AttnRes残差自注意力模块,通过深度维度的注意力加权机制替代传统固定残差累加方式,使YOLOv11网络能自适应选择更有价值的历史层特征进行聚合。该方法缓解了浅层细节信息在深层传播过程中被稀释的问题,有效融合浅层纹理与深层语义特征,提升小目标、密集目标和复杂场景的检测能力。AttnRes还改善了深层网络的梯度分布与训练稳定性,增强模型收敛质量和泛化能力。实验表明,该模块能以较小计算开销显著提升YOLOv11的特征表达能力、检测精度和整体鲁棒性。文中详细介绍了模块结构、实现原理、优势特点

Ai缝合怪、助力小伙伴高效发论文 128

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

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

探索云原生 1440

OpenGL 进阶系列10 - 光线跟踪实现简介(Ray Tracing)

OpenGL 实现光线跟踪(Ray Tracing)是一个相对复杂但有趣的挑战,通常用于生成高度逼真的图像效果,如反射、折射、阴影等。OpenGL 本身并不是为光线跟踪设计的,但可以通过结合计算着色器和现代 OpenGL 功能实现光线跟踪。光线跟踪的基本思路是从相机(或视点)出发,发射光线并计算这些光线与场景中物体的交点。光线与场景中物体相交的计算。计算交点的光照(基于表面法线、光源位置、材质等)。反射和折射的处理(如果物体是透明或反射的)。

GPU全栈博主 1535

精雕软件(JDpaint) 5.5 绿色版

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

gRPC -- Guides -- Custom Name Resolution

摘要:gRPC名称解析机制支持标准DNS和自定义实现,核心是服务发现。默认使用DNS解析(如grpc.io:50051),同时支持UnixDomainSocket、xDS等多种格式。自定义解析器(如my-resolver:///)允许对接Zookeeper/Kubernetes等系统,具备动态响应服务变更、支持负载均衡策略等优势。解析流程包括:注册解析器提供者→处理目标字符串→返回地址列表。目前Java/Go/C++支持自定义实现,Python暂不支持。URI格式遵循RFC-3986,三斜杠结构中的auth

dengfuma的专栏 448

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

ETCD组件在grpc中的实践

一、前言 grpc中没有像go-micro那样集成可插拔式的etcd库使用,如何使得grpc能够使用服务注册发现及命名解析的功能,因此本文基于etcd实现了Name Resolver。 二、所需的grpc版本及高版本grpc、protobuf与etcd兼容问题 grpc相关库: google.golang.org/grpc v1.26.0 google.golang.org/grpc/b...

HarvardFly的博客 1706

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

golang工程 grpc resovler简介

grpc微服务部署的时候,访问对应服务肯定不可能用ip的形式去访问,尤其云环境下,ip经常变动。采用resovler可以让我们客户端动态的去获取服务的地址去访问rpc服务。可以搭配服务中心来使用。例子如下,nameServer部分可以替换成地址数组即可,实际环境中就是向另一个服务器拿服务的地址。

qq_43058348的博客 538

gRPC之grpc负载均衡(resolver)

gRPC之grpc负载均衡(resolver)

YIYIYI 1193

gRPC高级特性与实战优化全解析。

gRPC支持四种通信模式:一元RPC、服务器流、客户端流和双向流。双向流式通信适合实时交互场景,例如聊天应用或实时数据同步。gRPC客户端可以通过集成服务发现工具(如Consul或ETCD)实现动态服务发现。拦截器是gRPC的AOP实现,可用于日志、认证和监控。

PxX_bo9n的博客 381

Nacos注册gRPC服务实现负载均衡的完整方案

gRPC作为高性能RPC框架,原生缺乏服务发现与动态负载均衡能力,需依赖外部注册中心实现生产级治理。Nacos凭借轻量、易运维、多语言支持及自定义元数据等特性,成为gRPC服务注册与发现的理想底座。其核心原理是通过NameResolver桥接Nacos实例列表与gRPC地址解析层,并结合WeightedRoundRobin等策略实现基于权重、版本、地域等元数据的智能流量分发。该方案显著提升服务扩缩容敏捷性、灰度发布可控性与故障恢复时效性,广泛适用于Java/Go/Python混合技术栈的微服务系统,尤其适合

weixin_32821533的博客 193

Grpc 自定义解析器 resolver

package grpc_builder import ( "fmt" "google.golang.org/grpc/resolver" ) const customResolverScheme = "custom" type customResolverBuilder struct { } type customResolver struct { target resolver.Target cc resolver.ClientConn } func (*customResol

NLSQQ的博客 873

基于etcd的服务发现与注册

1. 微服务架构上篇 4. 基于etcd的服务发现与注册 1. LB方案介绍 构建高可用、高性能的通信服务,通常采用服务注册与发现、负载均衡和容错处理等机制实现。根据负载均衡实现所在的位置不同,通常可分为以下三种解决方案: 1.1 集中式LB(Proxy代理模式) 在服务消费者和服务提供者之间有一个独立的LB,通常是专门的硬件设备如 F5,或者基于软件如 LVS,HAproxy等实现。LB上有所有服务的地址映射表,通常由运维配置注册,当服务消费方调用某个目标服务时,它向LB发起请求,由LB以某

stackfuture的博客 2717

gRPC之grpc resolver

gRPC之grpc resolver

YIYIYI 968

gRPC 命名解析

gRPC 命名解析 命名解析根据服务的 URI,从注册中心获取并解析服务实例 IP,默认支持 schema 为 DNS,grpclb,xds 等 gRPC 的命名解析的父类接口是 NameResolver NameResolver 包含有多个子类,用于实现命名解析 每个 NameResolver 都有一个 Provider,用于创建 NameResolver 实例;所有的 Provider 都注册到 NameResolverRegistry 中,NameResolverRegistry 创建 Facto

啦啦啦啦 la 1973

grpc进阶篇之resolver

当我们的服务刚刚成型时,可能一个服务只有一台实例,这时候client要建立grpc连接很简单,只需要指定server的ip就可以了。但是,当服务成熟了,业务量大了,这个时候,一个实例就就不够用了,我们需要部署一个服务集群。一个集群有很多实例,且可以随时的扩容,部分实例出现了故障也没关系,这样就提升了服务的处理能力和稳定性,但是也带来一个问题,grpc的client,如何和这个集群里的server建立连接? 这个问题可以一分为二,第一个问题:如何根据服务名称,返回实例的ip?这个问题有很多种解决方案,我们可

djqueen的博客 8162
上一篇: 史上最细gRPC(Go)入门教程(十)------gRPC压测工具ghz
下一篇: 史上最细gRPC(Go)入门教程(十二)---客户端负载均衡
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值