微服务，gRPC 一文全解（五）

最新推荐文章于 2024-09-28 11:38:42 发布
最新推荐文章于 2024-09-28 11:38:42 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： Golang 微服务 文章标签： go go-kit grpc 微服务 protobuf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25490573/article/details/107066387
版权

目录

前言

RPC

是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。
微服务常用更高效的rpc(远程过程调用协议)通信。

RPC优点：
  • 提高开发效率，开发人员可以把更多精力放在具体的接口实现，而不必考虑数据的底层传输问题。
  • 大多数rpc框架都是很多优秀开发人员的智慧结晶，它们的功能实现和执行效率都很优秀。
  • client端和server端必须遵循统一的接口规范，避免产生client和server之间接口或数据局结构不匹配的情况。
gRPC：
  • gRPC是一个高性能、通用的开源RPC框架，其由Google
    2015年主要面向移动应用开发并基于HTTP/2协议标准而设计，基于ProtoBuf(Protocol
    Buffers)序列化协议开发，且支持众多开发语言。gRPC提供了一种简单的方法来精确地定义服务和为iOS、Android和后台支持服务自动生成可靠性很强的客户端功能库。客户端充分利用高级流和链接功能，从而有助于节省带宽、降低的TCP链接次数、节省CPU使用、电池寿命。
  • 最新的Google API支持gRPC
  • 支持 C, C++, Node.js, Python, Ruby, Objective-C,PHP and C#
  • 当前版本Alpha
  • 协议 BSD
ProtoBuf
  • 其由Google 2001年设计，2008年开源。
  • Google内部的服务几乎都是用的PB协议
  • 久经考验、充分验证、良好实现
  • 使用ProtoBuf: Google、Hadoop、ActiveMQ、Netty
  • 当前版本v3.0.0-alpha-3
  • 协议 BSD
    proto文件的具体写法可以参考官网文档：https://developers.google.cn/protocol-buffers/docs/gotutorial

gRPC原生例子

proto文件

创建book.proto文件，并输入

syntax = "proto3"; // 版本声明，使用Protocol Buffers v3版本

package book; // 包名

// 包含id的一个请求消息
message BookRequest {
    int32 id = 1;
}

// 包含名称的响应消息
message BookResponse {
    string name = 1;
}

// 定义根据id获取名称的服务，对应go中的接口
service BookFun {
    rpc GetBookInfoByID (BookRequest) returns (BookResponse) {}
}

将.proto文件放到book文件夹下，并执行如下命令，生成book.pb.go文件，

protoc --go_out=plugins=grpc:. book.proto
服务端

获取grpc开发工具

go get google.golang.org/grpc

type BookEntity struct {
}
//实现GetBookInfoByID接口
func (b *BookEntity) GetBookInfoByID(ctx context.Context,requ *book.BookRequest) (*book.BookResponse, error){
	resp := new(book.BookResponse)
	switch requ.Id {
	case 1:
		resp.Name = "西游记"
	default:
		resp.Name = "金瓶梅"
	}
	return resp,nil
}

func main(){
	ls, _ := net.Listen("tcp", ":666")
	gs := grpc.NewServer()
	//将接口实现注册到grpc实例中
	book.RegisterBookFunServer(gs,new(BookEntity))
	gs.Serve(ls)
}
客户端
func main(){
	conn,err := grpc.Dial(":666",grpc.WithInsecure() )
	if err!=nil{
		panic(err)
	}
	defer conn.Close()
	//创建一个BookFun的客户端实例
	client := book.NewBookFunClient(conn)
	//发送请求
	resp,err := client.GetBookInfoByID(context.Background(),&book.BookRequest{Id:1})

	if err!=nil{
		fmt.Println(err)
	}
	fmt.Println(resp)
}

gRPC+gokit简单栗子

服务端

1.创建一个book.proto文件

syntax = "proto3"; // 版本声明，使用Protocol Buffers v3版本

package book; // 包名

// 包含id的一个请求消息
message BookRequest {
    int32 id = 1;
}

// 包含名称的响应消息
message BookResponse {
    string name = 1;
}

// 定义根据id获取名称的服务
service BookFun {
    rpc GetBookInfoByID (BookRequest) returns (BookResponse) {}
}

2.在文件目录下运行如下命令，生成book.pb.go, 需要提前安装protobuf并配置环境变量

protoc --go_out=plugins=grpc:. book.proto

3.在service文件夹下创建go文件 并创建接口和实现方法

