前言

个人网站： https://linzyblog.netlify.app/
示例代码已经上传到github：点击跳转
gRPC官方文档：点击跳转
grpc-gateway官方文档：点击跳转
源自 coreos 的一篇博客，转载到了 gRPC 官方博客 gRPC with REST and Open APIs。

一、gRPC-Gateway概述

1、简述

取自官方概述：
grpc-gateway is a plugin of protoc. It reads gRPC service definition, and generates a reverse-proxy server which translates a RESTful JSON API into gRPC. This server is generated according to custom options in your gRPC definition.

gRPC-Gateway 是 protoc 的插件。它读取gRPC服务定义并生成反向代理服务器，将 RESTful JSON API 转换为 gRPC。该服务器是根据服务定义中的 google.api.http 注释生成的。

2、出现

etcd v3 改用 gRPC 后为了兼容原来的 API，同时要提供 HTTP/JSON 方式的API，为了满足这个需求，要么开发两套 API，要么实现一种转换机制，所以grpc-gateway诞生了。

通过protobuf的自定义option实现了一个网关，服务端同时开启gRPC和HTTP服务。
HTTP服务接收客户端请求后转换为grpc请求数据，获取响应后转为json数据返回给客户端。
当 HTTP 请求到达 gRPC-Gateway 时，它将 JSON 数据解析为 Protobuf 消息。使用解析的 Protobuf 消息发出正常的 Go gRPC 客户端请求。
Go gRPC 客户端将 Protobuf 结构编码为 Protobuf 二进制格式，然后将其发送到 gRPC 服务器。
gRPC 服务器处理请求并以 Protobuf 二进制格式返回响应。
Go gRPC 客户端将其解析为 Protobuf 消息，并将其返回到 gRPC-Gateway，后者将 Protobuf 消息编码为 JSON 并将其返回给原始客户端。

架构如下

在这里插入图片描述

二、准备工作

由于本实践偏向 Grpc+Grpc Gateway的方面，我们的需求是同一个服务端支持Rpc和Restful Api，那么就意味着http2、TLS等等的应用，功能方面就是一个服务端能够接受来自grpc和Restful Api的请求并响应。

本文示例代码已经上传到github：点击跳转

1、目录结构

新建grpc-gateway-example文件夹，我们项目的初始目录目录如下：

grpc-gateway-example/
├── certs
├── client
├── cmd
├── pkg
├── proto
│   ├── google
│   │   └── api
│   │   │   └── annotations.proto
│   │   │   └── http.proto
│   │   └── protobuf
│   │   │   └── descriptor.proto
├── server
└── Makefile

certs：存放证书凭证
client：客户端
cmd：存放 cobra 命令模块
pkg：第三方公共模块
proto：protobuf的一些相关文件（含.proto、pb.go、.pb.gw.go)，google/api中用于存放annotations.proto、http.proto、google/protobuf中用于存放descriptor.proto
- 如果你生成Go代码的时候出现File not found，那一定就是找不到下面的文件。
- annotations.proto和http.proto文件需要手动从 https://github.com/googleapis/googleapis/tree/master/google/api地址复制到自己的项目中或者手动复制代码！！
- descriptor.proto文件可以直接复制代码！！
server：服务端
Makefile：用于存放编译的代码。

2、环境准备

1）Protobuf

详细的请移步到《gRPC（二）入门：Protobuf入门》

2）gRPC

详细的请移步到《gRPC（三）基础：gRPC快速入门》

3）gRPC-Gateway

gRPC-Gateway 只是一个插件，只需要安装一下就可以了。这里建议科学上网：

go get -u github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway

3、编写 IDL

1）google.api

proto 目录中有 google/api 目录，它用到了 google 官方提供的两个 api 描述文件，主要是针对 grpc-gateway 的 http 转换提供支持，定义了 Protocol Buffer 所扩展的 HTTP Option。

2）hello.proto

