2-2-GO-GRPC-Gateway 传奇2-1跟2-2的区别

参考

插件地址: https://github.com/grpc-ecosystem/grpc-gateway

官方文档: https://grpc-ecosystem.github.io/grpc-gateway/docs/tutorials/simple_hello_world/

https://www.liwenzhou.com/posts/Go/grpc-gateway/

https://www.cnblogs.com/cxt618/p/15647316.html

https://blog.csdn.net/dl962454/article/details/124384299

https://www.bilibili.com/video/BV1Jo4y1t7j3/?spm_id_from=333.337.search-card.all.click&vd_source=471e99ac4ee950e251666ac7914274a0

https://www.bilibili.com/video/BV1gP411U7Pq/?spm_id_from=333.999.0.0&vd_source=471e99ac4ee950e251666ac7914274a0

https://blog.csdn.net/Lance_Yuan24/article/details/127699748

----------------------------------------------------------------------------------------------------------------------

gRPC很棒——它以多种编程语言生成应用编程接口客户端和服务器存根，速度快，易于使用，带宽高效，其设计得到了谷歌的实战验证。

然而，您可能仍然希望提供传统的RESTful应用编程接口。

原因可能包括保持向后兼容性、支持语言或gRPC不太支持的客户端，以及简单地维护RESTful架构所涉及的美学和工具。

该项目旨在为您的gRPC服务提供HTTP+JSON接口。使用此库生成反向代理只需要在您的服务中进行少量配置以附加HTTP语义学。

最常见的 gRPC-Gateway 模式是创建单个 gRPC 网关服务器(可能在多台机器上运行)，作为客户端的代理与多个 gRPC 服务交互。

下图解释了此服务的工作原理。

gRPC 网关生成的反向代理被水平扩展以在多台机器上运行，并且在这些实例之前使用负载均衡器。单个实例可以托管多个 gRPC 服务的反向代理。

安装

注意这里必须用 go install 才能生成相应的可执行文件, 在GOROOT/bin目录中即可找到

go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway
go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2

------------------------------------------------------------------------------------------------------------------------

官方例子

为了理解gRPC-Gateway，我们将首先制作一个hello world gRPC服务

1. 创建一个proto文件

在创建gRPC服务之前，我们应该创建一个proto文件来定义我们需要的内容，

这里我们在目录proto/helloworld/hello_world.proto中创建一个名为hello_world.proto的文件。

gRPC服务是使用Google协议缓冲区定义的。要详细了解如何在

.proto文件中定义服务，请参阅他们的基础教程。

现在，您只需要知道服务器和客户端存根都有一个SayHello()RPC方法，

该方法从客户端获取一个HelloRequest参数，并从服务器返回一个HelloReply，该方法定义如下

syntax = "proto3";

option go_package= "./;helloworld"; //这里和官方不同  这里需要手动指定包名

package helloworld;

// The greeting service definition
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

2. 生成存根

对于生成存根，我们有两种选择：protoc和buf。

protoc是行业中广泛使用的更经典的生成体验，但它有一个相当陡峭的学习曲线。

buf是一个更新的工具，它考虑到了用户体验和速度。它还提供了protoc所不提供的弹性和断裂变化检测。我们在这里提供两者的说明

2.1 使用buf生成存根 https://grpc-ecosystem.github.io/grpc-gateway/docs/tutorials/generating_stubs/using_buf/

2.2 使用协议生成存根

假设您位于存储库的根目录，并且您的proto文件位于名为proto的目录中，下面是生成Go存根的protoc命令的示例：

在proto目录上一层创建helloworld文件夹

protoc -I ./proto \
--go_out ./proto --go_opt paths=source_relative \
--go-grpc_out ./proto --go-grpc_opt paths=source_relative \
./proto/helloworld/hello_world.proto

我的  在proto目录中进入命令行
protoc -I ./helloworld \
--go_out ../helloworld --go_opt paths=source_relative \
--go-grpc_out ../helloworld --go-grpc_opt paths=source_relative \
./helloworld/hello_world.proto

我的目录结构如下

我们使用go和go-grpc插件来生成Go类型和gRPC服务定义。

我们输出生成的文件相对于proto文件夹，

我们使用paths=source_relative选项，这意味着生成的文件将出现在与源.proto文件相同的目录中。