type BookInter interface {
	GetBookInfoByID(int32)string
}
type Book struct {
}
func(b * Book)GetBookInfoByID(id int32)string{
	switch id {
	case 1:
		return "西游记"
	case 2:
		return "三国演义"
	case 3:
		return "水浒传"
	case 4:
		return "红楼梦"
	case 5:
		return "金瓶梅"
	}
	return "未知id"
}

4.在transport文件夹下实现endpoint的编解码方法

func DecodeBook(ctx context.Context,inter interface{}) (request interface{}, err error){
	return inter,nil
}

func EncodeBook(ctx context.Context,inter interface{}) (response interface{}, err error){
	return inter,nil
}

5.在epoint文件夹下， 声明创建endpoint的方法，该方法调用业务逻辑

func GetGrpcEndpointForGetBookIDS(inter service.BookInter)endpoint.Endpoint{
	return func(ctx context.Context, request interface{}) (response interface{}, err error){
		bookresp := new(book.BookResponse)
		bookresp.Name =  inter.GetBookInfoByID(request.(*book.BookRequest).Id)
		return bookresp,nil
	}
}

6.声明一个结构体，并实现proto中的接口，在实现方法中调用endpoint的ServeGRPC方法。
kitgrpc 是 “github.com/go-kit/kit/transport/grpc”

//调用该方法将GetBookInfoByID方法的实现注册到gRPC服务中
func InitGRPCRouter(gs * grpc.Server)  {
	book.RegisterBookFunServer(gs,NewGrpcBook())
}
//创建实现接口的函数，此处实现了endpoint的创建，并赋值给结构体中的参数
func NewGrpcBook() book.BookFunServer{
	b :=  &GrpcBook{}
	b.Handler = kitgrpc.NewServer(epoint.GetGrpcEndpointForGetBookIDS(new(service.Book)),
		transport.DecodeBook,transport.EncodeBook)
	return b
}

type GrpcBook struct {
	Handler kitgrpc.Handler
}
//实现proto中的接口
func (g * GrpcBook)GetBookInfoByID(ctx context.Context,request *book.BookRequest)(*book.BookResponse,error){
	_,res ,err := g.Handler.ServeGRPC(ctx,request)
	return res.(*book.BookResponse),err
}

7.创建GRPC实例，并注册方法

func main(){
	ls, _ := net.Listen("tcp", ":666")
	gs := grpc.NewServer()

	router.InitGRPCRouter(gs)

	gs.Serve(ls)
}
客户端

1.声明解压缩方法，创建一个endpioint实例
import kitgrpc “github.com/go-kit/kit/transport/grpc”

//创建一个grpc客户端
//第二个参数是接口名称 .proto文件中的 BookFun 
//第三个参数是方法名称 .proto文件中的 GetBookInfoByID 
func GetEndpoint(cc *grpc.ClientConn, serviceName string, 	method string,) *kitgrpc.Client{
	//参数grpcReply是grpc返回值，实际上是取类型
	return  kitgrpc.NewClient(cc,serviceName,method,EncodeRequestBook,DecodeResponseBook,book.BookResponse{})
}
//编码
func EncodeRequestBook (ctx context.Context,inter interface{}) (request interface{}, err error){
	return inter,nil
}
//解码
func DecodeResponseBook(ctx context.Context,inter interface{}) (response interface{}, err error){
	return inter,nil
}

2.创建grpc实例并调用

func main(){
	conn,err := grpc.Dial(":666",grpc.WithInsecure() )
	if err!=nil{
		panic(err)
	}
	defer conn.Close()
	//创建endpoint，并指明grpc调用的接口名和方法名
	client := GetEndpoint(conn,"book.BookFun", "GetBookInfoByID")
	resp,err:= client.Endpoint()(context.Background(),&book.BookRequest{Id:1})

	if err!=nil{
		fmt.Println(err)
	}
	fmt.Println(resp)
}
测试

将服务运行起来，然后运行客户端，截图如下
在这里插入图片描述

拦截器

拦截器在作用于每一个 RPC 调用，通常用来做日志，认证，metric 等等

interfactor 分为两种

  • unary interceptor 拦截 unary(一元) RPC 调用
  • stream interceptor 处理 stream RPC
服务端

UnaryServerInterceptor

type UnaryServerInterceptor func(ctx context.Context, req interface{}, info *UnaryServerInfo, handler UnaryHandler) (resp interface{}, err error)

unary会根据消息进行拦截，todo后，可以调用invoker方法继续执行，并可以在方法后添加一些滞后操作

err := invoker(ctx, method, req, reply, cc, opts...)

StreamServerInteceptor源码

type StreamServerInterceptor func(srv interface{}, ss ServerStream, info *StreamServerInfo, handler StreamHandler) error

