基于CSE的微服务工程实践-多微服务框架演进

网友投稿 930 2022-05-30

开发团队选择同样的开发框架能够更好的进行经验积累和知识共享,从而提高开发效率。在实际项目中,这个过程经常被打破。团队需要根据用户需求的变化,选择更好的开发框架来解决面对的新问题。每个开发团队都不得不采取“持续迭代演进”的方法,来改造旧系统,开发新系统。

在[单体应用微服务改造实践]( https://bbs.huaweicloud.com/blogs/17ad483f325f11e9bd5a7ca23e93a891)中,分享了一种单体应用“持续迭代”改造微服务的方法。本文结合在改造过程中多微服务框架并存问题,描述一下使用CSE的开发实践。

本文假设应用已经采用网关搭建可持续演进的架构,如下图。这个架构由多种开发框架构建的基于REST的微服务组成。

本文提供的示例项目代码托管在[github](https://github.com/huaweicse/cse-java-chassis-samples/tree/master/multi-framework) 。

1      网关转发规则开发

CSE提供的edge service默认提供的转发规则对于采用CSE开发的微服务最简单,功能也最强大。根据配置的URL规则,将请求转发到对应的微服务,只是网关核心功能之一。当edge service将请求转发到CSE的微服务的时候,还具备如下功能:

·         实例发现和动态更新。网关可以通过微服务名称从服务中心发现实例列表,并在实例列表变化的时候,自动更新。

·         实例隔离和重试。当微服务存在多个实例的时候,如果一个实例出现故障,那么可以进行一次重试,将请求转发到其他实例;如果一个实例多次出现故障,需要在后续请求中将该实例隔离一段时间,避免频繁失败。

·         支持灰度发布。网关可以结合请求参数规则,或者版本规则,将请求转发到符合规则的实例上面去。比如将请求参数count>20的请求转发给v2版本的实例,count<=20的请求转发给v1版本的实例。

·         支持AZ亲和。网关需要结合微服务部署的数据中心信息,将请求转发给就近的数据中心,以提高效率。

·         支持流量控制。可以针对微服务、微服务的某个接口进行流量控制。

·         自动按照接口兼容性转发。这个场景指的是如果微服务存在多个版本,比如v1存在接口/a/b/c,v2新增了接口/x/y/z,那么当用户请求/x/y/z的时候,能够自动将请求转发给v2,而不需要做任何配置。

·         支持故障注入。故障注入用于模拟故障,这个在开发测试阶段比较有用。通过模拟延时等情况,能够测试网关在异常情况下是否正常工作。

上面列的功能是edge service的部分功能,这些功能都是开箱即用,无需用户开发的。此外,CSE提供handler的机制,还实现了其他大量的开箱即用功能,在上述列表中没有给出。下面的例子实现了一个edge service转发给CSE服务的Dispatcher,CSE也默认提供了几个Dispatcher,本例子参考了默认的Dispatcher代码,定制了转发的URL。

public class DefaultCseDispatcher extends AbstractEdgeDispatcher {   @Override   public void init(Router router) {     // Dispatcher patterns. This dispatcher only forward requests to store.     router.routeWithRegex("/store/(.*)").handler(CookieHandler.create());     router.routeWithRegex("/store/(.*)").handler(createBodyHandler());     router.routeWithRegex("/store/(.*)").failureHandler(this::onFailure).handler(this::onRequest);   }     protected void onRequest(RoutingContext context) {     Map pathParams = context.pathParams();     String microserviceName = "store";     String path = "/" + pathParams.get("param0");       EdgeInvocation edgeInvocation = new EdgeInvocation();     edgeInvocation.init(microserviceName, context, path, httpServerFilters);     edgeInvocation.edgeInvoke();   }     @Override   public int getOrder() {     return 10000;   } }

Edge service可以通过Dispatcher扩展,将请求转发给非CSE开发的REST服务。并且提供了一些扩展API供开发者使用,使用这些扩展API,能够使用CSE提供的部分功能。

其中:

·         DiscoveryTree 集成了实例发现和动态更新、实例隔离、AZ亲和等功能。

·         LoadbalanceHandler 集成了重试、灰度发布等功能。

下面例子展示了将请求转发给auth服务。

public class GenericHttpWithDiscoveryDispatcher extends AbstractEdgeDispatcher {   private static Logger LOGGER = LoggerFactory.getLogger(GenericHttpWithDiscoveryDispatcher.class);     private static Vertx vertx = VertxUtils.getOrCreateVertxByName("transport", null);     private static HttpClient httpClient = vertx.createHttpClient(new HttpClientOptions());     private DiscoveryTree discoveryTree = new DiscoveryTree();     private LoadbalanceHandler loadbalanceHandler;     class RetriableHandler implements Handler {     private RoutingContext context;       private String path;       private Buffer data;       private boolean isRetry = false;       public RetriableHandler(RoutingContext context, String path) {       this.context = context;       this.path = path;       this.context.response().setChunked(true);     }       @Override     public void handle(Invocation invocation, AsyncResponse asyncResponse) throws Exception {       URIEndpointObject endpoint = (URIEndpointObject) invocation.getEndpoint().getAddress();       HttpClientRequest clietRequest =           httpClient.request(context.request().method(),               endpoint.getPort(),               endpoint.getHostOrIp(),               "/" + path + "?" + context.request().query(),               clientResponse -> {                 context.response().setStatusCode(clientResponse.statusCode());                 VertxHttpHeaders headers = new VertxHttpHeaders();                 clientResponse.headers().forEach(entry -> {                   headers.add(entry.getKey(), entry.getValue());                 });                 context.response().headers().setAll(headers);                 clientResponse.handler(data -> {                   context.response().write(data);                 });                 clientResponse.endHandler((v) -> {                   context.response().end();                   asyncResponse.success("OK");                 });               });       clietRequest.headers().setAll(context.request().headers());       clietRequest.exceptionHandler(e -> {         asyncResponse.consumerFail(e);       });         if (!isRetry) {         // data can not be read twice, so cache it in retry          this.context.request().handler(d -> {           clietRequest.write(d);           data = d;         });           context.request().endHandler((v) -> {           clietRequest.end();         });           isRetry = true;       } else {         if (data != null) {           clietRequest.write(data);         }         clietRequest.end();       }     }   }     public GenericHttpWithDiscoveryDispatcher() {     discoveryTree.addFilter(new IsolationDiscoveryFilter());     discoveryTree.addFilter(new ServerDiscoveryFilter());     discoveryTree.sort();     loadbalanceHandler = new LoadbalanceHandler(discoveryTree);   }     @Override   public int getOrder() {     return 10001;   }     @Override   public void init(Router router) {     // Dispatcher patterns. This dispatcher only forward requests to auth.     String regex = "/auth/(.*)";     router.routeWithRegex(regex).failureHandler(this::onFailure).handler(this::onRequest);   }     protected void onRequest(RoutingContext context) {     Map pathParams = context.pathParams();       String microserviceName = "auth";     String path = pathParams.get("param0");       Invocation invocation =         new NonSwaggerInvocation(RegistryUtils.getAppId(), microserviceName, "0+", new RetriableHandler(context, path));     try {       loadbalanceHandler.handle(invocation, resp -> {         if (resp.isFailed()) {           context.response().setStatusCode(resp.getStatusCode());           context.response().write(((Exception) resp.getResult()).getMessage());           context.response().end();         }       });     } catch (Exception e) {       LOGGER.error("", e);     }   }   }

由于auth服务采用Spring MVC开发,该服务在注册的时候,不会生成契约信息。因此上面列出的几个功能是不具备的:

·         不支持流量控制。

·         不支持自动按照接口兼容性转发。

·         不支持故障注入。

此外,CSE通过Handler扩展提供的其他开箱即用功能,也是不具备的。

最后一个服务就是将请求转发给user了。user服务没有向服务中心注册,因此没有微服务信息,也没有契约信息。需要在代码里面写上实例列表和自己定义负载均衡。

public class GenericHttpDispatcher extends AbstractEdgeDispatcher {   private static Logger LOGGER = LoggerFactory.getLogger(GenericHttpDispatcher.class);     private static Vertx vertx = VertxUtils.getOrCreateVertxByName("transport", null);     private static HttpClient httpClient = vertx.createHttpClient(new HttpClientOptions());     public GenericHttpDispatcher() {   }     @Override   public int getOrder() {     return 10001;   }     @Override   public void init(Router router) {     // Dispatcher patterns. This dispatcher only forward requests to user.     String regex = "/user/(.*)";     router.routeWithRegex(regex).failureHandler(this::onFailure).handler(this::onRequest);   }     protected void onRequest(RoutingContext context) {     Map pathParams = context.pathParams();       String path = pathParams.get("param0");       HttpClientRequest clietRequest =         httpClient.request(context.request().method(),             // hard coded ip/port here. can use configurations.              9093,             "localhost",             "/" + path + "?" + context.request().query(),             clientResponse -> {               context.response().setStatusCode(clientResponse.statusCode());               VertxHttpHeaders headers = new VertxHttpHeaders();               clientResponse.headers().forEach(entry -> {                 headers.add(entry.getKey(), entry.getValue());               });               context.response().headers().setAll(headers);               clientResponse.handler(data -> {                 context.response().write(data);               });               clientResponse.endHandler((v) -> {                 context.response().end();               });             });            clietRequest.headers().setAll(context.request().headers());     clietRequest.exceptionHandler(e -> {       LOGGER.error("", e);     });     context.request().handler(data -> {       clietRequest.write(data);     });     context.request().endHandler((v) -> {       clietRequest.end();      });   } }

网关给user服务转发的过程中,没有上面列举的所有服务治理能力,只是一个单纯的HTTP转发器。

2      CSE访问第三方服务

在edge service转发给CSE服务的过程中,介绍了一组治理能力。这组治理能力在CSE服务调用其他CSE的服务的时候,也是具备的,而且这组能力不仅体现在调用者(consumer),提供者(provider)处理请求的时候,也会走handler链,从而具备流控、隔离等能力。 CSE之间的微服务调用非常简单,包括RestTemplate和RPC两种开发模式,这里不详细介绍,开发者可以参考开发指南进行学习。

CSE也提供了调用第三方服务的能力,通过使用CSE提供的第三方能力,这些治理能力对于调用者(consumer)一端,也是全部具备的。因此在CSE服务中调用其他第三方服务的时候,应该尽可能使用CSE提供的第三方访问能力,而不是使用普通的HTTP client。

使用CSE的http client的原理是首选通过接口的方式声明需要访问的服务端的契约。

@RequestMapping(path = "/") public interface AuthService {   @GetMapping(path = "/oauth/token")   Token auth(@RequestParam(name = "username") String username, @RequestParam(name = "password") String password,       @RequestParam(name = "grant_type") String grant_type,       @RequestParam(name = "scope") String scope,       @RequestParam(name = "client_id") String clientId,       @RequestParam(name = "client_secret") String clientSecret); }

然后本地模拟注册一个在服务中心注册的实例。

@Component public class ThirdPartyRegistry implements BootListener {     @Override   public void onBootEvent(BootEvent event) {     if (event.getEventType() == EventType.AFTER_REGISTRY) {       DiscoveryTree discoveryTree = new DiscoveryTree();       discoveryTree.addFilter(new IsolationDiscoveryFilter());       discoveryTree.addFilter(new ServerDiscoveryFilter());       discoveryTree.sort();         DiscoveryContext context = new DiscoveryContext();       Invocation invocation =           new NonSwaggerInvocation("default", "auth", "0+", null);       context.setInputParameters(invocation);       VersionedCache serversVersionedCache = discoveryTree.discovery(context,           "default",           "auth",           "0+");       List servers = serversVersionedCache.data();       List instances = new ArrayList<>(servers.size());       servers.forEach(item -> {         MicroserviceInstance instance = new MicroserviceInstance();         List endpoints = item.getInstance().getEndpoints();         List endpointsWithoutPrefix = new ArrayList<>(endpoints.size());         endpoints.forEach(e -> {           System.out.println(e);           endpointsWithoutPrefix.add(e.substring(0, e.indexOf("?")));         });         instance.setEndpoints(endpointsWithoutPrefix);         instances.add(instance);       });       RegistryUtils.getServiceRegistry()           .registerMicroserviceMapping(               "authStub",               "1.1.1",               instances,               AuthService.class);     }   } }

最后就可以按照CSE访问CSE服务一样访问这个第三方服务。

@RpcReference(microserviceName = "authStub", schemaId="authStub")   private AuthService authService;     @GetMapping("/auth")   public Token auth() {     return authService.auth("user_1", "123456", "password", "read", "client_2", "123456");   }

3      第三方服务访问CSE

基于CSE的微服务工程实践-多微服务框架演进

第三方访问CSE可以按照原生的第三方HTTP Client API来访问。 这个治理能力等同于第三方提供的功能,通常不包含治理能力。 这里不在详细描述。

4      总结

通过上面的例子,看到了CSE在处理多种REST开发框架并存情况下,网关转发和服务之间调用需要采用的技术。这些技术在微服务持续演进过程中会经常用到。但是微服务演进的最终目的是选择一套技术来解决问题,应该避免架构选型的多样化,这无疑会增加学习和维护的成本。同时可以看到CSE在服务治理能力方面的优势,这些优势对于微服务的可靠运行提供了非常强大的保障,这个才是CSE作为一个微服务框架核心重要的部分。

CSE Edge Service

版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。

上一篇:第一章 SDN介绍 (附件1 )【华为SDN产业链分析】
下一篇:在传统行业中,区块链的应用又扮演什么角色呢?
相关文章