SpringBoot集成gRPC微服务工程搭建实践的方法

时间：2022-09-05 20:13:26

前言

本文将使用maven、grpc、protocol buffers、docker、envoy等工具构建一个简单微服务工程，笔者所使用的示例工程是以前写的一个java后端工程，因为最近都在 学习微服务相关的知识，所以利用起来慢慢的把这个工程做成微服务化应用。在实践过程踩过很多坑，主要是经验不足对微服务还是停留在萌新阶段，通过本文 记录创建微服务工程碰到一些问题，此次实践主要是解决以下问题：

  • 如何解决、统一服务工程依赖管理
  • springboot集成grpc
  • 管理protocol buffers文件
  • 使用envoy代理访问grpc
  • 部署到docker

本文假设读者已经了解以下相关知识：

  • maven
  • envoy
  • grpc
  • protocol buffers
  • springboot
  • docker

由于是初步实现微服务，不会考虑过多的细节，现阶段只需要能够使用grpc正常通信，后续计划会发布到k8s中，使用istio实现来服务网格。

使用maven

现在比较流行的构建工具有maven和gradle，现阶段后端开发大多数都是用的maven所以本工程也使用maven来构建项目，当然使用gradle也可以两者概念大都想通，不同的地方大多是实现和配置方式不一致。

使用项目继承

根据maven的pom文件继承特性，将工程分不同的模块，所有的模块都继承父pom.xml的依赖、插件等内容，这样就可以实现统一管理，并方便以后管理、维护。先看一下大概的项目结构：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
appbubblebackend   （1）
├── appbubblecommon
├── appbubblesmsservice  （2）
├── appbubbleuserservice
├── docker-compose.yaml  （3）
├── pom.xml
├── protos     （4）
│ ├── sms
│ └── user
└── scripts     （5）
 ├── docker
 ├── envoy
 ├── gateway
 └── sql

以下是各个目录的用处简述，详细的用处文章后面都会提到，先在这里列出个大概：

  1. 工程主目录
  2. 单个服务工程目录（模块）
  3. docker-compose发布文件
  4. 存放.proto文件
  5. 发布、编译时用到的脚本文件

知道大概的项目工程结构后我们创建一个父pom.xml文件，放在appbubblebackend目录下面：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
   xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelversion>4.0.0</modelversion>
 <parent>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-parent</artifactid>
  <version>2.1.2.release</version>
  <relativepath/> <!-- lookup parent from repository -->
 </parent>
 
 <groupid>com.bubble</groupid>
 <artifactid>bubble</artifactid>
 <version>0.0.1-snapshot</version>
 <packaging>pom</packaging>
 
 <modules>
  <module>appbubblesmsservice</module>
  <module>appbubblecommon</module>
  <module>appbubbleuserservice</module>
 </modules>
 
 <!-- 省略其他部分 -->
</project>

因为使用springboot构架，所以主pom.xml文件继承自springboot的pom文件。 有了主pom.xml后然后使每个模块的pom.xml都继承自 主pom.xml文件：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
 xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelversion>4.0.0</modelversion>
 <parent>
 <groupid>com.bubble</groupid>
 <artifactid>bubble</artifactid>
 <version>0.0.1-snapshot</version>
 </parent>
 <artifactid>sms</artifactid>
 <version>0.0.1-snapshot</version>
 
 <!-- 省略其他部分 -->
</project>

经过上面的配置后，所有的模块都会继承appbubblebackend中的pom.xml文件，这样可以很方便的更改依赖、配置等信息。

依赖管理

maven提供依赖中心化的管理机制，通过项目继承特性所有对appbubblebackend/pom.xml所做的更改都会对其他模块产生影响，详细的依赖管理 内容可查看官方文档。

?
1
2
3
4
5
6
7
8
9
10
<dependencymanagement>
  <dependencies>
   <!-- grpc -->
   <dependency>
    <groupid>io.grpc</groupid>
    <artifactid>grpc-netty-shaded</artifactid>
    <version>${grpc.version}</version>
   </dependency>
  </dependencies>
</dependencymanagement>

通过dependencymanagement标签来配置依赖，这样可以就可以实现统一依赖的管理，并且还可以添加公共依赖。

插件管理

使用pluginmanagement可以非常方便的配置插件，因为项目中使用了protocol buffers需要集成相应的插件来生成java源文件：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<pluginmanagement>
   <plugins>
    <plugin>
     <groupid>org.xolstice.maven.plugins</groupid>
     <artifactid>protobuf-maven-plugin</artifactid>
     <version>0.5.1</version>
     <executions>
      <execution>
       <goals>
        <goal>compile</goal>
        <goal>compile-custom</goal>
       </goals>
      </execution>
     </executions>
    </plugin>
   </plugins>
</pluginmanagement>

protocol buffers插件的完整配置参数，可以这找到。

profile

