gRPC

# gRPC

数据在进行网络传输的时候，需要进行序列化，序列化协议有很多种，比如 xml, json，protobuf 等

gRPC 默认使用 protocol buffers ，这是 google 开源的一套成熟的结构数据序列化机制。

在学习 gRPC 之前，需要先了解 protocol buffers

序列化：将数据结构或对象转换成二进制串的过程。

反序列化：将在序列化过程中所产生的二进制串转换成数据结构或对象的过程。

# 安装 go

Go 官网下载地址：https://golang.org/dl/ (打开有点慢)

# 配置 go 环境变量

# 配置 GOPATH

GOPATH 是一个环境变量，用来表明你写的 go 项目的存放路径

GOPATH 路径最好只设置一个，所有的项目代码都放到 GOPATH 的 src 目录下。

GOPATH 需要自己手动创建

# 配置 go get 国内镜像

添加系统变量 GO111MODULE 值为 on

代理地址为 GOPROXY

阿里云： https://mirrors.aliyun.com/goproxy

微软： https://goproxy.io

七牛云： https://goproxy.cn

GoCenter： https://gocenter.io=

1
2
3
4
5
6
7

# 服务之间调用

服务拆分后，服务和服务之间发生的是进程和进程之间的调用，服务器和服务器之间的调用。

那么就需要发起网络调用，网络调用我们能立马想起的就是 http，但是在微服务架构中，http 虽然便捷方便，但性能较低，这时候就需要引入 RPC（远程过程调用），通过自定义协议发起 TCP 调用，来加快传输效率。

服务治理中有一个重要的概念 服务发现 ，服务发现中有一个重要的概念叫做 注册中心 。

每个服务启动的时候，会将自身的服务和 ip 注册到注册中心，其他服务调用的时候，只需要向注册中心申请地址即可。

# protobuf

protobuf 是谷歌开源的一种数据格式，适合高性能，对响应速度有要求的数据传输场景。因为 profobuf 是二进制数据格式，需要编码和解码。数据本身不具有可读性。因此只能反序列化之后得到真正可读的数据。

优势：

序列化后体积相比 Json 和 XML 很小，适合网络传输
支持跨平台多语言
消息格式升级和兼容性还不错
序列化反序列化速度很快

# 安装

第一步：下载通用编译器

地址：https://github.com/protocolbuffers/protobuf/releases

根据不同的操作系统，下载不同的包，我是 windows 电脑，解压出来是 protoc.exe

配置环境变量

安装 go 专用的 protoc 的生成器

go get github.com/golang/protobuf/protoc-gen-go

安装后会在 GOPATH 目录下生成可执行文件，protobuf 的编译器插件 protoc-gen-go ，执行 protoc 命令会自动调用这个插件

如何使用 protobuf

定义了一种源文件，扩展名为 .proto ，使用这种源文件，可以定义存储类的内容 (消息类型)
protobuf 有自己的编译器 protoc ，可以将 .proto 编译成对应语言的文件，就可以进行使用了

# hello world

假设，我们现在需要传输用户信息，其中有 username 和 age 两个字段

// 指定的当前proto语法的版本，有2和3
syntax = "proto3";
//option go_package = "path;name"; ath 表示生成的go文件的存放地址，会自动生成目录的
// name 表示生成的go文件所属的包名
option go_package="../service";
// 指定等会文件生成出来的package
package service;

