So verwenden Sie Spring Boot+gRPC zum Erstellen und Bereitstellen von Microservices-javaLernprogramm-php.cn

1. Warum Istio verwenden?

Derzeit ist Spring Boot für den Java-Technologie-Stack die beste Wahl zum Erstellen von Microservices. Spring Boot wird im Allgemeinen mit dem Microservice-Framework Spring Cloud verwendet, das viele Implementierungsfälle aufweist.

Spring Cloud scheint perfekt zu sein, aber nach der eigentlichen Entwicklung ist es leicht festzustellen, dass Spring Cloud die folgenden schwerwiegenden Probleme aufweist:

Logik im Zusammenhang mit der Service-Governance ist in SDKs wie Spring Cloud Netflix vorhanden, die mit dem Geschäft zusammenhängen Code ist eng gekoppelt.
SDK ist zu aufdringlich für den Geschäftscode und kann nicht abwärtskompatibel sein. Der Geschäftscode muss geändert werden, um ihn an das SDK-Upgrade anzupassen – auch wenn sich die Geschäftslogik überhaupt nicht ändert.
Die verschiedenen Komponenten sind umwerfend und die Qualität ist auch uneinheitlich. Der Code zwischen den Komponenten lässt sich nur schwer wiederverwenden, um die Governance-Logik zu implementieren.
ist an den Java-Technologie-Stack gebunden. Obwohl andere Sprachen verbunden werden können, muss die mit der Service-Governance verbundene Logik manuell implementiert werden, was nicht dem Prinzip entspricht, dass Microservices „in mehreren Sprachen entwickelt werden können“.
Spring Cloud ist lediglich ein Entwicklungsframework und implementiert nicht die für Microservices erforderliche Serviceplanung, Ressourcenzuweisung und andere Funktionen. Diese Anforderungen müssen mithilfe von Plattformen wie Kubernetes erfüllt werden. Spring Cloud und Kubernetes verfügen über überlappende Funktionen, und widersprüchliche Funktionen erschweren die reibungslose Zusammenarbeit zwischen beiden.

Gibt es Alternativen zu Spring Cloud? haben! Es ist Istio.

Istio trennt die Governance-Logik vollständig vom Geschäftscode und implementiert einen unabhängigen Prozess (Sidecar). Während der Bereitstellung existieren Sidecar und Geschäftscode gleichzeitig im selben Pod, aber der Geschäftscode ist sich der Existenz von Sidecar überhaupt nicht bewusst. Dadurch wird erreicht, dass die Governance-Logik nicht in den Geschäftscode eindringt – tatsächlich ist der Code nicht nur nicht aufdringlich, es gibt auch keine Kopplung zwischen beiden zur Laufzeit. Dies ermöglicht die Entwicklung verschiedener Microservices mit unterschiedlichen Sprachen und Technologie-Stacks, ohne sich um Service-Governance-Probleme kümmern zu müssen. Man kann sagen, dass dies eine sehr elegante Lösung ist.

Die Frage „Warum Istio verwenden?“ ist also leicht zu lösen – denn Istio löst die Schwachstellen traditioneller Microservices wie die Kopplung von Geschäftslogik und Service-Governance-Logik und die Unfähigkeit, sprachübergreifend gut zu implementieren, und das ist es auch sehr einfach zu bedienen. Sobald Sie Kubernetes beherrschen, ist es nicht schwierig, den Umgang mit Istio zu erlernen.

1.1. Warum gRPC als Kommunikationsframework verwenden?

In der Microservice-Architektur stellt die Kommunikation zwischen Diensten ein relativ großes Problem dar und wird im Allgemeinen über RPC oder RESTful API implementiert.

Spring Boot kann RestTemplate zum Aufrufen von Remote-Diensten verwenden, aber diese Methode ist nicht intuitiv und der Code ist auch ein großes Problem. gRPC ist leichter als gängige Java-RPC-Frameworks wie Dubbo Es ist auch sehr bequem zu verwenden, der Code ist gut lesbar und kann gut in Istio und Kubernetes integriert werden. Die Leistung ist nicht schlecht, daher wurde dieses Mal gRPC zur Lösung des Problems ausgewählt Kommunikationsproblem zwischen Spring Boot-Microservices. Obwohl gRPC nicht über Serviceerkennung, Lastausgleich und andere Funktionen verfügt, ist Istio in dieser Hinsicht sehr leistungsfähig und die beiden bilden eine perfekte komplementäre Beziehung.

