# servicecomb-getstarted

**Repository Path**: huaweicloud-microservices/servicecomb-getstarted

## Basic Information

- **Project Name**: servicecomb-getstarted
- **Description**: 使用 servicecomb 开发微服务应用入门
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2021-08-02
- **Last Updated**: 2023-02-28

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# `Servicecomb` 开发微服务应用指南

[toc]

本文档主要介绍使用 `Servicecomb` 开发微服务应用，并将此应用部署到华为云平台 `CCE` 的过程。

本文档的主要读者为：

* 具有 `Spring Boot` 或 `Spring Cloud` 微服务开发基础
* 基本了解微服务常见架构模式（如网关，微服务治理等）
* 需要将微服务应用部署到华为云平台的开发人员

`Servicecomb` 是华为推出的一套用来开发微服务的框架，类似于 `Spring Cloud` 框架。具体可参见[官方文档](http://servicecomb.apache.org/references/java-chassis/zh_CN/)。

# 1. 功能

本文档将对官方文档中给出的[计算 `bmi` 指数的应用]([体质指数微服务应用快速开发 - Apache ServiceComb](http://servicecomb.apache.org/cn/docs/products/java-chassis/bmi/))为基础，对其进行适当改造。改造后的应用将包含以下微服务。

* 计算服务：完成 `bmi` 指数的计算
* 身份管理服务：提供用户的注册，登录，角色等
* 网关服务：对外提供统一的入口，同时提供认证功能
  * 如果没有认证，则先请求身份管理服务获取 `Token`
  * 只有通过认证的用户才能访问计算服务

同时，还将提供一个简单的前端，主要向开发者演示如何访问网关服务。

# 2. 开发

首先使用 `Spring Boot` 进行开发计算服务和身份服务，然后将这两个服务转换为 `Servicecomb` 服务。然后使用 `Servicecomb` 提供的 `Edge Service SDK` 开发网关服务。最后使用 `Vue` 开发一个简单的前端以形成一个完整的应用。

本文档所示所有源码已上传至 https://gitee.com/huaweicloud-microservices/servicecomb-getstarted

**需要提前说明的是：由于云平台只支持 Java8，因此在开发时使用 Jdk8 进行开发，或不要使用 Java8 以上的新特性。本文档开发时使用的 Java11，在往云部署时，又改为了 Java8，这是没必要的。**

## 2.1 使用 `IDEA` 搭建项目

* 创建名为 `servicecomb-getstarted` 的 `Maven` 项目，将 `groupId`，`artifactId`, `version` 分别设为 `com.sgcc.tj.huaweicloud`，`servicecomb-getstarted` 和 `1.0`
* 工程创建好以后，打开 `pom.xml`，将 `packaging` 设置为 `pom`
* 创建三个 `servicecomb-getstarted` 项目的子模块，模块名分别为 `idm-service`, `gateway-service`, `calculaor-service`，这三个模块分别代表身份管理服务，网关服务，计算服务
* 创建一个名为 `ui` 的 `Vue` 模块，表示前端。创建此模块前，需要安装 `Vue` 插件
* 目前为止，项目的代码可由 `v1.0` 标签查看 

## 2.2 使用 `Spring Boot` 开发计算服务和身份管理服务

### 2.2.1 开发计算服务

* 在 `calculator-service` 工程下的 `pom.xml` 添加 `spring-boot` 插件和 `spring-boot-starter-web` 依赖

  ```xml
  <dependencies>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
          <version>2.4.5</version>
      </dependency>
  </dependencies>
  
  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
              <version>2.4.5</version>
              <configuration>
                  <mainClass>com.sgcc.tj.huaweicloud.Application</mainClass>
              </configuration>
              <executions>
                  <execution>
                      <goals>
                          <goal>repackage</goal>
                      </goals>
                  </execution>
              </executions>
          </plugin>
      </plugins>
  </build>
  ```

* 添加接口类 `BmiController`

  ```java
  package com.sgcc.tj.huaweicloud;
  
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  @RestController
  public class BmiController {
      @GetMapping("/api/calculator/bmi")
      public Float calculate(Float height, Float weight) {
          return weight / height / height;
      }
  }
  ```

* 添加 `Spring Boot` 启动类

  ```java
  package com.sgcc.tj.huaweicloud;
  
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  
  @SpringBootApplication
  public class Application {
      public static void main(String[] args) {
          SpringApplication.run(Application.class);
      }
  }
  ```

* 测试接口，保证接口可用

  ![](images\img1.png)

### 2.2.2 开发身份管理服务

* 与计算服务一样，修改 `pom.xml` ，添加启动类 `Application`

* 添加接口 `TokenController`，此接口用于提供类似于 `JWT` 的令牌，为简单起见，此接口只能返回一个用户信息，其他信息一律返回`401`

  ```java
  package com.sgcc.tj.huaweicloud;
  
  import org.springframework.http.HttpStatus;
  import org.springframework.web.bind.annotation.PostMapping;
  import org.springframework.web.bind.annotation.RestController;
  import org.springframework.web.server.ResponseStatusException;
  
  import java.util.StringJoiner;
  
  @RestController
  public class TokenController {
  
      @PostMapping("/api/token/simple")
      public String getToken(String username, String password) {
          if (username.equals("user") && password.equals("123")) {
              var joiner = new StringJoiner("#");
              joiner.add("username:user")  // 账号
                      .add("name:用户")  // 姓名
                      .add("role:user")  // 角色
                      .add("userId:1");  // userId
              return joiner.toString();
          }
  
          throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "无效的用户名或密码");
      }
  }
  ```
  
* 使用 Postman 测试，确保接口调用成功

  ![](images\img2.png)

* 至此，我们完成了 `Spring Boot` 版本的两个微服务，接下来，我们把这两个服务改造成`Servicecomb` 版本。

## 2.3 使用 `Servicecomb` 框架改造计算服务和身份管理服务

官方的 `Servicecomb` 与 `Spring Boot` 集成的文档请参考[在Spring Boot中使用java chassis](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/using-java-chassis-in-spring-boot/using-java-chassis-in-spring-boot.html))

改造之前，需要在本地安装服务注册中心（类似于 `Eureka` 或 `Nacos`，用于微服务的注册与发现）。为了与华为云平台的 `CSE` 更好对接，我们使用华为云提供的 `service center` 作为我们本地的服务注册中心。安装文档请参考[ServiceCenter 安装](http://servicecomb.apache.org/cn/docs/products/service-center/install/) 。安装结束后，运行前端和后端脚本，然后打开浏览器，可以看到如下仪表盘界面。可以看到，当前服务中心只有一个服务（即服务中心自己）。

![](images\service-center-dashboard.png)

### 2.3.1 改造计算服务

* 修改 `pom.xml` 文件，主要包括以下四部分内容

  * 引入 `servicecomb` 的依赖管理
  * 引入 `maven-compiler-plugin` 插件
  * 使用 `servicecomb` 提供的依赖包替换原有的 `spring-boot-starter` 依赖。由于计算服务属于 [web开发方式](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/using-java-chassis-in-spring-boot/web-application.html)，因此引入的依赖包为 `java-chassis-spring-boot-starter-servlet`
  * 引入 `service-center` 的依赖包 `registry-service-center`

  修改后的 `pom.xml` 如下所示（没有修改的部分使用 ... 代替)

  ```xml
  <?xml version="1.0" encoding="UTF-8"?>
  <project ...>
      ...
  
      <dependencies>
          <dependency>
              <groupId>org.apache.servicecomb</groupId>
              <artifactId>java-chassis-spring-boot-starter-servlet</artifactId>
          </dependency>
  
          <dependency>
              <groupId>org.apache.servicecomb</groupId>
              <artifactId>registry-service-center</artifactId>
          </dependency>
      </dependencies>
  
      <build>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.1</version>
              <configuration>
                  <source>11</source>
                  <target>11</target>
                  <compilerArgument>-parameters</compilerArgument>
              </configuration>
          </plugin>
          ...
      </build>
  
      <dependencyManagement>
          <dependencies>
              <dependency>
                  <groupId>org.apache.servicecomb</groupId>
                  <artifactId>java-chassis-dependencies</artifactId>
                  <version>2.3.0</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
          </dependencies>
      </dependencyManagement>
  
  </project>
  ```

* 改造 `Application` 类，只需要在类级别添加 `@EnableServiceComb` 注解以启用 `servicecomb` 功能

* 在 `src/main/resources` 目录下添加 `microservice.yaml` 文件完成微服务定义和服务中心配置。详细配置项可参考[微服务定义](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/build-provider/definition/service-definition.html) 和 [使用服务中心](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/registry/service-center.html) 中有关配置项的说明。此处各配置项简单说明如下。

  * servicecomb-starter：整个微服务应用的名字，所有的微服务都要用这个名字
  * calculator：此微服务的名字
  * 0.0.1 是当前此微服务的版本
  * development 表明该微服务当前处于开发状态。在正式往云平台部署的时候，需要删除此配置，或将其改为 `production`
  * http://127.0.0.1:30100：当前服务注册中心的地址
  * 0.0.0.0:8000：表明此微服务在 8000 端口上监听来自任何客户端发过来的请求

  ```yaml
  servicecomb:
    service:
      application: servicecomb-starter
      name: calculator
      version: 0.0.1
      environment: development
  
      registry:
        address: http://127.0.0.1:30100
  
    rest:
      address: 0.0.0.0:8000
  ```

* 修改 `BmiController` ，主要包含两个内容

  * 将原来的 `@RestController` 替换为 `@RestSchema(schemaId="calculator")` 。其中 `schemaId` 表示此接口的名字
  * 在类别上添加 `@RequestMapping` 注解，用法与 `Spring MVC` 相同。这一步不能省略

  ```java
  package com.sgcc.tj.huaweicloud;
  
  import org.apache.servicecomb.provider.rest.common.RestSchema;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  @RestSchema(schemaId = "calculator")
  @RequestMapping("/")
  public class BmiController {
      @GetMapping("/api/calculator/bmi")
      public Float calculate(Float height, Float weight) {
          return weight / height / height;
      }
  }
  ```

* 此时，启动 `Application` ，然后使用 `Postman` 等进行测试，确保接口正常工作

### 2.3.2 改造身份管理服务

改造过程与计算服务完全相同。此处略。各位读者可参考源代码。修改结束后进行测试，确保接口正常工作。

目前为止的代码可使用 `v3.0` 标签进行查看。

最后，观察服务中心界面，可发现现在启动了 `idm` 和 `calculator` 两个微服务，每个微服务有一个实例。这两个微服务正是我们开发的并注册到服务中心的微服务。

![](images\service-center-services.png)

![image-20210811173517116](images\service-center-instances.png)

## 2.4 使用 `Edge Service` 开发网关服务

网关模式是一种常见的微服务架构模式，用于对外提供访问的统一入口。网关不实现业务逻辑，其基本的功能是提供请求的路由转发。根据实际的需要，网关还有可能会提供安全认证、以及流量监控等微服务治理的附加功能。

本文档使用 `servicecomb` 自带的`Edge Service` 框架进行网关服务的开发，其官方文档可参考[使用 Edge Service 做网关](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/edge/by-servicecomb-sdk.html)

### 2.4.1 网关的基本转发功能

* 修改 `pom.xml` 文件，与前面两个微服务类似。具体内容如下。需要特别说明的是，`edge-core` 是 `Edge Service` 的依赖包，由于网关服务是整个微服务应用对外提供服务的入口，提供方式为 `http` 接口，所以此处引入了 `java-chassis-spring-boot-starter-servlet` 依赖

  ```xml
  <?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>servicecomb-getstarted</artifactId>
          <groupId>com.sgcc.tj.huaweicloud</groupId>
          <version>1.0</version>
      </parent>
      <modelVersion>4.0.0</modelVersion>
  
      <artifactId>gateway-service</artifactId>
  
      <properties>
          <maven.compiler.source>11</maven.compiler.source>
          <maven.compiler.target>11</maven.compiler.target>
      </properties>
  
      <dependencies>
          <dependency>
              <groupId>org.apache.servicecomb</groupId>
              <artifactId>java-chassis-spring-boot-starter-servlet</artifactId>
          </dependency>
          <dependency>
              <groupId>org.apache.servicecomb</groupId>
              <artifactId>edge-core</artifactId>
          </dependency>
          <dependency>
              <groupId>org.apache.servicecomb</groupId>
              <artifactId>registry-service-center</artifactId>
          </dependency>
      </dependencies>
  
      <build>
          <plugins>
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-compiler-plugin</artifactId>
                  <version>3.8.1</version>
                  <configuration>
                      <source>11</source>
                      <target>11</target>
                      <compilerArgument>-parameters</compilerArgument>
                  </configuration>
              </plugin>
              <plugin>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-maven-plugin</artifactId>
                  <version>2.4.5</version>
                  <configuration>
                      <mainClass>com.sgcc.tj.huaweicloud.Application</mainClass>
                  </configuration>
                  <executions>
                      <execution>
                          <goals>
                              <goal>repackage</goal>
                          </goals>
                      </execution>
                  </executions>
              </plugin>
          </plugins>
      </build>
  
      <dependencyManagement>
          <dependencies>
              <dependency>
                  <groupId>org.apache.servicecomb</groupId>
                  <artifactId>java-chassis-dependencies</artifactId>
                  <version>2.3.0</version>
                  <type>pom</type>
                  <scope>import</scope>
              </dependency>
          </dependencies>
      </dependencyManagement>
  
  </project>
  ```

* 创建启动类 `Application`，如下

  ```java
  package com.sgcc.tj.huaweicloud;
  
  import org.apache.servicecomb.springboot2.starter.EnableServiceComb;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  
  @EnableServiceComb
  @SpringBootApplication
  public class Application {
      public static void main(String[] args) {
          SpringApplication.run(Application.class);
      }
  }
  ```

* 添加 `microservice.yaml` 文件进行微服务定义、服务中心配置、网关转发配置、CORS配置，完整内容如下面的 `yaml` 文件所示。

  *  `servicecomb.service.*` 配置的含义与前面解释过的相同，用于进行微服务定义和服务中心配置
  * `servicecomb.http` 用于配置网关转发规则。官方文档请参考[使用 Edge Service 做网关](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/edge/by-servicecomb-sdk.html)
    * `dispatcher.edge.url.enabled: true`：启用按 `url` 转发
    * `dispatcher.edge.url.mappings`：`url` 映射规则
    * `mappings` 下定义了两个 `url` 规则，分别命名为 `idm` 和 `calculator`，在此例中分别对应对两个微服务的转发规则。每个规则下都包含四条配置，以下以 `idm` 映射为例。
      * `path`：用于匹配客户端发送的地址。此例中的值为 `/api/token/.*`，即任何以 `/api/token/` 开头的请求都会按此规则进行处理
      * `microserviceName`：当上述 `path` 匹配成功后，当前请求会被转发的微服务名称。此名称必须是之前注册到服务中心的微服务名称。此处的值为 `idm` ，表明请求会被网关转发到 `idm` 微服务，即身份管理微服务
      * `prefixSegmentCount`：前缀个数。此例中设置的值为0，表示网关会把客户端发过来的 `url ` 原封不动地发给微服务。如果值为1，则会去掉1个前缀，此时如果网关接收到的 `url` 为 `/api/abc/def`，则网关真正转发给微服务的 `url` 为 `/abc/def`
      * `versionRule`：匹配的微服务的版本，当前所有微服务版本都是 `0.0.1` ，在实际环境中，同一个微服务可能会同时存在多个版本的实例。
  * `servicecomb.cors` 用于配置 `CORS` 规则。如果从浏览器直接调用网关，需要处理跨域。具体请参考[跨域资源共享(CORS)配置](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/general-development/CORS.html)

  ```yaml
  servicecomb:
    service:
      application: servicecomb-starter
      name: gateway
      version: 0.0.1
      environment: development
  
      registry:
        address: http://127.0.0.1:30100
  
    rest:
      address: 0.0.0.0:9000
  
    http:
      dispatcher:
        edge:
          url:
            enabled: true
            mappings:
              idm:
                prefixSegmentCount: 0
                path: "/api/token/.*"
                microserviceName: idm
                versionRule: 0.0.1
              calculator:
                prefixSegmentCount: 0
                path: "/api/calculator/.*"
                microserviceName: calculator
                versionRule: 0.0.1
  
    cors:
      enabled: true
      origin: "*"
      allowCredentials: false
      allowedMethod: OPTIONS,GET,POST,PUT,DELETE
      maxAge: 3600
  ```

### 2.4.2 测试网关的转发功能

* 首先启动服务中心，然后依次启动计算服务、身份管理服务、网关服务

* 使用 `Postman` 等测试工具测试网关的转发功能

  ![测试token接口](images\gateway-token)

  ![image-20210812160748578](images\gateway-bmi)

* 打开服务中心的仪表盘，可以我们开发好的包含网关在内的三个微服务。同时，打开拓扑页，可以看到三个微服务之间的关系。由此可以看出 `gateway` 作为消费方，它会向另外两个微服务发起调用。

  ![image-20210812161016867](images\servicecenter-topnology)

### 2.4.4 增加网关认证功能

除了基本的路由转发，网关还有很多其他的用途。认证是网关需要提供的最常见的一种附加功能。

认证过程的基本逻辑是：在接收到请求后，网关会检查该请求是否需要认证。如果不需要认证，网关会直接放行（转发给微服务）。如果需要认证，网关会进一步检查该请求是否携带了合法的认证信息。只有这两项检查都通过了，网关才会将放行，否则，网关将返回 `401` 错误。在放行之前，网关可能会从认证信息中提取部分信息。这些信息会在转发请求时一并发给微服务。

* 实现 `AuthHandler`

  * 为了提供请求转发的吞吐量，`Edge Service` 框架采用了基于 `Vertx` 的异步编程模型。在 [官方文档中](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/edge/by-servicecomb-sdk.html#_3) 提到

    >  `Edge Service` 可以通过多种方式来扩展Edge Service的功能，包括Dispatcher、HttpServerFilter、Handler、HttpClientFilter等。比较常用和简单的是通过Handler来扩展。

  * 完整的 `AuthHandler` 代码如下。
    *  `init` 方法用于进行初始化操作
    * `handle` 方法用于进行认证。注意认证失败后要使用 `return` 提前返回，认证成功后要调用 `invocation.next(asyncResponse);` 以保证后续的 `handler` 继续进行处理。
    * 使用 `HttpServletRequestEx.getHeader("Authorization")` 从请求头部中获取认证信息。拿到认证信息后，对其进行解析，并调用 `Invocation.addContext` 方法将从认证信息中提取到的 `username`，`name` 等进行保存，这些信息会在转发时一并转发给目标微服务。

  ```java
  package com.sgcc.tj.huaweicloud;
  
  import org.apache.servicecomb.core.Handler;
  import org.apache.servicecomb.core.Invocation;
  import org.apache.servicecomb.core.definition.MicroserviceMeta;
  import org.apache.servicecomb.foundation.vertx.http.HttpServletRequestEx;
  import org.apache.servicecomb.swagger.invocation.AsyncResponse;
  import org.apache.servicecomb.swagger.invocation.InvocationType;
  import org.apache.servicecomb.swagger.invocation.exception.InvocationException;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.ws.rs.core.Response;
  import java.util.Arrays;
  import java.util.stream.Collectors;
  
  public class AuthHandler implements Handler {
      private static Logger LOGGER = LoggerFactory.getLogger(AuthHandler.class);
  
      private static final String[] AUTH_WHITELIST = {
              "/api/token/simple"
      };
  
      @Override
      public void init(MicroserviceMeta microserviceMeta, InvocationType invocationType) {
      }
  
      @Override
      public void handle(Invocation invocation, AsyncResponse asyncResponse) throws Exception {
          HttpServletRequestEx request = invocation.getRequestEx();
          String token = request.getHeader("Authorization");
          String url = request.getRequestURI();
  
          if (Arrays.asList(AUTH_WHITELIST).contains(url)) {
              invocation.next(asyncResponse);
              return;
          }
  
          if (token == null) {
              asyncResponse.consumerFail(new InvocationException(Response.Status.UNAUTHORIZED, "未认证访问"));
              return;
          }
  
          try {
              // token 类似于 "username:user#name:用户#role:user#userId:1"
              var map = Arrays.stream(token.split("#"))
                      .map(item -> item.split(":"))
                      .collect(Collectors.toMap(array -> array[0], array -> array[1]));
  
              invocation.addContext("username", map.get("username"));
              invocation.addContext("role", map.get("role"));
              invocation.addContext("name", map.get("name"));
              invocation.addContext("userId", map.get("userId"));
          } catch (Exception e) {
              asyncResponse.consumerFail(new InvocationException(Response.Status.UNAUTHORIZED, "未授权访问"));
              return;
          }
  
          invocation.next(asyncResponse);
      }
  }
  ```

* 注册 `AuthHandler`

  根据 `Vertx` 异步编程模型，自定义的 `Handler` 需要注册后才能使用。在 `Edge Service` 框架中，可以在类路径下添加 `config/cse.handler.xml` 进行自定义 `Handler` 的注册。其内容如下

  ```xml
  <config>
      <handler id="auth"
               class="com.sgcc.tj.huaweicloud.AuthHandler"/>
  </config>
  ```

* 在 `microservice.yaml` 文件中配置认证功能。在现有的 `microservice.yaml` 文件最下方插入以下内容。该配置会在每次转发请求之前按顺序进行 `auth` 和 `loadbalance` 的处理链。有关处理链的详细介绍请参考[处理链介绍](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/references-handlers/intruduction.html)。此处的 `loadbalance` 如果不填，网关服务在转发时会报错。

  ```yaml
  servicecomb:
    # 其他现有配置保留
    handler:
      chain:
        Consumer:
          default: auth,loadbalance
  ```

* 默认情况下，`Edge Service` 不会向微服务转发任何请求的头部。如果你希望转发请求的若干头部信息，可以在 `microservice.yaml` 添加以下配置。例如，如果你想让后面的微服务接收请求中的 `Authorization` 头部，可以将其加入到 `allowedHeaders` 中。

  ```yaml
  servicecomb:
    # 其他现有配置保留
    edge:
      filter:
        addHeader:
          enabled: true
          allowedHeaders: Authorization
  ```

### 2.4.5 测试认证服务

重新运行程序，使用 `Postman` 调用网关接口，可以看到，此时访问 `token` 接口，依然可以成功，但是，如果要访问 `calculator` 接口，则会报以下错误。

![image-20210812174907384](images\auth-failed)

![image-20210812175143310](images\auth-ok.png)

### 2.4.6 在微服务间传递消息

前已述及，网关服务在转发前，会将 `username` 等认证信息封装到 `InvocationContext` 中，这些信息会一同转发到微服务。微服务在接收到网关转发过来的请求后，可以提取这些信息。这也是 `Servicecomb` 下微服务之间传递信息的主要方式。详细内容请参考[使用Context传递控制消息 ](http://servicecomb.gitee.io/servicecomb-java-chassis-doc/java-chassis/zh_CN/general-development/context.html)

修改计算服务的 `BmiController` 如下

```java
package com.sgcc.tj.huaweicloud;

import org.apache.servicecomb.provider.rest.common.RestSchema;
import org.apache.servicecomb.swagger.invocation.context.InvocationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@RestSchema(schemaId = "calculator")
@RequestMapping("/")
public class BmiController {
    @GetMapping("/api/calculator/bmi")
    public String calculate(Float height, Float weight, InvocationContext context) {
        var username = context.getContext("username");
        var bmi = weight / height / height;
        return username + " bmi: " + bmi;
    }
}
```

重新启动计算服务，使用 `Postman` 进行测试，确保接口正确返回

![image-20210812180147885](images\use-context.png)

至此，本地开发全部结束。所有的代码可通过 `v4.0` 查看。

# 3. 部署

为了充分发挥容器云和微服务的优势，我们鼓励各业务在部署上云尽可能采用 `CCE + ServiceStage` 的方式进行部署。`CCE` 是华为云提供的企业级 `Kubernetes` 集群，可为用户提供高性能的容器化部署。`ServiceStage` 是华为云提供的一个微服务管理平台，它支持多种微服务框架及成套的开发工具。

本章详细描述 `BMI` 微服务应用部署到华为云的过程。概括而言，该过程包含以下几个步骤。

* 申请华为云资源及环境准备。按照云平台运营中心规定的流程申请资源。拿到资源后进行部署前的环境准备工作，主要包括创建项目，上传软件包或镜像等。

* 微服务应用对接 `ServiceStage` 。主要描述将微服务接入 `CSE` 的过程，`CSE` 是华为云用于提供服务注册、配置管理等功能的微服务引擎。
* 创建并部署微服务应用。创建应用及对应组件将各应用组件部署到 `CCE` 集群并配置外部访问方式。
* 测试微服务应用

## 3.1 申请华为云资源及环境准备

* 向云平台运营中心提交资源申请和用户申请。申请时应根据应用的实际情况对资源的容量进行合理估算，不要太高或太低，避免造成资源浪费或影响应用性能。另外，对于微服务应用，一般申请的资源以 `CCE` 为主。

* 申请经审批通过后运营中心会创建项目，开通 `VPC` 和安全组，下发资源，创建账户。

* 使用创建好的账号登录云平台运营系统，进行如下操作

  * 创建 `CSE` 专业版或专享版。打开 `ServiceStage` 的 `CSE` 页面，点击创建即可。创建成功后可显示 `CSE` 的地址

  * 获取 `AK/SK` 。操作过程请参考[获取AK/SK与项目名称](https://support.huaweicloud.com/devg-servicestage/ss-devg-0033.html) 。 `AK/SK` 请妥善保存。如果 `CSE` 是专享版，此步可省略。

  * 创建环境。操作过程请参考[环境管理](https://support.huaweicloud.com/usermanual-servicestage/servicestage_user_0406.html)。环境的定义如下面的引用所示。每个环境可用于不同目的，如开发环境，测试环境等，这一点与 `Spring` 的 `Profile` 类似。对于微服务应用，请至少创建一个环境。在基础资源中添加 `CCE` 集群，在可选资源中添加 `CSE` ，`ELB`（需申请审批），`RDS` 等

    > 环境是用于应用部署和运行的计算、存储、网络的集合。`ServiceStage` 把相同 `VPC` 下的基础资源（如 `CCE` 集群，`ECS` 等）加上可选资源（如 `ELB`, `RDS`）组合为一个环境。

## 3.2 微服务应用对接 `ServiceStage`

对接的过程每个微服务都完全相同。以 `Servicecomb Java` 版 为例，官方文档请参考[Java Chassis接入CSE](https://support.huaweicloud.com/devg-servicestage/ss-devg-0008.html)。 对接的过程基本上就是对接 `CSE` 的过程。

`CSE` 是 `ServiceStage` 提供的一个微服务应用的管理工具，对外提供服务中心，配置管理等很多微服务管理和治理功能。`CSE` 分专业版和专享版两个版本，这两个版本在对接时存在一定的不同。

为什么需要对接？因为我们在开发时使用的是本地的服务中心，当我们往云上部署时，需要把服务中心改成 `CSE` 提供的服务中心。

以下以计算服务为例，描述其接入 `CSE` 的过程。其他服务的接入过程类似。

* JDK 版本降级。使用 JDK8 重新编译微服务。**注：应在一开始就使用 JDK8 进行开发**

* 修改 `pom.xml` ，主要改动如下是添加如下的依赖声明。

  *  `solution-basic` 内置了所有对接所必需的功能。
  * `servicestage-environment` 是可选的，如果你不打算使用 `ServiceStage` 的环境变量覆盖 `microservice.yaml` 配置，此依赖可以去除。

  ```xml
  <dependency>
      <groupId>org.apache.servicecomb</groupId>
      <artifactId>solution-basic</artifactId>
  </dependency>
  <dependency>
      <groupId>org.apache.servicecomb</groupId>
      <artifactId>servicestage-environment</artifactId>
  </dependency>
  ```

* 修改 `microservice.yaml` 文件。主要改动如下

  * 将 `servicecomb.service.registry.address` 的值改为云平台 `CSE` 的地址

  * 对于 `CSE` 专业版，进行以下配置

    * 配置 `AK/SK` ，将以下配置加入到 `microservice.yaml` 文件中。使用之前拿到的 `AK/SK` 替换其中的 `$AK` 和 `$SK` 

      ```yaml
      servicecomb:
        credentials:
          accessKey: $AK
          secretKey: $SK
          akskCustomCipher: default
      ```

    * 添加配置 `servicecomb.service.registry.instance.watch` 并将其设为 `false`

* 所有的服务都修改结束后，使用 `mvn clean package` 命令将每个服务都打包成 `jar` 包，然后在 `OBS` 上创建一个桶并上传这些 `jar` 包。

* 修改后的代码已上传，可通过版本 `v5.0` 进行查看

## 3.3 创建并部署微服务应用

* 创建应用。官方文档请参考[创建应用](https://support.huaweicloud.com/usermanual-servicestage/servicestage_user_0409.html)。此处不需要添加环境变量
* 为每一个微服务都新建一个组件。官方文档请参考[创建微服务组件](https://support.huaweicloud.com/usermanual-servicestage/servicestage_user_0412.html)的操作步骤
  * 由于 `BMI` 应用使用的是 `servicecomb` 的 `Java SDK` ，因此在选择运行时和框架时，请选择 `Java Chassis` 和 `Java8`
  * “源码/软件包”一项请选择之前上传到 `OBS` 上对应的软件包
* 部署每一个微服务，每个服务的部署过程类似。部署过程请参考[部署组件](https://support.huaweicloud.com/usermanual-servicestage/servicestage_user_0419.html)
  * 网关服务建议放到最后部署
  * 按实际情况填写的环境，版本，部署系统，实例数量，CSE 等信息

## 3.4 测试微服务应用



# 4. 其他问题

* 可使用 `Roma Connect` 替代网关服务的开发。具体请参考相关文档。
* 关于文件上传，异常处理请参考[通用功能开发](http://servicecomb.apache.org/references/java-chassis/zh_CN/general-development/catalog.html)
* 其他问题可参考官方文档
* 部署之前一定要保证本地环境下测试通过