1.  为什么要用istio？目前，对于java技术栈来说，构建微服务的最佳选择是spring boot而spring boot一般搭配目前落地案例很多的微服务框架spring cloud来使用。
spring cloud看似很完美，但是在实际上手开发后，很容易就会发现spring cloud存在以下比较严重的问题：
服务治理相关的逻辑存在于spring cloud netflix等sdk中，与业务代码紧密耦合。
sdk对业务代码侵入太大，sdk发生升级且无法向下兼容时，业务代码必须做出改变以适配sdk的升级——即使业务逻辑并没有发生任何变化。
各种组件令人眼花缭乱，质量也参差不齐，学习成本太高，且组件之间代码很难完全复用，仅仅为了实现治理逻辑而学习sdk也并不是很好的选择。
绑定于java技术栈，虽然可以接入其他语言但要手动实现服务治理相关的逻辑，不符合微服务“可以用多种语言进行开发”的原则。
spring cloud仅仅是一个开发框架，没有实现微服务所必须的服务调度、资源分配等功能，这些需求要借助kubernetes等平台来完成。spring cloud and kubernetes have overlapping functionality, and conflicting features create difficulties in smooth collaboration between the two.。
替代spring cloud的选择有没有呢？有！它就是istio。
istio将治理逻辑完全独立于业务代码之外，实现了一个独立的进程（sidecar）。在部署时，sidecar和业务代码共存于同一个pod中，但业务代码完全无感知sidecar的存在。这就实现了治理逻辑对业务代码的零侵入——实际上不仅是代码没有侵入，在运行时两者也没有任何的耦合。这使得不同的微服务完全可以使用不同语言、不同技术栈来开发，也不用担心服务治理问题，可以说这是一种很优雅的解决方案了。
所以，“为什么要使用istio”这个问题也就迎刃而解了——因为istio解决了传统微服务诸如业务逻辑与服务治理逻辑耦合、不能很好地实现跨语言等痛点，而且非常容易使用。学习如何使用istio并不困难，只要掌握了kubernetes。
1.1.  为什么要使用grpc作为通信框架？在微服务架构中，服务之间的通信是一个比较大的问题，一般采用rpc或者restful api来实现。
spring boot可以使用resttemplate调用远程服务，但这种方式不直观，代码也比较复杂，进行跨语言通信也是个比较大的问题；而grpc相比dubbo等常见的java rpc框架更加轻量，使用起来也很方便，代码可读性高，并且与istio和kubernetes可以很好地进行整合，在protobuf和http2的加持下性能也还不错，所以这次选择了grpc来解决spring boot微服务间通信的问题。并且，虽然grpc没有服务发现、负载均衡等能力，但是istio在这方面就非常强大，两者形成了完美的互补关系。
由于考虑到各种grpc-spring-boot-starter可能会对spring boot与istio的整合产生不可知的副作用，所以这一次我没有用任何的grpc-spring-boot-starter，而是直接手写了grpc与spring boot的整合。如果您不想使用第三方框架来整合grpc和spring boot，可以参考我的简单实现方法。
1.2. 编写业务代码首先使用spring initializr建立父级项目spring-boot-istio，并引入grpc的依赖。pom文件如下：
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelversion>4.0.0</modelversion> <modules> <module>spring-boot-istio-api</module> <module>spring-boot-istio-server</module> <module>spring-boot-istio-client</module> </modules> <parent> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-starter-parent</artifactid> <version>2.2.6.release</version> <relativepath/> </parent> <groupid>site.wendev</groupid> <artifactid>spring-boot-istio</artifactid> <version>0.0.1-snapshot</version> <name>spring-boot-istio</name> <description>demo project for spring boot with istio.</description> <packaging>pom</packaging> <properties> <java.version>1.8</java.version> </properties> <dependencymanagement> <dependencies> <dependency> <groupid>io.grpc</groupid> <artifactid>grpc-all</artifactid> <version>1.28.1</version> </dependency> </dependencies> </dependencymanagement></project>
然后建立公共依赖模块spring-boot-istio-api，pom文件如下，主要就是grpc的一些依赖：
<?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"> <parent> <artifactid>spring-boot-istio</artifactid> <groupid>site.wendev</groupid> <version>0.0.1-snapshot</version> </parent> <modelversion>4.0.0</modelversion> <artifactid>spring-boot-istio-api</artifactid> <dependencies> <dependency> <groupid>io.grpc</groupid> <artifactid>grpc-all</artifactid> </dependency> <dependency> <groupid>javax.annotation</groupid> <artifactid>javax.annotation-api</artifactid> <version>1.3.2</version> </dependency> </dependencies> <build> <extensions> <extension> <groupid>kr.motd.maven</groupid> <artifactid>os-maven-plugin</artifactid> <version>1.6.2</version> </extension> </extensions> <plugins> <plugin> <groupid>org.xolstice.maven.plugins</groupid> <artifactid>protobuf-maven-plugin</artifactid> <version>0.6.1</version> <configuration> <protocartifact>com.google.protobuf:protoc:3.11.3:exe:${os.detected.classifier}</protocartifact> <pluginid>grpc-java</pluginid> <pluginartifact>io.grpc:protoc-gen-grpc-java:1.28.1:exe:${os.detected.classifier}</pluginartifact> <protocexecutable>/users/jiangwen/tools/protoc-3.11.3/bin/protoc</protocexecutable> </configuration> <executions> <execution> <goals> <goal>compile</goal> <goal>compile-custom</goal> </goals> </execution> </executions> </plugin> </plugins> </build></project>
建立src/main/proto文件夹，在此文件夹下建立hello.proto，定义服务间的接口如下：
syntax = "proto3";option java_package = "site.wendev.spring.boot.istio.api";option java_outer_classname = "helloworldservice";package helloworld;service helloworld { rpc sayhello (hellorequest) returns (helloresponse) {}}message hellorequest { string name = 1;}message helloresponse { string message = 1;}
很简单，就是发送一个name返回一个带name的message。
然后生成服务端和客户端的代码，并且放到java文件夹下。这部分内容可以参考grpc的官方文档。
一旦api模块可用，即可开发服务提供者（服务器）和服务消费者（客户端）。这里我们重点看一下如何整合grpc和spring boot。
1) 服务端
业务代码非常简单：
/** * 服务端业务逻辑实现 * * @author 江文 * @date 2020/4/12 2:49 下午 */@slf4j@componentpublic class helloserviceimpl extends helloworldgrpc.helloworldimplbase { @override public void sayhello(helloworldservice.hellorequest request, streamobserver<helloworldservice.helloresponse> responseobserver) { // 根据请求对象建立响应对象，返回响应信息 helloworldservice.helloresponse response = helloworldservice.helloresponse .newbuilder() .setmessage(string.format("hello, %s. this message comes from grpc.", request.getname())) .build(); responseobserver.onnext(response); responseobserver.oncompleted(); log.info("client message received：[{}]", request.getname()); }}
除了业务代码之外，我们还需要在应用启动时同时启动 grpc server。首先写一下server端的启动、关闭等逻辑：
/** * grpc server的配置——启动、关闭等 * 需要使用<code>@component</code>注解注册为一个spring bean * * @author 江文 * @date 2020/4/12 2:56 下午 */@slf4j@componentpublic class grpcserverconfiguration { @autowired helloserviceimpl service; /** 注入配置文件中的端口信息 */ @value("${grpc.server-port}") private int port; private server server; public void start() throws ioexception { // 构建服务端 log.info("starting grpc on port {}.", port); server = serverbuilder.forport(port).addservice(service).build().start(); log.info("grpc server started, listening on {}.", port); // 添加服务端关闭的逻辑 runtime.getruntime().addshutdownhook(new thread(() -> { log.info("shutting down grpc server."); grpcserverconfiguration.this.stop(); log.info("grpc server shut down successfully."); })); } private void stop() { if (server != null) { // 关闭服务端 server.shutdown(); } } public void block() throws interruptedexception { if (server != null) { // 服务端启动后直到应用关闭都处于阻塞状态，方便接收请求 server.awaittermination(); } }}
定义好grpc的启动、停止等逻辑后，就可以使用commandlinerunner把它加入到spring boot的启动中去了：
/** * 加入grpc server的启动、停止等逻辑到spring boot的生命周期中 * * @author 江文 * @date 2020/4/12 3:10 下午 */@componentpublic class grpccommandlinerunner implements commandlinerunner { @autowired grpcserverconfiguration configuration; @override public void run(string... args) throws exception { configuration.start(); configuration.block(); }}
我们将grpc的逻辑注册成spring bean是因为需要获取到它的实例并进行相应的操作。
这样，在启动spring boot时，由于commandlinerunner的存在，grpc服务端也就可以一同启动了。
2) 客户端
业务代码同样非常简单：
/** * 客户端业务逻辑实现 * * @author 江文 * @date 2020/4/12 3:26 下午 */@restcontroller@slf4jpublic class hellocontroller { @autowired grpcclientconfiguration configuration; @getmapping("/hello") public string hello(@requestparam(name = "name", defaultvalue = "jiangwen", required = false) string name) { // 构建一个请求 helloworldservice.hellorequest request = helloworldservice.hellorequest .newbuilder() .setname(name) .build(); // 使用stub发送请求至服务端 helloworldservice.helloresponse response = configuration.getstub().sayhello(request); log.info("server response received: [{}]", response.getmessage()); return response.getmessage(); }}
在启动客户端时，我们需要打开grpc的客户端，并获取到channel和stub以进行rpc通信，来看看grpc客户端的实现逻辑：
/** * grpc client的配置——启动、建立channel、获取stub、关闭等 * 需要注册为spring bean * * @author 江文 * @date 2020/4/12 3:27 下午 */@slf4j@componentpublic class grpcclientconfiguration { /** grpc server的地址 */ @value("${server-host}") private string host; /** grpc server的端口 */ @value("${server-port}") private int port; private managedchannel channel; private helloworldgrpc.helloworldblockingstub stub; public void start() { // 开启channel channel = managedchannelbuilder.foraddress(host, port).useplaintext().build(); // 通过channel获取到服务端的stub stub = helloworldgrpc.newblockingstub(channel); log.info("grpc client started, server address: {}:{}", host, port); } public void shutdown() throws interruptedexception { // 调用shutdown方法后等待1秒关闭channel channel.shutdown().awaittermination(1, timeunit.seconds); log.info("grpc client shut down successfully."); } public helloworldgrpc.helloworldblockingstub getstub() { return this.stub; }}
比服务端要简单一些。
最后，仍然需要一个commandlinerunner把这些启动逻辑加入到spring boot的启动过程中：
/** * 加入grpc client的启动、停止等逻辑到spring boot生命周期中 * * @author 江文 * @date 2020/4/12 3:36 下午 */@component@slf4jpublic class grpcclientcommandlinerunner implements commandlinerunner { @autowired grpcclientconfiguration configuration; @override public void run(string... args) { // 开启grpc客户端 configuration.start(); // 添加客户端关闭的逻辑 runtime.getruntime().addshutdownhook(new thread(() -> { try { configuration.shutdown(); } catch (interruptedexception e) { e.printstacktrace(); } })); }}
1.3､ 编写dockerfile业务代码跑通之后，就可以制作docker镜像，准备部署到istio中去了。
在开始编写dockerfile之前，先改动一下客户端的配置文件：
server: port: 19090spring: application: name: spring-boot-istio-clientserver-host: ${server-host}server-port: ${server-port}
接下来编写dockerfile：
1) 服务端：
from openjdk:8u121-jdkrun /bin/cp /usr/share/zoneinfo/asia/shanghai /etc/localtime \ && echo 'asia/shanghai' >/etc/timezoneadd /target/spring-boot-istio-server-0.0.1-snapshot.jar /env server_port="18080" entrypoint java -jar /spring-boot-istio-server-0.0.1-snapshot.jar
主要是规定服务端应用的端口为18080，并且在容器启动时让服务端也一起启动。
2) 客户端：
from openjdk:8u121-jdkrun /bin/cp /usr/share/zoneinfo/asia/shanghai /etc/localtime \ && echo 'asia/shanghai' >/etc/timezoneadd /target/spring-boot-istio-client-0.0.1-snapshot.jar /env grpc_server_host="spring-boot-istio-server"env grpc_server_port="18888"entrypoint java -jar /spring-boot-istio-client-0.0.1-snapshot.jar \ --server-host=$grpc_server_host \ --server-port=$grpc_server_port
可以看到这里添加了启动参数，配合前面的配置，当这个镜像部署到kubernetes集群时，就可以在kubernetes的配合之下通过服务名找到服务端了。
同时，服务端和客户端的pom文件中添加：
<build> <plugins> <plugin> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-maven-plugin</artifactid> <configuration> <executable>true</executable> </configuration> </plugin> <plugin> <groupid>com.spotify</groupid> <artifactid>dockerfile-maven-plugin</artifactid> <version>1.4.13</version> <dependencies> <dependency> <groupid>javax.activation</groupid> <artifactid>activation</artifactid> <version>1.1</version> </dependency> </dependencies> <executions> <execution> <id>default</id> <goals> <goal>build</goal> <goal>push</goal> </goals> </execution> </executions> <configuration> <repository>wendev-docker.pkg.coding.net/develop/docker/${project.artifactid}</repository> <tag>${project.version}</tag> <buildargs> <jar_file>${project.build.finalname}.jar</jar_file> </buildargs> </configuration> </plugin> </plugins> </build>
这样执行mvn clean package时就可以同时把docker镜像构建出来了。
2. 编写部署文件有了镜像之后，就可以写部署文件了：
1) 服务端：
apiversion: v1kind: servicemetadata: name: spring-boot-istio-serverspec: type: clusterip ports: - name: http port: 18080 targetport: 18080 - name: grpc port: 18888 targetport: 18888 selector: app: spring-boot-istio-server---apiversion: apps/v1kind: deploymentmetadata: name: spring-boot-istio-serverspec: replicas: 1 selector: matchlabels: app: spring-boot-istio-server template: metadata: labels: app: spring-boot-istio-server spec: containers: - name: spring-boot-istio-server image: wendev-docker.pkg.coding.net/develop/docker/spring-boot-istio-server:0.0.1-snapshot imagepullpolicy: always tty: true ports: - name: http protocol: tcp containerport: 18080 - name: grpc protocol: tcp containerport: 18888
主要是暴露服务端的端口：18080和grpc server的端口18888，以便可以从pod外部访问服务端。
2) 客户端：
apiversion: v1kind: servicemetadata: name: spring-boot-istio-clientspec: type: clusterip ports: - name: http port: 19090 targetport: 19090 selector: app: spring-boot-istio-client---apiversion: apps/v1kind: deploymentmetadata: name: spring-boot-istio-clientspec: replicas: 1 selector: matchlabels: app: spring-boot-istio-client template: metadata: labels: app: spring-boot-istio-client spec: containers: - name: spring-boot-istio-client image: wendev-docker.pkg.coding.net/develop/docker/spring-boot-istio-client:0.0.1-snapshot imagepullpolicy: always tty: true ports: - name: http protocol: tcp containerport: 19090
主要是暴露客户端的端口19090，以便访问客户端并调用服务端。
如果想先试试把它们部署到k8s可不可以正常访问，可以这样配置ingress：
apiversion: networking.k8s.io/v1beta1kind: ingressmetadata: name: nginx-web annotations: kubernetes.io/ingress.class: "nginx" nginx.ingress.kubernetes.io/use-reges: "true" nginx.ingress.kubernetes.io/proxy-connect-timeout: "600" nginx.ingress.kubernetes.io/proxy-send-timeout: "600" nginx.ingress.kubernetes.io/proxy-read-timeout: "600" nginx.ingress.kubernetes.io/proxy-body-size: "10m" nginx.ingress.kubernetes.io/rewrite-target: /spec: rules: - host: dev.wendev.site http: paths: - path: / backend: servicename: spring-boot-istio-client serviceport: 19090
istio的网关配置文件与k8s不大一样：
apiversion: networking.istio.io/v1alpha3kind: gatewaymetadata: name: spring-boot-istio-gatewayspec: selector: istio: ingressgateway servers: - port: number: 80 name: http protocol: http hosts: - "*"---apiversion: networking.istio.io/v1alpha3kind: virtualservicemetadata: name: spring-boot-istiospec: hosts: - "*" gateways: - spring-boot-istio-gateway http: - match: - uri: exact: /hello route: - destination: host: spring-boot-istio-client port: number: 19090
主要就是暴露/hello这个路径，并且指定对应的服务和端口。
3. 部署应用到istio首先搭建k8s集群并且安装istio。我使用的k8s版本是1.16.0，istio版本是最新的1.6.0-alpha.1，使用istioctl命令安装istio。建议跑通官方的bookinfo示例之后再来部署本项目。
注：以下命令都是在开启了自动注入sidecar的前提下运行的
我是在虚拟机中运行的k8s，所以istio-ingressgateway没有外部ip：
$ kubectl get svc istio-ingressgateway -n istio-systemname type cluster-ip external-ip port(s) ageistio-ingressgateway nodeport 10.97.158.232 <none> 15020:30388/tcp,80:31690/tcp,443:31493/tcp,15029:32182/tcp,15030:31724/tcp,15031:30887/tcp,15032:30369/tcp,31400:31122/tcp,15443:31545/tcp 26h
所以，需要设置ip和端口，以nodeport的方式访问gateway：
export ingress_port=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodeport}')export secure_ingress_port=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="https")].nodeport}')export ingress_host=127.0.0.1export gateway_url=$ingress_host:$ingress_port
这样就可以了。
接下来部署服务：
$ kubectl apply -f spring-boot-istio-server.yml$ kubectl apply -f spring-boot-istio-client.yml$ kubectl apply -f istio-gateway.yml
必须要等到两个pod全部变为running而且ready变为2/2才算部署完成。
接下来就可以通过
curl -s http://${gateway_url}/hello
访问到服务了。如果成功返回了hello, jiangwen. this message comes from grpc.的结果，没有出错则说明部署完成。
以上就是怎么使用spring boot+grpc构建微服务并部署的详细内容。