首页 > 编程开发 > Go语言

Golang中四种gRPC模式举例详解

来自：网络
时间：2024-06-07
阅读：

本博客需要你有一点基本的gRPC的常识，如果你完全是新手建议访问官网全面了解。

1. Unary RPC

proto文件如下

syntax = "proto3";
option go_package=".;service";

message HelloRequest {
  // Name of the person to greet
  string name = 1;
}

message HelloResponse {
  // Greeting message
  string greeting = 1;
}

service HelloService {
  // RPC method to say hello
  rpc SayHello (HelloRequest) returns (HelloResponse){}
}

使用命令(注意命令路径和自己的对应):

protoc -I . --go-grpc_out=require_unimplemented_servers=false:. --go_out=.  *.proto

对应目录上有xx.pb.go和xx_grpc.pb.go然后对应目录实现服务端接口

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"net"
	"test_grpc/service"
)

type HelloService struct {
}

func (hs *HelloService) SayHello(ctx context.Context, req *service.HelloRequest) (*service.HelloResponse, error) {
	resp := &service.HelloResponse{
		Greeting: fmt.Sprintf("hello %s --from Golang Server", req.Name),
	}
	return resp, nil
}

func main() {
	// listen on 127.0.0.1:50051
	listen, err := net.Listen("tcp", "127.0.0.1:50051")
	if err != nil {
		fmt.Println("Error happened when listen on 127.0.0.1:50051:", err)
		return
	}

	// grpc server
	s := grpc.NewServer()

	// register HelloService in grpc server
	service.RegisterHelloServiceServer(s, &HelloService{})

	// start rpc server
	fmt.Println("Golang rpc server is waiting messages......")
	if err = s.Serve(listen); err != nil {
		fmt.Println("Error happened when start rpc server:", err)
		return
	}
}

客户端接口如下：

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"test_grpc/service"
	"time"
)

func main() {
	// connect to server
	conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		fmt.Println("Connect to rpc server err:", err)
		return
	}
	defer conn.Close()

	// init service client
	c := service.NewHelloServiceClient(conn)

	// init context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	// send message
	req := &service.HelloRequest{Name: "Golang"}
	r, err := c.SayHello(ctx, req)
	if err != nil {
		fmt.Println("Send message err:", err)
		return
	}
	fmt.Println("Client:", r.Greeting)
}

实际上为了更好得感受gRPC这种跨语言调用的感觉，可以尝试使用python编写client端代码，直接复制proto文件，在python中使用以下命令生成对应的proto文件（注意命令和自己的对应）：

python -m grpc_tools.protoc -I . --python_out=. --pyi_out=. --grpc_python_out=. *.proto

使用python实现的客户端代码如下：

# client template
# grpc server address
channel = grpc.insecure_channel("127.0.0.1:50051")
stub = hello_pb2_grpc.HelloServiceStub(channel)

# send request
response = stub.SayHello(hello_pb2.HelloRequest(name="Python"))

print(response.greeting)
# hello Python --from Golang Server

2. Server-side streaming RPC

重新给出这个的proto文件，服务端将以流式数据的形式发送给客户端数据

syntax = "proto3";
option go_package=".;service";

message HelloRequest {
  // Name of the person to greet
  string name = 1;
}

message HelloResponse {
  // Greeting message
  string greeting = 1;
}

service HelloService {
  // RPC method to say hello
  rpc SayHello (HelloRequest) returns (stream HelloResponse){}
}

同理，生成对应的proto文件后，在对应的文件先生成server端的代码：

package main

import (
	"fmt"
	"google.golang.org/grpc"
	"net"
	"test_grpc/service"
)

type HelloService struct {
}

func (hs *HelloService) SayHello(req *service.HelloRequest, stream service.HelloService_SayHelloServer) error {
	resp := &service.HelloResponse{
		Greeting: fmt.Sprintf("hello %s --from Golang Server", req.Name),
	}
	// 连续发送5次
	for i := 0; i < 5; i++ {
		if err := stream.Send(resp); err != nil {
			return err
		}
	}
	return nil
}

func main() {
	// listen on 127.0.0.1:50051
	listen, err := net.Listen("tcp", "127.0.0.1:50051")
	if err != nil {
		fmt.Println("Error happened when listen on 127.0.0.1:50051:", err)
		return
	}

	// grpc server
	s := grpc.NewServer()

	// register HelloService in grpc server
	service.RegisterHelloServiceServer(s, &HelloService{})

	// start rpc server
	fmt.Println("Golang rpc server is waiting messages......")
	if err = s.Serve(listen); err != nil {
		fmt.Println("Error happened when start rpc server:", err)
		return
	}
}

