使用Spring Cloud和Docker构建微服务（转）

【编者的话】这是系列博文中的第一篇，本文作者使用Spring Cloud和Docker构建微服务平台，文章的例子浅显易懂。本系列博文主要向大家介绍如何使用Spring Cloud和Docker构建微服务平台。

什么是Spring Cloud？

Spring Cloud 是Pivotal提 供的用于简化分布式系统构建的工具集。Spring Cloud引入了云平台连接器（Cloud Connector）和服务连接器（Service Connector）的概念。云平台连接器是一个接口，需要由云平台提供者进行实现，以便库中的其他模块可以与该云平台协同工作。（更多介绍，可以阅读 InfoQ的报道。）

在Spring Cloud提供的解决方案中，你将会发现如下的内容：

• Configuration Service
• Discovery Service
• Circuit breakers
• Distributed sessions

 

Spring Boot

Spring Cloud最重要的一点是它可以和Spring Boot一起工作，Spring Boot可以帮助开发者更容易地创建基于Spring的应用程序和服务。

从Spring Boot项目名称中的Boot就可以看出来，Spring Boot的作用在于创建和启动新的基于Spring框架的项目。Spring Boot会选择最适合的Spring子项目和第三方开源库进行整合。大部分Spring Boot应用只需要非常少的配置就可以快速运行起来。Spring Boot包含的特性如下：

• 创建可以独立运行的Spring应用。
• 直接嵌入Tomcat或Jetty服务器，不需要部署WAR文件。
• 提供推荐的基础POM文件来简化Apache Maven配置。
• 尽可能的根据项目依赖来自动配置Spring框架。
• 提供可以直接在生产环境中使用的功能，如性能指标、应用信息和应用健康检查。
• 没有代码生成，也没有XML配置文件。

 

服务发现和智能路由

每一个服务都含有一个特定意义的微服务架构。当你在Spring Cloud上构建微服务架构时，这里有几个基本概念需要首先澄清下。首先，你需要要先创建Configuration Service和Discovery Service两个基础服务。如下图所示：

上面的图片说明了四个微服务以及各个服务之间的依赖关系。

Configuration service处于最顶端，黄色标识，而且被其它微服务所依赖。

Discovery service处于最低端，蓝色标识，同时也被其它服务所依赖。

绿色标识的两个微服务是我们本系列博文中用到的两个应用案例：电影和观影建议。

Configuration Service

Configuration Service在微服务架构中是一个非常重要的组件。如12要素应用理论所说， 微服务应用的配置应该存储在环境中，而不是本地项目中。

Configuration service（配置服务）是一个必不可少的基础组件的原因是因为它可以对所有通过点对点和检索的基础服务进行服务管理。

假设我们有多个部署环境。比如我们有一个临时环境和一个生产环境，针对每个环境的配置将会是不同的。每一个configuration service 将会由一个独立的Git仓库来存放环境配置。没有其它环境能够访问到这个配置仓库，它只是提供该环境中运行的配置服务罢了。

当Configuration service启动后，它将会指向那些根据配置文件配置的路径并启动对应服务。每一个微服务通过读取自己配置文件中的具体环境来运行。在这一过程中，配置是通过版本管理来进行的内部和集中化管理，更改配置不需要重启服务。

通过Spring Cloud提供的服务终端，你可以更改环境配置，并向Discovery service（发现服务）发送一个刷新信号，所有的用户都会收到新的配置通知。

Discovery Service

Discovery Service（发现服务）是另一个重要的微服务架构的组件。Discovery Service管理运行在容器中的众多服务实例，而这些实例工作在集群环境下。在这些应用中，我们使用客户端的方式称之为从服务到服务。举个例子，我使用Spring Cloud Feign ，这是一个基于Restful风格的微服务提供的客户端开源项目，它是从Netflix OSS project项目中派生出来的。

@FeignClient("movie")
public interface MovieClient {
@RequestMapping(method = RequestMethod.GET, value = "/movies")
PagedResources findAll();

@RequestMapping(method = RequestMethod.GET, value = "/movies/{id}")
Movie findById(@RequestParam("id") String id);

@RequestMapping(method = RequestMethod.POST, value = "/movies",
  produces = MediaType.APPLICATION_JSON_VALUE)
void createMovie(@RequestBody Movie movie);
} 

在上面的例子中，我创建了一个Feign 客户端，并映射了一个REST API方法来暴露电影服务。使用@FeignClient注解，可以声明我想要为movie微服务而创建的客户端API。接下来我声明了一个我想要实现的服务映射。通过在方法上声明一个URL规则来描述一个REST API的路由规则。

