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、启动 & 请求
  • 六、最终目录结构

前言

个人网站: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_第1张图片

二、准备工作

由于本实践偏向 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

gRPC(八)生态 grpc-gateway 应用:同一个服务端支持Rpc和Restful Api_第2张图片

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

gRPC(八)生态 grpc-gateway 应用:同一个服务端支持Rpc和Restful Api_第3张图片

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

三、命令行模块 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
  2. 注册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(八)生态 grpc-gateway 应用:同一个服务端支持Rpc和Restful Api_第4张图片

六、最终目录结构

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/

你可能感兴趣的:(Grpc,restful,gateway,rpc,网络,微服务)