gRPC初探——概念介绍以及如何构建一个简单的gRPC服务

1. gRPC简介
2. 使用Protocol Buffers进行服务定义
- 2.1 定义消息
- 2.2 定义服务接口
3.构建简单的gRPC服务
4. 总结
5. 参考资料

对于分布式系统而言,不同的服务分布在不同的节点上,一个服务要完成自己的功能经常需要调用其他服务的接口,比如典型的微服务架构。通常这种服务调用方式有两种,一种是发送HTTP请求的方式,另一种则是RPC的方式,RPC是Remote Procedure Call(远程过程调用)的简称,可以让我们像调用本地接口一样使用远程服务。相比HTTP调用,RPC的方式至少在以下几个方面有优势

传输效率

RPC可以自定义TCP报文,基于TCP协议进行通信,比如dubbo;同时也支持使用HTTP2协议进行通信,比如gRPC。这相比传统的HTTP1.1协议报文体积会更小,传输效率会更高。
性能消耗

RPC框架通常自带高效的序列化机制,序列化和反序列化耗时更低,序列化后的字节数通常也更小。
负责均衡

RPC框架通常自带负载均衡策略,而HTTP请求要做负载均衡需要外部应用如Nginx的支持。
服务治理

下游服务新增,重启,下线时能自动通知上游使用者,而HTTP的方式需要事先通知并修改相关配置。

正因为基于RPC方式的服务调用有着性能消耗低,传输效率高,更容易做负载均衡和服务治理的优点,所以分布式系统内部大多采用这种方式进行分布式服务调用。可供选择的RPC框架很多,比如Hession,Dubbo,Thrift这些很早就开源,平时项目中使用也很多。不过最近有一个叫gRPC的RPC框架很火,被使用在很多微服务相关的开源项目中,比如华为的Apache ServiceComb Saga。这篇博客作为我学习gRPC的入门笔记,只对它的核心概念和简单用法做些介绍

1. gRPC简介

gRPC是由Google开发并开源的RPC框架,它具有以下特点

语言中立

支持C,Java,Go等多种语言来构建RPC服务,这是gRPC被广泛的应用在微服务项目中的重要原因,因为不同的微服务可能用不同的语言构建。
基于HTTP/2协议

支持双向流,消息头压缩,单TCP的多路复用,服务端推送等,这些特性使得gRPC更加适用于移动场景下的客户端和服务端之间的通信。
基于IDL定义服务

编写.proto文件即可生成特定语言的数据结构、服务端接口和客户端Stub。
支持Protocol Buffer序列化

Protocol Buffer是由Google开发的一种数据序列化协议(类似于XML、JSON、Hession),平台无关,压缩和传输效率高,语法简单,表达能力强。

一个gRPC服务的大体架构可以用官网上的一幅图表示

gRPC服务端使用C++构建,客户端可以使用Ruby或者Java构建,客户端通过一个Stub存根(代理)对象发起RPC调用,请求和响应消息都使用Protocol Buffer进行序列化。

当我们在微服务中使用gRPC时,整个服务调用过程如下所示(图片来自网络)

通过gRPC,远程服务的调用对使用者更加简单和透明,底层的传输方式,序列化方式,通信细节等统统不需要关系,当然这些对其他RPC框架而言也适用。

2. 使用Protocol Buffers进行服务定义

一个直观的想法,在客户端调用服务端提供的远程接口前,双方必须进行一些约定,比如接口的方法签名,请求和响应的数据结构等,这个过程称为服务定义。服务定义需要特定的接口定义语言(IDL)来完成,gRPC中默认使用protocol buffers。它是google很早就开源的一款序列化框架,其定义了一种数据序列化协议,独立于语言和平台,提供了多种语言的实现:Java,C++,Go等,每一种实现都包含了相应语言的编译器和库文件。使用它进行服务定义需要编写.proto后缀的IDL文件,并通过其编译器生成特定语言的数据结构、服务端接口和客户端Stub代码。

2.1 定义消息

消息是表示RPC接口的请求参数和响应结果的数据结构。如下定义了一个请求消息和响应消息

//定义请求消息的结构

message SearchResponse {

  // repeated表示该字段可以重复任意次,等价于数组:Result[]

  repeated Result result = 1;

}

//定义响应消息的结构

message Result {

  //required表示该字段的值恰好为1个

  required string url = 1;

  //optional表示该字段的值为0或1个

  optional string title = 2;

  

  repeated string snippets = 3;

}

定义消息的关键字为message,相当于java中的class关键字,一个消息就相当于java中的一个类。消息内可以有多个字段,字段的类型可以分类如下

基本数据类型

int32表示java中的int,int64表示java中的long,string表示java中的string,具体的对应关系如下表所示
复杂数据类型

枚举,map等。

enum Corpus {

    UNIVERSAL = 0;

    WEB = 1;

    IMAGES = 2;

    LOCAL = 3;

    NEWS = 4;

    PRODUCTS = 5;

