微服务通讯：gRPC入门教程

骑猪看日落 2024-03-22 16:48 65阅读 0赞

## 微服务通讯：个、RPC入门教程 ##

> gRPC是一个RPC框架，用于服务器之间服务的相互通讯，常见微服务项目开发中。市面上的RPC有很多，例如：dubbo、SpringCloud底层封装的等

### 1 概念 ###

#### 1.1 gRPC ####

>  *  gRPC是一个高性能、开源的通用RPC（远程过程调用remote procedure call）框架。
>  *  gRPC与语言无关，你可以用C++作为服务器，使用Go、Java等作为客户端  
>     ![在这里插入图片描述][0e6626c448b746a6b65ea4bd9ad6e29e.png]
>  *  gPRC会屏蔽底层的细节，client只需要直接定义好方法，就能拿到预期的返回结果，对于Server端来说，还需要实现我们定义的方法。【类比于Java中的Feign，但是feign不是RPC，feign是基于HTTP的，有7层】
>  *  官网地址：https://grpc.io/docs/what-is-grpc/introduction/
>  *  中文教程地址：http://doc.oschina.net/grpc
>  *  gRPC使用了Protocol Buffss（简称`protobuf`），这是谷歌开源的一套成熟的数据结构序列化机制

①服务端编写过程

*  创建gRPC Server对象，你可以理解为它是Serverdaunt抽象的对象
 *  将server（其包含被调用的服务端接口）注册到gRPC Server的内部注册中心
    
    > 这样可以在接收到请求时，通过内部的服务发现，发现该服务端接口并转接进行逻辑处理
 *  创建Listen，监听TCP端口
 *  gRPC Server开始Listen、Accept，直到Stop

②客户端编写

*  创建与给定目标（服务端）的连接交互
 *  创建对应Client对象
 *  发送RPC请求，等待同步响应，得到回调后返回响应结果
 *  输出响应结果

#### 1.2 protobuf ####

##### ①介绍 #####

1.  谷歌开源的一种数据格式，适合高性能
2.  二进制数据格式，需要编码和解码，数据本身不具有可读性，只能反序列化后才能得到真正可读的数据
3.  序列化后体积比json和XML更小，适合网络传输
4.  支持跨平台多语言
5.  序列化、反序列化很快
6.  消息格式升级和兼容性很不错

##### ②安装protobuf #####

1.  进入[对应的GitHub][GitHub]

*  根据自己操作系统下载对应版本：  
    ![在这里插入图片描述][2378c66e41d049b9b54946641992fadd.png]

1.  下载成功后解压并配置环境变量

> 配置为系统环境变量，因为配置为用户环境变量Goland可能不识别

# 打开cmd执行以下命令查看是否配置成功
    protoc

![在这里插入图片描述][bb0a548d93894fad8e830aa997044f50.png]

### 2 gRPC安装及使用 ###

#### 2.1 安装 ####

1.  安装gRPC核心库

// 下载grpc
    go get google.golang.org/grpc
    
    //安装对应工具
    go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
    go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

#### 2.2 使用 ####

##### ①proto文件编写【定义接口】 #####

1.  编写proto文件

hello.proto:

//使用proto3的语法
    syntax = "proto3";
    
    //指明最后生成的go文件夹最后放在哪个目录的哪个包中
    // . 表示当前目录; service表示包名为service
    option go_package = ".;service";
    
    //1. 定义一个服务【SayHello】，服务中可以有对应的方法【SayHello】
    service SayHello {
        
      rpc SayHello(HelloRequest) returns (HelloResponse) {
        }
    }
    
    //关键字：message，可以理解为go中的结构体
    message HelloRequest{
        
      string requestName = 1; //1表示消息顺序
    //  int64 age = 2;
    }
    
    message HelloResponse {
        
      string responseMsg = 1;
    }

1.  执行以下命令，生成对应文件

protoc --go_out=. .\hello.proto
     protoc --go-grpc_out=. hello.proto

![在这里插入图片描述][ef680c9753d549738e04f70576672c65.png]  
3. 将server/proto文件下的hello.pb.go和hello\_grpc.pb.go同时复制一份放在client/ptoro下

> 最终结构：

![在这里插入图片描述][42eea6c0936044bb8ec622ff973853b3.png]

`注意：`

> 如果发现Goland识别不了protoc命令，
> 
>  *  报如下错误：protoc‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件
>  *  解决办法：将protoc配置为系统环境变量，然后重启Goland即可

##### ②服务端编写 #####

*  编写服务端的启动代码  
    main.go:

