快速入门:服务到服务的弹性

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

通过模拟系统故障来观察 Dapr 的弹性能力。 在本快速入门中,您将:

  • 运行两个微服务应用程序:checkoutorder-processorcheckout将持续进行Dapr服务调用请求到order-processor
  • 通过模拟系统故障来触发弹性规范。
  • 去除故障以允许微服务应用程序恢复。

Diagram showing the resiliency applied to Dapr APIs

在继续快速入门之前,请选择您首选的特定语言 Dapr SDK。

先决条件

对于此示例,您将需要:

第1步:设置环境

克隆在Quickstarts存储库中提供的示例

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

第2步:运行 order-processor 服务

在终端窗口中,从快速入门目录的根目录,导航到 order-processor 目录。

  1. cd service_invocation/python/http/order-processor

安装依赖项:

  1. pip3 install -r requirements.txt

与 Dapr sidecar 一起运行 order-processor 服务。

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

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

在新的终端窗口中,从 Quickstart 目录的根目录导航到 checkout 目录。

  1. cd service_invocation/python/http/checkout

安装依赖项:

  1. pip3 install -r requirements.txt

与 Dapr sidecar 一起运行 checkout 服务。

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

然后 Dapr sidecar 加载位于资源目录中的弹性规范:

  1. apiVersion: dapr.io/v1alpha1
  2. kind: Resiliency
  3. metadata:
  4. name: myresiliency
  5. scopes:
  6. - checkout
  7. spec:
  8. policies:
  9. retries:
  10. retryForever:
  11. policy: constant
  12. maxInterval: 5s
  13. maxRetries: -1
  14. circuitBreakers:
  15. simpleCB:
  16. maxRequests: 1
  17. timeout: 5s
  18. trip: consecutiveFailures >= 5
  19. targets:
  20. apps:
  21. order-processor:
  22. retry: retryForever
  23. circuitBreaker: simpleCB

第4步:查看服务调用输出

当服务和sidecars都在运行时,请注意订单是如何通过Dapr服务调用从checkout服务传递到order-processor服务的。

checkout服务输出:

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

order-processor服务输出:

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

步骤 5:引入故障

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

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

  1. targets:
  2. apps:
  3. order-processor:
  4. retry: retryForever
  5. circuitBreaker: simpleCB

order-processor 窗口中,停止服务:

  1. CTRL + C

一旦第一个请求失败,将应用名为retryForever的重试策略:

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

重试将无限期地对每个失败的请求进行,每隔5秒一次。

  1. retryForever:
  2. policy: constant
  3. maxInterval: 5s
  4. maxRetries: -1

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

  1. INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open
  1. circuitBreakers:
  2. simpleCB:
  3. maxRequests: 1
  4. timeout: 5s
  5. trip: consecutiveFailures >= 5

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

  1. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  2. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open
  3. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  4. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

只要停止 order-processor 服务,这种半开/开放行为将继续下去。

第6步:移除故障

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

order-processor 服务终端上,重新启动应用程序:

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

checkout服务输出:

  1. == APP == Order passed: {"orderId": 5}
  2. == APP == Order passed: {"orderId": 6}
  3. == APP == Order passed: {"orderId": 7}
  4. == APP == Order passed: {"orderId": 8}
  5. == APP == Order passed: {"orderId": 9}
  6. == APP == Order passed: {"orderId": 10}

order-processor服务输出:

  1. == APP == Order received: {"orderId": 5}
  2. == APP == Order received: {"orderId": 6}
  3. == APP == Order received: {"orderId": 7}
  4. == APP == Order received: {"orderId": 8}
  5. == APP == Order received: {"orderId": 9}
  6. == APP == Order received: {"orderId": 10}

先决条件

对于此示例,您将需要:

第1步:设置环境

克隆在Quickstarts存储库中提供的示例

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

第2步:运行 order-processor 服务

在终端窗口中,从快速入门目录的根目录, 导航到 order-processor 目录。

  1. cd service_invocation/javascript/http/order-processor

安装依赖项:

  1. npm install

与 Dapr sidecar 一起运行 order-processor 服务。

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

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

在新的终端窗口中,从 Quickstart 目录的根目录导航到 checkout 目录。

  1. cd service_invocation/javascript/http/checkout