    VIDEO = 6;

  }

map<key_type, value_type> map_field = N;

和java中类中可以定义类一样,Protocol Buffers中消息内也可以定义消息,形成多层的嵌套结构

message Outer {                  // Level 0

  message MiddleAA {  // Level 1

    message Inner {   // Level 2

      required int64 ival = 1;

      optional bool  booly = 2;

    }

  }

关于消息定义,有几点需要注意的地方

1.消息中的字段前可以有修饰符,修饰符主要有三种

required

required int64 ival = 1;

该字段的值恰好只有一个,没有或传入多个都将报错。
optional

optional int32 result_per_page = 3 [default = 10];

该字段的值有0个或1个,传入多个将报错。且以optional修饰的字段可以设置默认值,若没有设置,则编译器会根据类型自动设置一个默认值,比如string设置为空字符串,bool类型设置为false等。
repeated

repeated int32 samples = 4

该字段相当于java中的数组,可以有0个或多个值。

2.消息中的字段有唯一编号,如下所示

这个唯一编号用来在消息的二进制格式中进行字段的区分,范围从1-229 - 1,其中19000-19999是保留编号不能使用。这些字段编号在使用过程中不能进行修改,否则会出现问题。

2.2 定义服务接口

标题中的接口可以类比java中的Interface,内部可以有多个方法。gRPC中使用service关键定义服务接口

service HelloService {

  rpc SayHello (HelloRequest) returns (HelloResponse);

}

message HelloRequest {

  string greeting = 1;

}

message HelloResponse {

  string reply = 1;

}

该服务接口HelloService内部只有一个rpc方法SayHello,请求参数为HelloRequest,响应结果为HelloResponse。

grpc中可以定义4中类型的rpc方法

1.简单rpc方法

rpc SayHello(HelloRequest) returns (HelloResponse){

}

客户端发送一个请求,从服务端获得一个响应,整个过程就像一个本地的方法调用。

2.服务端流式响应的rpc方法

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse){

}

客户端发送一个请求,并从服务端获得一个流(stream)。服务端可以往流中写入N个消息作为响应,并且每个消息可以单独发送,客户端可以从流中按顺序读取这些消息,如下图所示(图片来自网络)

3.客户端流式请求的rpc方法

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse) {

}

客户端通过流发送一连串的多个请求,并等待从服务端返回的一个响应。

4.双向流式rpc方法

rpc BidiHello(stream HelloRequest) returns (stream HelloResponse){

}

客户端通过流发送N个请求,服务端通过流发送N个响应,彼此相互独立,并且读写没有特定的次序要求,比如服务端可以收到所有请求后再返回响应,也可以每读取一个或K个请求会返回响应。

该特性可以充分利用HTTP/2.0的多路复用功能,实现了服务端和客户端的全双工通信,如下图所示(图片来自网络)

3.构建简单的gRPC服务

按照惯例,编写一个gRPC版本的hello world来讲解如何构建一个简单的gRPC服务——客户端发送一个请求,服务端返回一个响应。

比如

客户端:takumiCX

服务端:Hello takumiCX

3.1 编写proto文件,定义消息和接口

创建proto文件
定义消息和接口

//Protocal Buffers的版本有v2和v3之分,语法有较多变化,且相互不兼容

//这里使用的v3版本的

syntax = "proto3";

//编译后生成的消息类HelloRequest和HelloReply是否分别放在单独的class文件中

option java_multiple_files = true;

//生成代码的包路径

option java_package = "com.takumiCX.greeter";

//最外层的类名称

option java_outer_classname = "HelloWorldProto";

//包命名空间

package helloworld;

// 服务接口

service Greeter {

    // 一个简单的rpc方法

    rpc SayHello (HelloRequest) returns (HelloReply) {}

}

// 请求消息

message HelloRequest {

    string name = 1;

}

// 响应消息

message HelloReply {

    string message = 1;

}

3.2 通过maven插件生成相应代码

pom文件配置如下

<dependencies>

    <dependency>

        <groupId>io.grpc</groupId>

        <artifactId>grpc-netty-shaded</artifactId>

        <version>1.16.1</version>

    </dependency>

    <dependency>

        <groupId>io.grpc</groupId>

        <artifactId>grpc-protobuf</artifactId>

        <version>1.16.1</version>

    </dependency>

    <dependency>

        <groupId>io.grpc</groupId>

        <artifactId>grpc-stub</artifactId>

        <version>1.16.1</version>

    </dependency>

</dependencies>