这将生成一个*.pb.go和一个*_grpc.pb.go文件 proto/helloworld/hello_world.proto

参数讲解：

• -I 或者 --proto_path：

用于指定所编译的源码，就是我们所导入的proto文件，支持多次指定，按照顺序搜索，如果未指定，则使用当前工作目录

• --go_out：

同样的也有其他语言的，例如--java_out、--csharp_out,用来指定语言的生成位置，用于生成*.pb.go 文件

• --go_opt：paths=source_relative 指定--go_out生成文件是基于相对路径的

• --go-grpc_out：用于生成 *_grpc.pb.go 文件
• --go-grpc_opt：
• paths=source_relative 指定--go_grpc_out生成文件是基于相对路径的
• require_unimplemented_servers=false 默认是true，会在server类多生成一个接口

• --grpc-gateway_out：是使用到了 protoc-gen-grpc-gateway.exe 插件，用于生成pb.gw.go文件
• --grpc-gateway_opt：
• logtostderr=true 记录log
• paths=source_relative 指定--grpc-gateway_out生成文件是基于相对路径的
• generate_unbound_methods=true 如果proto文件没有写api接口信息，也会默认生成

• --openapiv2_out：使用到了protoc-gen-openapiv2.exe 插件，用于生成swagger.json 文件

3. 服务器端实现

在grpc/test目录中创建helloworld目录

创建helloworldserver.go用于实现GRPC服务器端

注意 : 第一行注释不要去掉 就放在第一行

//go:build ignore

package main

import (
    "context"
    "log"
    "net"

    "braceapi.hgbaoxian.cn/braceapi/grpc/grpcserver/helloworld"
    "google.golang.org/grpc"
)

type server struct {
    helloworld.UnimplementedGreeterServer
}

func NewServer() *server {
    return &server{}
}

func (s *server) SayHello(ctx context.Context, in *helloworld.HelloRequest) (*helloworld.HelloReply, error) {
    return &helloworld.HelloReply{Message: in.Name + " world"}, nil
}

func main() {
    // Create a listener on TCP port
    lis, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalln("Failed to listen:", err)
    }

    // Create a gRPC server object
    s := grpc.NewServer()
    // Attach the Greeter service to the server
    helloworld.RegisterGreeterServer(s, &server{})
    // Serve gRPC Server
    log.Println("Serving gRPC on 0.0.0.0:8080")
    log.Fatal(s.Serve(lis))
}

运行测试: 确定没有问题

$ go run helloworldserver.go
2023/05/31 11:30:52 Serving gRPC on 0.0.0.0:8080

4. 将gRPC-Gateway注释添加到现有原型文件

4.1 修改proto文件

现在我们已经有了一个工作的Go gRPC服务器，我们需要添加gRPC-Gateway注解。

注解定义gRPC服务如何映射到JSON请求和响应。

使用协议缓冲区时，每个RPC必须使用google.api.http注释定义HTTP方法和路径。

所以我们需要将google/api/http.proto导入添加到proto文件中。我们还需要添加我们想要的HTTP->gRPC映射。

在这种情况下，我们将POST /v1/example/echo映射到我们的SayHelloRPC。

与我们之前编写的proto文件略有不同，本次我们需要用到 google/api/annotations.proto 文件。因此，我们可以把annotations.proto文件先下载下来，

可以在googleapi项目中下载，路径为：https://github.com/googleapis/googleapis/tree/master/google/api 。

本次我们需要使用到 google/api/annotations.proto文件，由于annotations.proto又引用到了google/api/http.proto，

google/protobuf/descriptor.proto(这个文件在protoc安装目录/include/google/protobuf)，

所以为了简单 我们可以把annotations.proto和http.proto存放到protoc安装目录/include/google/api下(手动创建api文件)

helloworld.proto文件内如修改如下:

syntax = "proto3";

option go_package= "./;helloworld";

package helloworld;

import "google/api/annotations.proto";

// The greeting service definition

service Greeter {

// Sends a greeting

rpc SayHello (HelloRequest) returns (HelloReply) {

option (google.api.http) = {

post: "/v1/example/echo"

body: "*"

};

}

}

// The request message containing the user's name

message HelloRequest {

string name = 1;

}

// The response message containing the greetings

message HelloReply {

string message = 1;

}