更令人兴奋的是，这一切在Spring Cloud中都很容易，我所要做的仅仅是知道service ID来创建我的Feign 客户端。服务的URL地址在运行时环境是自动配置的，因为每一个在集群中的微服务将会在启动时通过绑定serviceid的方式来进行注册。

微服务架构中的其它服务，也是通过上面提到的方式运行。我只需要知道进行通讯服务的serviceid，所有的操作都是通过Spring自动绑定的。

API Gateway

API Gateway 服务是Spring Cloud的另一个重要组件（关于它的介绍可以阅读本篇文章）。它可以用来管理集群服务中的领域实体。下图的绿色六边形是我们提供的数据驱动服务，主要用来管理自己的实体类和数据库。通过添加API Gateway服务，我们可以为通过下面绿颜色的服务为每一个API路由创建一个代理暴露接口。

假设推荐服务和电影服务都暴露他们自己的REST API在自己管理的域实体上。API gataway通过discovery service和从其它服务注入的基于代理路由的 API方法。通过这种方式，包括推荐服务和电影服务将拥有一个完整定义的路由，通过暴露的REST API获得本地的微服务。API Gateway将会重定义路由请求到服务实例，这些请求都是基于HTTP的。

示例项目

我已经在GitHub上创建了一个实例项目，这个项目是一个端到端的原生云平台，使用Spring Cloud构建实际的微服务架构。

基本概念:

• 使用Docker进行集成测试
• 混合持久化
• 微服务架构
• 服务发现
• API网关

 

Docker

使用Docker对每一个服务进行构建和部署。使用Docker Compose在一个开发机上进行端到端的集成测试。

混合持久化

混合持久化其实就是说使用多种数据库来存储。不同的微服务实例都会使用它们自己的数据库，并通过REST服务或者消息总线来通信，举个例子，你可以使用基于以下数据库来构建微服务：

• Neo4j（图形化）
• MongoDB（文档化）
• MySQL（关联）

 

微服务架构

这个例子演示了如何使用微服务创建一个新的应用。由于在项目中的每一个微服务只有一个单一的父项目。开发者为此得到的收益是可以在本机上运行和开发每一个微服务。添加一个新的微服务非常简单，当发现微服务时将会自动发现运行时的集群环境上。

Service Discovery

项目中包含两个发现服务，一个在Netflix Eureka，另一个使用了
Consul from Hashicorp。多种发现服务提供了多种选择，一个是使用（Consul）来做DNS服务集群，另一个是（Consul）基于代理的API 网关。

API 网关

每一个微服务都关联Eureka，在整个集群中检索API路由。使用这个策略，每一个在集群上运行的微服务只需要通过一个 共同的API网关进行负载均衡和暴露接口，每一个服务也会自动发现并将路由请求转发到自己的路由服务中。这个代理技术有助于开发用户界面，作为平台完整的 API通过自己的主机映射为代理服务。

Docker 实例

下面的实例将会通过Maven来构建，使用Docker为每一个微服务构建容器镜像。我们可以很优雅的使用Docker Compose在我们自己的主机上搭建全部的微服务集群。

开始构建

在这之前，请先移步至项目的GitHub 仓库。

https://github.com/kbastani/spring-cloud-microservice-example

克隆或者fork这个项目并且把源码下载到自己的电脑上。下载完毕后，你需要使用Maven和Docker来编译和构建本地的容器镜像。

下载Docker

首先，如果你还没有Docker请先下载它。可以跟随这个指南来获取Docker，然后在开发机上安装并运行。

当然你也需要安装Docker Compose，这个指南将会帮到你。

环境要求

能够运行实例程序，需要在你的开发机上安装下面的软件：

• Maven 3
• Java 8
• Docker
• Docker Compose

 

构建项目

通过命令行方式来构建当前项目，在项目的根目录中运行如下的命令：

$ mvn clean install

项目将会根据pom.xml中的每一个项目声明中下载相应的依赖jar包。每一个服务都将会被构建，同时Maven的Docker插件将会自动从本地Docker Registry中构建每一个容器镜像。Docker将会在构建成功后，根据命令行运行mvn clean install来清除相应的资源。

在项目成功构建后，你将会看到如下的输出：

