入门指南：服务间的弹性

通过服务调用API开始使用Dapr的弹性功能

通过模拟系统故障来测试Dapr的弹性功能。在本入门指南中，您将会：

运行两个微服务应用程序：checkout和order-processor。checkout将持续向order-processor发起Dapr服务调用请求。
通过模拟系统故障来触发弹性机制。
移除故障以让微服务应用程序恢复。

在继续入门指南之前，选择您偏好的Dapr SDK语言版本。

前提条件

对于此示例，您将需要：

Docker Desktop

步骤1：设置环境

克隆入门指南仓库中提供的示例。

git clone https://github.com/dapr/quickstarts.git

步骤2：运行`order-processor`服务

在终端窗口中，从入门指南目录的根目录导航到order-processor目录。

cd service_invocation/python/http/order-processor

安装依赖项：

pip3 install -r requirements.txt

运行order-processor服务及其Dapr sidecar。

dapr run --app-port 8001 --app-id order-processor --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3501 -- python3 app.py

步骤3：运行`checkout`服务应用程序

在新的终端窗口中，从入门指南目录的根目录导航到checkout目录。

cd service_invocation/python/http/checkout

安装依赖项：

pip3 install -r requirements.txt

运行checkout服务及其Dapr sidecar。

dapr run --app-id checkout --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3500 -- python3 app.py

Dapr sidecar随后加载位于资源目录中的弹性配置：

apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
  name: myresiliency
scopes:
  - checkout

spec:
  policies:
    retries:
      retryForever:
        policy: constant
        maxInterval: 5s
        maxRetries: -1 

    circuitBreakers:
      simpleCB:
        maxRequests: 1
        timeout: 5s 
        trip: consecutiveFailures >= 5

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

步骤4：查看服务调用输出

当两个服务和sidecar都在运行时，注意订单如何通过Dapr服务调用从checkout服务传递到order-processor服务。

checkout服务输出：

== APP == Order passed: {"orderId": 1}
== APP == Order passed: {"orderId": 2}
== APP == Order passed: {"orderId": 3}
== APP == Order passed: {"orderId": 4}

order-processor服务输出：

== APP == Order received: {"orderId": 1}
== APP == Order received: {"orderId": 2}
== APP == Order received: {"orderId": 3}
== APP == Order received: {"orderId": 4}

步骤5：引入故障

通过停止order-processor服务来模拟故障。一旦实例停止，来自checkout服务的服务调用操作将开始失败。

由于resiliency.yaml配置将order-processor服务定义为弹性目标，所有失败的请求将应用重试和断路器策略：

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

在order-processor窗口中，停止服务：

CTRL + C

一旦第一个请求失败，名为retryForever的重试策略将被应用：

INFO[0005] Error processing operation endpoint[order-processor, order-processor:orders]. Retrying...

重试将以5秒的间隔无限期地继续每个失败的请求。

retryForever:
  policy: constant
  maxInterval: 5s
  maxRetries: -1

一旦连续5次重试失败，断路器策略simpleCB将被触发，断路器打开，停止所有请求：

INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open

circuitBreakers:
  simpleCB:
  maxRequests: 1
  timeout: 5s 
  trip: consecutiveFailures >= 5

经过5秒后，断路器将切换到半开状态，允许一个请求通过以验证故障是否已解决。如果请求继续失败，断路器将再次触发回到打开状态。

INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open   
INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

这种半开/打开行为将持续到order-processor服务停止为止。

步骤6：移除故障

一旦您重新启动order-processor服务，应用程序将无缝恢复，继续接受订单请求。

在order-processor服务终端中，重新启动应用程序：

dapr run --app-port 8001 --app-id order-processor --app-protocol http --dapr-http-port 3501 -- python3 app.py

checkout服务输出：

== APP == Order passed: {"orderId": 5}
== APP == Order passed: {"orderId": 6}
== APP == Order passed: {"orderId": 7}
== APP == Order passed: {"orderId": 8}
== APP == Order passed: {"orderId": 9}
== APP == Order passed: {"orderId": 10}

order-processor服务输出：

== APP == Order received: {"orderId": 5}
== APP == Order received: {"orderId": 6}
== APP == Order received: {"orderId": 7}
== APP == Order received: {"orderId": 8}
== APP == Order received: {"orderId": 9}
== APP == Order received: {"orderId": 10}

前提条件

对于此示例，您将需要：

Docker Desktop

步骤1：设置环境

克隆入门指南仓库中提供的示例。