同理给出客户端的代码：

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"io"
	"log"
	"test_grpc/service"
	"time"
)

func main() {
	// connect to server
	conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		fmt.Println("Connect to rpc server err:", err)
		return
	}
	defer conn.Close()

	// init service client
	c := service.NewHelloServiceClient(conn)

	// init context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	// send message
	req := &service.HelloRequest{Name: "Golang"}
	stream, err := c.SayHello(ctx, req)
	if err != nil {
		fmt.Println("Send message err:", err)
		return
	}

	// 加载消息
	for {
		resp, err := stream.Recv()
		// 读到结束标志
		if err == io.EOF {
			log.Fatalf("end.....")
			break
		}

		if err != nil {
			log.Fatalf("failed to receive response: %v", err)
		}

		log.Printf("Greeting: %s", resp.Greeting)
	}
}

3. Client-side streaming RPC

对应的proto文件如下

syntax = "proto3";
option go_package=".;service";

message HelloRequest {
  // Name of the person to greet
  string name = 1;
}

message HelloResponse {
  // Greeting message
  string greeting = 1;
}

service HelloService {
  // RPC method to say hello
  rpc SayHello (stream HelloRequest) returns (HelloResponse){}
}

同理使用protoc命令生成对应的proto文件，后先编写client端的代码，如下：

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"log"
	"test_grpc/service"
	"time"
)

func main() {
	// connect to server
	conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		fmt.Println("Connect to rpc server err:", err)
		return
	}
	defer conn.Close()

	// init service client
	c := service.NewHelloServiceClient(conn)

	// init context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	// create stream

	stream, err := c.SayHello(ctx)
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}

	names := []string{"World", "Gophers", "Anthropic"}

	for _, name := range names {
		// request body
		req := &service.HelloRequest{Name: name}
		if err := stream.Send(req); err != nil {
			log.Fatalf("faild to send request: %v", err)
		}
	}

	resp, err := stream.CloseAndRecv()
	if err != nil {
		log.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
	}
	log.Printf("Greeting: %s", resp.Greeting)
}

对应得完成服务端的代码：

package main

import (
	"fmt"
	"google.golang.org/grpc"
	"io"
	"net"
	"strings"
	"test_grpc/service"
)

type HelloService struct {
}

func (hs *HelloService) SayHello(stream service.HelloService_SayHelloServer) error {
	var strs []string
	for {
		msg, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}

		strs = append(strs, msg.Name)
	}

	resp := &service.HelloResponse{Greeting: strings.Join(strs, " ")}

	err := stream.SendAndClose(resp)
	if err != nil {
		return err
	}
	return nil
}

func main() {
	// listen on 127.0.0.1:50051
	listen, err := net.Listen("tcp", "127.0.0.1:50051")
	if err != nil {
		fmt.Println("Error happened when listen on 127.0.0.1:50051:", err)
		return
	}

	// grpc server
	s := grpc.NewServer()

	// register HelloService in grpc server
	service.RegisterHelloServiceServer(s, &HelloService{})

	// start rpc server
	fmt.Println("Golang rpc server is waiting messages......")
	if err = s.Serve(listen); err != nil {
		fmt.Println("Error happened when start rpc server:", err)
		return
	}
}

4. Bidirectional streaming RPC

新的proto文件被如下给出：

syntax = "proto3";
option go_package=".;service";

message HelloRequest {
  // Name of the person to greet
  string name = 1;
}

message HelloResponse {
  // Greeting message
  string greeting = 1;
}

service HelloService {
  // RPC method to say hello
  rpc SayHello (stream HelloRequest) returns (stream HelloResponse){}
}

和上文中的操作一致，同时给出server端的代码：

package main

import (
	"fmt"
	"google.golang.org/grpc"
	"io"
	"log"
	"net"
	"test_grpc/service"
)

type HelloService struct {
}

func (hs *HelloService) SayHello(stream service.HelloService_SayHelloServer) error {
	for {
		msg, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}

		name := msg.Name
		resp := &service.HelloResponse{Greeting: name}

		if err = stream.Send(resp); err != nil {
			log.Fatalf("Failed to send a resp:%s", err)
		}
	}

	return nil
}