<build>

    <extensions>

        <extension>

            <groupId>kr.motd.maven</groupId>

            <artifactId>os-maven-plugin</artifactId>

            <version>1.5.0.Final</version>

        </extension>

    </extensions>

    <plugins>

        <plugin>

            <groupId>org.xolstice.maven.plugins</groupId>

            <artifactId>protobuf-maven-plugin</artifactId>

            <version>0.5.1</version>

            <configuration>

                <protocArtifact>com.google.protobuf:protoc:3.5.1-1:exe:${os.detected.classifier}</protocArtifact>

                <pluginId>grpc-java</pluginId>

                <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.16.1:exe:${os.detected.classifier}</pluginArtifact>

            </configuration>

            <executions>

                <execution>

                    <goals>

                        <goal>compile</goal>

                        <goal>compile-custom</goal>

                    </goals>

                </execution>

            </executions>

        </plugin>

    </plugins>

</build>

在target目录下可以看到编译器通过编译proto文件为我们生成了对应的类,如下图所示

3.3 gRPC服务端创建

第一步:首先要创建一个具体的服务接口实现类GreeterImpl,扩展gRPC为我们生成的服务抽象类GreeterGrpc.GreeterImplBase,重写服务方法

 //扩展gRPC自动生成的服务接口抽象,实现业务功能

    static class GreeterImpl extends GreeterGrpc.GreeterImplBase{

        @Override

        public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {

            //构建响应消息,从请求消息中获取姓名,在前面拼接上"Hello "

            HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName()).build();

            //在流关闭或抛出异常前可以调用多次

            responseObserver.onNext(reply);

            //关闭流

            responseObserver.onCompleted();

        }

    }

创建server对象,监听特定端口,注册具体的服务实现类并启动

 //服务要监听的端口

        int port=50051;

        //创建server对象,监听端口,注册服务并启动

        Server server = ServerBuilder.

                forPort(port)  //监听50051端口

                .addService(new GreeterImpl()) //注册服务

                .build()  //创建Server对象

                .start(); //启动

        log.info("Server started,listening on "+port);

        server.awaitTermination();

完整代码如下

/**

 * @author: takumiCX

 * @create: 2018-12-01

 **/

public class HelloWorldServer {

    private static final Logger log=Logger.getLogger(HelloWorldServer.class.getName());

    //扩展gRPC自动生成的服务接口,实现业务功能

    static class GreeterImpl extends GreeterGrpc.GreeterImplBase{

        @Override

        public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {

            //构建响应消息,从请求消息中获取姓名,在前面拼接上"Hello "

            HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName()).build();

            //在流关闭或抛出异常前可以调用多次

            responseObserver.onNext(reply);

            //关闭流

            responseObserver.onCompleted();

        }

    }

    public static void main(String[] args) throws IOException, InterruptedException {

        //服务要监听的端口

        int port=50051;

        //创建服务对象,监听端口,注册服务并启动

        Server server = ServerBuilder.

                forPort(port)  //监听50051端口

                .addService(new GreeterImpl()) //注册服务

                .build()  //创建Server对象

                .start(); //启动

        log.info("Server started,listening on "+port);

        server.awaitTermination();

    }

}

gRPC的服务端创建过程如下所示(图片来自网络)

3.5 gRPC客户端创建

整个过程可以分为3步

1.根据服务端的ip和端口号,创建ManagedChannel
2.创建供客户端使用的stub对象,可以创建两种类型的stub,一种进行同步调用,一种进行异步调用,后者发起调用的业务线程不会同步阻塞。
3.通过stub对象发起rpc调用,获取服务端响应。

完整代码如下:

/**

 * @author: takumiCX

 * @create: 2018-12-01

 **/

public class HelloWorldClient {

    private static final Logger log=Logger.getLogger(HelloWorldClient.class.getName());

    public static void main(String[] args) {

        String host="localhost";

        int port=50051;

        //1.创建ManagedChannel,绑定服务端ip地址和端口

        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port)

                .usePlaintext()

                .build();

        //2.获得同步调用的stub对象

        GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);

//        //获得异步调用的stub对象

//        GreeterGrpc.GreeterFutureStub futureStub = GreeterGrpc.newFutureStub(channel);

        Scanner scanner = new Scanner(System.in);

        while (true){

            //从控制台读取用户输入

            String name = scanner.nextLine().trim();

            //构建请求消息

            HelloRequest helloRequest = HelloRequest.newBuilder().setName(name).build();

            //通过stub代理对象进行服务调用,获取服务端响应

            HelloReply helloReply = stub.sayHello(helloRequest);

            final String message = helloReply.getMessage();

            log.warning("Greeting: "+message);

        }

    }

}

gRPC客户端的调用流程如下所示

3.6 测试

先启动gRPC服务端,然后启动gRPC客户单。客户端发送gRPC请求takumiCX,收到了来自服务端的响应Hello takumiCX

4. 总结

gRPC作为开源RPC框架的新势力,基于HTTP/2.0协议进行设计,使用高性能的Protocol Buffer进行消息的序列化,因而性能非常好,而且提供了完整的负载均衡和服务治理能力,加上其和语言无关、平台无关的特点,非常适合作为微服务内部服务间调用的选型。

5. 参考资料

《深入浅出gRPC》

https://developers.google.com/protocol-buffers/

https://grpc.io/docs/guides/concepts.html#service-definition