安装依赖项:

  1. npm install

与 Dapr sidecar 一起运行 checkout 服务。

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

然后 Dapr sidecar 加载位于资源目录中的弹性规范:

  1. apiVersion: dapr.io/v1alpha1
  2. kind: Resiliency
  3. metadata:
  4. name: myresiliency
  5. scopes:
  6. - checkout
  7. spec:
  8. policies:
  9. retries:
  10. retryForever:
  11. policy: constant
  12. maxInterval: 5s
  13. maxRetries: -1
  14. circuitBreakers:
  15. simpleCB:
  16. maxRequests: 1
  17. timeout: 5s
  18. trip: consecutiveFailures >= 5
  19. targets:
  20. apps:
  21. order-processor:
  22. retry: retryForever
  23. circuitBreaker: simpleCB

第4步:查看服务调用输出

当服务和sidecars都在运行时,请注意订单是如何通过Dapr服务调用从checkout服务传递到order-processor服务的。

checkout服务输出:

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

order-processor服务输出:

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

步骤 5:引入故障

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

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

  1. targets:
  2. apps:
  3. order-processor:
  4. retry: retryForever
  5. circuitBreaker: simpleCB

order-processor 窗口中,停止服务:

  1. CMD + C
  1. CTRL + C

一旦第一个请求失败,将应用名为retryForever的重试策略:

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

重试将无限期地对每个失败的请求进行,每隔5秒一次。

  1. retryForever:
  2. policy: constant
  3. maxInterval: 5s
  4. maxRetries: -1

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

  1. INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open
  1. circuitBreakers:
  2. simpleCB:
  3. maxRequests: 1
  4. timeout: 5s
  5. trip: consecutiveFailures >= 5

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

  1. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  2. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open
  3. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  4. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

只要停止 Redis 容器,这种半开/开放行为将继续下去。

第6步:移除故障

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

order-processor 服务终端上,重新启动应用程序:

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

checkout服务输出:

  1. == APP == Order passed: {"orderId": 5}
  2. == APP == Order passed: {"orderId": 6}
  3. == APP == Order passed: {"orderId": 7}
  4. == APP == Order passed: {"orderId": 8}
  5. == APP == Order passed: {"orderId": 9}
  6. == APP == Order passed: {"orderId": 10}

order-processor服务输出:

  1. == APP == Order received: {"orderId": 5}
  2. == APP == Order received: {"orderId": 6}
  3. == APP == Order received: {"orderId": 7}
  4. == APP == Order received: {"orderId": 8}
  5. == APP == Order received: {"orderId": 9}
  6. == APP == Order received: {"orderId": 10}

先决条件

对于此示例,您将需要:

第1步:设置环境

克隆在Quickstarts存储库中提供的示例

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

第2步:运行 order-processor 服务

在终端窗口中,从快速入门目录的根目录, 导航到 order-processor 目录。

  1. cd service_invocation/csharp/http/order-processor

安装依赖项:

  1. dotnet restore
  2. dotnet build

与 Dapr sidecar 一起运行 order-processor 服务。

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

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

在新的终端窗口中,从 Quickstart 目录的根目录导航到 checkout 目录。

  1. cd service_invocation/csharp/http/checkout

安装依赖项:

  1. dotnet restore
  2. dotnet build

与 Dapr sidecar 一起运行 checkout 服务。

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

然后 Dapr sidecar 加载位于资源目录中的弹性规范:

  1. apiVersion: dapr.io/v1alpha1
  2. kind: Resiliency
  3. metadata:
  4. name: myresiliency
  5. scopes:
  6. - checkout
  7. spec:
  8. policies:
  9. retries:
  10. retryForever:
  11. policy: constant
  12. maxInterval: 5s
  13. maxRetries: -1
  14. circuitBreakers:
  15. simpleCB:
  16. maxRequests: 1
  17. timeout: 5s
  18. trip: consecutiveFailures >= 5
  19. targets:
  20. apps:
  21. order-processor:
  22. retry: retryForever
  23. circuitBreaker: simpleCB

第4步:查看服务调用输出

当服务和sidecars都在运行时,请注意订单是如何通过Dapr服务调用从checkout服务传递到order-processor服务的。

checkout服务输出:

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

order-processor服务输出:

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