func main() {
	// listen on 127.0.0.1:50051
	listen, err := net.Listen("tcp", "127.0.0.1:50051")
	if err != nil {
		fmt.Println("Error happened when listen on 127.0.0.1:50051:", err)
		return
	}

	// grpc server
	s := grpc.NewServer()

	// register HelloService in grpc server
	service.RegisterHelloServiceServer(s, &HelloService{})

	// start rpc server
	fmt.Println("Golang rpc server is waiting messages......")
	if err = s.Serve(listen); err != nil {
		fmt.Println("Error happened when start rpc server:", err)
		return
	}
}

同时给出下面的client端的代码：

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"io"
	"log"
	"test_grpc/service"
	"time"
)

func main() {
	// connect to server
	conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		fmt.Println("Connect to rpc server err:", err)
		return
	}
	defer conn.Close()

	// init service client
	c := service.NewHelloServiceClient(conn)

	// init context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	// create stream
	stream, err := c.SayHello(ctx)
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}

	names := []string{"World", "Gophers", "Anthropic"}

	waitc := make(chan struct{})
	go func() {
		for {
			resp, err := stream.Recv()
			if err == io.EOF {
				close(waitc)
				return
			}
			if err != nil {
				log.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
			}
			log.Printf("Greeting: %s", resp.Greeting)
		}
	}()

	go func() {
		for _, name := range names {
			// request body
			req := &service.HelloRequest{Name: name}
			if err := stream.Send(req); err != nil {
				log.Fatalf("faild to send request: %v", err)
			}

			// send delay
			time.Sleep(1)
		}
		// 发送结束的消息
		if err := stream.CloseSend(); err != nil {
			log.Fatalf("failed to close stream: %v", err)
		}
	}()

	<-waitc
}

一定要注意关闭发送或者避免针对一个已经关闭stream进行发送消息，读取消息是被允许的，这里有一点类似chan

4. ALTS

4.1 ALTS的介绍

应用层传输安全（ALTS）是谷歌开发的一种相互验证和传输加密系统。它用于确保谷歌基础设施内 RPC 通信的安全。ALTS 类似于相互 TLS，但经过设计和优化，可满足 Google 生产环境的需要。ALTS在gRPC中有以下的特征：

  • 使用ALTS作为传输协议创建gRPC的服务端和客户端；
  • ALSTS是一个端到端的保护，具有隐私性和完成性；
  • 应用可以访问对等信息比如对等服务账户；
  • 支持客户端和服务端的认知；
  • 最小的代码更改就能使用ALTS；

值得注意的是ALTS被全部发挥作用如果应用程序运行在CE或者GKE中

4.2 gRPC客户端使用ALTS传输安全协议

gRPC客户端使用ALTS认证去连接服务端，正如下面代码中所描述的：

import (
  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/alts"
)

altsTC := alts.NewClientCreds(alts.DefaultClientOptions())
// connect to server
conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithTransportCredentials(altsTC))

gRPC服务端能够使用ALTS认证来运行客户端连接到它，正如下面的描述：

import (
  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/alts"
)

altsTC := alts.NewServerCreds(alts.DefaultServerOptions())
server := grpc.NewServer(grpc.Creds(altsTC))

4.3 Server Authorization

gRPC 内置了使用 ALTS 的服务器授权支持。使用 ALTS 的 gRPC 客户端可以在建立连接前设置预期的服务器服务账户。然后，在握手结束时，服务器授权会保证服务器身份与客户端指定的服务账户之一相匹配。否则，连接将失败。

import (
  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/alts"
)

clientOpts := alts.DefaultClientOptions()
clientOpts.TargetServiceAccounts = []string{expectedServerSA}
altsTC := alts.NewClientCreds(clientOpts)
conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(altsTC))

总结  

最新文章 相关文章

Go语言web框架Gin响应客户端的方式

目录 前言 一、响应html页面 1、我们首先定义一个存放模板文件的templates文件夹 2、让程序进行页面渲染和加载 3、通过请求来响应页面 4、启动测试 5、静态文件处理

2024-10-20 21:49:39

Golang标准库之errors包应用方式

目录 一. errors的基本应用 二. 错误类型的比较 三. error的扩展 3.1 自定义error 3.2 Unwrap与Nested error 3.3 errors.Is方法与错误分类 3.4 errors.As方法与错误信

2024-10-20 21:49:21

Go语言标准错误error全面解析

目录 错误类型 新建错误 错误解析 错误处理 总结错误类型 errorString错误是程序中处理逻辑和系统稳定新的重要组成部分。在go语言中内置错误如下：// The error built-in int

2024-10-20 21:49:12