message User {
  string username = 1;
  int32 age = 2;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

运行 protoc 命令编译成 go 中间文件

# 进入到项目文件夹中 即proto存放目录 执行下面命令
# 编译user.proto之后输出到service文件夹
#protoc --go_out=../service user.proto  #提示未创建目录
 protoc --go_out=./ .\user.proto

1
2
3
4

打开 user.pb.go 文件 同步依赖

创建 main.go

package main

import (
   "ProtoProject/service"
   "fmt"
   "google.golang.org/protobuf/proto"
)

func main() {
   user := &service.User{
      Username: "iekr",
      Age:      18,
   }

   marshal, err := proto.Marshal(user)
   if err != nil {
      panic(err)
   }

   //反序列化
   newUser := &service.User{}
   err = proto.Unmarshal(marshal, newUser)
   if err != nil {
      panic(err)
   }
   fmt.Println(newUser.String())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# proto 文件介绍

message ： protobuf 中定义一个消息类型是通过关键字 message 字段指定的。

消息就是需要传输的数据格式的定义。

message 关键字类似于 C++ 中的 class，Java 中的 class，go 中的 struct

例如：

message User {
  string username = 1;
  int32 age = 2;
}

1
2
3
4

在消息中承载的数据分别对应于每一个字段。

其中每个字段都有一个名字和一种类型。

# 字段规则

required : 消息体中必填字段，不设置会导致编解码异常。（例如位置 1）
optional : 消息体中可选字段。（例如位置 2）
repeated : 消息体中可重复字段，重复的值的顺序会被保留（例如位置 3）在 go 中重复的会被定义为切片。

message User {
  string username = 1;
  int32 age = 2;
  optional string password = 3;
  repeated string address = 4;
}

1
2
3
4
5
6

# 字段映射

.proto Type	Notes	C++ Type	Python Type	Go Type
double		double	float	float64
float		float	float	float32
int32	使用变长编码，对于负值的效率很低，如果你的域有可能有负值，请使用 sint64 替代	int32	int	int32
uint32	使用变长编码	uint32	int/long	uint32
uint64	使用变长编码	uint64	int/long	uint64
sint32	使用变长编码，这些编码在负值时比 int32 高效的多	int32	int	int32
sint64	使用变长编码，有符号的整型值。编码时比通常的 int64 高效。	int64	int/long	int64
fixed32	总是 4 个字节，如果数值总是比总是比 228 大的话，这个类型会比 uint32 高效。	uint32	int	uint32
fixed64	总是 8 个字节，如果数值总是比总是比 256 大的话，这个类型会比 uint64 高效。	uint64	int/long	uint64
sfixed32	总是 4 个字节	int32	int	int32
sfixed32	总是 4 个字节	int32	int	int32
sfixed64	总是 8 个字节	int64	int/long	int64
bool		bool	bool	bool
string	一个字符串必须是 UTF-8 编码或者 7-bit ASCII 编码的文本。	string	str/unicode	string
bytes	可能包含任意顺序的字节数据。	string	str	[]byte

# 默认值

protobuf3 删除了 protobuf2 中用来设置默认值的 default 关键字，取而代之的是 protobuf3 为各类型定义的默认值，也就是约定的默认值，如下表所示：

类型	默认值
bool	false
整型	0
string	空字符串 ""
枚举 enum	第一个枚举元素的值，因为 Protobuf3 强制要求第一个枚举元素的值必须是 0，所以枚举的默认值就是 0；
message	不是 null，而是 DEFAULT_INSTANCE

# 标识号

标识号 ：在消息体的定义中，每个字段都必须要有一个唯一的标识号，标识号是 [0,2^29-1] 范围内的一个整数。

message Person { 

  string name = 1;  // (位置1)
  int32 id = 2;  
  optional string email = 3;  
  repeated string phones = 4; // (位置4)
}

1
2
3
4
5
6
7

以 Person 为例，name=1，id=2, email=3, phones=4 中的 1-4 就是标识号。

# 定义多个消息类型

一个 proto 文件中可以定义多个消息类型

message UserRequest {
  string username = 1;
  int32 age = 2;
  optional string password = 3;
  repeated string address = 4;
}

message UserResponse {
  string username = 1;
  int32 age = 2;
  optional string password = 3;
  repeated string address = 4;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

# 嵌套消息

可以在其他消息类型中定义、使用消息类型，在下面的例子中，Person 消息就定义在 PersonInfo 消息内，如：

message PersonInfo {
    message Person {
        string name = 1;
        int32 height = 2;
        repeated int32 weight = 3;
    } 
	repeated Person info = 1;
}

1
2
3
4
5
6
7
8

如果你想在它的父消息类型的外部重用这个消息类型，你需要以 PersonInfo.Person 的形式使用它，如：

message PersonMessage {
	PersonInfo.Person info = 1;
}

1
2
3

当然，你也可以将消息嵌套任意多层，如 :

message Grandpa { // Level 0
    message Father { // Level 1
        message son { // Level 2
            string name = 1;
            int32 age = 2;
    	}
	} 
    message Uncle { // Level 1
        message Son { // Level 2
            string name = 1;
            int32 age = 2;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 定义服务 (Service)

如果想要将消息类型用在 RPC 系统中，可以在.proto 文件中定义一个 RPC 服务接口，protocol buffer 编译器将会根据所选择的不同语言生成服务接口代码及存根。

service SearchService {
	//rpc 服务的函数名 （传入参数）返回（返回参数）
	rpc Search (SearchRequest) returns (SearchResponse);
}

1
2
3
4

上述代表表示，定义了一个 RPC 服务，该方法接收 SearchRequest 返回 SearchResponse

# gRPC 实例

# RPC 和 gRPC 介绍

**RPC（Remote Procedure Call）远程过程调用协议，一种通过网络从远程计算机上请求服务，而不需要了解底层网络技术的协议。**RPC 它假定某些协议的存在，例如 TCP/UDP 等，为通信程序之间携带信息数据。在 OSI 网络七层模型中，RPC 跨越了传输层和应用层，RPC 使得开发包括网络分布式多程序在内的应用程序更加容易。

过程是什么？过程就是业务处理、计算任务，更直白的说，就是程序，就是像调用本地方法一样调用远程的过程

RPC 采用客户端 / 服务端的模式，通过 request-response 消息模式实现

gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。

官方网站：https://grpc.io/

底层协议：

HTTP2: https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
GRPC-WEB ： https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md

# HTTP2

HTTP/1 里的 header 对应 HTTP/2 里的 HEADERS frame
HTTP/1 里的 payload 对应 HTTP/2 里的 DATA frame

gGRPC 把元数据放到 HTTP/2 Headers 里，请求参数序列化之后放到 DATA frame 里

基于 HTTP/2 协议的优点

公开标准
HTTP/2 的前身是 Google 的 SPDY (opens new window) ，有经过实践检验
HTTP/2 天然支持物联网、手机、浏览器
基于 HTTP/2 多语言客户端实现容易
1. 每个流行的编程语言都会有成熟的 HTTP/2 Client
2. HTTP/2 Client 是经过充分测试，可靠的
3. 用 Client 发送 HTTP/2 请求的难度远低于用 socket 发送数据包 / 解析数据包
HTTP/2 支持 Stream 和流控
基于 HTTP/2 在 Gateway/Proxy 很容易支持
1. nginx 和 envoy 都有支持
HTTP/2 安全性有保证
1. HTTP/2 天然支持 SSL，当然 gRPC 可以跑在 clear text 协议（即不加密）上。
2. 很多私有协议的 rpc 可能自己包装了一层 TLS 支持，使用起来也非常复杂。开发者是否有足够的安全知识？使用者是否配置对了？运维者是否能正确理解？
3. HTTP/2 在公有网络上的传输上有保证。比如这个 CRIME 攻击 (opens new window)，私有协议很难保证没有这样子的漏洞。
HTTP/2 鉴权成熟
1. 从 HTTP/1 发展起来的鉴权系统已经很成熟了，可以无缝用在 HTTP/2 上
2. 可以从前端到后端完全打通的鉴权，不需要做任何转换适配

基于 HTTP/2 协议的缺点

rpc 的元数据的传输不够高效

尽管 HPAC 可以压缩 HTTP Header，但是对于 rpc 来说，确定一个函数调用，可以简化为一个 int，只要两端去协商过一次，后面直接查表就可以了，不需要像 HPAC 那样编码解码。可以考虑专门对 gRPC 做一个优化过的 HTTP/2 解析器，减少一些通用的处理，感觉可以提升性能。
HTTP/2 里一次 gRPC 调用需要解码两次

一次是 HEADERS frame，一次是 DATA frame。
HTTP/2 标准本身是只有一个 TCP 连接，但是实际在 gRPC 里是会有多个 TCP 连接，使用时需要注意。

gRPC 选择基于 HTTP/2，那么它的性能肯定不会是最顶尖的。但是对于 rpc 来说中庸的 qps 可以接受，通用和兼容性才是最重要的事情。

官方的 benchmark：https://grpc.io/docs/guides/benchmarking.html
https://github.com/hank-whu/rpc-benchmark

gRPC 目前是 k8s 生态里的事实标准，而 Kubernetes 又是容器编排的事实标准。gRPC 已经广泛应用于 Istio 体系，包括:

Envoy 与 Pilot (现在叫 istiod) 间的 XDS 协议
mixer 的 handler 扩展协议
MCP (控制面的配置分发协议)

在 Cloud Native 的潮流下，开放互通的需求必然会产生基于 HTTP/2 的 RPC。

# 实例

# 服务端

protobuf.proto

// 这个就是protobuf的中间文件

// 指定的当前proto语法的版本，有2和3
syntax = "proto3";
option go_package="../service";

// 指定等会文件生成出来的package
package service;

// 定义request model
message ProductRequest{
  int32 prod_id = 1; // 1代表顺序
}

// 定义response model
message ProductResponse{
  int32 prod_stock = 1; // 1代表顺序
}

// 定义服务主体
service ProdService{
  // 定义方法
  rpc GetProductStock(ProductRequest) returns(ProductResponse);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

生成：需要指定 grpc 插件

protoc --go_out=plugins=grpc:./ .\product.proto

服务端使用：

package main

import (
	"ProtoProject/service"
	"fmt"
	"google.golang.org/grpc"
	"log"
	"net"
)

func main() {
	rpcServer := grpc.NewServer()

	service.RegisterProdServiceServer(rpcServer, service.ProductService)

	//启动服务
	listenr, err := net.Listen("tcp", ":8002")
	if err != nil {
		log.Fatal("启动监听出错", err)
	}
	err = rpcServer.Serve(listenr)
	if err != nil {
		log.Fatal("启动服务出错", err)
	}
	fmt.Println("启动grpc服务端成功")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 客户端

新建 client 包 grpc_client 类

package main

import (
   "ProtoProject/service"
   "context"
   "fmt"
   "google.golang.org/grpc"
   "google.golang.org/grpc/credentials/insecure"
   "log"
)

func main() {
   conn, err := grpc.Dial(":8002", grpc.WithTransportCredentials(insecure.NewCredentials()))
   if err != nil {
      log.Fatal("服务端出错连接失败")
   }

   defer conn.Close()

   prodClient := service.NewProdServiceClient(conn)

   request := &service.ProductRequest{ProdId: 123}
   stockResponse, err := prodClient.GetProductStock(context.Background(), request)
   if err != nil {
      log.Fatal("查询库存出错", err)
   }
   fmt.Println("查询成功", stockResponse)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在 client 包新建 service 包将 protobuf 生成的 product.pb.go 复制一份到 service 包中

# 认证

TLS（Transport Layer Security，安全传输层)，TLS 是建立在 传输层 TCP 协议之上的协议，服务于应用层，它的前身是 SSL（Secure Socket Layer，安全套接字层），它实现了将应用层的报文进行加密后再交由 TCP 进行传输的功能。

TLS 协议主要解决如下三个网络安全问题。

保密 (message privacy)，保密通过加密 encryption 实现，所有信息都加密传输，第三方无法嗅探；
完整性 (message integrity)，通过 MAC 校验机制，一旦被篡改，通信双方会立刻发现；
认证 (mutual authentication)，双方认证，双方都可以配备证书，防止身份被冒充

# 生成自签证书

安装 openssl 选择 140MB 的 5mb 多没有 cnf 配置文件并配置环境变量

网站下载：http://slproweb.com/products/Win32OpenSSL.html
在项目中创建存放证书的目录

生成私钥文件

## 需要输入密码
openssl genrsa -des3 -out ca.key 2048

1
2

创建证书请求

openssl req -new -key ca.key -out ca.csr
# 输入密码 并填写信息 可以为空

1
2

生成 ca.crt

openssl x509 -req -days 365 -in ca.csr -signkey ca.key -out ca.crt
#输入密码

1
2

找到 openssl.cnf 文件在 OpenSSL 的 bin\cnf 目录下

将 openssl.cnf 复制一份拷贝到当前项目的证书文件夹下
打开 copy_extensions = copy
打开 req_extensions = v3_req
找到 [v3_req], 添加 subjectAltName = @alt_names

添加新的标签 [alt_names] , 和标签字段

[ alt_names ]

DNS.1 = *.mszlu.com  # 匹配域名
#可以配置多个
#DNS.2 = *.com

1
2
3
4
5

生成证书私钥 server.key

openssl genpkey -algorithm RSA -out server.key

通过私钥 server.key 生成证书请求文件 server.csr

openssl req -new -nodes -key server.key -out server.csr -days 3650 -config ./openssl.cnf -extensions v3_req

生成 SAN 证书

openssl x509 -req -days 365 -in server.csr -out server.pem -CA ca.crt -CAkey ca.key -CAcreateserial -extfile ./openssl.cnf -extensions v3_req
#输入密码

1
2

key： 服务器上的私钥文件，用于对发送给客户端数据的加密，以及对从客户端接收到数据的解密。
csr： 证书签名请求文件，用于提交给证书颁发机构（CA）对证书签名。
crt： 由证书颁发机构（CA）签名后的证书，或者是开发者自签名的证书，包含证书持有人的信息，持有人的公钥，以及签署者的签名等信息。
pem： 是基于 Base64 编码的证书格式，扩展名包括 PEM、CRT 和 CER。

什么是 SAN？

SAN（Subject Alternative Name）是 SSL 标准 x509 中定义的一个扩展。使用了 SAN 字段的 SSL 证书，可以扩展此证书支持的域名，使得一个证书可以支持多个不同域名的解析。

# 服务端应用证书

将 server.key 和 server.pem copy 到项目中

在 server 端添加证书编码

package main

import (
	"ProtoProject/service"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"log"
	"net"
)

func main() {
	//添加证书
	creds, err2 := credentials.NewServerTLSFromFile("cert/server.pem", "cert/server.key")
	if err2 != nil {
		log.Fatal("证书生成错误", err2)
	}

	//创建服务器时 添加证书
	rpcServer := grpc.NewServer(grpc.Creds(creds))

	//注册一个服务
	service.RegisterProdServiceServer(rpcServer, service.ProductService)

	//启动服务
	listenr, err := net.Listen("tcp", ":8002")
	if err != nil {
		log.Fatal("启动监听出错", err)
	}
	err = rpcServer.Serve(listenr)
	if err != nil {
		log.Fatal("启动服务出错", err)
	}
	fmt.Println("启动grpc服务端成功")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 客户端认证

将公钥 copy 到客户端

package main

import (
	"ProtoProject/service"
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"log"
)

func main() {

	creds, eer := credentials.NewClientTLSFromFile("cert/server.pem", "*.mszlu.com")
	if eer != nil {
		log.Fatal("证书错误")
	}

	conn, err := grpc.Dial(":8002", grpc.WithTransportCredentials(creds))
	if err != nil {
		log.Fatal("服务端出错连接失败")
	}

	defer conn.Close()

	prodClient := service.NewProdServiceClient(conn)

	request := &service.ProductRequest{ProdId: 123}
	stockResponse, err := prodClient.GetProductStock(context.Background(), request)
	if err != nil {
		log.Fatal("查询库存出错", err)
	}
	fmt.Println("查询成功", stockResponse)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

上述认证方式为单向认证：

1586953-20210625171059706-1447106002-16509094111532

中间人攻击

# 双向认证

上面的 server.pem 和 server.key 是服务端的公钥和私钥。

如果双向认证，客户端也需要生成对应的公钥和私钥。

私钥：

openssl genpkey -algorithm RSA -out client.key

证书:

openssl req -new -nodes -key client.key -out client.csr -days 3650 -config ./openssl.cnf -extensions v3_req

SAN 证书：

openssl x509 -req -days 365 -in client.csr -out client.pem -CA ca.crt -CAkey ca.key -CAcreateserial -extfile ./openssl.cnf -extensions v3_req
#输入密码

1
2

服务端：

package main

import (
	"ProtoProject/service"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io/ioutil"
	"log"
	"net"
)

func main() {

	/*	//添加证书
		creds, err2 := credentials.NewServerTLSFromFile("cert/server.pem", "cert/server.key")
		if err2 != nil {
			log.Fatal("证书生成错误", err2)
		}
	*/
	cert, err := tls.LoadX509KeyPair("cert/server.pem", "cert/server.key")
	if err != nil {
		log.Fatal("证书读取错误", err)
	}
	// 创建一个新的、空的 CertPool
	certPool := x509.NewCertPool()
	ca, err := ioutil.ReadFile("cert/ca.crt")
	if err != nil {
		log.Fatal("ca证书读取错误", err)
	}
	// 尝试解析所传入的 PEM 编码的证书。如果解析成功会将其加到 CertPool 中，便于后面的使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于 TLS 的 TransportCredentials 选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链，允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		// 要求必须校验客户端的证书。可以根据实际情况选用以下参数
		ClientAuth: tls.RequireAndVerifyClientCert,
		// 设置根证书的集合，校验方式使用 ClientAuth 中设定的模式
		ClientCAs: certPool,
	})

	//创建服务器时 添加证书
	rpcServer := grpc.NewServer(grpc.Creds(creds))

	//注册一个服务
	service.RegisterProdServiceServer(rpcServer, service.ProductService)

	//启动服务
	listenr, err := net.Listen("tcp", ":8002")
	if err != nil {
		log.Fatal("启动监听出错", err)
	}
	err = rpcServer.Serve(listenr)
	if err != nil {
		log.Fatal("启动服务出错", err)
	}
	fmt.Println("启动grpc服务端成功")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

客户端：

package main

import (
	"ProtoProject/service"
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io/ioutil"
	"log"
)

func main() {

	/*	creds, eer := credentials.NewClientTLSFromFile("cert/server.pem", "*.mszlu.com")
		if eer != nil {
			log.Fatal("证书错误")
		}*/
	cert, _ := tls.LoadX509KeyPair("cert/client.pem", "cert/client.key")
	// 创建一个新的、空的 CertPool
	certPool := x509.NewCertPool()
	ca, _ := ioutil.ReadFile("cert/ca.crt")
	// 尝试解析所传入的 PEM 编码的证书。如果解析成功会将其加到 CertPool 中，便于后面的使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于 TLS 的 TransportCredentials 选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链，允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		// 要求必须校验客户端的证书。可以根据实际情况选用以下参数
		ServerName: "*.mszlu.com",
		RootCAs:    certPool,
	})

	conn, err := grpc.Dial(":8002", grpc.WithTransportCredentials(creds))
	if err != nil {
		log.Fatal("服务端出错连接失败")
	}

	defer conn.Close()

	prodClient := service.NewProdServiceClient(conn)

	request := &service.ProductRequest{ProdId: 123}
	stockResponse, err := prodClient.GetProductStock(context.Background(), request)
	if err != nil {
		log.Fatal("查询库存出错", err)
	}
	fmt.Println("查询成功", stockResponse)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# Token 认证

# 服务端添加用户名密码的校验

在 grpc_server 添加拦截请求

package main

import (
	"ProtoProject/service"
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
	"io/ioutil"
	"log"
	"net"
)

func main() {

	/*	//添加证书
		creds, err2 := credentials.NewServerTLSFromFile("cert/server.pem", "cert/server.key")
		if err2 != nil {
			log.Fatal("证书生成错误", err2)
		}
	*/
	cert, err := tls.LoadX509KeyPair("cert/server.pem", "cert/server.key")
	if err != nil {
		log.Fatal("证书读取错误", err)
	}
	// 创建一个新的、空的 CertPool
	certPool := x509.NewCertPool()
	ca, err := ioutil.ReadFile("cert/ca.crt")
	if err != nil {
		log.Fatal("ca证书读取错误", err)
	}
	// 尝试解析所传入的 PEM 编码的证书。如果解析成功会将其加到 CertPool 中，便于后面的使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于 TLS 的 TransportCredentials 选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链，允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		// 要求必须校验客户端的证书。可以根据实际情况选用以下参数
		ClientAuth: tls.RequireAndVerifyClientCert,
		// 设置根证书的集合，校验方式使用 ClientAuth 中设定的模式
		ClientCAs: certPool,
	})

	//实现token认证 需要合法的用户名和密码
	//定义一个拦截器
	var authInterceptor grpc.UnaryServerInterceptor
	authInterceptor = func(
		ctx context.Context,
		req interface{},
		info *grpc.UnaryServerInfo,
		handler grpc.UnaryHandler,
	) (resp interface{}, err error) {
		//拦截普通方法请求，验证 Token
		err = Auth(ctx)
		if err != nil {
			return
		}
		// 继续处理请求
		return handler(ctx, req)
	}
	//创建服务器时 添加证书
	rpcServer := grpc.NewServer(grpc.Creds(creds), grpc.UnaryInterceptor(authInterceptor))

	//注册一个服务
	service.RegisterProdServiceServer(rpcServer, service.ProductService)

	//启动服务
	listenr, err := net.Listen("tcp", ":8002")
	if err != nil {
		log.Fatal("启动监听出错", err)
	}
	err = rpcServer.Serve(listenr)
	if err != nil {
		log.Fatal("启动服务出错", err)
	}
	fmt.Println("启动grpc服务端成功")
}

func Auth(ctx context.Context) error {
	//实际上就是拿到  拿到传输用户名和密码
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return fmt.Errorf("missing credentials")
	}
	var user string
	var password string

	if val, ok := md["user"]; ok {
		user = val[0]
	}
	if val, ok := md["password"]; ok {
		password = val[0]
	}

	if user != "admin" || password != "admin" {
		return status.Errorf(codes.Unauthenticated, "token不合法")
	}
	return nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

# 客户端实现

客户端需要实现 PerRPCCredentials 接口。

type PerRPCCredentials interface {
	// GetRequestMetadata gets the current request metadata, refreshing
	// tokens if required. This should be called by the transport layer on
	// each request, and the data should be populated in headers or other
	// context. If a status code is returned, it will be used as the status
	// for the RPC. uri is the URI of the entry point for the request.
	// When supported by the underlying implementation, ctx can be used for
	// timeout and cancellation. Additionally, RequestInfo data will be
	// available via ctx to this call.
	// TODO(zhaoq): Define the set of the qualified keys instead of leaving
	// it as an arbitrary string.
	GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error)
	// RequireTransportSecurity indicates whether the credentials requires
	// transport security.
	RequireTransportSecurity() bool
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

GetRequestMetadata 方法返回认证需要的必要信息， RequireTransportSecurity 方法表示是否启用安全链接，在生产环境中，一般都是启用的，但为了测试方便，暂时这里不启用了。

实现接口：

在 client 包下创建 auth 包新建 auth 接口

package auth

import "context"

type Authentication struct {
	User     string
	Password string
}

func (a *Authentication) GetRequestMetadata(context.Context, ...string) (
	map[string]string, error,
) {
	return map[string]string{"user": a.User, "password": a.Password}, nil
}

func (a *Authentication) RequireTransportSecurity() bool {
	return false
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在 client 实现类中添加 auth 接口并实现创建客户端时传入改实现

	//使用jwt oauth等认证
	token := &auth.Authentication{
		User:     "admin",
		Password: "admin",
	}

	conn, err := grpc.Dial(":8002", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))

1
2
3
4
5
6
7

编辑

上次更新: 2023/12/06, 01:31:48

← 性能调优 Kubernetes（K8S）→