package main
    
    import (
    	"context"
    	"fmt"
    	"go_code/demo01/grpc/client/proto"
    	"google.golang.org/grpc"
    	"net"
    )
    
    // hello Server
    type server struct {
        
    	proto.UnimplementedSayHelloServer
    }
    
    func (s *server) SayHello(ctx context.Context, req *proto.HelloRequest) (*proto.HelloResponse, error) {
        
    	//服务端实现接口【具体处理逻辑】
    	fmt.Printf("client端远程调用成功..., 传入参数为=%v", req.GetRequestName())
    	return &proto.HelloResponse{
        ResponseMsg: "hello," + req.RequestName}, nil
    }
    
    func main() {
        
    	//1. 开启端口
    	listen, _ := net.Listen("tcp", ":9090")
    	//2. 创建grpc服务
    	grpcServer := grpc.NewServer()
    	//3. 将我们自己编写好的服务注册到grpc
    	proto.RegisterSayHelloServer(grpcServer, &server{
        })
    
    	//4. 启动服务
    	err := grpcServer.Serve(listen)
    	if err != nil {
        
    		fmt.Printf("failed to server: %v", err)
    		return
    	}
    }

整体结构：  
![在这里插入图片描述][21650cc7a9554b56a2cb663e7530e7b4.png]

##### ③客户端编写 #####

main.go:

package main
    
    import (
    	"context"
    	"fmt"
    	pb "go_code/demo01/grpc/server/proto"
    	"google.golang.org/grpc"
    	"google.golang.org/grpc/credentials/insecure"
    	"log"
    )
    
    func main() {
        
    	//1. 与Server建立连接[案例中：此处禁用安全传输，我们这里没有使用加密验证]
    	conn, err := grpc.Dial("127.0.0.1:9090", grpc.WithTransportCredentials(insecure.NewCredentials()))
    	if err != nil {
        
    		log.Fatalf("did not connect: %v", err)
    	}
    	defer conn.Close() //延时关闭连接
    
    	//2. 与对应服务建立连接
    	client := pb.NewSayHelloClient(conn)
    	//3. 执行grpc调用[对应方法已经在对应的Server端实现了]
    	resp, _ := client.SayHello(context.Background(), &pb.HelloRequest{
        RequestName: "curry"})
    	fmt.Println(resp.GetResponseMsg())
    
    }

##### ④测试结果 #####

*  配置goland同时启动多个实例  
    ![在这里插入图片描述][70fdffd6e4e94444809c0b5bc1c1f0eb.png]
 *  启动server和client，查看结果  
    ![在这里插入图片描述][6bca8964204c40fcace765b56ad33d8e.png]

### 3 https及实现grpc加密通信 ###

#### 3.1 加密相关知识 ####

#### 3.2 实现grpc加密通信【基于TLS】 ####

##### 1. 安装openssl并配置环境变量 #####

> 在github上找到对应版本并安装：https://github.com/openssl/openssl/releases

# 在cmd窗口输入以下命令，查看是否配置成功
    openssl

![在这里插入图片描述][344c4352dd7b44ee86837f2ccbcb4c79.png]

##### 2. 生成对应key和证书 #####

> 在上面入门的基础上新建文件夹`key`，通过cmd来到key目录下，执行下面命令

# 1. 生成私钥
    openssl genrsa -out server.key 2048
    
    # 2. 生成证书，全部回车即可，可以不填[就是一些基本信息：国家、地区什么的]
    openssl req -new -x509 -key server.key -out server.crt -days 36500
    
    # 3. 生成csr[同样可以全部回车，不填写任何信息]
    openssl req -new -key server.key -out server.csr

最终效果：  
![在这里插入图片描述][c921451710934d48bc8b54abe9bffc02.png]

##### 3. 配置openssl.cnf #####