4.2 生成gRPC-Gateway存根

现在我们已经将gRPC-Gateway注释添加到proto文件中，我们需要使用gRPC-Gateway生成器来生成存根。

4.2.1 使用buf

4.2.2 使用protoc命令生成相应文件

就多了红色部分的选项 --grpc-gateway_out 和 --grpc-gateway_opt

protoc -I ./proto \

--go_out ./proto --go_opt paths=source_relative \

--go-grpc_out ./proto --go-grpc_opt paths=source_relative \

--grpc-gateway_out ./proto --grpc-gateway_opt paths=source_relative \

./proto/helloworld/hello_world.proto

我的 在proto目录中进入命令行

protoc -I ./helloworld \

--go_out ../helloworld --go_opt paths=source_relative \

--go-grpc_out ../helloworld --go-grpc_opt paths=source_relative \

--grpc-gateway_out ../helloworld --grpc-gateway_opt paths=source_relative \

./helloworld/hello_world.proto

• --grpc-gateway_out：是使用到了 protoc-gen-grpc-gateway.exe 插件，用于生成pb.gw.go文件
• --grpc-gateway_opt：
• logtostderr=true 记录log
• paths=source_relative 指定--grpc-gateway_out生成文件是基于相对路径的
• generate_unbound_methods=true 如果proto文件没有写api接口信息，也会默认生成

执行后生成的文件结构如下:

主要是多生成了一个*.gw.pb.go的文件

4.3 修改服务器端文件

braceapi\grpc\test\helloworld\helloworldserver.go

//go:build ignore

package main

import (

"context"

"log"

"net"

"net/http"

"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"

"google.golang.org/grpc"

"google.golang.org/grpc/credentials/insecure"

helloworldpb "braceapi.hgbaoxian.cn/braceapi/grpc/grpcserver/helloworld"

)

type server struct {

helloworldpb.UnimplementedGreeterServer

}

func NewServer() *server {

return &server{}

}

func (s *server) SayHello(ctx context.Context, in *helloworldpb.HelloRequest) (*helloworldpb.HelloReply, error) {

return &helloworldpb.HelloReply{Message: in.Name + " world"}, nil

}

func main() {

// Create a listener on TCP port

lis, err := net.Listen("tcp", ":8080")

if err != nil {

log.Fatalln("Failed to listen:", err)

}

// Create a gRPC server object

s := grpc.NewServer()

// Attach the Greeter service to the server

helloworldpb.RegisterGreeterServer(s, &server{})

// Serve gRPC server

log.Println("Serving gRPC on 0.0.0.0:8080")

//开启一个协程单独处理grpc协议请求

go func() {

log.Fatalln(s.Serve(lis))

}()

//以下是主线程处理http协议的请求

// Create a client connection to the gRPC server we just started

// This is where the gRPC-Gateway proxies the requests

conn, err := grpc.DialContext(

context.Background(),

"0.0.0.0:8080",

grpc.WithBlock(),

grpc.WithTransportCredentials(insecure.NewCredentials()),

)

if err != nil {

log.Fatalln("Failed to dial server:", err)

}

gwmux := runtime.NewServeMux()

// Register Greeter

err = helloworldpb.RegisterGreeterHandler(context.Background(), gwmux, conn)

if err != nil {

log.Fatalln("Failed to register gateway:", err)

}

gwServer := &http.Server{

Addr: ":8090",

Handler: gwmux,

}

log.Println("Serving gRPC-Gateway on http://0.0.0.0:8090")

log.Fatalln(gwServer.ListenAndServe())

}

整体结构

5. 测试gRPC-Gateway

现在我们可以启动服务器了：

go run helloworldserver.go

2023/05/31 16:05:15 Serving gRPC on 0.0.0.0:8080
2023/05/31 16:05:15 Serving gRPC-Gateway on http://0.0.0.0:8090

然后我们使用cURL发送HTTP请求

curl -X POST -k http://localhost:8090/v1/example/echo -d '{"name": " hello"}'
  %  Total  % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100    44  100    26  100    18  16539  11450 --:--:-- --:--:-- --:--:-- 44000{"message":" hello world"}

postman测试

希望这能让您对如何使用gRPC-Gateway有所了解。

hello world程序的完整源代码可以在这里找到helloworld-grpc-网关。