Angesichts der Tatsache, dass verschiedene GRPC-Spring-Boot-Starter möglicherweise unbekannte Nebenwirkungen auf die Integration von Spring Boot und Istio haben, habe ich dieses Mal keinen GRPC-Spring-Boot-Starter verwendet, sondern ihn direkt von Hand geschrieben Integration von gRPC und Spring Boot. Wenn Sie zur Integration von gRPC und Spring Boot kein Framework eines Drittanbieters verwenden möchten, können Sie sich auf meine einfache Implementierungsmethode beziehen.

1.2. Schreiben Sie Geschäftscode

Verwenden Sie zunächst Spring Initializr, um das übergeordnete Projekt spring-boot-istio einzurichten und gRPC-Abhängigkeiten einzuführen. Die POM-Datei lautet wie folgt:

<?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>

Nach dem Login kopieren

Erstellen Sie dann das öffentliche Abhängigkeitsmodul spring-boot-istio-api. Die POM-Datei lautet wie folgt, hauptsächlich einige Abhängigkeiten von 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>

Nach dem Login kopieren

Erstellen Sie den Ordner src/main/proto Erstellen Sie „Hallo“ unter diesem Ordner. Proto definiert die Schnittstelle zwischen Diensten wie folgt:

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;
}

Nach dem Login kopieren

Es ist ganz einfach: Senden Sie einfach einen Namen und senden Sie eine Nachricht mit dem Namen zurück.

Generieren Sie dann die Server- und Client-Codes und legen Sie sie im Java-Ordner ab. Für diesen Teil lesen Sie bitte die offizielle Dokumentation von gRPC.

Sobald das API-Modul verfügbar ist, können Dienstanbieter (Server) und Dienstkonsumenten (Clients) entwickelt werden. Hier konzentrieren wir uns auf die Integration von gRPC und Spring Boot.

1) Der serverseitige

Geschäftscode ist sehr einfach:

/**
 * 服务端业务逻辑实现
 * 
 * @author 江文
 * @date 2020/4/12 2:49 下午
 */
@Slf4j
@Component
public 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());
    }
}

Nach dem Login kopieren

Zusätzlich zum Geschäftscode müssen wir gleichzeitig mit dem Start der Anwendung auch den gRPC-Server starten. Schreiben Sie zunächst die Start-, Stopp- und andere Logik auf der Serverseite:

/**
 * 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();
        }
    }
}

Nach dem Login kopieren

Nachdem Sie die Start-, Stopp- und andere Logik von gRPC definiert haben, können Sie sie mit CommandLineRunner zum Start von Spring Boot hinzufügen:

/** 
 * 加入gRPC Server的启动、停止等逻辑到Spring Boot的生命周期中
 *
 * @author 江文
 * @date 2020/4/12 3:10 下午
 */
@Component
public class GrpcCommandLineRunner implements CommandLineRunner {
    @Autowired
    GrpcServerConfiguration configuration;

    @Override
    public void run(String... args) throws Exception {
        configuration.start();
        configuration.block();
    }
}

Nach dem Login kopieren

Wir werden uns registrieren die Logik von gRPC Es wird zu einem Spring Bean, weil Sie seine Instanz abrufen und entsprechende Vorgänge ausführen müssen.

Auf diese Weise kann beim Starten von Spring Boot aufgrund der Existenz von CommandLineRunner der gRPC-Server gemeinsam gestartet werden.

2) Der Geschäftscode des Kunden

ist ebenfalls sehr einfach:

/**
 * 客户端业务逻辑实现
 *
 * @author 江文
 * @date 2020/4/12 3:26 下午
 */
@RestController
@Slf4j
public 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();
    }
}

Nach dem Login kopieren

在启动客户端时，我们需要打开gRPC的客户端，并获取到channel和stub以进行RPC通信，来看看gRPC客户端的实现逻辑：

/**
 * gRPC Client的配置——启动、建立channel、获取stub、关闭等
 * 需要注册为Spring Bean
 *
 * @author 江文
 * @date 2020/4/12 3:27 下午
 */
@Slf4j
@Component
public 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;
    }
}

Nach dem Login kopieren

比服务端要简单一些。

最后，仍然需要一个CommandLineRunner把这些启动逻辑加入到Spring Boot的启动过程中：

/**
 * 加入gRPC Client的启动、停止等逻辑到Spring Boot生命周期中
 *
 * @author 江文
 * @date 2020/4/12 3:36 下午
 */