步骤 5:引入故障

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

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

  1. targets:
  2. apps:
  3. order-processor:
  4. retry: retryForever
  5. circuitBreaker: simpleCB

order-processor 窗口中,停止服务:

  1. CMD + C
  1. CTRL + C

一旦第一个请求失败,将应用名为retryForever的重试策略:

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

重试将无限期地对每个失败的请求进行,每隔5秒一次。

  1. retryForever:
  2. policy: constant
  3. maxInterval: 5s
  4. maxRetries: -1

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

  1. INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open
  1. circuitBreakers:
  2. simpleCB:
  3. maxRequests: 1
  4. timeout: 5s
  5. trip: consecutiveFailures >= 5

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

  1. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  2. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open
  3. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  4. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

只要停止 Redis 容器,这种半开/开放行为将继续下去。

第6步:移除故障

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

order-processor 服务终端上,重新启动应用程序:

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

checkout服务输出:

  1. == APP == Order passed: {"orderId": 5}
  2. == APP == Order passed: {"orderId": 6}
  3. == APP == Order passed: {"orderId": 7}
  4. == APP == Order passed: {"orderId": 8}
  5. == APP == Order passed: {"orderId": 9}
  6. == APP == Order passed: {"orderId": 10}

order-processor服务输出:

  1. == APP == Order received: {"orderId": 5}
  2. == APP == Order received: {"orderId": 6}
  3. == APP == Order received: {"orderId": 7}
  4. == APP == Order received: {"orderId": 8}
  5. == APP == Order received: {"orderId": 9}
  6. == APP == Order received: {"orderId": 10}

先决条件

对于此示例,您将需要:

第1步:设置环境

克隆在Quickstarts存储库中提供的示例

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

第2步:运行 order-processor 服务

在终端窗口中,从快速入门目录的根目录, 导航到 order-processor 目录。

  1. cd service_invocation/java/http/order-processor

安装依赖项:

  1. mvn clean install

与 Dapr sidecar 一起运行 order-processor 服务。

  1. 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服务应用程序

在新的终端窗口中,从 Quickstart 目录的根目录导航到 checkout 目录。

  1. cd service_invocation/java/http/checkout

安装依赖项:

  1. mvn clean install

与 Dapr sidecar 一起运行 checkout 服务。

  1. 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 加载位于资源目录中的弹性规范:

  1. apiVersion: dapr.io/v1alpha1
  2. kind: Resiliency
  3. metadata:
  4. name: myresiliency
  5. scopes:
  6. - checkout
  7. spec:
  8. policies:
  9. retries:
  10. retryForever:
  11. policy: constant
  12. maxInterval: 5s
  13. maxRetries: -1
  14. circuitBreakers:
  15. simpleCB:
  16. maxRequests: 1
  17. timeout: 5s
  18. trip: consecutiveFailures >= 5
  19. targets:
  20. apps:
  21. order-processor:
  22. retry: retryForever
  23. circuitBreaker: simpleCB

第4步:查看服务调用输出

当服务和sidecars都在运行时,请注意订单是如何通过Dapr服务调用从checkout服务传递到order-processor服务的。

checkout服务输出:

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

order-processor服务输出:

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

步骤 5:引入故障

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

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

  1. targets:
  2. apps:
  3. order-processor:
  4. retry: retryForever
  5. circuitBreaker: simpleCB

order-processor 窗口中,停止服务:

  1. CMD + C
  1. CTRL + C

一旦第一个请求失败,将应用名为retryForever的重试策略:

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

重试将无限期地对每个失败的请求进行,每隔5秒一次。

  1. retryForever:
  2. policy: constant
  3. maxInterval: 5s
  4. maxRetries: -1

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

  1. INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open
  1. circuitBreakers:
  2. simpleCB:
  3. maxRequests: 1
  4. timeout: 5s
  5. trip: consecutiveFailures >= 5

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

  1. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  2. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open
  3. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  4. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

只要停止 Redis 容器,这种半开/开放行为将继续下去。

第6步:移除故障

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

order-processor 服务终端上,重新启动应用程序:

  1. 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服务输出:

  1. == APP == Order passed: {"orderId": 5}
  2. == APP == Order passed: {"orderId": 6}
  3. == APP == Order passed: {"orderId": 7}
  4. == APP == Order passed: {"orderId": 8}
  5. == APP == Order passed: {"orderId": 9}
  6. == APP == Order passed: {"orderId": 10}

