Golang（Go）gRPC：proto、客户端、服务端 的使用

已于 2024-12-09 20:43:41 修改
阅读量1.1k 收藏 16
点赞数 24
分类专栏： Golang 基础学习专栏 文章标签： golang go gRPC
于 2024-12-09 20:36:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xietansheng/article/details/144357277
版权

原文链接：https://xiets.blog.csdn.net/article/details/144357277

版权声明：原创文章禁止转载

专栏目录：Golang 专栏（总目录）

文章目录

gRPC 相关链接：

Go gRPC：

1. gPRC 简介

RPC 是远程过程调用 (Remote Procedure Call) 的缩写形式，gRPC 最初是由 Google 创建的，高性能、开源通用、跨语言和平台 的 RPC 框架。

gRPC 使用 Protocol Buffers 定义服务，Protocol Buffers 是一个强大的二进制序列化工具集和语言。

2. 安装 gRPC

把 proto 文件编译生成 Go 代码，需要安装 Protocol Buffer 编译器 和 两个 Go 插件。

2.1 安装 Protocol Buffer 编译器

安装 Protocol Buffer 编译器安装：

  • Linux 安装：apt install -y protobuf-compiler
  • MacOS 安装：brew install protobuf

其他安装方式，参考：Protocol Buffer Compiler Installation

安装后将得到一个 protoc 命令工具：

$ protoc --help

2.2 安装 Go 插件

需要安装两个 Go 插件：

protoc-gen-go-grpc 工具用于在 gRPC 的 protobuf 定义文件中生成服务端的 Go 语言绑定（name_grpc.pb.go 文件）。

protoc-gen-go 是一个 protoc 插件，用于为 Protocol Buffer 语言的 proto2 和 proto3 版本生成 Go 代码（name.pb.go 文件）。

使用 go install 命令安装这两个插件：

$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
$ go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

安装后在 ${GOPATH}/bin 目录下将会多出两个命令工具：protoc-gen-go-grpc、protoc-gen-go。

运行 protoc 命令生成 Go 代码时，该命令内部将会在 PATH 环境变量中查找 protoc-gen-go-grpc 和 protoc-gen-go 这两个命令。因此需要确保 ${GOPATH}/bin 路径在 PATH 环境变量中：

export PATH="${PATH}:$(go env GOPATH)/bin"

3. gRPC 使用示例

创建一个名为 project1 的项目：

$ mkdir project1 && cd project1 
$ go mod init xiets.com/project1

后面所有命令都将在 project1/ 目录下执行。

添加 gRPC 依赖模块：

$ go get -u google.golang.org/grpc

3.1 proto 文件定义服务

使用 proto3 语言定义服务，保存到 project1/protos/user.proto 文件：

syntax = "proto3";          // 指定语言版本

// 具体编程语言的参数。
// 生成 Go 代码的导包路径和包名, 必须包含 "." 或 "/"。
// 如果没有指定包名则默认使用路径的最后一个文件夹名作为包名。
// 也可以自定义包名, 自定义包名的格式为在路径后面加上分号和自定义包名, 如: "grpc_service/user;user2"。
option go_package = "grpc_service/user";

// 服务接口 (可以定义多个服务, 编译后映射为一个类/接口)
service UserServ {
    // 服务方法 (可以定义多个方法, 编译后映射为一个类/接口的方法)
    rpc Login (LoginRequest) returns (LoginReply);
}

// 消息对象, 请求参数 (编译后映射为一个类/对象)
message LoginRequest {
    string username = 1;    // 类/对象的字段 (从1开始编号, 最小编号是1, 可以不按数值顺序, 值不能重复)
    string password = 2;    // 一旦消息类型被使用, 字段编号就不能更改, 因为它标识了消息传输格式中的字段, 更改编号相当于删除旧字段再创建新字段
}

// 消息对象 (响应参数)
message LoginReply {
    string message = 1;
}

3.2 编译 proto 文件

生成 Go 代码，参考：https://protobuf.dev/reference/go/go-generated/

编译 proto 文件，生成 客户端 和 服务端 代码：

$ protoc -I./protos \
         --go-grpc_out=. \
         --go_out=. \
         --go-grpc_opt=paths=import \
         --go_opt=paths=import \
         ./protos/user.proto