@Component
@Slf4j
public 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();
            }
        }));
    }
}

Nach dem Login kopieren

1.3､编写Dockerfile

业务代码跑通之后，就可以制作Docker镜像，准备部署到Istio中去了。

在开始编写Dockerfile之前，先改动一下客户端的配置文件：

server:
  port: 19090
spring:
  application:
      name: spring-boot-istio-clientserver-host: ${server-host}server-port: ${server-port}

Nach dem Login kopieren

接下来编写Dockerfile：

1) 服务端：

FROM openjdk:8u121-jdk
RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
  && echo &#39;Asia/Shanghai&#39; >/etc/timezone
ADD /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

Nach dem Login kopieren

主要是规定服务端应用的端口为18080，并且在容器启动时让服务端也一起启动。

2) 客户端：

FROM openjdk:8u121-jdk
RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
  && echo &#39;Asia/Shanghai&#39; >/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

Nach dem Login kopieren

可以看到这里添加了启动参数，配合前面的配置，当这个镜像部署到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>

Nach dem Login kopieren

这样执行mvn clean package时就可以同时把docker镜像构建出来了。

2. 编写部署文件

有了镜像之后，就可以写部署文件了：

1) 服务端：

apiVersion: v1
kind:
 Servicemetadata:
  name: spring-boot-istio-server
spec:
  type: ClusterIP
  ports:
    - name: http 
      port: 18080
      targetPort: 18080
    - name: grpc
      port: 18888
      targetPort: 18888
  selector:
    app: spring-boot-istio-server

---apiVersion: apps/v1
kind:
 Deploymentmetadata:
  name: spring-boot-istio-server
spec:
  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

Nach dem Login kopieren

主要是暴露服务端的端口：18080和gRPC Server的端口18888，以便可以从Pod外部访问服务端。

2) 客户端：

apiVersion: v1
kind:
 Servicemetadata:
  name:
 spring-boot-istio-client
spec:
  type: ClusterIP
  ports:
    - name: http
      port: 19090
      targetPort: 19090
  selector:
    app: spring-boot-istio-client

---apiVersion: apps/v1
kind:
 Deploymentmetadata:
  name: spring-boot-istio-client
spec:
  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

Nach dem Login kopieren

主要是暴露客户端的端口19090，以便访问客户端并调用服务端。

如果想先试试把它们部署到k8s可不可以正常访问，可以这样配置Ingress：

apiVersion: networking.k8s.io/v1beta1
kind:
 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

Nach dem Login kopieren

Istio的网关配置文件与k8s不大一样：

apiVersion: networking.istio.io/v1alpha3
kind:
 Gatewaymetadata:
  name: spring-boot-istio-gateway
spec:
  selector:
    istio: ingressgateway
  servers:
    - port:
        number: 80
        name: http
        protocol: HTTP
      hosts:
        - "*"

---apiVersion: networking.istio.io/v1alpha3
kind: Virtual
Servicemetadata:
  name: spring-boot-istio
spec:
  hosts:
    - "*"
  gateways:
    - spring-boot-istio-gateway
  http:
    - match:
        - uri:
            exact: /hello
      route:
        - destination:
            host: spring-boot-istio-client
            port:
              number: 19090

Nach dem Login kopieren

主要就是暴露/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-system
NAME                   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

Nach dem Login kopieren

所以，需要设置IP和端口，以NodePort的方式访问gateway：

export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath=&#39;{.spec.ports[?(@.name=="http2")].nodePort}&#39;)
export SECURE_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath=&#39;{.spec.ports[?(@.name=="https")].nodePort}&#39;)
export INGRESS_HOST=127.0.0.1export GATEWAY_URL=$INGRESS_HOST:$INGRESS_PORT

Nach dem Login kopieren

这样就可以了。

接下来部署服务：

$ kubectl apply -f spring-boot-istio-server.yml
$ kubectl apply -f spring-boot-istio-client.yml
$ kubectl apply -f istio-gateway.yml

Nach dem Login kopieren

必须要等到两个pod全部变为Running而且Ready变为2/2才算部署完成。

接下来就可以通过

curl -s http://${GATEWAY_URL}/hello

Nach dem Login kopieren

访问到服务了。如果成功返回了Hello, JiangWen. This message comes from gRPC.的结果，没有出错则说明部署完成。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Spring Boot+gRPC zum Erstellen und Bereitstellen von Microservices. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!