git clone https://github.com/dapr/quickstarts.git

步骤2：运行`order-processor`服务

在终端窗口中，从入门指南目录的根目录导航到order-processor目录。

cd service_invocation/javascript/http/order-processor

安装依赖项：

npm install

运行order-processor服务及其Dapr sidecar。

dapr run --app-port 5001 --app-id order-processor --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3501 -- npm start

步骤3：运行`checkout`服务应用程序

在新的终端窗口中，从入门指南目录的根目录导航到checkout目录。

cd service_invocation/javascript/http/checkout

安装依赖项：

npm install

运行checkout服务及其Dapr sidecar。

dapr run --app-id checkout --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3500 -- npm start

Dapr sidecar随后加载位于资源目录中的弹性配置：

apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
  name: myresiliency
scopes:
  - checkout

spec:
  policies:
    retries:
      retryForever:
        policy: constant
        maxInterval: 5s
        maxRetries: -1 

    circuitBreakers:
      simpleCB:
        maxRequests: 1
        timeout: 5s 
        trip: consecutiveFailures >= 5

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

步骤4：查看服务调用输出

当两个服务和sidecar都在运行时，注意订单如何通过Dapr服务调用从checkout服务传递到order-processor服务。

checkout服务输出：

== APP == Order passed: {"orderId": 1}
== APP == Order passed: {"orderId": 2}
== APP == Order passed: {"orderId": 3}
== APP == Order passed: {"orderId": 4}

order-processor服务输出：

== APP == Order received: {"orderId": 1}
== APP == Order received: {"orderId": 2}
== APP == Order received: {"orderId": 3}
== APP == Order received: {"orderId": 4}

步骤5：引入故障

通过停止order-processor服务来模拟故障。一旦实例停止，来自checkout服务的服务调用操作将开始失败。

由于resiliency.yaml配置将order-processor服务定义为弹性目标，所有失败的请求将应用重试和断路器策略：

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

在order-processor窗口中，停止服务：

MacOs
Windows

CMD + C

CTRL + C

一旦第一个请求失败，名为retryForever的重试策略将被应用：

INFO[0005] Error processing operation endpoint[order-processor, order-processor:orders]. Retrying...

重试将以5秒的间隔无限期地继续每个失败的请求。

retryForever:
  policy: constant
  maxInterval: 5s
  maxRetries: -1

一旦连续5次重试失败，断路器策略simpleCB将被触发，断路器打开，停止所有请求：

INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open

circuitBreakers:
  simpleCB:
  maxRequests: 1
  timeout: 5s 
  trip: consecutiveFailures >= 5

经过5秒后，断路器将切换到半开状态，允许一个请求通过以验证故障是否已解决。如果请求继续失败，断路器将再次触发回到打开状态。

INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open   
INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

这种半开/打开行为将持续到order-processor服务停止为止。

步骤6：移除故障

一旦您重新启动order-processor服务，应用程序将无缝恢复，继续接受订单请求。

在order-processor服务终端中，重新启动应用程序：

dapr run --app-port 5001 --app-id order-processor --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3501 -- npm start

checkout服务输出：

== APP == Order passed: {"orderId": 5}
== APP == Order passed: {"orderId": 6}
== APP == Order passed: {"orderId": 7}
== APP == Order passed: {"orderId": 8}
== APP == Order passed: {"orderId": 9}
== APP == Order passed: {"orderId": 10}

order-processor服务输出：

== APP == Order received: {"orderId": 5}
== APP == Order received: {"orderId": 6}
== APP == Order received: {"orderId": 7}
== APP == Order received: {"orderId": 8}
== APP == Order received: {"orderId": 9}
== APP == Order received: {"orderId": 10}

前提条件

对于此示例，您将需要：

Docker Desktop

步骤1：设置环境

克隆入门指南仓库中提供的示例。

git clone https://github.com/dapr/quickstarts.git

步骤2：运行`order-processor`服务

在终端窗口中，从入门指南目录的根目录导航到order-processor目录。

cd service_invocation/csharp/http/order-processor

安装依赖项：

dotnet restore
dotnet build

运行order-processor服务及其Dapr sidecar。

dapr run --app-port 7001 --app-id order-processor --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3501 -- dotnet run

步骤3：运行`checkout`服务应用程序

在新的终端窗口中，从入门指南目录的根目录导航到checkout目录。

cd service_invocation/csharp/http/checkout

安装依赖项：

dotnet restore
dotnet build