# -IPATH, --proto_path=PATH
#       在 proto 文件中需要被 import 引用的其他 proto 文件所在目录, 可以多次指定多个。
#       import 操作将在此目录下查找。
#
# --go-grpc_out=OUT_DIR
#       user_grpc.pb.go 源码文件输出目录, 最终输出路径为: "{OUT_DIR}/{paths}/user_grpc.pb.go", 
#       其中 "{paths}" 与 --go-grpc_opt=paths 参数值有关, 详见后面解释。
#
# --go_out=OUT_DIR
#       user.pb.go 源码文件输出目录, 最终输出路径为: "{OUT_DIR}/{paths}/user.pb.go",
#       其中 "{paths}" 与 --go_opt=paths 参数值有关, 详见后面解释。
#
# --go-grpc_opt=paths
# --go_opt=paths
#       源码路径 在 OUT_DIR 目录下的形式, 有两个值: "import"(默认) 和 "source_relative"
#
#       import: 
#           参数值形式: 
#               --go-grpc_opt=paths=import
#               --go_opt=paths=import
#           源码保存路径使用导包路径, 即 go_package 参数定义的多级路径, 最终路径为: "{OUT_DIR}/{go_package}/*.pb.go"
#
#       source_relative: 
#           参数值形式: 
#               --go-grpc_opt=paths=source_relative
#               --go_opt=paths=source_relative
#           源码保存路径使用 proto 文件的相对路径 (相对于 -I 参数指定的目录), 使用此方式, go_package 参数的值只用于确定包名。
#           例如 "-I./protos" 和 "./protos/aa/bb/user.proto", 最终路径为: "{OUT_DIR}/aa/bb/*.pb.go"
#
# ./protos/user.proto
#       要编译的 proto 文件, 可以指定多个, 也支持 "./protos/*.proto" 通配符形式。

protoc 命令的 --xxx_out 和 --xxx_opt 等类型的参数，如果不在 protoc --help 列出的参数中，则将从 PATH 目录下查找名为 protoc-gen-xxx 的插件命令，并把参数值传递给插件，通过插件生成相应的源码。前面安装的两个 Go 插件的作用就在这里。

编译后生成的文件目录结构：

project1
│── protos
│   └── user.proto
│── grpc_service
│   └── user
│       │── user.pb.go
│       └── user_grpc.pb.go
│── go.mod
└── go.sum

3.3 服务端代码

gRPC 服务端代码：project1/server/main.py

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"log"
	"net"
	pb "xiets.com/project1/grpc_service/user"
)

func main() {
	// 创建 TCP 监听
	listen, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}

	// 创建 gRPC 服务
	var opts []grpc.ServerOption
	grpcServer := grpc.NewServer(opts...)

	// 注册 UserServ 服务实例到 gRPC 服务
	userServ := &UserServ{}
	pb.RegisterUserServServer(grpcServer, userServ)

	// 在指定监听上运行 gGPC 服务 (阻塞至服务终止)
	err = grpcServer.Serve(listen)
	if err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

// UserServ 用于实现 UserServ 服务接口
type UserServ struct {
	pb.UnimplementedUserServServer
}

func (u *UserServ) Login(ctx context.Context, request *pb.LoginRequest) (*pb.LoginReply, error) {
	// 获取请求参数
	username := request.GetUsername()
	password := request.GetPassword()

	// 处理请求 ...
	log.Printf("UserServ.Login: username=%s, password=%s\n", username, password)

	// 构建响应参数
	reply := &pb.LoginReply{
		Message: fmt.Sprintf("Hi: %s", request.GetUsername()),
	}
	return reply, nil
}

启动 gRPC 服务端：

$ go run server/main.go

3.4 客户端代码

gRPC 服务端代码：project1/client/main.go

package main

import (
	"context"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"log"
	pb "xiets.com/project1/grpc_service/user"
)

func main() {
	// 创建 gRPC 连接
	addr := "localhost:8080"
	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	}
	conn, err := grpc.Dial(addr, opts...)
	if err != nil {
		log.Fatalf("grpc dial error: %v", err)
	}

	// 延迟关闭连接
	defer func(conn *grpc.ClientConn) {
		_ = conn.Close()
	}(conn)

	// 创建 UserServ 客户端实例 (在指定连接上通信)
	client := pb.NewUserServClient(conn)

	// 创建请求对象
	req := &pb.LoginRequest{
		Username: "hello",
		Password: "world",
	}
	// 调用请求, 返回响应
	resp, err := client.Login(context.Background(), req)
	if err != nil {
		log.Fatalf("grpc call error: %v", err)
	}
	// 获取响应参数
	log.Printf("resp: %s\n", resp.GetMessage())
}

运行 gRPC 客户端：