编写Demo的 .proto 文件，我们在 proto目录下新建 hello.proto 文件，写入文件内容：

syntax = "proto3";

package proto;
option go_package = "./proto/helloworld;helloworld";

import "proto/google/api/annotations.proto";

// 定义Hello服务
service Hello {
  // 定义SayHello方法
  rpc SayHello(HelloRequest) returns (HelloResponse) {
    // http option 网关
    option (google.api.http) = {
      post: "/hello_world"
      body: "*"
    };
  }
}

// HelloRequest 请求结构
message HelloRequest {
  string referer = 1;
}

// HelloResponse 响应结构
message HelloResponse {
  string message = 1;
}

在 hello.proto 文件中，引用了 google/api/annotations.proto ，达到支持HTTP Option的效果

定义了一个 serviceRPC 服务 HelloWorld，在其内部定义了一个 HTTP Option 的POST方法，HTTP 响应路径为/hello_world。
定义message类型HelloWorldRequest、HelloWorldResponse，用于响应请求和返回结果。

每个方法都必须添加 google.api.http 注解后 gRPC-Gateway 才能生成对应 http 方法。
其中post为 HTTP Method，即 POST 方法， /hello_world 则是请求路径。

3）编译proto

在Makefile文件内输入以下内容：

protoc:
        protoc  --go_out=.  --go-grpc_out=. --grpc-gateway_out=. ./proto/*.proto

Go Plugins 用于生成 .pb.go 文件
gRPC Plugins 用于生成 _grpc.pb.go
gRPC-Gateway 则是 pb.gw.go

使用 make protoc 编译proto：

➜ make protoc
protoc  --go_out=.  --go-grpc_out=. --grpc-gateway_out=. ./proto/*.proto

在这里插入图片描述

4、制作证书

详细的请移步到《gRPC（五）进阶：通过TLS建立安全连接》

在服务端支持Rpc和Restful Api，需要用到TLS，因此我们要先制作证书

进入certs目录，生成TLS所需的公钥密钥文件

1）生成CA根证书

在 ca.conf 文件并写入内容如下:

[ req ]
default_bits       = 4096
distinguished_name = req_distinguished_name

[ req_distinguished_name ]
countryName                 = GB
countryName_default         = CN
stateOrProvinceName         = State or Province Name (full name)
stateOrProvinceName_default = ZheJiang
localityName                = Locality Name (eg, city)
localityName_default        = HuZhou
organizationName            = Organization Name (eg, company)
organizationName_default    = Step
commonName                  = linzyblog.netlify.app
commonName_max              = 64
commonName_default          = linzyblog.netlify.app

生成ca私钥，得到ca.key

openssl genrsa -out ca.key 4096

生成ca证书签发请求，得到ca.csr

$ openssl req -new -sha256 -out ca.csr -key ca.key -config ca.conf
GB [CN]:
State or Province Name (full name) [ZheJiang]:
Locality Name (eg, city) [HuZhou]:
Organization Name (eg, company) [Step]:
linzyblog.netlify.app [linzyblog.netlify.app]:

生成ca根证书，得到ca.crt

openssl x509 -req -days 3650 -in ca.csr -signkey ca.key -out ca.crt

在这里插入图片描述

2）生成终端用户证书

在 server.conf 写入以下内容：

[ req ]
default_bits       = 2048
distinguished_name = req_distinguished_name

[ req_distinguished_name ]
countryName                 = Country Name (2 letter code)
countryName_default         = CN
stateOrProvinceName         = State or Province Name (full name)
stateOrProvinceName_default = ZheJiang
localityName                = Locality Name (eg, city)
localityName_default        = HuZhou
organizationName            = Organization Name (eg, company)
organizationName_default    = Step
commonName                  = CommonName (e.g. server FQDN or YOUR name)
commonName_max              = 64
commonName_default          = linzyblog.netlify.app

[ req_ext ]
subjectAltName = @alt_names

[alt_names]
DNS.1   = grpc-gateway-example
IP      = 127.0.0.1

生成私钥，得到server.key

openssl genrsa -out server.key 2048

生成证书签发请求，得到server.csr

openssl req -new -sha256 -out server.csr -key server.key -config server.conf

这里也一直回车就好。

用CA证书生成终端用户证书，得到server.crt

openssl x509 -req -days 3650 -CA ca.crt -CAkey ca.key -CAcreateserial -in server.csr -out server.pem -extensions req_ext -extfile server.conf

在这里插入图片描述

这样我们需要的证书凭证就足够了

三、命令行模块 cmd

1、Cobra介绍

官方文档：点击跳转

Cobra 是一个用于创建强大的现代 CLI 应用程序的库。它提供了一个简单的界面来创建强大的现代 CLI 界面，类似于 git 和 go 工具。

Cobra 提供：

简易的子命令行模式
完全兼容 POSIX 的命令行模式(包括短版和长版）
嵌套的子命令
全局、本地和级联flags
使用Cobra很容易的生成应用程序和命令，使用 cobra create appname和 cobra add cmdname
提供智能提示
自动生成commands和flags的帮助信息
自动生成详细的 help 信息，如 app -help。
自动识别帮助 flag、 -h，--help。
自动生成应用程序在 bash 下命令自动完成功能。
自动生成应用程序的 man 手册。
命令行别名。
自定义 help 和 usage 信息。
可选的与 viper 的紧密集成。

2、概念

Cobra 建立在命令（commands）、参数（arguments ）、选项（flags）的结构之上。

commands：命令代表行为,一般表示 action，即运行的二进制命令服务。同时可以拥有子命令（children commands）
arguments：参数代表命令行参数。
flags：选项代表对命令行为的改变，即命令行选项。二进制命令的配置参数，可对应配置文件。参数可分为全局参数和子命令参数。

最好的命令行程序在实际使用时，就应该像在读一段优美的语句，能够更加直观的知道如何与用户进行交互。

执行命令行程序应该遵循一般的格式：

#appname command  arguments
docker pull alpine:latest

#appname command flag
docker ps -a

#appname command flag argument
git commit -m "linzy"

3、安装

使用 Cobra 很容易。首先，用于go get安装最新版本的库。

go get -u github.com/spf13/cobra@latest

4、编写 server

在编写 cmd 时需要先用 server 进行测试关联，因此这一步我们先写 server.go 用于测试

在 server 模块下新建 server.go 文件，写入测试内容：

package server

import (
    "log"
)

var (
    ServerPort  string
    CertName    string
    CertPemPath string
    CertKeyPath string
)

func Serve() (err error) {
    log.Println(ServerPort)

    log.Println(CertName)

    log.Println(CertPemPath)

    log.Println(CertKeyPath)

    return nil
}

5、编写 cmd

在cmd模块下新建 root.go 文件，写入内容：

package cmd

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
)

// rootCmd表示在没有任何子命令的情况下的基本命令
var rootCmd = &cobra.Command{
    // Command的用法，Use是一个行用法消息
    Use: "grpc",
    // Short是help命令输出中显示的简短描述
    Short: "Run the gRPC hello-world server",
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(-1)
    }
}

当前 cmd 目录下继续新建 server.go 文件，写入内容：

package cmd

import (
    "github.com/spf13/cobra"
    "grpc-gateway-example/server"
    "log"
)

// 创建附加命令
// 本地标签：在本地分配一个标志，该标志仅适用于该特定命令。
var serverCmd = &cobra.Command{
    Use:   "server",
    Short: "Run the gRPC hello-world server",
    // 运行:典型的实际工作功能。大多数命令只会实现这一点；
    // 另外还有PreRun、PreRunE、PostRun、PostRunE等等不同时期的运行命令，但比较少用，具体使用时再查看亦可
    Run: func(cmd *cobra.Command, args []string) {
        defer func() {
            if err := recover(); err != nil {
                log.Println("Recover error : %v", err)
            }
        }()

        server.Serve()
    },
}

// 在 init() 函数中定义flags和处理配置。
func init() {
    // 我们定义了一个flag，值存储在&server.ServerPort中，长命令为--port，短命令为-p，，默认值为50052。
    // 命令的描述为server port。这一种调用方式成为Local Flags 本地标签
    serverCmd.Flags().StringVarP(&server.ServerPort, "port", "p", "50052", "server port")
    serverCmd.Flags().StringVarP(&server.CertPemPath, "cert-pem", "", "./certs/server.pem", "cert pem path")
    serverCmd.Flags().StringVarP(&server.CertKeyPath, "cert-key", "", "./certs/server.key", "cert key path")
    serverCmd.Flags().StringVarP(&server.CertName, "cert-name", "", "grpc-gateway-example", "server's hostname")

    // AddCommand向这父命令（rootCmd）添加一个或多个命令
    rootCmd.AddCommand(serverCmd)
}

6、启动 & 请求

我们在 grpc-gateway-example 目录下，新建文件main.go，写入内容：

package main

import "grpc-gateway-example/cmd"

func main() {
    cmd.Execute()
}

当前目录下执行·go run main.go server·，查看输出是否为（此时应为默认值）：

$ go run main.go server
2022/11/10 12:08:22 50052
2022/11/10 12:08:22 grpc-gateway-example                       
2022/11/10 12:08:22 ./certs/server.pem                         
2022/11/10 12:08:22 ./certs/server.key

执行go run main.go server --port=8000 --cert-pem=test-pem --cert-key=test-key --cert-name=test-name，检验命令行参数是否正确：

$ go run main.go server --port=8000 --cert-pem=test-pem --cert-key=test-key --cert-name=test-name
2022/11/10 12:24:53 8000
2022/11/10 12:24:54 test-name
2022/11/10 12:24:54 test-pem 
2022/11/10 12:24:54 test-key

到这都无误，我们的 cmd 模块编写就正确了，下面开始我们的重点

7、目录结构

完成以上操作之后我们的目录是这样的结构，看看是不是缺少了：

grpc-gateway-example/
├── certs
├── client
├── cmd                        // 命令行模块
│   ├── root.go
│   └── server.go
├── pkg
├── proto
│   ├── google
│   │   └── api
│   │   │   ├── annotations.proto
│   │   │   └── http.proto
│   │   └── protobuf
│   │   │   └── descriptor.proto
│   ├── helloworld
│   │   ├── hello.pb.go        // proto编译后文件
│   │   ├── hello.pb.gw.go    // gateway编译后文件
│   │   └── hello_grpc.pb.go// proto编译后接口文件
│   ├── hello.proto
├── server                    // GRPC服务端
│   └── server.go
└── Makefile

四、服务端模块 server

1、编写 hello.proto

在server目录下新建文件 hello.go ，写入文件内容：

package server

import (
    "context"
    "grpc-gateway-example/proto/helloworld"
)

type helloService struct {
    helloworld.UnimplementedHelloServer
}

func NewHelloService() *helloService {
    return &helloService{}
}

// ctx context.Context用于接受上下文参数
// r *pb.HelloWorldRequest用于接受protobuf的Request参数
func (h helloService) SayHello(ctx context.Context, r *helloworld.HelloRequest) (*helloworld.HelloResponse, error) {
    return &helloworld.HelloResponse{
        Message: "hello grpc-gateway",
    }, nil
}

2、编写 grpc.go

在 pkg 下新建 util 目录，新建 grpc.go 文件，写入内容：

package util

import (
    "google.golang.org/grpc"
    "net/http"
    "strings"
)

// 将gRPC请求和HTTP请求分别调用不同的handler处理。
func GrpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
    if otherHandler == nil {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            grpcServer.ServeHTTP(w, r)
        })
    }
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
            grpcServer.ServeHTTP(w, r)
        } else {
            otherHandler.ServeHTTP(w, r)
        }
    })
}

GrpcHandlerFunc 函数是用于判断请求是来源于 Rpc 客户端还是 Restful Api 的请求，根据不同的请求注册不同的 ServeHTTP 服务； r.ProtoMajor == 2 也代表着请求必须基于 HTTP/2。
简而言之函数将gRPC请求和HTTP请求分别调用不同的handler处理。

如果不需要 TLS 建立安全链接，则可以使用h2c：

func GrpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
    return h2c.NewHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
            grpcServer.ServeHTTP(w, r)
        } else {
            otherHandler.ServeHTTP(w, r)
        }
    }), &http2.Server{})
}

3、编写 tls.go

在pkg下的 util 目录下，新建 tls.go 文件，写入内容：

package util

import (
    "crypto/tls"
    "golang.org/x/net/http2"
    "io/ioutil"
    "log"
)

// 用于处理从证书凭证文件（PEM），最终获取tls.Config作为HTTP2的使用参数
func GetTLSConfig(certPemPath, certKeyPath string) *tls.Config {
    var certKeyPair *tls.Certificate
    cert, _ := ioutil.ReadFile(certPemPath)
    key, _ := ioutil.ReadFile(certKeyPath)

    // 从一对PEM编码的数据中解析公钥/私钥对。成功则返回公钥/私钥对
    pair, err := tls.X509KeyPair(cert, key)
    if err != nil {
        log.Println("TLS KeyPair err: %v\n", err)
    }

    certKeyPair = &pair

    return &tls.Config{
        // tls.Certificate：返回一个或多个证书，实质我们解析PEM调用的X509KeyPair的函数声明
        // 就是func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (Certificate, error)，返回值就是Certificate
        Certificates: []tls.Certificate{*certKeyPair},
        // http2.NextProtoTLS：NextProtoTLS是谈判期间的NPN/ALPN协议，用于HTTP/2的TLS设置
        NextProtos: []string{http2.NextProtoTLS},
    }
}

GetTLSConfig 函数是用于获取TLS配置，在内部，我们读取了 server.key 和 server.pem 这类证书凭证文件。经过一系列处理获取 tls.Config 作为 HTTP2 的使用参数。

4、重新编写核心文件 server/server.go

修改server目录下的server.go文件，该文件是我们服务里的核心文件，写入内容：

package server

import (
    "context"
    "crypto/tls"
    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "grpc-gateway-example/pkg/util"
    "grpc-gateway-example/proto/helloworld"
    "log"
    "net"
    "net/http"
)

var (
    ServerPort  string
    CertName    string
    CertPemPath string
    CertKeyPath string
    EndPoint    string
)

func Serve() (err error) {
    EndPoint = ":" + ServerPort
    // 用于监听本地的网络地址通知
    // 它的函数原型func Listen(network, address string) (Listener, error)
    conn, err := net.Listen("tcp", EndPoint)
    if err != nil {
        log.Printf("TCP Listen err:%v\n", err)
    }

    // 通过util.GetTLSConfig解析得到tls.Config，传达给http.Server服务的TLSConfig配置项使用
    tlsConfig := util.GetTLSConfig(CertPemPath, CertKeyPath)
    srv := createInternalServer(conn, tlsConfig)

    log.Printf("gRPC and https listen on: %s\n", ServerPort)

    // NewListener将会创建一个Listener
    // 它接受两个参数，第一个是来自内部Listener的监听器，第二个参数是tls.Config（必须包含至少一个证书）
    if err = srv.Serve(tls.NewListener(conn, tlsConfig)); err != nil {
        log.Printf("ListenAndServe: %v\n", err)
    }

    return err
}

// 将认证的中间件注册进去, 前面所获取的tlsConfig仅能给HTTP使用
func createInternalServer(conn net.Listener, tlsConfig *tls.Config) *http.Server {
    var opts []grpc.ServerOption

    // 输入证书文件和服务器的密钥文件构造TLS证书凭证
    creds, err := credentials.NewServerTLSFromFile(CertPemPath, CertKeyPath)
    if err != nil {
        log.Printf("Failed to create server TLS credentials %v", err)
    }

    // grpc.Creds()其原型为func Creds(c credentials.TransportCredentials) ServerOption
    // 该函数返回 ServerOption，它为服务器连接设置凭据
    opts = append(opts, grpc.Creds(creds))

    // 创建了一个没有注册服务的grpc服务端
    grpcServer := grpc.NewServer(opts...)

    // 注册grpc服务
    helloworld.RegisterHelloServer(grpcServer, NewHelloService())

    // 创建 grpc-gateway 关联组件
    // context.Background()返回一个非空的空上下文。
    // 它没有被注销，没有值，没有过期时间。它通常由主函数、初始化和测试使用，并作为传入请求的顶级上下文
    ctx := context.Background()
    // 从客户端的输入证书文件构造TLS凭证
    dcreds, err := credentials.NewClientTLSFromFile(CertPemPath, CertName)
    if err != nil {
        log.Printf("Failed to create client TLS credentials %v", err)
    }
    // grpc.WithTransportCredentials 配置一个连接级别的安全凭据(例：TLS、SSL)，返回值为type DialOption
    // grpc.DialOption DialOption选项配置我们如何设置连接（其内部具体由多个的DialOption组成，决定其设置连接的内容）
    dopts := []grpc.DialOption{grpc.WithTransportCredentials(dcreds)}

    // 创建HTTP NewServeMux及注册grpc-gateway逻辑
    // runtime.NewServeMux：返回一个新的ServeMux，它的内部映射是空的；
    // ServeMux是grpc-gateway的一个请求多路复用器。它将http请求与模式匹配，并调用相应的处理程序
    gwmux := runtime.NewServeMux()

    // RegisterHelloWorldHandlerFromEndpoint：注册HelloWorld服务的HTTP Handle到grpc端点
    if err := helloworld.RegisterHelloHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
        log.Printf("Failed to register gw server: %v\n", err)
    }

    // http服务
    // 分配并返回一个新的ServeMux
    mux := http.NewServeMux()
    // 为给定模式注册处理程序
    mux.Handle("/", gwmux)

    return &http.Server{
        Addr:      EndPoint,
        Handler:   util.GrpcHandlerFunc(grpcServer, mux),
        TLSConfig: tlsConfig,
    }
}

5、server流程刨析

1）启动监听

net.Listen("tcp", EndPoint) 函数用于监听本地网络地址的监听。其函数原型Listen(ctx context.Context, network, address string) (Listener, error)

参数：

network：必须是tcp, tcp4, tcp6, unix或unixpacket。
address：对于TCP网络，如果address参数中的host为空或未指定的IP地址，则会自动返回一个可用的端口或者IP地址。

net.Listen("tcp", EndPoint)函数返回值是Listener：

type Listener interface {
    // 接受等待并将下一个连接返回给Listener
    Accept() (Conn, error)

    // 关闭Listener
    Close() error

    // 返回 Listener 的网络地址。
    Addr() Addr
}

net.Listen 会返回一个监听器的结构体，返回接下来的动作，让其执行下一步的操作，可用执行以下操作Accept、Close、Addr。

2）获取TLSConfig

通过调用 util.GetTLSConfig 函数解析得到 tls.Config，通过传达给 createInternalServer函数完成 http.Server 服务的 TLSConfig 配置项使用。

3）创建内部服务

程序采用HTTP2、HTTPS，需要支持TLS，在启动 grpc.NewServer() 前需要将serverOptions（服务器选项，类似于中间件，可用设置例如凭证、编解码器和保持存活参数等选项。），而前面所获取的 tlsConfig 仅能给HTTP使用，因此第一步我们要创建 grpc 的 TLS 认证凭证。

创建 grpc 的 TLS 认证凭证

引用 google.golang.org/grpc/credentials 第三方包，credentials 包实现gRPC库支持的各种凭据，这些凭据封装了客户机与服务器进行身份验证所需的所有状态，并进行各种断言，例如，关于客户机的身份、角色或是否授权进行特定调用。

我们调用 NewServerTLSFromFile 它能够从服务器的输入证书文件和密钥文件构造TLS凭据。

func NewServerTLSFromFile(certFile, keyFile string) (TransportCredentials, error) {
    // LoadX509KeyPair从一对文件中读取并解析一个公私钥对。文件中必须包含PEM编码的数据。
    cert, err := tls.LoadX509KeyPair(certFile, keyFile)
    if err != nil {
        return nil, err
    }
    // NewTLS使用tls.Config来构建基于TLS的TransportCredentials（传输凭证）
    return NewTLS(&tls.Config{Certificates: []tls.Certificate{cert}}), nil
}

grpc ServerOption

grpc.Creds() 其原型为func Creds(c credentials.TransportCredentials) ServerOption，返回一个为服务器连接设置凭据的ServerOption。

创建 grpc 服务端

grpc.NewServer() 创建一个没有注册服务的grpc服务端，可以配置 ServerOption

注册grpc服务

// 注册grpc服务
helloworld.RegisterHelloServer(grpcServer, NewHelloService())

创建 grpc-gateway 关联组件

// context.Background()返回一个非空的空上下文。
// 它没有被注销，没有值，没有过期时间。它通常由主函数、初始化和测试使用，并作为传入请求的顶级上下文
ctx := context.Background()
// 从客户端的输入证书文件构造TLS凭证
dcreds, err := credentials.NewClientTLSFromFile(CertPemPath, CertName)
if err != nil {
    log.Printf("Failed to create client TLS credentials %v", err)
}
// grpc.WithTransportCredentials 配置一个连接级别的安全凭据(例：TLS、SSL)，返回值为type DialOption
// grpc.DialOption DialOption选项配置我们如何设置连接（其内部具体由多个的DialOption组成，决定其设置连接的内容）
dopts := []grpc.DialOption{grpc.WithTransportCredentials(dcreds)}

创建HTTP NewServeMux及注册 grpc-gateway 逻辑

// 创建HTTP NewServeMux及注册grpc-gateway逻辑
// runtime.NewServeMux：返回一个新的ServeMux，它的内部映射是空的；
// ServeMux是grpc-gateway的一个请求多路复用器。它将http请求与模式匹配，并调用相应的处理程序
gwmux := runtime.NewServeMux()

// RegisterHelloWorldHandlerFromEndpoint：注册HelloWorld服务的HTTP Handle到grpc端点
if err := helloworld.RegisterHelloHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
    log.Printf("Failed to register gw server: %v\n", err)
}

// http服务
// 分配并返回一个新的ServeMux
mux := http.NewServeMux()
// 为给定模式注册处理程序
mux.Handle("/", gwmux)

注册具体服务

// RegisterHelloWorldHandlerFromEndpoint：注册HelloWorld服务的HTTP Handle到grpc端点
if err := helloworld.RegisterHelloHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
    log.Printf("Failed to register gw server: %v\n", err)
}

ctx：上下文
gwmux：grpc-gateway 的请求多路复用器
EndPoint：服务网络地址
dopts：配置好的安全凭据

4）创建Listener

// NewListener将会创建一个Listener
// 它接受两个参数，第一个是来自内部Listener的监听器，第二个参数是tls.Config（必须包含至少一个证书）
if err = srv.Serve(tls.NewListener(conn, tlsConfig)); err != nil {
    log.Printf("ListenAndServe: %v\n", err)
}

5）服务接受请求

我们调用 srv.Serve(tls.NewListener(conn, tlsConfig))它是http.Server的方法，并且需要一个Listener作为参数。

func (srv *Server) Serve(l net.Listener) error {
    ...
    defer l.Close()
    ...
    baseCtx := context.Background()
    ...
    ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    for {
        rw, e := l.Accept()
        ...
        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew, runHooks) // before Serve can return
        go c.serve(ctx)
    }
}

它创建了一个 context.Background() 上下文对象，并调用 Listener 的 Accept 方法开始接受请求，在获取到连接数据后使用 newConn 创建连接对象，在最后使用goroutine的方式处理连接请求，完成请求后自动关闭连接。

五、验证功能

1、编写 client

在目录client下，创建 main.go 文件，新增以下内容：

package main

import (
    "golang.org/x/net/context"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    "grpc-gateway-example/proto/helloworld"
    "log"
)

func main() {
    creds, err := credentials.NewClientTLSFromFile("./certs/server.pem", "grpc-gateway-example")
    if err != nil {
        log.Println("Failed to create TLS credentials %v", err)
        return
    }
    conn, err := grpc.Dial(":50052", grpc.WithTransportCredentials(creds))
    defer conn.Close()

    if err != nil {
        log.Println(err)
    }

    c := helloworld.NewHelloClient(conn)
    ct := context.Background()
    body := &helloworld.HelloRequest{
        Referer: "Grpc",
    }

    r, err := c.SayHello(ct, body)
    if err != nil {
        log.Println(err)
    }

    log.Println(r)
}

2、启动 & 请求

# 启动服务端
$ go run main.go server
2022/11/10 16:34:06 gRPC and https listen on: 50052

# 启动客户端
$ go run client/main.go
2022/11/10 16:34:43 message:"hello grpc-gateway"

执行测试Restful Api，用POST方式访问https://localhost:50052/hello_world
在这里插入图片描述

六、最终目录结构

grpc-gateway-example/
├── certs                    //证书凭证
│   ├── ca.conf
│   ├── ca.crt
│   ├── ca.csr
│   ├── ca.key
│   ├── server.conf
│   ├── server.csr
│   ├── server.key
│   └── server.pem
├── client                    // 客户端
│   └── main.go
├── cmd                        // 命令行模块
│   ├── root.go
│   └── server.go
├── pkg                        // 第三方公共模块
│   └── util
│   │   │   ├── grpc.go
│   │   │   └── tls.go
├── proto
│   ├── google
│   │   └── api
│   │   │   ├── annotations.proto
│   │   │   └── http.proto
│   │   └── protobuf
│   │   │   └── descriptor.proto
│   ├── helloworld
│   │   ├── hello.pb.go        // proto编译后文件
│   │   ├── hello.pb.gw.go    // gateway编译后文件
│   │   └── hello_grpc.pb.go// proto编译后接口文件
│   ├── hello.proto
├── server                    // GRPC服务端
│   └── server.go
├── main.go
└── Makefile

参考：
https://developer.aliyun.com/article/879486
https://eddycjy.com/posts/go/grpc-gateway/2018-02-27-hello-world/

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

gRPC（八）生态 grpc-gateway 应用：同一个服务端支持Rpc和Restful Api

前言

一、gRPC-Gateway概述

1、简述

2、出现

二、准备工作

1、目录结构

2、环境准备

1）Protobuf

2）gRPC

3）gRPC-Gateway

3、编写 IDL

1）google.api

2）hello.proto

3）编译proto

4、制作证书

1）生成CA根证书

2）生成终端用户证书

三、命令行模块 cmd

1、Cobra介绍

2、概念

3、安装

4、编写 server

5、编写 cmd

6、启动 & 请求

7、目录结构

四、服务端模块 server

1、编写 hello.proto

2、编写 grpc.go

3、编写 tls.go

4、重新编写核心文件 server/server.go

5、server流程刨析

1）启动监听

2）获取TLSConfig

3）创建内部服务

4）创建Listener

5）服务接受请求

五、验证功能

1、编写 client

2、启动 & 请求

六、最终目录结构

热门文章

最新文章

相关电子书

相关实验场景