> 更改openssl.cnf (Linux上是openssl.cfg)
> 
> 1.  复制一份你安装的openssl的bin目录里面的openssl.cnf文件到你项目所在目录
> 2.  找到\[CA\_default\],打开copy\_extensions = copy (就是把前面的\#去掉)
> 3.  找到\[req\]，打开req\_extensions = v3\_req \# The extensions to add to a certificate request
> 4.  找到\[ v3\_req \]，添加subjectAltName = @alt\_names
> 5.  添加新的标签\[alt\_names\]和标签字段  
>     `DNS.1 = *.ziyi.com`

![在这里插入图片描述][57d6104b3df84d35a3876ce9a08161e1.png]

# 1. 生成证书私钥test.key
    openssl genpkey -algorithm RSA -out test.key
    
    # 2. 通过私钥test.key生成证书请求文件test.csr（注意cfg和cnf，linux上是cfg）
    openssl req -new -nodes -key test.key -out test.csr -days 3650 -subj "/C=cn/OU=myorg/O=mycomp/CN=myname" -config ./openssl.cnf -extensions v3_req
    #test.csr是上面生成的证书请求文件。ca.crt/server.key是CA证书文件和key，用来对test.csr进行签名认证，这两个文件在第2大部分已经生成
    
    # 3. 生成SAN证书 pem
    openssl x509 -req -days 365 -in test.csr -out test.pem -CA server.crt -CAkey server.key -CAcreateserial -extfile ./openssl.cnf -extensions v3_req

##### 4. 编写main.go代码（客户端、服务端） #####

*  服务端

package main
    
    import (
    	"context"
    	"fmt"
    	"go_code/demo01/grpc/client/proto"
    	"google.golang.org/grpc"
    	"google.golang.org/grpc/credentials"
    	"net"
    )
    
    // hello Server
    type server struct {
        
    	proto.UnimplementedSayHelloServer
    }
    
    func (s *server) SayHello(ctx context.Context, req *proto.HelloRequest) (*proto.HelloResponse, error) {
        
    	//服务端实现接口【具体处理逻辑】
    	fmt.Printf("client端远程调用成功..., 传入参数为=%v", req.GetRequestName())
    	return &proto.HelloResponse{
        ResponseMsg: "hello," + req.RequestName}, nil
    }
    
    func main() {
        
    	//TSL认证
    	//两个参数分别是crtFile、keyFile
    	//自带签名证书文件和私钥文件
    	//0. 配置证书和私钥文件
    	creds, _ := credentials.NewServerTLSFromFile("E:\\Go\\GoPro\\src\\go_code\\demo01\\grpc\\key\\test.pem",
    		"E:\\Go\\GoPro\\src\\go_code\\demo01\\grpc\\key\\test.key")
    	//1. 开启端口
    	listen, _ := net.Listen("tcp", ":9090")
    	2. 创建grpc服务
    	//grpcServer := grpc.NewServer()
    	
    	//2. 创建带证书的服务
    	grpcServer := grpc.NewServer(grpc.Creds(creds))
    	//3. 将我们自己编写好的服务注册到grpc
    	proto.RegisterSayHelloServer(grpcServer, &server{
        })
    
    	//4. 启动服务
    	err := grpcServer.Serve(listen)
    	if err != nil {
        
    		fmt.Printf("failed to server: %v", err)
    		return
    	}
    }

结果：  
![在这里插入图片描述][2d86969b235a4ad5bbef5953f5e53bc7.png]

#### 3.3 实现grpc加密通信【基于Token】 ####

##### 1. 认识对应接口 #####

gRPC提供给我们了一个接口，接口中有两个方法，接口位于credentials包下，这个接口需要客户端来实现

type PerRPCCredentials interface {
        
    	/*
    	获取元数据信息，也就是客户端提供了k-v对，
    	context用于控制超时和取消，uri是请求入口处的uri
    	*/
    	GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error)
    
    	/*
    	用于设置是否需要TLS认证进行安全传入，如果返回true则必须加上TLS验证
    	*/
    	RequireTransportSecurity() bool
    }

> token是可以和TLS结合的

##### 2. 编写服务端代码 #####

package main
    
    import (
    	"context"
    	"errors"
    	"fmt"
    	"go_code/demo01/grpc/client/proto"
    	"google.golang.org/grpc"
    	"google.golang.org/grpc/credentials/insecure"
    	"google.golang.org/grpc/metadata"
    	"net"
    )
    
    // hello Server
    type server struct {
        
    	proto.UnimplementedSayHelloServer
    }
    
    // 业务
    func (s *server) SayHello(ctx context.Context, req *proto.HelloRequest) (*proto.HelloResponse, error) {
        
    	fmt.Printf("---------------")
    	//【校验token】
    	//获取客户端传入的元数据信息
    	md, ok := metadata.FromIncomingContext(ctx)
    	if !ok {
        
    		return nil, errors.New("未传输token")
    	}
    	var appId string
    	var appKey string
    	if v, ok := md["appId"]; ok {
        
    		appId = v[0]
    	}
    	if v, ok := md["appKey"]; ok {
        
    		appKey = v[0]
    	}
    
    	if appId != "ziyi" || appKey != "123456" {
        
    		return nil, errors.New("token 不正确")
    	}
    
    	//服务端实现接口【具体处理逻辑】
    	fmt.Printf("client端远程调用成功..., 传入参数为=%v", req.GetRequestName())
    	return &proto.HelloResponse{
        ResponseMsg: "hello," + req.RequestName}, nil
    }
    
    func main() {
        
    	TSL认证
    	两个参数分别是crtFile、keyFile
    	自带签名证书文件和私钥文件
    	0. 配置证书和私钥文件
    	//creds, _ := credentials.NewServerTLSFromFile("E:\\Go\\GoPro\\src\\go_code\\demo01\\grpc\\key\\test.pem",
    	//	"E:\\Go\\GoPro\\src\\go_code\\demo01\\grpc\\key\\test.key")
    
    	//1. 开启端口
    	listen, _ := net.Listen("tcp", ":9090")
    	2. 创建grpc服务
    	//grpcServer := grpc.NewServer()
    
    	//2. 创建带证书的服务
    	grpcServer := grpc.NewServer(grpc.Creds(insecure.NewCredentials()))
    	//3. 将我们自己编写好的服务注册到grpc
    	proto.RegisterSayHelloServer(grpcServer, &server{
        })
    
    	//4. 启动服务
    	err := grpcServer.Serve(listen)
    	if err != nil {
        
    		fmt.Printf("failed to server: %v", err)
    		return
    	}
    }

