go 微服务(3) gRPC

golang.png

RPC

gRPC 是由 Google 主导开发的 RPC 框架，使用HTTP/2协议并用ProtoBuf作为序列化工具。

grpc_logo.png

RPC 主流框架

Dubbo
Motan
Thrift
gRPC

这些是当前主流的一些 RPC 框架，其中 Dubbo 是阿里推出的 RPC 框架，开始只支持 java 现在也支持多语言，Thrift 和 gRPC 是最近流行起来的 RPC 框架，而且支持多语言。接下来我们就重点地说一说 gRPC

gRPC

在 gRPC 是 google 推出的，google 的东西主要推崇是效率，所以相对于其他 RPC 框架 gRPC 就在性能方面还是具有一定优势的。gRPC 是一款中立语言，可以在多种环境下运行，随后我们就不以 go 来而做实例而是用 nodejs 写一个 gRPC 的例子。我们可以用不同语言来写客户端和服务端。

客户端/服务端通讯

SOAP, REST, GraphQL
SSE, WebSockets
Raw TCP

客户端库带来的问题

通讯协议需要客户端库
- SOAP Library
- HTTP Client Library
  正常运行在浏览器是没有问题，因为浏览器支持 HTTP client library 但是如果只是一个 go 应用、python 应用或者运行在 V8 引擎上 nodejs 应用，我们就需要引入 HTTP client library。
Hard to maintain and patch client libraries
- HTTP/1.1 HTTP/2 new features, security etc.

Why gRPC was invented

客户端: One library for popular languages
协议: gRPC 支持 HTTP/2(隐式支持)
消息格式: Protocol buffers as format

gRPC 模式

Unary gRPC（一元操作）
Server streaming RPC(服务器流)
Client Streaming RPC(客户端流)
Bidirectional streaming RPC（双向流)

OIP.jpeg

 npm init -y

创建 proto 文件(todo.proto)

定义好 proto 文件，然后可以根据 proto 文件被编译为目标语言，这里定义 todo.proto,

syntax = "proto3";

package todoPackage;

service Todo{
   rpc createTodo(TodoItem) returns (TodoItem);
   rpc readTodos(void) returns (TodoItems);
}

message void{

}

message TodoItem {
   int32 id = 1;
   string text = 2;
}

message TodoItems{
   repeated TodoItem items = 1;
}

除了结构语句，都需要使用分号(;)结尾
package 表示包，主要是命名空间
结构定义
- message 类型用于定义方法的参数和返回类型，message 定义结构体名称首字母大写，遵循驼峰命名，字段命名一般小写int32 id = 1;，后面数字 1 表示字段位置，这里多说一句，字段编码是不可以重复是唯一的，编码 1 - 15 范围是效率最高的，大于 15 会随着编码增加时间和空间效率降低。
- enum
service 相当于定义接口，在接口里有很多方法，内部提供一些 rpc 方法，rpc 方法名一般也是采用驼峰命名规则。
修饰词，修饰词是针对字段，主要修饰和说明字段
- required 是必填字段
- optional 可选字段
- repeated repeated TodoItem items = 1; 表示列表形式数据类型
数据类型

引入依赖

npm install grpc @grpc/proto-loader

grpc

grpc/proto-loader

proto-loader 用于加载 gRPC 中使用到的的.proto文件。

const grpc = require("grpc");

const protoLoader = require("@grpc/proto-loader")

const packageDef = protoLoader.loadSync("todo.proto",{});
const grpcObject = grpc.loadPackageDefinition(packageDef);
const todoPackage = grpcObject.todoPackage;

nodejs rpc 文档

protoLoader 加载 todo.proto 文件返回一个 packageDef(对象),loadSync 可以自定义加载选项，这里我们只用默认选项所以只传入空对象
通过调用 grpc 的 loadPackageDefinition 将加载 proto 文件输出 grpc 库

创建 gRPC 服务端

const server = new grpc.Server();
server.bind("0.0.0.0:40000",grpc.ServerCredentials.createInsecure());
server.addService(todoPackage.Todo.service,{
    "createTodo":createTodo,
    "readTodos":readTodos,
    "readTodosStream":readTodosStream
});
server.start();

我们之前提价在 proto 中定义接口，也就是一种协议，这些接口方法实现还需要我们语言进行实现。

创建服务const server = new grpc.Server();
将服务绑定到 localhost 的 40000 端口上，因为 gRPC 背后是 http2 协议，所以需要提供ServerCredentials.createInsecure()

const todos = []

function createTodo(call,callback){
    console.log(call);
}

在 createTodo 方法两个参数，call 是客户端调用 createtodo 传入对象这是一个结构体，我们暂时只是对其打印输出，通过 callback 可以从服务端向客户端传输数据。

创建 gRPC 客户端

首先是引入依赖这个服务端一样，复制代码即可

const grpc = require("grpc");

const protoLoader = require("@grpc/proto-loader")

//
const packageDef = protoLoader.loadSync("todo.proto",{});
const grpcObject = grpc.loadPackageDefinition(packageDef);
const todoPackage = grpcObject.todoPackage;

const client = new todoPackage.Todo("localhost:40000",
    grpc.credentials.createInsecure());

定义请求指定地址的服务端的客户端

client.createTodo({
    "id":-1,
    "text":"hello"
},(err,response) => {
    console.log("Recieved from server " + JSON.stringify(response))
})

客户端发起请求传输数据给服务端，createTodo 第一个参数消息结构体，第二个参数是一个回调在 response 可以接受服务端返回数据

下面为服务端输出 call 结构体，request 字段对象为客户端请求服务端输入的数据

ServerUnaryCall {
  domain: null,
  _events: { error: [Function] },
  _eventsCount: 1,
  _maxListeners: undefined,
  call: Call {},
  cancelled: false,
  metadata: Metadata { _internal_repr: { 'user-agent': [Array] }, flags: 0 },
  request: { id: -1, text: 'test' } }

在服务端定义 todos 数据用于模拟 todo 的存储

const todos = []

对 createTodo 进行调整，将从客户端传入数据进行保存后，并将新增的 todo 对象返回给客户端。

function createTodo(call,callback){
    const todoItem = {
        "id":todos.length + 1,
        "text":call.request.text
    }
    todos.push(todoItem)
    // console.log(call);
    callback(null,todoItem);
}

运行程序后我们可以客户端看到从服务端返回的数据

Recieved from server {"id":3,"text":"test"}

const text = process.argv[2]

client.createTodo({
    "id":-1,
    "text":text
},(err,response) => {
    console.log("Recieved from server " + JSON.stringify(response))
})

服务端以流形式传输数据给客户端

service Todo{
    rpc createTodo(TodoItem) returns (TodoItem);
    rpc readTodos(voidNoParam) returns (TodoItems);
    rpc readTodosStream(voidNoParam) returns (stream TodoItem);
    
}

服务端实现 readTodosStream

function readTodosStream(call,callback){
    todos.forEach( t => call.write(t));
    call.end();
}

客户端实现 readTodosStream

const call = client.readTodosStream();
call.on("data",item => {
    console.log("received item form server " + JSON.stringify(item))
})

call.on("end",e => console.log("server done!"))

received item form server {"id":1,"text":"hello"}
received item form server {"id":2,"text":"hello"}
Recieved from server {"items":[{"id":1,"text":"hello"},{"id":2,"text":"hello"},{"id":3,"text":"world"}]}
Recieved from server {"id":4,"text":"zidea"}
received item form server {"id":3,"text":"world"}
server done!