order-processor服务输出:

  1. == APP == Order received: {"orderId": 5}
  2. == APP == Order received: {"orderId": 6}
  3. == APP == Order received: {"orderId": 7}
  4. == APP == Order received: {"orderId": 8}
  5. == APP == Order received: {"orderId": 9}
  6. == APP == Order received: {"orderId": 10}

先决条件

对于此示例,您将需要:

第1步:设置环境

克隆在Quickstarts存储库中提供的示例

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

第2步:运行 order-processor 服务

在终端窗口中,从快速入门目录的根目录, 导航到 order-processor 目录。

  1. cd service_invocation/go/http/order-processor

安装依赖项:

  1. go build .

与 Dapr sidecar 一起运行 order-processor 服务。

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

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

在新的终端窗口中,从 Quickstart 目录的根目录导航到 checkout 目录。

  1. cd service_invocation/go/http/checkout

安装依赖项:

  1. go build .

与 Dapr sidecar 一起运行 checkout 服务。

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

然后 Dapr sidecar 加载位于资源目录中的弹性规范:

  1. apiVersion: dapr.io/v1alpha1
  2. kind: Resiliency
  3. metadata:
  4. name: myresiliency
  5. scopes:
  6. - checkout
  7. spec:
  8. policies:
  9. retries:
  10. retryForever:
  11. policy: constant
  12. maxInterval: 5s
  13. maxRetries: -1
  14. circuitBreakers:
  15. simpleCB:
  16. maxRequests: 1
  17. timeout: 5s
  18. trip: consecutiveFailures >= 5
  19. targets:
  20. apps:
  21. order-processor:
  22. retry: retryForever
  23. circuitBreaker: simpleCB

第4步:查看服务调用输出

当服务和sidecars都在运行时,请注意订单是如何通过Dapr服务调用从checkout服务传递到order-processor服务的。

checkout服务输出:

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

order-processor服务输出:

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

步骤 5:引入故障

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

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

  1. targets:
  2. apps:
  3. order-processor:
  4. retry: retryForever
  5. circuitBreaker: simpleCB

order-processor 窗口中,停止服务:

  1. CMD + C
  1. CTRL + C

一旦第一个请求失败,将应用名为retryForever的重试策略:

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

重试将无限期地对每个失败的请求进行,每隔5秒一次。

  1. retryForever:
  2. policy: constant
  3. maxInterval: 5s
  4. maxRetries: -1

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

  1. INFO[0025] Circuit breaker "order-processor:orders" changed state from closed to open
  1. circuitBreakers:
  2. simpleCB:
  3. maxRequests: 1
  4. timeout: 5s
  5. trip: consecutiveFailures >= 5

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

  1. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  2. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open
  3. INFO[0030] Circuit breaker "order-processor:orders" changed state from open to half-open
  4. INFO[0030] Circuit breaker "order-processor:orders" changed state from half-open to open

只要停止 Redis 容器,这种半开/开放行为将继续下去。

第6步:移除故障

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

order-processor 服务终端上,重新启动应用程序:

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

checkout服务输出:

  1. == APP == Order passed: {"orderId": 5}
  2. == APP == Order passed: {"orderId": 6}
  3. == APP == Order passed: {"orderId": 7}
  4. == APP == Order passed: {"orderId": 8}
  5. == APP == Order passed: {"orderId": 9}
  6. == APP == Order passed: {"orderId": 10}

order-processor服务输出:

  1. == APP == Order received: {"orderId": 5}
  2. == APP == Order received: {"orderId": 6}
  3. == APP == Order received: {"orderId": 7}
  4. == APP == Order received: {"orderId": 8}
  5. == APP == Order received: {"orderId": 9}
  6. == APP == Order received: {"orderId": 10}

告诉我们您的想法

我们一直在努力改进我们的快速入门示例,并重视您的反馈。 您觉得此快速入门有帮助吗? 您有改进的建议吗?

加入我们的discord频道参与讨论。

下一步

访问此链接了解有关Dapr弹性的更多信息。

探索 Dapr 教程 >>