使用profile的目的是为了区分生成docker镜像时的一些特殊配置，示例工程只配置了一个docker-build的profile:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<profiles>
 <profile>
  <id>docker-build</id>
  <properties>
   <jarname>app</jarname>
  </properties>
 </profile>
</profiles>
 
 <properties>
 <jarname>${project.artifactid}-${project.version}</jarname>
</properties>
 
<build>
 <finalname>${jarname}</finalname>
</build>

如果使用mvn package -p docker-build命令生成jar包时，相应的输出文件名是app.jar这样可以方便在dockerfile中引用文件，而不需要使用${project.artifactid}-${project.version}的形式来查找输出的jar这样可以省去了解析pom.xml文件。如果还需要特殊的参数可以或者不同的行为，可以添加多个profile，这样配置起来非常灵活。

protocol buffers文件管理

因为是使用微服务开发，而且rpc通信框架是使用的grpc，所以每个服务工程都会使用.proto文件。服务工程之间又会有使用同一份.proto文件的需求，比如在进行rpc通信时服务提供方返回的消息test定义在a.proto文件中,那么在使用方在解析消息时也同样需要a.proto文件来将接收到的消息转换成test消息，因此管理.proto文件也有一些小麻烦。关于protocol buffers的使用可参考 官方文档。

protocol buffers文件管理规约

在我们的示例项目中使用集中管理的方式，即将所有的.proto文件放置在同一个目录（appbubblebackend/protos）下并按服务名称来划分:

?
1
2
3
4
5
├── sms
│ ├── smsmessage.proto
│ └── smsservice.proto
└── user
 └── usermessage.proto

还可以将整个目录放置在一个单独的git仓库中，然后在项目中使用git subtree来管理文件。

protocol buffers 插件配置

有了上面的目录结构后，就需要配置一下protocol buffers的编译插件来支持这种.proto文件的组织结构。在讲解如何配置插件解决.proto文件的编译问题之前，推荐读者了解一下插件的配置文档：xolstice maven plugins。在我们的工程中使用如下配置：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<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.17.1:exe:${os.detected.classifier}</pluginartifact>
   <additionalprotopathelements combine.children="append" combine.self="append">
    <additionalprotopathelement>${gopath}/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis</additionalprotopathelement>
    <additionalprotopathelement>${gopath}/src</additionalprotopathelement>
   </additionalprotopathelements>
   <protosourceroot>${protos.basedir}</protosourceroot>
   <writedescriptorset>true</writedescriptorset>
   <includedependenciesindescriptorset>true</includedependenciesindescriptorset>
  </configuration>
  <!-- ... -->
 </plugin>

首先上面的插件配置使用protosourceroot标签将protocol buffers的源文件目录更改成appbubblebackend/protos目录，因为工程中使用了googleapis来定义服务接口,所以需要使用添加additionalprotopathelement标签添加额外的依赖文件。注意这个插件的配置是在appbubblebackend/pom.xml文件中的，服务工程都是继承此文件的。在父pom文件配置好以后，再看一下服务工程的插件配置：