stream会根据流进行拦截，
通过调用streamer 可以获得 ClientStream, 包装ClientStream 并重载他的 RecvMsg 和 ·SendMsg 方法，即可做一些拦截处理了最后将包装好的 ClientStream 返回给客户
例子如下：（偷来的，原文）

type wrappedStream struct{
	grpc.ClientStream
}
func (w *wrappedStream) RecvMsg(m interface{})error{
	log.Printf("Receive a message (Type: %T)", m)
	return w.ClientStream.RecvMsg(m)
}
func (w *wrappedStream)SendMsg(m interface{})error{
	log.Printf("Send a message (Type: %T)", m)
	return w.ClientStream.SendMsg(m)
}

func streamInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption)(grpc.ClientStream, error){
	// do soming

	// return ClientStream
	s , err := streamer(ctx, desc, cc, method, opts...)
	if err != nil{
		return nil, err
		}
	return &wrappedStream{s}, nil
}

添加方法

s := grpc.NewServer(
    grpc.UnaryInterceptor(unaryInterceptor),
    grpc.StreamInterceptor(streamInterceptor)
)

链式拦截器
调用 grpc.NewServer 时，使用ChainUnaryInterceptor 和 ChainStreamInterceptor 可以设置链式的 interceptor

func ChainStreamInterceptor(interceptors ...StreamServerInterceptor) ServerOption
func ChainUnaryInterceptor(interceptors ...UnaryServerInterceptor) ServerOption

第一个 interceptor 是最外层的，最后一个为最内层
使用UnaryInterceptor, StreamInterceptor·添加的interceptor，总是最先执行

客户端

对应服务端

UnaryClientInterceptor

type UnaryClientInterceptor func(ctx context.Context, method string, req, reply interface{}, cc *ClientConn, invoker UnaryInvoker, opts ...CallOption) error

StreamClientInterceptor

type StreamClientInterceptor func(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, streamer Streamer, opts ...CallOption) (ClientStream, error)

添加方法

conn, err := grpc.Dial(
    grpc.WithUnaryInterceptor(unaryInterepotr),
    grpc.WithStreamInterceptor(streamInterceptor)
)

链式拦截器

func WithChainStreamInterceptor(interceptors ...StreamClientInterceptor) DialOption
func WithChainUnaryInterceptor(interceptors ...UnaryClientInterceptor) DialOption

元数据

grpc能够通过ctx上下文携带元数据
实现方法是通过grpc包下的metadate包实现
“google.golang.org/grpc/metadata”

MD

MD是元数据的基本结构如下，通过操作md实现在ctx上下文中添加提取数据

type MD map[string][]string

创建MD

  • 键不允许是“grpc-”开头，该开头已内部使用
  • 键以“-bin” 为后缀，这时，值会在传输前后以 base64 进行编解码，进行二进制存储
  • 提示：
    如果对metadata进行修改，那么需要用拷贝的副本进行修改 （FromIncomingContext的注释）
    方法是：func (md MD) Copy() MD
func New(m map[string]string) MD
func Pairs(kv ...string) MD
//将若干个md连接到一起
func Join(mds ...MD) MD
//从上下文中提取一个md
//如果对metadata进行修改，那么需要用拷贝的副本进行修改
func FromIncomingContext(ctx context.Context) (md MD, ok bool)
//创建一个md副本  
func (md MD) Copy() MD

md := metadata.New(map[string]string{"key1": "val1", "key2": "val2"})
md = metadata.Pairs(
    "key1", "val1",
    "key1", "val1-2",
    "key2", "val2",
    "key-bin", string([]byte{96, 102}),
)
发送方法

客户端

//向一个已有的ctx中拼接
func AppendToOutgoingContext(ctx context.Context, kv ...string) context.Context
//根据MD创建一个新的ctx上下文
func NewOutgoingContext(ctx context.Context, md MD) context.Context

服务器

  • server 端会把 metadata 分为 header 和 trailer 发送给 client
  • unary RPC 可以通过 CallOption grpc.SendHeader 和 grpc.SetTriler 来发送 header, trailer metadata
  • stream RPC 则可以直接使用 ServerStream 接口的方法
  • SetTriler 可以被调用多次，并且所有 metadata 会被合并，当 RPC 返回的时候， trailer metadata 会被发送
//unary rpc
func SendHeader(ctx context.Context, md metadata.MD) error
func SetTrailer(ctx context.Context, md metadata.MD) error
//stream rpc
func SendHeader(md metadata.MD) error
func SetTrailer(md metadata.MD) error
接收方法