$ go run client/main.go
2. 【gRPC系列学习】 创建一元gRPC的客户端与服务端
菜鸟的博客
12-21 795
编写proto文件，安装protoc，编译为pb文件，编写客户端代码，服务端代码，解析pb文件中ServiceDesc字段含义及用法
Golang 结合 gRPC：构建高可用的分布式服务
最新发布
Golang编程笔记的博客
04-20 901
在当今的软件开发领域，分布式系统变得越来越重要。随着业务规模的不断扩大，单体应用逐渐难以满足高并发、高可用和可扩展性的需求。Golang 作为一种高效、简洁且并发性能优秀的编程语言，与 gRPC 这一高性能、开源的远程过程调用（RPC）框架相结合，可以为构建高可用的分布式服务提供强大的支持。本文的目的是全面介绍如何使用 Golang 结合 gRPC 来构建高可用的分布式服务。我们将涵盖从基础概念到实际项目开发的各个方面，包括 gRPC 的原理、核心算法、数学模型、项目实战以及实际应用场景等内容。
Go-grpcall是一个客户端库利用反射模式轻松请求GRPC服务器
08-14
grpcall 是一个客户端库利用反射模式轻松请求GRPC服务器。 并轻松制作grpc代理模式中间件，如grpc-gateway。
proto 客户端 JAVA_Kubernetes官方java客户端之五：proto基本操作
weixin_31608037的博客
02-26 152
欢迎访问我的GitHub内容：所有原创文章分类汇总及配套源码，涉及Java、Docker、Kubernetes、DevOPS等；概览本文是《Kubernetes官方java客户端》系列的第五篇，以下提到的java客户端都是指client-jar.jar；经过前面四篇文章的准备和尝试，我们对java客户端有了初步了解，也成功运行了hello world，接下来要做的是继续深入学习和实践，掌握这门利器...
golang微服务学习(grpc)
weixin_73388622的博客
04-20 328
golang官方的net/rpc库使用encoding/gob进行编解码，支持tcp和http数据传输方式，由于其他语言不支持gob编解码方式，所以golang的RPC只支持golang开发的服务器与客户端之间的交互。官方还提供了net/rpc/jsonrpc库实现RPC方法，jsonrpc采用JSON进行数据编解码，因而支持跨语言调用，目前jsonrpc库是基于tcp协议实现的，暂不支持http传输方式。函数第一参数是接收参数，第二个参数是返回给客户端的参数，必须是指针类型。函数名必须首字母大写。
grpc- go最简单的客户端 服务端程序
qq_38871173的博客
11-06 116
更改 go包源 go env -w GO111MODULE=on go env -w GOPROXY=https://goproxy.cn 下grpc-go包及pb包 go get google.golang.org/grpc go get -u github.com/golang/protobuf/proto go get -u github.com/golang/protobuf/protoc-gen-go 安装pb 下载地址： https://github.com/protocolbuffers/pr
go gRPC 服务端、客户端双向流demo
白小白的小白的博客
09-03 551
go grpc
go语言实现简单的grpc客户端服务端案例
小诸葛的博客
10-14 847
创建一个.proto文件来定义服务接口。
gRPC：gRPC客户端与服务器端通信机制
kkchenjj的博客
07-12 1157
在gRPC的流式通信允许客户端和服务器之间进行更复杂的交互，包括服务器流RPC、客户端流RPC和双向流RPC。在gRPC 使用 Protocol Buffers (Protobuf) 作为其数据序列化机制。Protobuf 是一种高效、灵活的二进制格式，由 Google 开发，用于结构化数据的序列化，不仅比 XML 更小、更快，也比 JSON 更紧凑。在gRPC中，可以通过消息来定义错误状态。gRPC的错误处理机制通过定义详细的错误状态和使用。
Golang-node-grpc:使用golang请求node服务，得到验证码
05-28
在本文中，我们将深入探讨如何使用Golang与Node.js通过gRPC进行通信，特别是在获取验证码这一具体场景下。gRPC是一种高性能、开源和通用的RPC（远程过程调用）框架，它基于HTTP/2协议，支持多种语言，包括Node.js和...
go-php-grpc-example:Golang服务端，PHP客户端示例代码
03-16
Golang服务端，PHP客户端的GRPC示例代码 博客地址： ://www.xhyonline.com/?p 1416 一，安装环境 我们需要.proto文件，然后通过.proto命令编译，因此需要安装protoc 地址： : 我是Windows环境，因此就下载了这个...
客户端 protobuf 支持 库
05-16
用于 网络数据传输的 protobuf 数据类型。这个就是 Unity 客户端 支持 protobuf 数据的 写入和读取 的 动态库
golang 微服务 实现gRPC服务端与客户端
全栈开发工程师，不定期分享Python、Golang、Java、前端等程序员必备技术，干货满满，不断充电！
10-20 828
golang 微服务 实现gRPC服务端与客户端
史上最细gRPC(Go)入门教程(十二)---客户端负载均衡
探索云原生
05-29 2816
本文主要介绍了 gRPC 内置的负载均衡策略及其配置与使用，包括 Name Resolver、ServiceConfig 等。 gRPC 系列相关代码见 Github 1. 概述 gRPC 负载均衡包括客户端负载均衡和服务端负载均衡两种方向。本文主要介绍的是客户端负载均衡。 gRPC 的客户端负载均衡主要分为两个部...
深入解析grpc源码2-客户端与服务器通信流程
白日梦程序员的博客
12-10 1988
前面已经讲了grpc 基础使用、protobuf 使用及原理，今天开始逐步探究grpc-go 源码实现，grpc 底层通信协议是对http2 协议的封装，grpc 并没有使用golang 官方实现的http2，而是自己实现了http2，引用了官方的帧解析器和其他枚举值，http2在其他语言实现大同小异。 一般rpc 协议会包含请求方法，请求参数，请求参数在grpc被称为消息，内容是protobuf二进制内容，方法会携带在http2 的header 里面，最后服务器解包，获取方法路由到相应的handler.
Golang——gRPC与ProtoBuf介绍
weixin_57023347的博客
06-06 1952
微服务架构中，由于每个服务对应的代码库是独立运行的，无法直接调用，彼此之间的通信就是一个大问题。gRPC可以实现微服务，将大的项目拆分为多个小且独立的业务模块，也就是服务，各个服务将使用高效的protobuf协议进行RPC调用，gRPC默认使用protocol buffers，这个是google开源的一套成熟的结构数据序列化机制，当然也可以使用其它数据结构如JSON。可以用proto files创建gRPC服务，用message类型来定义方法参数和返回类型。
GoLang：gRPC协议的介绍以及详细教程，从Protocol开始
weixin_54703767的博客
01-06 2599
gRPC（Google Remote Procedure Call）是一个由Google开发的高性能、开源RPC（远程过程调用）框架。它基于HTTP/2进行数据传输，使用ProtoBuf（Protocol Buffers）作为接口描述语言，支持多种编程语言，如Java、Go、C#等，适用于不同语言环境。gRPC的显著特点包括其高效的通信性能，支持双向流、多路复用和二进制传输，以及集成的安全机制，如SSL/TLS。这些特性使gRPC特别适合用于构建高性能的分布式系统和微服务架构中的服务间通信，尤其在需要处理大
Go语言---linux下安装golang protoc详细教程以及完整安装protoc-gen-go工具
m0_73537205的博客
08-02 2137
Protobuf 在 .proto 定义需要处理的结构化数据，可以通过 protoc 工具，将 .proto 文件转换为 C、C++、Golang、Java、Python 等多种语言的代码，兼容性好，易于使用。
【golang】10、grpc server 和 client、proto
呆呆的猫的博客
10-26 1716
grpc 的 server 和 client、proto
golang实现grpc服务端与客户端
05-23
首先，需要安装gRPC和protobuf。可以使用以下命令： ``` go get -u google.golang.org/grpc go get -u github.com/golang/protobuf/proto go get -u github.com/golang/protobuf/protoc-gen-go ``` 接下来，我们需要定义protobuf文件，其中包含服务的RPC方法和消息格式，例如： ``` syntax = "proto3"; package myservice; message Request { string message = 1; } message Response { string message = 1; } service MyService { rpc SayHello(Request) returns (Response) {} } ``` 然后，使用以下命令将protobuf文件编译为Go代码： ``` protoc --go_out=plugins=grpc:. myservice.proto ``` 这将生成myservice.pb.go文件。 接下来，我们需要实现gRPC服务端和客户端。以下是一个简单的示例： 服务端： ``` package main import ( "log" "net" "google.golang.org/grpc" pb "path/to/myservice" ) type myServiceServer struct{} func (s *myServiceServer) SayHello(ctx context.Context, req *pb.Request) (*pb.Response, error) { log.Printf("Received message: %v", req.Message) return &pb.Response{Message: "Hello " + req.Message}, nil } func main() { lis, err := net.Listen("tcp", ":50051") if err != nil { log.Fatalf("failed to listen: %v", err) } s := grpc.NewServer() pb.RegisterMyServiceServer(s, &myServiceServer{}) if err := s.Serve(lis); err != nil { log.Fatalf("failed to serve: %v", err) } } ``` 客户端： ``` package main import ( "log" "golang.org/x/net/context" "google.golang.org/grpc" pb "path/to/myservice" ) func main() { conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure()) if err != nil { log.Fatalf("failed to connect: %v", err) } defer conn.Close() c := pb.NewMyServiceClient(conn) res, err := c.SayHello(context.Background(), &pb.Request{Message: "World"}) if err != nil { log.Fatalf("failed to call SayHello: %v", err) } log.Printf("Response message: %v", res.Message) } ``` 运行服务端和客户端，即可进行gRPC通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

谢TS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值