?
1
2
3
4
5
6
7
8
9
10
11
12
<plugins>
 <plugin>
 <groupid>org.xolstice.maven.plugins</groupid>
 <artifactid>protobuf-maven-plugin</artifactid>
 <configuration>
  <includes>
  <include>${project.artifactid}/*.proto</include>
  <include>user/*.proto</include>
  </includes>
 </configuration>
 </plugin>
 </plugins>

服务工程主要使用includes标签，将需要的.proto文件包含在编译脚本中，includes标签中的include只是一个指定匹配.proto文件的匹配模式，<include>${project.artifactid}/*.proto</include>意思是appbubblebackend/protos/${project.artifactid}目录下的所有以.proto文件结尾的文件，如果服务工程有多个依赖可以将需要依赖的文件也添加到编译服务中，如上面的<include>user/*.proto</include>就将appbubblebackend/protos/user中的.proto文件添加进来，然后进行整体的编译。

grpc

grpc是由google开源的rpc通信框架，grpc使用protocol buffers定义服务接口并自动生成grpc相关代码，有了这些代码后就可以非常方便的实现grpc服务端和gprc客户端，过多的细节就不细说了先看一下如何使用在springboot中使用grpc。

运行grpc服务

利用applicationrunner接口，在sprintboot中运行grpc服非常方便，只需要像下面代码一样就可以运行一个简单的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
package com.bubble.sms.grpc;
 
@component
public class grpcserverinitializer implements applicationrunner {
 
 
 @autowired
 private list<bindableservice> services;
 
 @value("${grpc.server.port:8090}")
 private int port;
 
 @override
 public void run(applicationarguments args) throws exception {
 
  serverbuilder serverbuilder = serverbuilder
    .forport(port);
 
  if (services != null && !services.isempty()) {
   for (bindableservice bindableservice : services) {
    serverbuilder.addservice(bindableservice);
   }
  }
  server server = serverbuilder.build();
  serverbuilder.intercept(transmitstatusruntimeexceptioninterceptor.instance());
  server.start();
  startdaemonawaitthread(server);
 }
 
 
 private void startdaemonawaitthread(server server) {
  thread awaitthread = new thread(() -> {
   try {
    server.awaittermination();
   } catch (interruptedexception ignore) {
    
   }
  });
  awaitthread.setdaemon(false);
  awaitthread.start();
 }
}

envoy代理

grpc服务运行起来后就需要进行调试了，比如使用curl、chrome等工具向grpc服务发起restful请求，实际上grpc的调试并没有那么简单。一开始的方案是使用了grpc-gateway，为每个服务都启动一个网关将http 1.x请求转换并发送到grpc服务。然而grpc-gateway只有go语言的版本，并没有java语言的版本，所有在编译和使用中比较困难，后来发现了envoy提供了envoy.grpc_json_transcoder这个http过滤器，可以很方便的将restful json api转换成grpc请求并发送给grpc服务器。

envoy的相关配置都放置在appbubblebackend/scripts/envoy目录中，里面的envoy.yaml是一份简单的配置文件：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static_resources:
 listeners:
 - name: grpc-8090
 address:
  socket_address: { address: 0.0.0.0, port_value: 8090 }
 filter_chains:
 - filters:
  - name: envoy.http_connection_manager
  config:
   stat_prefix: sms_http
   codec_type: auto
   # 省略部分配置
   http_filters:
   - name: envoy.grpc_json_transcoder
   config:
    proto_descriptor: "/app/app.protobin"
    services: ["sms.smsservice"]
    match_incoming_request_route: true
    print_options:
    add_whitespace: true
    always_print_primitive_fields: true
    always_print_enums_as_ints: false
    preserve_proto_field_names: false
# 省略部分配置

使用envoy.grpc_json_transcoder过滤器的主要配置是proto_descriptor选项，该选项指向一个proto descriptor set文件。appbubblebackend/scripts/envoy/compile-descriptor.sh是编译proto descriptor set的脚本文件， 运行脚本文件会在脚本目录下生成一个app.protobin的文件，将此文件设置到envoy.grpc_json_transcoder就可大致完成了envoy的代理配置。

使用docker发布

经过上面的一系统准备工作之后，我们就可以将服务发布到docker中了，docker相关的文件都放置中appbubblebackend/scripts/docker和一个appbubblebackend/docker-compose.yaml文件。在发布时使用单个dockerfile文件来制作服务镜像：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from rcntech/ubuntu-grpc:v0.0.5
expose 8080
expose 8090
 
#将当前目录添加文件到/bubble
arg app_project_name
#复制父pom.xml
add /pom.xml /app/pom.xml
add /protos /app/protos
add $app_project_name /app/$app_project_name
add scripts/gateway /app/gateway
add scripts/docker/entrypoint.sh /app/entrypoint.sh
run chmod u+x /app/entrypoint.sh
 
entrypoint ["/app/entrypoint.sh"]

有了dockerfile文件后，在docker-compose.yaml里面做一些配置就能将服务打包成镜像：

?
1
2
3
4
5
6
7
8
9
10
sms:
build:
context: ./
dockerfile: scripts/docker/dockerfile
args:
 app_project_name: "appbubblesmsservice"
environment:
apollo_meta: "http://apollo-configservice-dev:8080"
app_project_name: "appbubblesmsservice"
env: dev

同时编写了一个通用的entrypoint.sh脚本文件来启动服务器：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/bin/bash
 
export gopath=${home}/go
export path=$path:/usr/local/go/bin:$gopath/bin
 
rootprojectdir="/app"
projectdir="${rootprojectdir}/${app_project_name}"
 
cd ${rootprojectdir}/appbubblecommon
./mvnw install
 
cd $projectdir
#打包app.jar
./mvnw package -dskiptests -p docker-build
#编译proto文件
./mvnw protobuf:compile protobuf:compile-custom -p docker-build
 
 
# run service
java -jar ${projectdir}/target/app.jar

entrypoint.sh脚本中将服务工程编译成app.jar包再运行服务。还有envoy代理也要启动起来这样我们就可以使用curl或其他工具直接进行测试了。

总结

搭建这个工程大概摸索了一周的时间，主要的时间是花在了protocol buffers文件的管理与使用envoy作为代理调试grpc服务上。文章中的示例工程已经传到了github: appbubblebackend 后面会打算慢慢的完善这个应用，这是个简单的短视屏应用除了服务器还包含了android和ios端，等到将后端微服务化为开源出来供学习交流使用。

参考引用

grpc官方文档
protocol buffers maven 插件文档
protocol buffers官方文档
grpc 官方文档中文版
grpc-json transcoder

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://juejin.im/post/5c3ed5a2f265da616f703399

标签：

相关文章