运行checkout服务及其Dapr sidecar。

dapr run --app-id checkout --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3500 -- dotnet run

Dapr sidecar随后加载位于资源目录中的弹性配置：

apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
  name: myresiliency
scopes:
  - checkout

spec:
  policies:
    retries:
      retryForever:
        policy: constant
        maxInterval: 5s
        maxRetries: -1 

    circuitBreakers:
      simpleCB:
        maxRequests: 1
        timeout: 5s 
        trip: consecutiveFailures >= 5

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

步骤4：查看服务调用输出

当两个服务和sidecar都在运行时，注意订单如何通过Dapr服务调用从checkout服务传递到order-processor服务。

checkout服务输出：

== APP == Order passed: {"orderId": 1}
== APP == Order passed: {"orderId": 2}
== APP == Order passed: {"orderId": 3}
== APP == Order passed: {"orderId": 4}

order-processor服务输出：

== APP == Order received: {"orderId": 1}
== APP == Order received: {"orderId": 2}
== APP == Order received: {"orderId": 3}
== APP == Order received: {"orderId": 4}

步骤5：引入故障

通过停止order-processor服务来模拟故障。一旦实例停止，来自checkout服务的服务调用操作将开始失败。

由于resiliency.yaml配置将order-processor服务定义为弹性目标，所有失败的请求将应用重试和断路器策略：

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

在order-processor窗口中，停止服务：

MacOs
Windows

CMD + C

CTRL + C

一旦第一个请求失败，名为retryForever的重试策略将被应用：

INFO[0005] Error processing operation endpoint[order-processor, order-processor:orders]. Retrying...

重试将以5秒的间隔无限期地继续每个失败的请求。

retryForever:
  policy: constant
  maxInterval: 5s
  maxRetries: -1

一旦连续5次重试失败，断路器策略simpleCB将被触发，断路器打开，停止所有请求：

INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open

circuitBreakers:
  simpleCB:
  maxRequests: 1
  timeout: 5s 
  trip: consecutiveFailures >= 5

经过5秒后，断路器将切换到半开状态，允许一个请求通过以验证故障是否已解决。如果请求继续失败，断路器将再次触发回到打开状态。

INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open   
INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

这种半开/打开行为将持续到order-processor服务停止为止。

步骤6：移除故障

一旦您重新启动order-processor服务，应用程序将无缝恢复，继续接受订单请求。

在order-processor服务终端中，重新启动应用程序：

dapr run --app-port 7001 --app-id order-processor --app-protocol http --dapr-http-port 3501 -- dotnet run

checkout服务输出：

== APP == Order passed: {"orderId": 5}
== APP == Order passed: {"orderId": 6}
== APP == Order passed: {"orderId": 7}
== APP == Order passed: {"orderId": 8}
== APP == Order passed: {"orderId": 9}
== APP == Order passed: {"orderId": 10}

order-processor服务输出：

== APP == Order received: {"orderId": 5}
== APP == Order received: {"orderId": 6}
== APP == Order received: {"orderId": 7}
== APP == Order received: {"orderId": 8}
== APP == Order received: {"orderId": 9}
== APP == Order received: {"orderId": 10}

前提条件

对于此示例，您将需要：

Dapr CLI和已初始化的环境。
Java JDK 17（或更高版本）：
- Oracle JDK，或
- OpenJDK
Apache Maven，版本3.x。

Docker Desktop

步骤1：设置环境

克隆入门指南仓库中提供的示例。

git clone https://github.com/dapr/quickstarts.git

步骤2：运行`order-processor`服务

在终端窗口中，从入门指南目录的根目录导航到order-processor目录。

cd service_invocation/java/http/order-processor

安装依赖项：

mvn clean install

运行order-processor服务及其Dapr sidecar。

dapr run --app-id order-processor --resources-path ../../../resources/ --app-port 9001 --app-protocol http --dapr-http-port 3501 -- java -jar target/OrderProcessingService-0.0.1-SNAPSHOT.jar

步骤3：运行`checkout`服务应用程序

在新的终端窗口中，从入门指南目录的根目录导航到checkout目录。

cd service_invocation/java/http/checkout

安装依赖项：

mvn clean install

运行checkout服务及其Dapr sidecar。

dapr run --app-id checkout --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3500 -- java -jar target/CheckoutService-0.0.1-SNAPSHOT.jar

Dapr sidecar随后加载位于资源目录中的弹性配置：

apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
  name: myresiliency