[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] spring-cloud-microservice-example-parent .......... SUCCESS [  0.268 s]
[INFO] users-microservice ................................ SUCCESS [ 11.929 s]
[INFO] discovery-microservice ............................ SUCCESS [  5.640 s]
[INFO] api-gateway-microservice .......................... SUCCESS [  5.156 s]
[INFO] recommendation-microservice ....................... SUCCESS [  7.732 s]
[INFO] config-microservice ............................... SUCCESS [  4.711 s]
[INFO] hystrix-dashboard ................................. SUCCESS [  4.251 s]
[INFO] consul-microservice ............................... SUCCESS [  6.763 s]
[INFO] movie-microservice ................................ SUCCESS [  8.359 s]
[INFO] movies-ui ......................................... SUCCESS [ 15.833 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

 

通过Docker compose 启动集群

现在每一个镜像都成功构建完毕，我们使用Docker Compose来加速启动我们的集群。我已经将Docker Compose的yaml文件包含进了项目中，大家可以从GitHub上获取。

现在我们通过下面的命令行启动微服务集群：

$ docker-compose up

如果一切配置都是正确的，每一个容器镜像将会通过在Docker上的虚拟容器和自动发现的网络服务来运行。当他们开始顺序启动时，你将会看到一系列的日志输出。这可能需要一段时间来完成，取决于运行你实例程序的机器性能。

一旦容器启动成功，你将会通过Eureka主机看到通过Discovery service注册上来的应用服务。

通过命令行终端复制粘贴下面的命令到Docker中定义的$DOCKER_HOST环境变量中。

$ open $(echo \"$(echo $DOCKER_HOST)\"|
\sed 's/tcp:\/\//http:\/\//g'|
\sed 's/[0-9]\{4,\}/8761/g'|
\sed 's/\"//g')

如果Eureka正确的启动，浏览器将会启动并打开Eureka服务的仪表盘，如下图所示：

我们将会看到每一个正在运行的服务实例和状态。通过下面的命令来获取数据驱动服务，例如 movie 服务。

$ open $(echo \"$(echo $DOCKER_HOST)/movie\"|
        \sed 's/tcp:\/\//http:\/\//g'|
        \sed 's/[0-9]\{4,\}/10000/g'|
        \sed 's/\"//g')

这个命令将会访问根据导航网关终端提供的代理方式访问movie服务的REST API终端。这些REST API使用 HATEOAS 来配置，它是一个通过内嵌链接的方式支持自动发现服务的接口。

{
  "_links" : {
"self" : {
  "href" : "http://192.168.59.103:10000/movie"
},
"resume" : {
  "href" : "http://192.168.59.103:10000/movie/resume"
},
"pause" : {
  "href" : "http://192.168.59.103:10000/movie/pause"
},
"restart" : {
  "href" : "http://192.168.59.103:10000/movie/restart"
},
"metrics" : {
  "href" : "http://192.168.59.103:10000/movie/metrics"
},
"env" : [ {
  "href" : "http://192.168.59.103:10000/movie/env"
}, {
  "href" : "http://192.168.59.103:10000/movie/env"
} ],
"archaius" : {
  "href" : "http://192.168.59.103:10000/movie/archaius"
},
"beans" : {
  "href" : "http://192.168.59.103:10000/movie/beans"
},
"configprops" : {
  "href" : "http://192.168.59.103:10000/movie/configprops"
},
"trace" : {
  "href" : "http://192.168.59.103:10000/movie/trace"
},
"info" : {
  "href" : "http://192.168.59.103:10000/movie/info"
},
"health" : {
  "href" : "http://192.168.59.103:10000/movie/health"
},
"hystrix.stream" : {
  "href" : "http://192.168.59.103:10000/movie/hystrix.stream"
},
"routes" : {
  "href" : "http://192.168.59.103:10000/movie/routes"
},
"dump" : {
  "href" : "http://192.168.59.103:10000/movie/dump"
},
"refresh" : {
  "href" : "http://192.168.59.103:10000/movie/refresh"
},
"mappings" : {
  "href" : "http://192.168.59.103:10000/movie/mappings"
},
"autoconfig" : {
  "href" : "http://192.168.59.103:10000/movie/autoconfig"
}
  }
}  

 

总结

这是使用Spring Cloud和Docker构建微服务架构的系列博文的第一部分。在本文中，我们接触到了如下的概念:

• Service Discovery
• Externalized Configuration
• API Gateway
• Service Orchestration with Docker Compose

在这之后的博文中，我们将会演示如何使用后台服务来构建前端应用程序，同时也会介绍一个混合性持久化的实例，使用MySQL和Neo4j。

原文链接：Building Microservices with Spring Cloud and Docker（翻译：隋鑫）