gRPC(八)生态 grpc-gateway 应用:同一个服务端支持Rpc和Restful Api

简介: 版权声明:本文为博主原创文章,未经博主允许不得转载。https://blog.csdn.net/weixin_46618592/article/details/127776709?spm=1001.2014.3001.5501

前言

个人网站: 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
  1. 生成ca私钥,得到ca.key
openssl genrsa -out ca.key 4096
  1. 生成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]:
  1. 生成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
  1. 生成私钥,得到server.key
openssl genrsa -out server.key 2048
  1. 生成证书签发请求,得到server.csr
openssl req -new -sha256 -out server.csr -key server.key -config server.conf

这里也一直回车就好。

  1. 用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 appnamecobra add cmdname
  • 提供智能提示
  • 自动生成commands和flags的帮助信息
  • 自动生成详细的 help 信息,如 app -help。
  • 自动识别帮助 flag、 -h,--help
  • 自动生成应用程序在 bash 下命令自动完成功能。
  • 自动生成应用程序的 man 手册。
  • 命令行别名。
  • 自定义 helpusage 信息。
  • 可选的与 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 认证凭证。

  1. 创建 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
}
  1. grpc ServerOption

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

  1. 创建 grpc 服务端

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

  1. 注册grpc服务
// 注册grpc服务
helloworld.RegisterHelloServer(grpcServer, NewHelloService())
  1. 创建 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)}
  1. 创建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)
  1. 注册具体服务
// 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/

目录
相关文章
|
1天前
|
Java API 网络架构
【Spring Boot】详解restful api
【Spring Boot】详解restful api
8 0
|
2天前
|
缓存 安全 API
构建高效API:RESTful设计原则与实践
【6月更文挑战第10天】在数字化时代,API作为不同软件组件之间通信的桥梁,其设计质量直接影响到应用的性能和用户体验。本文深入探讨了RESTful API的设计原则,并通过实际案例分析如何构建高效、可扩展且安全的API。我们将从资源定义、接口一致性、错误处理等方面入手,逐步揭示如何优化API设计,以满足不断变化的技术需求和业务目标。
|
2天前
|
缓存 监控 API
探索RESTful API设计的最佳实践
【6月更文挑战第10天】在数字化时代,API作为不同软件系统间通信的桥梁,其设计至关重要。本文旨在揭示如何构建高效、可维护且用户友好的RESTful API,涵盖从基础原则到高级技巧,为开发者提供一条清晰的道路,以实现最佳的API设计实践。
|
2天前
|
运维 Serverless API
Serverless 应用引擎产品使用合集之SD API模式可以通过什么方式进行访问
阿里云Serverless 应用引擎(SAE)提供了完整的微服务应用生命周期管理能力,包括应用部署、服务治理、开发运维、资源管理等功能,并通过扩展功能支持多环境管理、API Gateway、事件驱动等高级应用场景,帮助企业快速构建、部署、运维和扩展微服务架构,实现Serverless化的应用部署与运维模式。以下是对SAE产品使用合集的概述,包括应用管理、服务治理、开发运维、资源管理等方面。
|
2天前
|
SQL 缓存 测试技术
RESTful API设计的最佳实践:构建高效、可维护的Web服务接口
【6月更文挑战第11天】构建高效、可维护的RESTful API涉及多个最佳实践:遵循客户端-服务器架构、无状态性等REST原则;设计时考虑URL结构(动词+宾语,使用标准HTTP方法)、使用HTTP状态码、统一响应格式及错误处理;确保数据安全(HTTPS、认证授权、输入验证);实施版本控制;并提供详细文档和测试用例。这些实践能提升Web服务接口的性能和质量。
|
2天前
|
JavaScript 关系型数据库 Serverless
Serverless 应用引擎操作报错合集之在调用stable Diffusion函数计算api接口返回,报错:"Not Found"一般是什么原因
Serverless 应用引擎(SAE)是阿里云提供的Serverless PaaS平台,支持Spring Cloud、Dubbo、HSF等主流微服务框架,简化应用的部署、运维和弹性伸缩。在使用SAE过程中,可能会遇到各种操作报错。以下是一些常见的报错情况及其可能的原因和解决方法。
|
3天前
|
移动开发 监控 API
WebSocket API 详解与应用指南
WebSocket API 是HTML5的一种技术,它允许服务器与客户端建立持久的全双工连接,改变传统HTTP请求-响应模式,实现双向通信。API包括WebSocket构造函数、连接状态属性(如readyState)、方法(如send和close)及事件(如onopen和onmessage)。它简化了实时Web应用程序的开发,适用于在线聊天、实时数据监控等场景。
11 5
|
4天前
|
设计模式 安全 API
深入理解RESTful API设计原则与实践
本文深入探讨了RESTful API设计的原则与实践,从HTTP方法的选择、资源的命名、状态码的运用以及安全性等方面进行了详细分析。通过对常见的设计模式和最佳实践的解读,读者将能够更好地理解和应用RESTful API设计,提升自身的技术水平。
|
6天前
|
JSON 前端开发 API
Apache HttpClient调用Spring3 MVC Restful Web API演示
Apache HttpClient调用Spring3 MVC Restful Web API演示
11 1
|
7天前
|
机器学习/深度学习 自然语言处理 监控
从数据到决策:拼多多商品详情API在市场分析中的应用
本文探讨了如何利用拼多多商品详情API进行市场分析,该API提供商品基本信息、价格销量、用户评价和商品属性等数据,助力商家和分析师理解消费者行为、预测市场趋势、分析竞争环境及优化产品策略。通过数据收集、分析和整合,企业可借助此工具制定精准市场策略。案例展示了市场趋势、竞争情报和用户评价情感分析的应用。未来,随着技术进步,此类API的应用将更加广泛,推动电商行业创新。