scopes:
  - checkout

spec:
  policies:
    retries:
      retryForever:
        policy: constant
        maxInterval: 5s
        maxRetries: -1 

    circuitBreakers:
      simpleCB:
        maxRequests: 1
        timeout: 5s 
        trip: consecutiveFailures >= 5

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

步骤4：查看服务调用输出

当两个服务和sidecar都在运行时，注意订单如何通过Dapr服务调用从checkout服务传递到order-processor服务。

checkout服务输出：

== APP == Order passed: {"orderId": 1}
== APP == Order passed: {"orderId": 2}
== APP == Order passed: {"orderId": 3}
== APP == Order passed: {"orderId": 4}

order-processor服务输出：

== APP == Order received: {"orderId": 1}
== APP == Order received: {"orderId": 2}
== APP == Order received: {"orderId": 3}
== APP == Order received: {"orderId": 4}

步骤5：引入故障

通过停止order-processor服务来模拟故障。一旦实例停止，来自checkout服务的服务调用操作将开始失败。

由于resiliency.yaml配置将order-processor服务定义为弹性目标，所有失败的请求将应用重试和断路器策略：

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

在order-processor窗口中，停止服务：

MacOs
Windows

CMD + C

CTRL + C

一旦第一个请求失败，名为retryForever的重试策略将被应用：

INFO[0005] Error processing operation endpoint[order-processor, order-processor:orders]. Retrying...

重试将以5秒的间隔无限期地继续每个失败的请求。

retryForever:
  policy: constant
  maxInterval: 5s
  maxRetries: -1

一旦连续5次重试失败，断路器策略simpleCB将被触发，断路器打开，停止所有请求：

INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open

circuitBreakers:
  simpleCB:
  maxRequests: 1
  timeout: 5s 
  trip: consecutiveFailures >= 5

经过5秒后，断路器将切换到半开状态，允许一个请求通过以验证故障是否已解决。如果请求继续失败，断路器将再次触发回到打开状态。

INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open   
INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

这种半开/打开行为将持续到order-processor服务停止为止。

步骤6：移除故障

一旦您重新启动order-processor服务，应用程序将无缝恢复，继续接受订单请求。

在order-processor服务终端中，重新启动应用程序：

dapr run --app-id order-processor --resources-path ../../../resources/ --app-port 9001 --app-protocol http --dapr-http-port 3501 -- java -jar target/OrderProcessingService-0.0.1-SNAPSHOT.jar

checkout服务输出：

== APP == Order passed: {"orderId": 5}
== APP == Order passed: {"orderId": 6}
== APP == Order passed: {"orderId": 7}
== APP == Order passed: {"orderId": 8}
== APP == Order passed: {"orderId": 9}
== APP == Order passed: {"orderId": 10}

order-processor服务输出：

== APP == Order received: {"orderId": 5}
== APP == Order received: {"orderId": 6}
== APP == Order received: {"orderId": 7}
== APP == Order received: {"orderId": 8}
== APP == Order received: {"orderId": 9}
== APP == Order received: {"orderId": 10}

前提条件

对于此示例，您将需要：

Docker Desktop

步骤1：设置环境

克隆入门指南仓库中提供的示例。

git clone https://github.com/dapr/quickstarts.git

步骤2：运行`order-processor`服务

在终端窗口中，从入门指南目录的根目录导航到order-processor目录。

cd service_invocation/go/http/order-processor

安装依赖项：

go build .

运行order-processor服务及其Dapr sidecar。

dapr run --app-port 6001 --app-id order-processor --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3501 -- go run .

步骤3：运行`checkout`服务应用程序

在新的终端窗口中，从入门指南目录的根目录导航到checkout目录。

cd service_invocation/go/http/checkout

安装依赖项：

go build .

运行checkout服务及其Dapr sidecar。

dapr run --app-id checkout --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3500 -- go run .

Dapr sidecar随后加载位于资源目录中的弹性配置：

apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
  name: myresiliency
scopes:
  - checkout

spec:
  policies:
    retries:
      retryForever:
        policy: constant
        maxInterval: 5s
        maxRetries: -1 

    circuitBreakers:
      simpleCB:
        maxRequests: 1
        timeout: 5s 
        trip: consecutiveFailures >= 5

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

步骤4：查看服务调用输出

当两个服务和sidecar都在运行时，注意订单如何通过Dapr服务调用从checkout服务传递到order-processor服务。

checkout服务输出：