Go语言的io输入输出流方式

目录 Go语言的io输入输出流 go语言输入输出在io库中 上述只是输入输出流的基本用法 常用的类型有 总结 Go语言的io输入输出流Go语言的输入输出流不如其他语言那么直观

2024-10-20 21:49:02

Go中Vendo机制的使用

目录 1. 介绍 2. vendor 目录位置 3. 搜索顺序 4. vendor 的不足1. 介绍自 Go 1.6 起，vendor 机制正式启用，它允许把项目的依赖放到一个位于本项目的 vendor 目录中，这个 vendo

2024-10-18 23:12:01

go语言中io操作中的 io.Reader 和 io.Writer的获取方法

目录 go中Reader Writer接口定义 os.File对象中的RW实现代码 bufio.Reader中的RW实现代码 bytes.Buffer中的RW实现代码我们在对文件进行io操作的时候，经常看到需要我们传递一

2024-10-18 23:11:52

golang并发编程使用Select语句的实现

目录 select 语句的基本用法 示例代码 示例 1：从多个通道接收数据 示例 2：实现超时机制 示例 3：非阻塞的通道操作 select 语句的注意事项 高级用法 在 Go 语言中，select

2024-10-18 23:11:43

go语言time.After()的作用

目录 1.延迟执行、定时任务 2.超时控制 go time.After 定时器示例 3.time.Sleep和time.After的差异 time.After是一个非常实用的函数，它返回一个用于读取的单向通道（<-cha

2024-10-18 23:11:35

go实现一个内存缓存系统的示例代码