##### 3. 客户端代码 #####

package main
    
    import (
    	"context"
    	"fmt"
    	pb "go_code/demo01/grpc/server/proto"
    	"google.golang.org/grpc"
    	"google.golang.org/grpc/credentials/insecure"
    	"log"
    )
    
    type ClientTokenAuth struct {
        
    
    }
    
    func (c ClientTokenAuth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error){
        
    	return map[string]string{
        
    		"appId": "ziyi",
    		"appKey": "123456",
    	}, nil
    }
    
    func (c ClientTokenAuth) RequireTransportSecurity() bool {
        
    	return false
    }
    
    func main() {
        
    	0. 设置证书文件test.pem 【因为是测试，故：域名此处写死：*.ziyi.com】，线上应该通过浏览器去获取
    	//creds, _ := credentials.NewClientTLSFromFile("E:\\Go\\GoPro\\src\\go_code\\demo01\\grpc\\key\\test.pem",
    	//	"*.ziyi2.com")
    
    	//1. 与Server建立连接[案例中：此处禁用安全传输，我们这里没有使用加密验证]
    	var opts []grpc.DialOption
    	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials())) //这里我们不使用TLS，因此这里传入空
    	opts = append(opts, grpc.WithPerRPCCredentials(new(ClientTokenAuth))) //传入我们自定义的验证方式【Token】
    	conn, err := grpc.Dial("127.0.0.1:9090", opts...)
    
    	1. 与Server建立带加密的连接
    	//conn, err := grpc.Dial("127.0.0.1", grpc.WithTransportCredentials(creds))
    	if err != nil {
        
    		log.Fatalf("did not connect: %v", err)
    	}
    	defer conn.Close() //延时关闭连接
    
    	//2. 与对应服务建立连接
    	client := pb.NewSayHelloClient(conn)
    	//3. 执行grpc调用[对应方法已经在对应的Server端实现了]
    	resp, _ := client.SayHello(context.Background(), &pb.HelloRequest{
        RequestName: "curry"})
    	fmt.Println(resp.GetResponseMsg())
    
    }

> `总结：`gRPC将各种认证方式浓缩到一个凭证（credentials）上，可以单独使用一种拼争，比如只使用TLS或者只使用自定义凭证，也可以多种凭证组合，gRPC提供统一的gRPC验证机制，使得研发人员使用方便，这也是gRPC设计的巧妙之处

[0e6626c448b746a6b65ea4bd9ad6e29e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3002fc1b393c445ca84c7f0bb6b8921e.png
[GitHub]: https://github.com/protocolbuffers/protobuf/releases
[2378c66e41d049b9b54946641992fadd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2b5fc45ae9f1405a8245d855d8e20b4f.png
[bb0a548d93894fad8e830aa997044f50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bc1ca31c3cb44d7ab06248ca127ddb05.png
[ef680c9753d549738e04f70576672c65.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5222f3d65f004edcaebc4e63d71f9316.png
[42eea6c0936044bb8ec622ff973853b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e8ca9a77f6bf4c6d93eed8442c196419.png
[21650cc7a9554b56a2cb663e7530e7b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/50b3d0ea022d4ced8364bb7471d27db5.png
[70fdffd6e4e94444809c0b5bc1c1f0eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/03f11863dc2341e98b01151dd994d5f6.png
[6bca8964204c40fcace765b56ad33d8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bbc857e27ba0470796f8267a4490d17a.png
[344c4352dd7b44ee86837f2ccbcb4c79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b56b8212a8b7433692611dd2ee4ad3f0.png
[c921451710934d48bc8b54abe9bffc02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bf8cbf58fc59458d964b96207dc6aa63.png
[57d6104b3df84d35a3876ce9a08161e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f91515ad19f24d2a8314c6bade054ad0.png
[2d86969b235a4ad5bbef5953f5e53bc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7e9fff53ceed4d30b9bd15fb03bd8d6a.png