== APP == Order passed: {"orderId": 1}
== APP == Order passed: {"orderId": 2}
== APP == Order passed: {"orderId": 3}
== APP == Order passed: {"orderId": 4}

order-processor服务输出：

== APP == Order received: {"orderId": 1}
== APP == Order received: {"orderId": 2}
== APP == Order received: {"orderId": 3}
== APP == Order received: {"orderId": 4}

步骤5：引入故障

通过停止order-processor服务来模拟故障。一旦实例停止，来自checkout服务的服务调用操作将开始失败。

由于resiliency.yaml配置将order-processor服务定义为弹性目标，所有失败的请求将应用重试和断路器策略：

  targets:
    apps:
      order-processor:
        retry: retryForever
        circuitBreaker: simpleCB

在order-processor窗口中，停止服务：

MacOs
Windows

CMD + C

CTRL + C

一旦第一个请求失败，名为retryForever的重试策略将被应用：

INFO[0005] Error processing operation endpoint[order-processor, order-processor:orders]. Retrying...

重试将以5秒的间隔无限期地继续每个失败的请求。

retryForever:
  policy: constant
  maxInterval: 5s
  maxRetries: -1

一旦连续5次重试失败，断路器策略simpleCB将被触发，断路器打开，停止所有请求：

INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open

circuitBreakers:
  simpleCB:
  maxRequests: 1
  timeout: 5s 
  trip: consecutiveFailures >= 5

经过5秒后，断路器将切换到半开状态，允许一个请求通过以验证故障是否已解决。如果请求继续失败，断路器将再次触发回到打开状态。

INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open   
INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open  
INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

这种半开/打开行为将持续到order-processor服务停止为止。

步骤6：移除故障

一旦您重新启动order-processor服务，应用程序将无缝恢复，继续接受订单请求。

在order-processor服务终端中，重新启动应用程序：

dapr run --app-port 6001 --app-id order-processor --resources-path ../../../resources/ --app-protocol http --dapr-http-port 3501 -- go run .

checkout服务输出：

== APP == Order passed: {"orderId": 5}
== APP == Order passed: {"orderId": 6}
== APP == Order passed: {"orderId": 7}
== APP == Order passed: {"orderId": 8}
== APP == Order passed: {"orderId": 9}
== APP == Order passed: {"orderId": 10}

order-processor服务输出：

== APP == Order received: {"orderId": 5}
== APP == Order received: {"orderId": 6}
== APP == Order received: {"orderId": 7}
== APP == Order received: {"orderId": 8}
== APP == Order received: {"orderId": 9}
== APP == Order received: {"orderId": 10}

告诉我们您的想法！

我们正在不断努力改进我们的入门指南示例，重视您的反馈。您觉得这个入门指南有帮助吗？您有改进建议吗？

加入我们的discord频道讨论。

下一步

访问此链接以获取有关Dapr弹性的更多信息。

探索Dapr教程 >>

Feedback

Was this page helpful?

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.

入门指南：服务间的弹性

前提条件

步骤1：设置环境

步骤2：运行order-processor服务

步骤3：运行checkout服务应用程序

步骤4：查看服务调用输出

步骤5：引入故障

步骤6：移除故障

前提条件

步骤1：设置环境

步骤2：运行order-processor服务

步骤3：运行checkout服务应用程序

步骤4：查看服务调用输出

步骤5：引入故障

步骤6：移除故障

前提条件

步骤1：设置环境

步骤2：运行order-processor服务

步骤3：运行checkout服务应用程序

步骤4：查看服务调用输出

步骤5：引入故障

步骤6：移除故障

前提条件

步骤1：设置环境

步骤2：运行order-processor服务

步骤3：运行checkout服务应用程序

步骤4：查看服务调用输出

步骤5：引入故障

步骤6：移除故障

前提条件

步骤1：设置环境

步骤2：运行order-processor服务

步骤3：运行checkout服务应用程序

步骤4：查看服务调用输出

步骤5：引入故障

步骤6：移除故障

告诉我们您的想法！

下一步

Feedback

步骤2：运行`order-processor`服务

步骤3：运行`checkout`服务应用程序

步骤2：运行`order-processor`服务

步骤3：运行`checkout`服务应用程序

步骤2：运行`order-processor`服务

步骤3：运行`checkout`服务应用程序

步骤2：运行`order-processor`服务

步骤3：运行`checkout`服务应用程序

步骤2：运行`order-processor`服务

步骤3：运行`checkout`服务应用程序