目录 面试内容：面试内容： 支持设定过期时间，精度到秒 支持设定最大内存，当内存超出时做出合适的处理 支持并发安全 要求按照以下接口实现SetMemory(size string) bool Set(key s

2024-10-18 23:11:26

Golang Map简介以及底层原理

目录 Map 简介 Map 定义 Map Iteration Map 的线程安全 map 底层原理 哈希函数 哈希冲突 Growing map扩容 双倍扩容 Growing过程 避免溢出 代码分析

2024-10-18 23:11:17

Go语言中的定时器原理与实战应用

目录 一、Timer定时器 1. 创建Timer 2. 停止Timer 3. 重置Timer 4. time.AfterFunc 5. time.After 二、Ticker定时器 1. 创建Ticker 2. 监听Ticker事件 3. 停止T

2024-10-14 19:47:39

Golang 错误处理：如何优雅地处理与外部 API 的错误

保证与外部 api 交互时的应用程序稳定性至关重要。go 提供了完善的错误处理机制，让您优雅地捕捉来自外部 api 的错误。首先使用 error 接口指示操作成功与否，其次 if 语句检查

2024-09-30 00:06:02

Go语言字符串处理库strings包详解

目录 Golang字符串处理库strings 1. 导入strings包 2. 字符串的查找 1. 判断字符串是否包含子串 2. 判断某个字符串是否包含了多个字符串中的某一个 3. 字符串计数 4.

2024-09-29 23:28:06

使用IDEA配置GO语言的开发环境备忘录

目录1. 安装GO1.1 下载&安装1.2 配置相关环境变量1.3 检查安装2. 配置IDEA2.1 安装GO插件2.2 配置GOROOT2.3 配置GOPATH3. GO HelloWorld总结1. 安装GO1.1 下载&安装进入GO

2024-08-28 19:53:16

Golang发送Get和Post请求的实现

目录Get请求Post请求最近在研究钉钉机器人，发现钉钉的第三方接口有时需要用Get或者Post请求访问，虽然说可以通过Apifox直接模拟发送请求，但是我还是想研究一个如何使用Golang来

2024-08-28 19:53:13

一文了解Go 并发与并行

目录并发（Concurrency）并行（Parallelism）关系与区别Go语言，由Google的Robert Griesemer、Rob Pike和Ken Thompson于2009年开发，是一种静态类型、垃圾回收、多线程并发的编程语言。

2024-08-28 19:53:11

go语言解决并发问题小结

目录一、选择GO的原因二、GO解决的并发问题方法1：使用sync.WaitGroup方法2：使用ErrGroup库一、选择GO的原因作为一个后端开发，日常工作中接触最多的两门语言就是PHP和GO了。无

2024-08-28 19:53:09

Golang使用切片实现单链表的示例代码

单链表（Single Linked List）是链表数据结构的一种实现方式，它包含一系列节点（Node），每个节点都包含一个数据域和一个指向下一个节点的指针。与数组相比，链表的一个主要优点是它们可

2024-08-28 19:53:07

Go语言使用MongoDB数据库详细步骤

目录MongoDB 安装(Docker)安装 MongoDB Go 驱动基础代码使用 Go Driver 连接到 MongoDB在 Go 里面使用 BSON 对象CRUD 操作插入文档更新文档查询文档删除文档下一步总结Mong

2024-08-28 19:53:05

Golang操作excel的技巧与方法

目录关键术语介绍创建表格读取表格修改表格样式设置关键术语介绍为了方便开源库的快速上手，我们先来了解 excel 中的几个关键术语，如下图所示，①为sheet，也就是表格中的页签；②为

2024-08-28 19:53:03

使用Go语言编写一个简单的Web框架

目录一、Go Web框架的基本原理二、编写一个简单的Web框架1. 创建HTTP服务器2. 实现路由3. 添加中间件4. 使用模板引擎一、Go Web框架的基本原理在编写Web框架之前，我们需要了

2024-08-28 19:53:00

图文详解Go程序如何编译并运行起来的

目录Go程序是如何编译的从hello RdrB1te开始Go 编译过程Go程序是如何运行起来的Go程序的入口？总结Go程序是如何编译的从hello RdrB1te开始package main import "fmt" f

2024-08-28 19:52:59

Go语言使用Json的方法实现

目录 1、使用标准库中的encoding/json包 2、使用第三方包3、decode 4、注意5、更灵活地使用JSON使用json.RawMessage使用interface{}在Go语言中，处理JSON数据通常涉及编码（将

2024-08-28 19:52:54

详解如何使用Golang实现自定义规则引擎

目录支持的语句逻辑与算术运算流程控制高级语句规则语法的解析定义规则语法编写解析器语法解析器生成语法树遍历语法树生成语句表达式规则语法的执行支持自定义对象注入支持

2024-08-28 19:52:52

go 微服务框架kratos使用中间件的方法

目录一、中间件的概念二、go原生http中使用中间件的方法三、go微服务框架Kratos使用中间件的方法一、中间件的概念在go语言中，中间件是一种用于处理http请求的开发模式，允许开

2024-08-28 19:52:50

golang开发 gorilla websocket的使用示例详解

目录websocket的简单使用改成自定义的协议生产的部署很多APP都需要主动向用户推送消息，这就需要用到长连接的服务，即我们通常提到的websocket，同样也是使用socket服务，通信协议

2024-08-28 19:52:47

Go中阻塞以及非阻塞操作实现(Goroutine和main Goroutine)

main函数本身也是一个Goroutine。在Go语言中，main函数是程序的入口点。当程序启动时，Go运行时会创建一个名为main的Goroutine，并在其中执行main函数的代码。这个main Goroutine

2024-08-28 19:52:41

Golang安全读写共享变量的方式详解

目录1. 使用互斥锁(Mutex)2. 使用channel3. 读写锁(sync.RWMutex)4. 原子操作(sync/atomic包)5. sync.Once1. 使用互斥锁(Mutex)互斥锁（Mutex）是一种常用的同步原语，用于防止多

2024-08-28 19:52:39

Go使用Viper库读取YAML配置文件的示例代码

安装 Viper： 首先，你需要确保已经安装了 Viper。可以通过运行以下命令来安装 Viper：go get github.com/spf13/viper创建 YAML 配置文件： 创建一个配置文件 config.yaml，包含数据

2024-08-28 19:52:37

使用Go语言实现接口继承的方式

目录如何使用Go语言实现接口继承？示例代码原因和解决方案总结如何使用Go语言实现接口继承？在Go语言中，接口（interface）是一种定义方法集合的类型，它并不包含方法的具体实现，只是规

2024-08-28 19:52:35

热点内容

goland2020.2.x永久激活码破解详细教程亲测可用(Windows Linux Mac)
2020-11-25
解决Goland 提示 Unresolved reference 错误的问题
2020-12-15
golang gorm 计算字段和获取sum()值的实现
2020-12-19
golang判断net.Conn 是否已关闭的操作
2020-12-24
go日志系统logrus显示文件和行号的操作
2020-11-10
golang获取网卡信息操作
2020-12-24
GoAdminGroup/go-admin的安装和运行的教程详解
2020-09-29
golang gorm多条件筛选查询操作
2020-12-19
如何解决go语言输出中文乱码的问题
2020-12-29
Goland调节字体大小的设置(编辑区,terminal区,页面字体)
2020-12-21
返回顶部
顶部