客户端

  • 和服务器对应采用Header和Trailer方法接收，
    它们返回CallOption，放在grpc调用的方法的最后一个参数 opts …grpc.CallOption上
var header,trailer metadata.MD
bookclient := book.NewBookFunClient(conn)
resp,err:=bookclient.GetBookInfoByID(context.Background(),&book.BookRequest{Id:1}, 
grpc.Header(&header),
grpc.Trailer(&trailer))

stream RPC 同理

stream, err := bookclient.GetBookInfoByID(ctx)

// retrieve header
header, err := stream.Header()
// retrieve trailer
trailer := stream.Trailer()

服务端

  • 服务端调用 FromIncomingContext 即可从 context 中接收 client 发送的 metadata
func FromIncomingContext(ctx context.Context) (md MD, ok bool)

func (g * GrpcBook)GetBookInfoByID(ctx context.Context,request *book.BookRequest)(*book.BookResponse,error){
	//在次提示，如需修改md，请先copy
	md,ok := metadata.FromIncomingContext(ctx)
	//TODO
}

未完待续。。。

此人未设置昵称
关注
专栏目录
go grpc测试_用gokit写出优雅的gRPC微服务
weixin_36388341的博客
12-27 677
用go-kit写出优雅的gRPC微服务微服务在这几年一直是大家谈论的话题。微服务是一种软件架构，它将一个大且聚合的业务项目拆解为多个小且独立的业务模块，模块即服务，各服务间使用高效的协议(protobuf、JSON 等)相互调用即是 RPC。这种拆分代码库的方式有以下特点：每个服务应作为小规模的、独立的业务模块运行，独立部署每个服务应在进行自动化测试和(分布式)部署时，不影响其他服务每个...
微服务grpc通讯 案例 nest 版
u011485634的博客
07-24 846
微服务grpc通讯 案例 nest 版
grpc的初始化
多看多听多总结
12-14 1608
1、grpc_completion_queue 在src/core/lib/surface下completion_queue_factory.cc和complection_queue.cc文件中，其结构定义如下
gRPC基础讲解
最新发布
记录一位C++爱好者的笔记
09-28 1601
RPC 即远程过程调用协议（Remote Procedure Call Protocol），可以让我们像调用本地函数一样发起远程调用。RPC 凭借其强大的治理功能，成为解决分布式系统通信问题的一大利器。gRPC是一个现代的、高性能、开源的和的通用 RPC 框架（g就是谷歌的意思），基于 HTTP2 协议设计，序列化使用 PB(Protocol Buffer)，PB 是一种语言无关的高性能序列化框架，基于 HTTP2+PB 保证了的高性能。上面的图就是一个客户端远程连接一个服务器，调用它的函数。
gRPC C++源码阅读 grpc初始化
happyAnger6的专栏
06-01 2519
http://www.anger6.com/?p=420 这篇文章讲述grpc核心代码的初始化流程。 先看一个类图 任何依赖grpc核心lib初始化的代码，都需要在.cc文件中定义类型为GrpcLibraryInitializer的静态变量g_gli_initializer。这个对象的作用通过类图可以看出，会以单例模式初始化g_glip,g_core_co...
2. 用go-kit整合grpc服务
songtaiwu的博客
04-23 1114
我们先简单看下如何构建一个grpc服务的，梳理出里面的主要关键点。
go-kit实践之1：go-kit 与 grpc 结合开发微服务（go-kit endpoint的使用）
weixin_42117918的博客
04-10 6958
go-kit是一个微服务的开发工具集，微服务系统中的大多数常见问题，因此，使用者可以将精力集中在业务逻辑上。 grpc缺乏服务治理的功能，我们可以通过go-kit结合grpc来实现我们的完整需求。go-kit抽象的endpoint设计让我们可以很容易包装其它微服务框架使用的协议。endpoint为Servers和Clients提供了基于RPC方法的构建模块。 先来看看endpoint源码： ...
Spring Boot微服务集成gRPC通讯完整示例
09-08
在现代的分布式系统中，通信协议的选择至关重要，gRPC作为一种高效、高性能的远程过程调用（RPC）框架，被广泛应用于微服务架构中。Spring Boot作为Java开发微服务的首选框架，与gRPC的结合使得服务间的通信变得更加...
golang grpc微服务实践
qq_46081276的博客
09-29 1378
关于golang， grpc ， etcd, grpc-gateway 使用
微服务04——gRPC
YTIANYE的博客
12-21 773
目录 简介 实现方式： 安装： gRPC远程调用 目录结构 person.proto 编译 person.pb.go（编译后自动生成） grpc_server.go grpc_client.go 结果 简介 gRPC是Google基于protobuf开发的跨语言的开源RPC框架。基于http 2.0协议设计，可以基于一个HTTP/2链接提供多个服务。在 gRPC里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务.
SpringBoot整合高性能微服务框架 gRPC
公众号：微观技术
03-13 1307
Spring Boot 作为主流微服务框架，拥有成熟的社区生态。市场应用广泛，为了方便大家，整理了一个基于spring boot的常用中间件快速集成入门系列手册，涉及RPC、缓存、消息队列、分库分表、注册中心、分布式配置等常用开源组件，大概有几十篇文章，陆续会开放出来，感兴趣同学可以关注&收藏 1、简介 在 gRPC 里，客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得我们能够更容易地创建分布式应用和服务。 gRPC 基于 HTTP/2 标准设计，带来诸如双.
go-kit+grpc+consul开发实战
Xiang_lhh的博客
04-02 1884
基于go-kit开发grpc接口，并使用go-kit注册到consul中。 如果不知道go-kit几个层级，那么这篇文章不适合你，先去看go-kit基础，再来看这篇文章 我们首先编写proto文件 编写好proto文件之后，进行代码生成 protoc --go_out=plugins=grpc:./ ./test.proto 利用go-kit实现接口，go-kit实现的接口，只用于数据透传，并调用底层endpoint，并不做逻辑执行 ...
GO微服务实战第十八节 案例：Go-kit 如何集成 gRPC？
fegus的博客
08-22 863
首先定义了 UserService 结构，它有一个名为 CheckPassword 的 grpc_transport.Handler 的方法。这个方法会调用 grpc_transport.Handler 的 ServeGRPC 方法来将请求交由 Go-kit 处理。// 定义接口 type UserService interface {}​​}
sprintf函数实现_TrustKeeper 技术分享：Gokit gRPC Consul 实现微服务注册发现
weixin_39881575的博客
11-30 279
Trustkeeper 使用 Gokit 实现微服务化。在开发环境中我们使用 docker compose 管理服务。本篇文章讲分享使用 gokit 开发 Golang 微服务过程中 grpc 往 consul 数据中心注册和发现服务。依赖 Docker 环境，Consul 单机集群架设请参考 wenweih/docker-vault-consul-cockroach-redis-example系...
使用微服务框架go-kit搭建用户微服务
阿磊的博客
12-04 1806
什么是 Go kit? Go是一种很棒的通用语言，但是微服务需要一定量的专业支持。 RPC安全性，系统可观察性，基础结构集成甚至程序设计。Go kit 填补了标准库留下的空白，并使 Go 成为在任何组织中编写微服务的一流语言 下面基于go-kit实现用户微服务，用户的登陆，注册和获取用户信息，使用jwt方式来加密和解码，本文事例比较简单，主要是实现微服务和理解微服务开发，通信使用grpc服务来编码和解码 涉及到技术的如下： 1.grpc 2.consul服务注册使用 3.golang/r...
【grpc】grpc入门二，基本使用方法
SauryN的博客
04-08 691
上篇介绍了使用protobuf生成grpc相关代码，并实现了服务端方法，本篇介绍下具体的使用。这里有个需要注意的点，因为。
你不知道的gRPC反向代理
omnispace的博客
06-29 5042
一个gRPC Proxy的实现方案 导语 可用性、可靠性和扩展性是衡量后台服务的基本标准，HTTP反向代理，是任何一个提供大型Web服务后台所必备的，用以提高服务的这些基础参数，且通过支持到负载均衡而进一步提升服务性能。然而，随着微服务框架的盛行，RPC技术也已经开始承载大量的微服务之间的通信，在众多RPC技术中，gRPC是Google开源的通用高性能RPC框架，因此，一个支持gRPC的反向代...
GRPC开发(5)-grpc服务开发-带证书才是安全的服务
Salted fish in hand, I have the world.
07-09 1335
cd ~/goproject/grpcpro 项目中，server、client、protoc、cert目录都是并列的，go mod的模块是grpcpro 改造server.go 把 s := grpc.NewServer() 改成 creds, err := credentials.NewServerTLSFromFile("…/cert/server.crt", “…/cert/server....
基于consul和gRPC的微服务演示项目
从给出的文件信息来看，"micro-service-demo.rar" 是一个关于微服务的演示示例项目，该演示项目结合了Consul和gRPC技术，用于展示如何在一个微服务环境中利用这两项技术来实现服务发现、通信和治理。项目的文件名...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值